Merge remote-tracking branch 'upstream/sdk-1.3.231' into main
Bug: 112606
Change-Id: Icbf28c5b65557e9087e32c85b2b5a4aa55ab484e
diff --git a/.appveyor.yml b/.appveyor.yml
index bf8c572..b08c47b 100644
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -98,7 +98,7 @@
auth_token:
secure: YglcSYdl0TylEa59H4K6lylBEDr586NAt2EMgZquSo+iuPrwgZQuJLPCoihSm9y6
release: master-tot
- description: "Continuous build of the latest master branch by Appveyor and Travis CI"
+ description: "Continuous build of the latest master branch by Appveyor and Github"
artifact: artifacts-zip
draft: false
prerelease: false
diff --git a/.github/workflows/continuous_deployment.yml b/.github/workflows/continuous_deployment.yml
new file mode 100644
index 0000000..c375ac4
--- /dev/null
+++ b/.github/workflows/continuous_deployment.yml
@@ -0,0 +1,170 @@
+# NOTE: This workflow was ported from Travis.
+# Travis was using Ubuntu 14.04. Ubuntu 14.04 is not supportted by GitHub workflows. Ubuntu 20.04 is recommended.
+# Travis was using Clang 3.6. The earliest version support by Ubuntu 20.04 is Clang 6.0.
+# Travis was caching the clang package. APT package caching is not natively supported by GitHub actions/cache.
+# Travis was using Mac OS X 10.13.6 / Xcode 9.4.1 / LLVM 9.1.0
+
+# NOTE: The following documentation may be useful to maintainers of this workflow.
+# Github actions: https://docs.github.com/en/actions
+# Github github-script action: https://github.com/actions/github-script
+# GitHub REST API: https://docs.github.com/en/rest
+# Octokit front-end to the GitHub REST API: https://octokit.github.io/rest.js/v18
+# Octokit endpoint methods: https://github.com/octokit/plugin-rest-endpoint-methods.js/tree/master/docs/repos
+
+# TODO: Use actions/upload-artifact and actions/download-artifact to simplify deployment.
+# TODO: Use composite actions to refactor redundant code.
+
+name: Continuous Deployment
+
+on:
+ workflow_dispatch:
+ push:
+ branches:
+ - master
+
+jobs:
+ linux:
+ runs-on: ${{matrix.os.genus}}
+ strategy:
+ fail-fast: false
+ matrix:
+ os: [{genus: ubuntu-20.04, family: linux}]
+ compiler: [{cc: clang, cxx: clang++}, {cc: gcc, cxx: g++}]
+ cmake_build_type: [Debug, Release]
+ steps:
+ - uses: actions/checkout@v2
+ - uses: actions/setup-python@v2
+ with:
+ python-version: '3.7'
+ - name: Install Ubuntu Package Dependencies
+ run: |
+ sudo apt-get -qq update
+ sudo apt-get install -y clang-6.0
+ - name: Install GoogleTest
+ run: |
+ # check out pre-breakage version of googletest; can be deleted when
+ # issue 3128 is fixed
+ # git clone --depth=1 https://github.com/google/googletest.git External/googletest
+ mkdir -p External/googletest
+ cd External/googletest
+ git init
+ git remote add origin https://github.com/google/googletest.git
+ git fetch --depth 1 origin 0c400f67fcf305869c5fb113dd296eca266c9725
+ git reset --hard FETCH_HEAD
+ cd ../..
+ - name: Update Glslang Sources
+ run: |
+ ./update_glslang_sources.py
+ - name: Build
+ env:
+ CC: ${{matrix.compiler.cc}}
+ CXX: ${{matrix.compiler.cxx}}
+ run: |
+ mkdir build && cd build
+ cmake -DCMAKE_BUILD_TYPE=${{matrix.cmake_build_type}} -DCMAKE_INSTALL_PREFIX=`pwd`/install ..
+ make -j4 install
+ - name: Test
+ run: |
+ cd build
+ ctest --output-on-failure &&
+ cd ../Test && ./runtests
+ - name: Zip
+ if: ${{ matrix.compiler.cc == 'clang' }}
+ env:
+ ARCHIVE: glslang-master-${{matrix.os.family}}-${{matrix.cmake_build_type}}.zip
+ run: |
+ cd build/install
+ zip ${ARCHIVE} \
+ bin/glslangValidator \
+ include/glslang/* \
+ include/glslang/**/* \
+ lib/libGenericCodeGen.a \
+ lib/libglslang.a \
+ lib/libglslang-default-resource-limits.a \
+ lib/libHLSL.a \
+ lib/libMachineIndependent.a \
+ lib/libOGLCompiler.a \
+ lib/libOSDependent.a \
+ lib/libSPIRV.a \
+ lib/libSPVRemapper.a \
+ lib/libSPIRV-Tools.a \
+ lib/libSPIRV-Tools-opt.a
+ - name: Deploy
+ if: ${{ matrix.compiler.cc == 'clang' }}
+ env:
+ ARCHIVE: glslang-master-${{matrix.os.family}}-${{matrix.cmake_build_type}}.zip
+ uses: actions/github-script@v5
+ with:
+ script: |
+ const script = require('.github/workflows/deploy.js')
+ await script({github, context, core})
+
+ macos:
+ runs-on: ${{matrix.os.genus}}
+ strategy:
+ fail-fast: false
+ matrix:
+ os: [{genus: macos-11, family: osx}]
+ compiler: [{cc: clang, cxx: clang++}]
+ cmake_build_type: [Debug, Release]
+ steps:
+ - uses: actions/checkout@v2
+ - uses: actions/setup-python@v2
+ with:
+ python-version: '3.7'
+ - name: Install GoogleTest
+ run: |
+ # check out pre-breakage version of googletest; can be deleted when
+ # issue 3128 is fixed
+ # git clone --depth=1 https://github.com/google/googletest.git External/googletest
+ mkdir -p External/googletest
+ cd External/googletest
+ git init
+ git remote add origin https://github.com/google/googletest.git
+ git fetch --depth 1 origin 0c400f67fcf305869c5fb113dd296eca266c9725
+ git reset --hard FETCH_HEAD
+ cd ../..
+ - name: Update Glslang Sources
+ run: |
+ ./update_glslang_sources.py
+ - name: Build
+ env:
+ CC: ${{matrix.compiler.cc}}
+ CXX: ${{matrix.compiler.cxx}}
+ run: |
+ mkdir build && cd build
+ cmake -DCMAKE_BUILD_TYPE=${{matrix.cmake_build_type}} -DCMAKE_INSTALL_PREFIX=`pwd`/install ..
+ make -j4 install
+ - name: Test
+ run: |
+ cd build
+ ctest --output-on-failure &&
+ cd ../Test && ./runtests
+ - name: Zip
+ env:
+ ARCHIVE: glslang-master-${{matrix.os.family}}-${{matrix.cmake_build_type}}.zip
+ run: |
+ cd build/install
+ zip ${ARCHIVE} \
+ bin/glslangValidator \
+ include/glslang/* \
+ include/glslang/**/* \
+ lib/libGenericCodeGen.a \
+ lib/libglslang.a \
+ lib/libglslang-default-resource-limits.a \
+ lib/libHLSL.a \
+ lib/libMachineIndependent.a \
+ lib/libOGLCompiler.a \
+ lib/libOSDependent.a \
+ lib/libSPIRV.a \
+ lib/libSPVRemapper.a \
+ lib/libSPIRV-Tools.a \
+ lib/libSPIRV-Tools-opt.a
+ - name: Deploy
+ env:
+ ARCHIVE: glslang-master-${{matrix.os.family}}-${{matrix.cmake_build_type}}.zip
+ uses: actions/github-script@v5
+ with:
+ script: |
+ const script = require('.github/workflows/deploy.js')
+ await script({github, context, core})
diff --git a/.github/workflows/continuous_integration.yml b/.github/workflows/continuous_integration.yml
new file mode 100644
index 0000000..7c36c68
--- /dev/null
+++ b/.github/workflows/continuous_integration.yml
@@ -0,0 +1,157 @@
+# NOTE: This workflow was ported from Travis.
+# Travis was using Ubuntu 14.04. Ubuntu 14.04 is not supportted by GitHub workflows. Ubuntu 20.04 is recommended.
+# Travis was using Clang 3.6. The earliest version support by Ubuntu 20.04 is Clang 6.0.
+# Travis was caching the clang package. APT package caching is not natively supported by GitHub actions/cache.
+# Travis was using Mac OS X 10.13.6 / Xcode 9.4.1 / LLVM 9.1.0
+#
+name: Continuous Integration
+
+on:
+ workflow_dispatch:
+ pull_request:
+ branches:
+ - master
+
+jobs:
+ linux:
+ runs-on: ${{matrix.os}}
+ strategy:
+ fail-fast: false
+ matrix:
+ os: [ubuntu-20.04]
+ compiler: [{cc: clang, cxx: clang++}, {cc: gcc, cxx: g++}]
+ cmake_build_type: [Debug, Release]
+ steps:
+ - uses: actions/checkout@v2
+ - uses: actions/setup-python@v2
+ with:
+ python-version: '3.7'
+ - name: Install Ubuntu Package Dependencies
+ run: |
+ sudo apt-get -qq update
+ sudo apt-get install -y clang-6.0
+ - name: Install GoogleTest
+ run: |
+ # check out pre-breakage version of googletest; can be deleted when
+ # issue 3128 is fixed
+ # git clone --depth=1 https://github.com/google/googletest.git External/googletest
+ mkdir -p External/googletest
+ cd External/googletest
+ git init
+ git remote add origin https://github.com/google/googletest.git
+ git fetch --depth 1 origin 0c400f67fcf305869c5fb113dd296eca266c9725
+ git reset --hard FETCH_HEAD
+ cd ../..
+ - name: Update Glslang Sources
+ run: |
+ ./update_glslang_sources.py
+ - name: Build
+ env:
+ CC: ${{matrix.compiler.cc}}
+ CXX: ${{matrix.compiler.cxx}}
+ run: |
+ mkdir build && cd build
+ cmake -DCMAKE_BUILD_TYPE=${{matrix.cmake_build_type}} -DCMAKE_INSTALL_PREFIX=`pwd`/install ..
+ make -j4 install
+ - name: Test
+ run: |
+ cd build
+ ctest --output-on-failure &&
+ cd ../Test && ./runtests
+
+ macos:
+ runs-on: ${{matrix.os}}
+ strategy:
+ fail-fast: false
+ matrix:
+ os: [macos-11]
+ compiler: [{cc: clang, cxx: clang++}]
+ cmake_build_type: [Debug, Release]
+ steps:
+ - uses: actions/checkout@v2
+ - uses: actions/setup-python@v2
+ with:
+ python-version: '3.7'
+ - name: Install GoogleTest
+ run: |
+ # check out pre-breakage version of googletest; can be deleted when
+ # issue 3128 is fixed
+ # git clone --depth=1 https://github.com/google/googletest.git External/googletest
+ mkdir -p External/googletest
+ cd External/googletest
+ git init
+ git remote add origin https://github.com/google/googletest.git
+ git fetch --depth 1 origin 0c400f67fcf305869c5fb113dd296eca266c9725
+ git reset --hard FETCH_HEAD
+ cd ../..
+ - name: Update Glslang Sources
+ run: |
+ ./update_glslang_sources.py
+ - name: Build
+ env:
+ CC: ${{matrix.compiler.cc}}
+ CXX: ${{matrix.compiler.cxx}}
+ run: |
+ mkdir build && cd build
+ cmake -DCMAKE_BUILD_TYPE=${{matrix.cmake_build_type}} -DCMAKE_INSTALL_PREFIX=`pwd`/install ..
+ make -j4 install
+ - name: Test
+ run: |
+ cd build
+ ctest --output-on-failure &&
+ cd ../Test && ./runtests
+
+ android:
+ runs-on: ${{matrix.os}}
+ strategy:
+ fail-fast: false
+ matrix:
+ os: [ubuntu-20.04]
+ compiler: [{cc: clang, cxx: clang++}]
+ cmake_build_type: [Release]
+ steps:
+ - uses: actions/checkout@v2
+ - uses: actions/setup-python@v2
+ with:
+ python-version: '3.7'
+ - name: Install Ubuntu Package Dependencies
+ if: ${{matrix.os == 'ubuntu-20.04'}}
+ run: |
+ sudo apt-get -qq update
+ sudo apt-get install -y clang-6.0
+ - name: Install Android NDK
+ run: |
+ export ANDROID_NDK=$HOME/android-ndk
+ git init $ANDROID_NDK
+ pushd $ANDROID_NDK
+ git remote add dneto0 https://github.com/dneto0/android-ndk.git
+ git fetch --depth=1 dneto0 r17b-strip
+ git checkout FETCH_HEAD
+ popd
+ - name: Install GoogleTest
+ run: |
+ # check out pre-breakage version of googletest; can be deleted when
+ # issue 3128 is fixed
+ # git clone --depth=1 https://github.com/google/googletest.git External/googletest
+ mkdir -p External/googletest
+ cd External/googletest
+ git init
+ git remote add origin https://github.com/google/googletest.git
+ git fetch --depth 1 origin 0c400f67fcf305869c5fb113dd296eca266c9725
+ git reset --hard FETCH_HEAD
+ cd ../..
+ - name: Update Glslang Sources
+ run: |
+ ./update_glslang_sources.py
+ - name: Build
+ env:
+ CC: ${{matrix.compiler.cc}}
+ CXX: ${{matrix.compiler.cxx}}
+ run: |
+ export ANDROID_NDK=$HOME/android-ndk
+ export TOOLCHAIN_PATH=$ANDROID_NDK/build/cmake/android.toolchain.cmake
+ echo $ANDROID_NDK
+ echo $TOOLCHAIN_PATH
+ mkdir build && cd build
+ cmake -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_PATH} -DANDROID_NATIVE_API_LEVEL=android-14 -DCMAKE_BUILD_TYPE=${{matrix.cmake_build_type}} -DANDROID_ABI="armeabi-v7a with NEON" -DBUILD_TESTING=OFF ..
+ make -j4
diff --git a/.github/workflows/deploy.js b/.github/workflows/deploy.js
new file mode 100644
index 0000000..9f8d242
--- /dev/null
+++ b/.github/workflows/deploy.js
@@ -0,0 +1,73 @@
+module.exports = async ({github, context, core}) => {
+ try {
+ await github.rest.git.updateRef({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ ref: 'tags/master-tot',
+ sha: context.sha
+ })
+ } catch (error) {
+ core.setFailed(`upload master-tot tag; ${error.name}; ${error.message}`)
+ }
+
+ let release
+ try {
+ release = await github.rest.repos.getReleaseByTag({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ tag: 'master-tot'
+ })
+ } catch (error) {
+ core.setFailed(`get the master release; ${error.name}; ${error.message}`)
+ }
+
+ try {
+ await github.rest.repos.updateRelease({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ release_id: release.data.id
+ })
+ } catch (error) {
+ core.setFailed(`update the master release; ${error.name}; ${error.message}`)
+ }
+
+ let release_assets
+ try {
+ release_assets = await github.rest.repos.listReleaseAssets({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ release_id: release.data.id
+ })
+ } catch (error) {
+ core.setFailed(`list release assets; ${error.name}; ${error.message}`)
+ }
+
+ const { ARCHIVE } = process.env
+ for (const release_asset of release_assets.data) {
+ if (release_asset.name === `${ ARCHIVE }`) {
+ try {
+ await github.rest.repos.deleteReleaseAsset({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ asset_id: release_asset.id
+ })
+ } catch (error) {
+ core.setFailed(`delete ${ ARCHIVE }; ${error.name}; ${error.message}`)
+ }
+ }
+ }
+
+ try {
+ const asset_path = `./build/install/${ ARCHIVE }`
+ const fs = require("fs")
+ await github.rest.repos.uploadReleaseAsset({
+ owner: context.repo.owner,
+ repo: context.repo.repo,
+ release_id: release.data.id,
+ name: `${ ARCHIVE }`,
+ data: fs.readFileSync(asset_path)
+ })
+ } catch (error) {
+ core.setFailed(`upload ${ ARCHIVE }; ${error.name}; ${error.message}`)
+ }
+}
diff --git a/.gitignore b/.gitignore
index ab25cec..333fb76 100644
--- a/.gitignore
+++ b/.gitignore
@@ -18,3 +18,7 @@
third_party/
buildtools/
tools/
+
+# Random OS stuff
+.DS_Store
+._*
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index cb0392e..0000000
--- a/.travis.yml
+++ /dev/null
@@ -1,141 +0,0 @@
-# Linux and Mac Build Configuration for Travis
-
-language: cpp
-
-os:
- - linux
- - osx
-
-# Use Ubuntu 14.04 LTS (Trusty) as the Linux testing environment.
-sudo: false
-dist: trusty
-
-env:
- global:
- - secure: aGFrgzyKp+84hKrGkxVWg8cHV61uqrKEHT38gfSQK6+WS4GfLOyH83p7WnsEBb7AMhzU7LMNFdvOFr6+NaMpVnqRvc40CEG1Q+lNg9Pq9mhIZLowvDrfqTL9kQ+8Nbw5Q6/dg6CTvY7fvRfpfCEmKIUZBRkoKUuHeuM1uy3IupFcdNuL5bSYn3Beo+apSJginh9DI4BLDXFUgBzTRSLLyCX5g3cpaeGGOCr8quJlYx75W6HRck5g9SZuLtUoH9GFEV3l+ZEWB8noErW+J56L03bwNwFuuAh321evw++oQk5KFa8rlDvar3SJ3b1RHB8u/eq5DBYMyaK/fS8+Q7QbGr8diF/wDe68bKO7U9IhpNfExXmczCpExjHomW5TQv4rYdGhygPMfW97aIsPRYyNKcl4fkmb7NDrM8w0Jscdq2g5c2Kz0ItyZoBri/NXLwFQQjaVCs7Pf97TjuMA7mK0GJmDTRzi6SrDYlWMt5BQL3y0CCojyfLIRcTh0CQjQI29s97bLfQrYAxt9GNNFR+HTXRLLrkaAlJkPGEPwUywlSfEThnvHLesNxYqemolAYpQT4ithoL4GehGIHmaxsW295aKVhuRf8K9eBODNqrfblvM42UHhjntT+92ZnQ/Gkq80GqaMxnxi4PO5FyPIxt0r981b54YBkWi8YA4P7w5pNI=
- matrix:
- - GLSLANG_BUILD_TYPE=Release
- - GLSLANG_BUILD_TYPE=Debug
-
-compiler:
- - clang
- - gcc
-
-matrix:
- fast_finish: true # Show final status immediately if a test fails.
- exclude:
- # Skip GCC builds on Mac OS X.
- - os: osx
- compiler: gcc
- include:
- # Additional build using Android NDK.
- - env: BUILD_NDK=ON
-
-cache:
- apt: true
-
-branches:
- only:
- - master
-
-addons:
- apt:
- packages:
- - clang-3.6
-
-install:
- # Make sure that clang-3.6 is selected on Linux.
- - if [[ "$TRAVIS_OS_NAME" == "linux" && "$CC" == "clang" ]]; then
- export CC=clang-3.6 CXX=clang++-3.6;
- fi
- # Download a recent Android NDK and use its android.toolchain.cmake file.
- - if [[ "$BUILD_NDK" == "ON" ]]; then
- export ANDROID_NDK=$HOME/android-ndk;
- git init $ANDROID_NDK;
- pushd $ANDROID_NDK;
- git remote add dneto0 https://github.com/dneto0/android-ndk.git;
- git fetch --depth=1 dneto0 r17b-strip;
- git checkout FETCH_HEAD;
- popd;
- export TOOLCHAIN_PATH=$ANDROID_NDK/build/cmake/android.toolchain.cmake;
- fi
-
-before_script:
- # check out pre-breakage version of googletest; can be deleted when
- # issue 3128 is fixed
- # git clone --depth=1 https://github.com/google/googletest.git External/googletest
- - mkdir -p External/googletest
- - cd External/googletest
- - git init
- - git remote add origin https://github.com/google/googletest.git
- - git fetch --depth 1 origin 0c400f67fcf305869c5fb113dd296eca266c9725
- - git reset --hard FETCH_HEAD
- - cd ../..
- # get spirv-tools and spirv-headers
- - ./update_glslang_sources.py
-
-script:
- - mkdir build && cd build
- # For Android, do release building using NDK without testing.
- # Use android-14, the oldest native API level supporeted by NDK r17b.
- # We can use newer API levels if we want.
- # For Linux and macOS, do debug/release building with testing.
- - if [[ "$BUILD_NDK" == "ON" ]]; then
- cmake -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_PATH}
- -DANDROID_NATIVE_API_LEVEL=android-14
- -DCMAKE_BUILD_TYPE=Release
- -DANDROID_ABI="armeabi-v7a with NEON"
- -DBUILD_TESTING=OFF ..;
- make -j4;
- else
- cmake -DCMAKE_BUILD_TYPE=${GLSLANG_BUILD_TYPE}
- -DCMAKE_INSTALL_PREFIX=`pwd`/install ..;
- make -j4 install;
- ctest --output-on-failure &&
- cd ../Test && ./runtests;
- fi
-
-after_success:
- # For debug build, the generated dll has a postfix "d" in its name.
- - if [[ "${GLSLANG_BUILD_TYPE}" == "Debug" ]]; then
- export SUFFIX="d";
- else
- export SUFFIX="";
- fi
- # Create tarball for deployment
- - if [[ ${CC} == clang* && "${BUILD_NDK}" != "ON" ]]; then
- cd ../build/install;
- export TARBALL=glslang-master-${TRAVIS_OS_NAME}-${GLSLANG_BUILD_TYPE}.zip;
- zip ${TARBALL}
- bin/glslangValidator
- include/glslang/*
- lib/libGenericCodeGen${SUFFIX}.a
- lib/libglslang${SUFFIX}.a
- lib/libglslang-default-resource-limits${SUFFIX}.a
- lib/libHLSL${SUFFIX}.a
- lib/libMachineIndependent${SUFFIX}.a
- lib/libOGLCompiler${SUFFIX}.a
- lib/libOSDependent${SUFFIX}.a
- lib/libSPIRV${SUFFIX}.a
- lib/libSPVRemapper${SUFFIX}.a
- lib/libSPIRV-Tools${SUFFIX}.a
- lib/libSPIRV-Tools-opt${SUFFIX}.a;
- fi
-
-before_deploy:
- # Tag the current top of the tree as "master-tot".
- # Travis CI replies on the tag name to properly push to GitHub Releases.
- - git config --global user.name "Travis CI"
- - git config --global user.email "builds@travis-ci.org"
- - git tag -f master-tot
- - git push -q -f https://${glslangtoken}@github.com/KhronosGroup/glslang --tags
-
-deploy:
- provider: releases
- api_key: ${glslangtoken}
- on:
- branch: master
- condition: ${CC} == clang* && ${BUILD_NDK} != ON
- file: ${TARBALL}
- skip_cleanup: true
- overwrite: true
diff --git a/Android.mk b/Android.mk
index c9b221f..40cddb7 100644
--- a/Android.mk
+++ b/Android.mk
@@ -96,6 +96,7 @@
LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti $(GLSLANG_DEFINES)
LOCAL_EXPORT_C_INCLUDES:=$(LOCAL_PATH)
LOCAL_SRC_FILES:= \
+ glslang/CInterface/glslang_c_interface.cpp \
glslang/GenericCodeGen/CodeGen.cpp \
glslang/GenericCodeGen/Link.cpp \
glslang/HLSL/hlslAttributes.cpp \
@@ -149,6 +150,7 @@
LOCAL_MODULE:=SPIRV
LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti -Werror $(GLSLANG_DEFINES)
LOCAL_SRC_FILES:= \
+ SPIRV/CInterface/spirv_c_interface.cpp \
SPIRV/GlslangToSpv.cpp \
SPIRV/InReadableOrder.cpp \
SPIRV/Logger.cpp \
diff --git a/BUILD.bazel b/BUILD.bazel
index 1115b7d..12168fa 100644
--- a/BUILD.bazel
+++ b/BUILD.bazel
@@ -146,6 +146,7 @@
"SPIRV/GLSL.ext.NV.h",
"SPIRV/GLSL.std.450.h",
"SPIRV/NonSemanticDebugPrintf.h",
+ "SPIRV/NonSemanticShaderDebugInfo100.h",
"SPIRV/spirv.hpp",
],
outs = [
@@ -155,6 +156,7 @@
"include/SPIRV/GLSL.ext.NV.h",
"include/SPIRV/GLSL.std.450.h",
"include/SPIRV/NonSemanticDebugPrintf.h",
+ "include/SPIRV/NonSemanticShaderDebugInfo100.h",
"include/SPIRV/spirv.hpp",
],
cmd_bash = "mkdir -p $(@D)/include/SPIRV && cp $(SRCS) $(@D)/include/SPIRV/",
diff --git a/BUILD.gn b/BUILD.gn
index 70e1068..928fad6 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -136,6 +136,7 @@
"SPIRV/Logger.cpp",
"SPIRV/Logger.h",
"SPIRV/NonSemanticDebugPrintf.h",
+ "SPIRV/NonSemanticShaderDebugInfo100.h",
"SPIRV/SPVRemapper.cpp",
"SPIRV/SPVRemapper.h",
"SPIRV/SpvBuilder.cpp",
diff --git a/CHANGES.md b/CHANGES.md
index ebab4da..e7b6f14 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -3,6 +3,47 @@
All notable changes to this project will be documented in this file.
This project adheres to [Semantic Versioning](https://semver.org/).
+## 11.12.0 2022-10-12
+
+### Other changes
+* Update generator version
+* Add support for GL_EXT_mesh_shader
+* Add support for NonSemantic.Shader.DebugInfo.100
+* Make OpEmitMeshTasksEXT a terminal instruction
+* Make gl_SubGroupARB a flat in int in Vulkan
+* Add support for GL_EXT_opacity_micromap
+* Add preamble support to C interface
+
+## 11.11.0 2022-08-11
+
+### Other changes
+* Add OpSource support to C interface
+* Deprecate samplerBuffer for spirv1.6 and later
+* Add support for SPV_AMD_shader_early_and_late_fragment_tests
+
+## 11.10.0 2022-06-02
+
+### Other changes
+* Generate OpLine before OpFunction
+* Add support for VK_EXT_fragment_shader_barycentric
+* Add whitelist filtering for debug comments in SPIRV-Remap
+* Add support for GL_EXT_ray_cull_mask
+
+## 11.9.0 2022-04-06
+
+### Other changes
+* Add GLSL version override functionality
+* Add eliminate-dead-input-components to -Os
+* Add enhanced-msgs option
+* Explicitly use Python 3 for builds
+
+## 11.8.0 2022-01-27
+
+### Other changes
+* Add support for SPIR-V 1.6
+* Add support for Vulkan 1.3
+* Add --hlsl-dx-position-w option
+
## 11.7.0 2021-11-11
### Other changes
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d5b727a..b581c84 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -33,7 +33,7 @@
# increase to 3.1 once all major distributions
# include a version of CMake >= 3.1
-cmake_minimum_required(VERSION 2.8.12)
+cmake_minimum_required(VERSION 3.14.0)
if (POLICY CMP0048)
cmake_policy(SET CMP0048 NEW)
endif()
@@ -50,6 +50,7 @@
# Adhere to GNU filesystem layout conventions
include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
# Needed for CMAKE_DEPENDENT_OPTION macro
include(CMakeDependentOption)
@@ -106,10 +107,17 @@
option(ENABLE_RTTI "Enables RTTI" OFF)
option(ENABLE_EXCEPTIONS "Enables Exceptions" OFF)
option(ENABLE_OPT "Enables spirv-opt capability if present" ON)
-option(ENABLE_PCH "Enables Precompiled header" ON)
+
+if(MINGW OR (CMAKE_SYSTEM_NAME STREQUAL "Darwin" AND ${CMAKE_CXX_COMPILER_ID} MATCHES "GNU"))
+ # Workaround for CMake behavior on Mac OS with gcc, cmake generates -Xarch_* arguments
+ # which gcc rejects
+ option(ENABLE_PCH "Enables Precompiled header" OFF)
+else()
+ option(ENABLE_PCH "Enables Precompiled header" ON)
+endif()
option(ENABLE_CTEST "Enables testing" ON)
-if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT AND WIN32)
+if(ENABLE_GLSLANG_INSTALL AND CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT AND WIN32)
set(CMAKE_INSTALL_PREFIX "install" CACHE STRING "..." FORCE)
endif()
@@ -163,7 +171,7 @@
add_compile_options(-Werror=deprecated-copy)
endif()
- if(NOT CMAKE_VERSION VERSION_LESS "3.13")
+ if(NOT CMAKE_VERSION VERSION_LESS "3.13" AND NOT CMAKE_SYSTEM_NAME STREQUAL "Darwin")
# Error if there's symbols that are not found at link time.
# add_link_options() was added in CMake 3.13 - if using an earlier
# version don't set this - it should be caught by presubmits anyway.
@@ -184,7 +192,11 @@
# Error if there's symbols that are not found at link time.
# add_link_options() was added in CMake 3.13 - if using an earlier
# version don't set this - it should be caught by presubmits anyway.
- add_link_options("-Wl,-undefined,error")
+ if (WIN32)
+ add_link_options("-Wl,--no-undefined")
+ else()
+ add_link_options("-Wl,-undefined,error")
+ endif()
endif()
elseif(MSVC)
if(NOT ENABLE_RTTI)
@@ -356,3 +368,38 @@
COMMAND bash ${IGNORE_CR_FLAG} runtests ${RESULTS_PATH} ${VALIDATOR_PATH} ${REMAP_PATH}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/Test/)
endif()
+
+if(ENABLE_GLSLANG_INSTALL)
+ file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/glslang-config.cmake.in" [=[
+ @PACKAGE_INIT@
+ include("@PACKAGE_PATH_EXPORT_TARGETS@")
+ ]=])
+
+ set(PATH_EXPORT_TARGETS "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}/glslang-targets.cmake")
+ configure_package_config_file(
+ "${CMAKE_CURRENT_BINARY_DIR}/glslang-config.cmake.in"
+ "${CMAKE_CURRENT_BINARY_DIR}/glslang-config.cmake"
+ PATH_VARS
+ PATH_EXPORT_TARGETS
+ INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
+ )
+
+ write_basic_package_version_file("${CMAKE_CURRENT_BINARY_DIR}/glslang-config-version.cmake"
+ VERSION ${GLSLANG_VERSION}
+ COMPATIBILITY SameMajorVersion
+ )
+
+ install(
+ EXPORT glslang-targets
+ NAMESPACE "glslang::"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
+ )
+
+ install(
+ FILES
+ "${CMAKE_CURRENT_BINARY_DIR}/glslang-config.cmake"
+ "${CMAKE_CURRENT_BINARY_DIR}/glslang-config-version.cmake"
+ DESTINATION
+ "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
+ )
+endif()
\ No newline at end of file
diff --git a/LICENSE.txt b/LICENSE.txt
index 5f58565..054e68a 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -303,41 +303,647 @@
GPL 3 with special bison exception
--------------------------------------------------------------------------------
- Bison implementation for Yacc-like parsers in C
+ GNU GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
- Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
- 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.
+ Preamble
- 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.
+ The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
- You should have received a copy of the GNU General Public License
- along with this program. If not, see <http://www.gnu.org/licenses/>.
+ 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.
- As a special exception, you may create a larger work that contains
- part or all of the Bison parser skeleton and distribute that work
- under terms of your choice, so long as that work isn't itself a
- parser generator using the skeleton or a modified version thereof
- as a parser skeleton. Alternatively, if you modify or redistribute
- the parser skeleton itself, you may (at your option) remove this
- special exception, which will cause the skeleton and the resulting
- Bison output files to be licensed under the GNU General Public
- License without this special exception.
+ 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.
- This special exception was added by the Free Software Foundation in
- version 2.2 of Bison.
+ 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.
+
+Bison Exception
+
+As a special exception, you may create a larger work that contains part or all
+of the Bison parser skeleton and distribute that work under terms of your
+choice, so long as that work isn't itself a parser generator using the skeleton
+or a modified version thereof as a parser skeleton. Alternatively, if you
+modify or redistribute the parser skeleton itself, you may (at your option)
+remove this special exception, which will cause the skeleton and the resulting
+Bison output files to be licensed under the GNU General Public License without
+this special exception.
+
+This special exception was added by the Free Software Foundation in version
+2.2 of Bison.
+
+ END OF TERMS AND CONDITIONS
--------------------------------------------------------------------------------
================================================================================
--------------------------------------------------------------------------------
-The preprocessor has the core licenses stated above, plus an additional licence:
+The preprocessor has the core licenses stated above, plus additional licences:
/****************************************************************************\
Copyright (c) 2002, NVIDIA Corporation.
@@ -382,3 +988,29 @@
TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF
NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
\****************************************************************************/
+
+/*
+** Copyright (c) 2014-2016 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and/or associated documentation files (the "Materials"),
+** to deal in the Materials without restriction, including without limitation
+** the rights to use, copy, modify, merge, publish, distribute, sublicense,
+** and/or sell copies of the Materials, and to permit persons to whom the
+** Materials are 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 Materials.
+**
+** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
+**
+** THE MATERIALS ARE 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 MATERIALS OR THE USE OR OTHER DEALINGS
+** IN THE MATERIALS.
+*/
diff --git a/OGLCompilersDLL/CMakeLists.txt b/OGLCompilersDLL/CMakeLists.txt
index 0b007d4..b44cbc7 100644
--- a/OGLCompilersDLL/CMakeLists.txt
+++ b/OGLCompilersDLL/CMakeLists.txt
@@ -41,8 +41,19 @@
source_group("Source" FILES ${SOURCES})
endif(WIN32)
-if(ENABLE_GLSLANG_INSTALL)
- install(TARGETS OGLCompiler EXPORT OGLCompilerTargets
- ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
- install(EXPORT OGLCompilerTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
-endif(ENABLE_GLSLANG_INSTALL)
+if(ENABLE_GLSLANG_INSTALL AND NOT BUILD_SHARED_LIBS)
+ install(TARGETS OGLCompiler EXPORT glslang-targets)
+
+ # Backward compatibility
+ file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/OGLCompilerTargets.cmake" "
+ message(WARNING \"Using `OGLCompilerTargets.cmake` is deprecated: use `find_package(glslang)` to find glslang CMake targets.\")
+
+ if (NOT TARGET glslang::OGLCompiler)
+ include(\"\${CMAKE_CURRENT_LIST_DIR}/../../${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}/glslang-targets.cmake\")
+ endif()
+
+ add_library(OGLCompiler ALIAS glslang::OGLCompiler)
+ ")
+ install(FILES "${CMAKE_CURRENT_BINARY_DIR}/OGLCompilerTargets.cmake" DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+
+endif()
diff --git a/README.md b/README.md
index 9b8cfb3..5e642e6 100644
--- a/README.md
+++ b/README.md
@@ -19,8 +19,8 @@
If people are only using this location to get spirv.hpp, I recommend they get that from [SPIRV-Headers](https://github.com/KhronosGroup/SPIRV-Headers) instead.
-[](https://travis-ci.org/KhronosGroup/glslang)
-[](https://ci.appveyor.com/project/Khronoswebmaster/glslang/branch/master)
+[](https://ci.appveyor.com/project/Khronoswebmaster/glslang/branch/master)
+
# Glslang Components and Status
@@ -85,7 +85,15 @@
* `.frag` for a fragment shader
* `.comp` for a compute shader
-There is also a non-shader extension
+For ray tracing pipeline shaders:
+* `.rgen` for a ray generation shader
+* `.rint` for a ray intersection shader
+* `.rahit` for a ray any-hit shader
+* `.rchit` for a ray closest-hit shader
+* `.rmiss` for a ray miss shader
+* `.rcall` for a callable shader
+
+There is also a non-shader extension:
* `.conf` for a configuration file of limits, see usage statement for example
## Building (CMake)
@@ -161,8 +169,8 @@
For building on Android:
```bash
-cmake $SOURCE_DIR -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DANDROID_ABI=arm64-v8a -DCMAKE_BUILD_TYPE=Release -DANDROID_STL=c++_static -DANDROID_PLATFORM=android-24 -DCMAKE_SYSTEM_NAME=Android -DANDROID_TOOLCHAIN=clang -DANDROID_ARM_MODE=arm -DCMAKE_MAKE_PROGRAM=$ANDROID_NDK_ROOT/prebuilt/linux-x86_64/bin/make -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_ROOT/build/cmake/android.toolchain.cmake
-# If on Windows will be -DCMAKE_MAKE_PROGRAM=%ANDROID_NDK_ROOT%\prebuilt\windows-x86_64\bin\make.exe
+cmake $SOURCE_DIR -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DANDROID_ABI=arm64-v8a -DCMAKE_BUILD_TYPE=Release -DANDROID_STL=c++_static -DANDROID_PLATFORM=android-24 -DCMAKE_SYSTEM_NAME=Android -DANDROID_TOOLCHAIN=clang -DANDROID_ARM_MODE=arm -DCMAKE_MAKE_PROGRAM=$ANDROID_NDK_HOME/prebuilt/linux-x86_64/bin/make -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_HOME/build/cmake/android.toolchain.cmake
+# If on Windows will be -DCMAKE_MAKE_PROGRAM=%ANDROID_NDK_HOME%\prebuilt\windows-x86_64\bin\make.exe
# -G is needed for building on Windows
# -DANDROID_ABI can also be armeabi-v7a for 32 bit
```
@@ -421,6 +429,77 @@
In practice, `ShCompile()` takes shader strings, default version, and
warning/error and other options for controlling compilation.
+### C Functional Interface (new)
+
+This interface is located `glslang_c_interface.h` and exposes functionality similar to the C++ interface. The following snippet is a complete example showing how to compile GLSL into SPIR-V 1.5 for Vulkan 1.2.
+
+```cxx
+std::vector<uint32_t> compileShaderToSPIRV_Vulkan(glslang_stage_t stage, const char* shaderSource, const char* fileName)
+{
+ const glslang_input_t input = {
+ .language = GLSLANG_SOURCE_GLSL,
+ .stage = stage,
+ .client = GLSLANG_CLIENT_VULKAN,
+ .client_version = GLSLANG_TARGET_VULKAN_1_2,
+ .target_language = GLSLANG_TARGET_SPV,
+ .target_language_version = GLSLANG_TARGET_SPV_1_5,
+ .code = shaderSource,
+ .default_version = 100,
+ .default_profile = GLSLANG_NO_PROFILE,
+ .force_default_version_and_profile = false,
+ .forward_compatible = false,
+ .messages = GLSLANG_MSG_DEFAULT_BIT,
+ .resource = reinterpret_cast<const glslang_resource_t*>(&glslang::DefaultTBuiltInResource),
+ };
+
+ glslang_shader_t* shader = glslang_shader_create(&input);
+
+ if (!glslang_shader_preprocess(shader, &input)) {
+ printf("GLSL preprocessing failed %s\n", fileName);
+ printf("%s\n", glslang_shader_get_info_log(shader));
+ printf("%s\n", glslang_shader_get_info_debug_log(shader));
+ printf("%s\n", input.code);
+ glslang_shader_delete(shader);
+ return std::vector<uint32_t>();
+ }
+
+ if (!glslang_shader_parse(shader, &input)) {
+ printf("GLSL parsing failed %s\n", fileName);
+ printf("%s\n", glslang_shader_get_info_log(shader));
+ printf("%s\n", glslang_shader_get_info_debug_log(shader));
+ printf("%s\n", glslang_shader_get_preprocessed_code(shader));
+ glslang_shader_delete(shader);
+ return std::vector<uint32_t>();
+ }
+
+ glslang_program_t* program = glslang_program_create();
+ glslang_program_add_shader(program, shader);
+
+ if (!glslang_program_link(program, GLSLANG_MSG_SPV_RULES_BIT | GLSLANG_MSG_VULKAN_RULES_BIT)) {
+ printf("GLSL linking failed %s\n", fileName);
+ printf("%s\n", glslang_program_get_info_log(program));
+ printf("%s\n", glslang_program_get_info_debug_log(program));
+ glslang_program_delete(program);
+ glslang_shader_delete(shader);
+ return std::vector<uint32_t>();
+ }
+
+ glslang_program_SPIRV_generate(program, stage);
+
+ std::vector<uint32_t> outShaderModule(glslang_program_SPIRV_get_size(program));
+ glslang_program_SPIRV_get(program, outShaderModule.data());
+
+ const char* spirv_messages = glslang_program_SPIRV_get_messages(program);
+ if (spirv_messages)
+ printf("(%s) %s\b", fileName, spirv_messages);
+
+ glslang_program_delete(program);
+ glslang_shader_delete(shader);
+
+ return outShaderModule;
+}
+```
+
## Basic Internal Operation
* Initial lexical analysis is done by the preprocessor in
diff --git a/SPIRV/CInterface/spirv_c_interface.cpp b/SPIRV/CInterface/spirv_c_interface.cpp
index a0790f4..d56ad46 100644
--- a/SPIRV/CInterface/spirv_c_interface.cpp
+++ b/SPIRV/CInterface/spirv_c_interface.cpp
@@ -36,6 +36,8 @@
#include "SPIRV/Logger.h"
#include "SPIRV/SpvTools.h"
+static_assert(sizeof(glslang_spv_options_t) == sizeof(glslang::SpvOptions), "");
+
typedef struct glslang_program_s {
glslang::TProgram* program;
std::vector<unsigned int> spirv;
@@ -57,22 +59,22 @@
return EShLangFragment;
case GLSLANG_STAGE_COMPUTE:
return EShLangCompute;
- case GLSLANG_STAGE_RAYGEN_NV:
+ case GLSLANG_STAGE_RAYGEN:
return EShLangRayGen;
- case GLSLANG_STAGE_INTERSECT_NV:
+ case GLSLANG_STAGE_INTERSECT:
return EShLangIntersect;
- case GLSLANG_STAGE_ANYHIT_NV:
+ case GLSLANG_STAGE_ANYHIT:
return EShLangAnyHit;
- case GLSLANG_STAGE_CLOSESTHIT_NV:
+ case GLSLANG_STAGE_CLOSESTHIT:
return EShLangClosestHit;
- case GLSLANG_STAGE_MISS_NV:
+ case GLSLANG_STAGE_MISS:
return EShLangMiss;
- case GLSLANG_STAGE_CALLABLE_NV:
+ case GLSLANG_STAGE_CALLABLE:
return EShLangCallable;
- case GLSLANG_STAGE_TASK_NV:
- return EShLangTaskNV;
- case GLSLANG_STAGE_MESH_NV:
- return EShLangMeshNV;
+ case GLSLANG_STAGE_TASK:
+ return EShLangTask;
+ case GLSLANG_STAGE_MESH:
+ return EShLangMesh;
default:
break;
}
@@ -81,13 +83,25 @@
GLSLANG_EXPORT void glslang_program_SPIRV_generate(glslang_program_t* program, glslang_stage_t stage)
{
+ glslang_spv_options_t spv_options;
+ spv_options.generate_debug_info = false;
+ spv_options.strip_debug_info = false;
+ spv_options.emit_nonsemantic_shader_debug_info = false;
+ spv_options.emit_nonsemantic_shader_debug_source = false;
+ spv_options.disable_optimizer = true;
+ spv_options.optimize_size = false;
+ spv_options.disassemble = false;
+ spv_options.validate = true;
+
+ glslang_program_SPIRV_generate_with_options(program, stage, &spv_options);
+}
+
+GLSLANG_EXPORT void glslang_program_SPIRV_generate_with_options(glslang_program_t* program, glslang_stage_t stage, glslang_spv_options_t* spv_options) {
spv::SpvBuildLogger logger;
- glslang::SpvOptions spvOptions;
- spvOptions.validate = true;
const glslang::TIntermediate* intermediate = program->program->getIntermediate(c_shader_stage(stage));
- glslang::GlslangToSpv(*intermediate, program->spirv, &logger, &spvOptions);
+ glslang::GlslangToSpv(*intermediate, program->spirv, &logger, reinterpret_cast<glslang::SpvOptions*>(spv_options));
program->loggerMessages = logger.getAllMessages();
}
diff --git a/SPIRV/CMakeLists.txt b/SPIRV/CMakeLists.txt
index 22f767d..2408e4c 100644
--- a/SPIRV/CMakeLists.txt
+++ b/SPIRV/CMakeLists.txt
@@ -62,7 +62,8 @@
disassemble.h
GLSL.ext.AMD.h
GLSL.ext.NV.h
- NonSemanticDebugPrintf.h)
+ NonSemanticDebugPrintf.h
+ NonSemanticShaderDebugInfo100.h)
set(SPVREMAP_HEADERS
SPVRemapper.h
@@ -109,30 +110,36 @@
endif()
if(ENABLE_GLSLANG_INSTALL)
- if(BUILD_SHARED_LIBS)
- if (ENABLE_SPVREMAPPER)
- install(TARGETS SPVRemapper EXPORT SPVRemapperTargets
- ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
- LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
- endif()
- install(TARGETS SPIRV EXPORT SPIRVTargets
- ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
- LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
- RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
- else()
- if (ENABLE_SPVREMAPPER)
- install(TARGETS SPVRemapper EXPORT SPVRemapperTargets
- ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
- endif()
- install(TARGETS SPIRV EXPORT SPIRVTargets
- ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
- endif()
-
if (ENABLE_SPVREMAPPER)
- install(EXPORT SPVRemapperTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+ install(TARGETS SPVRemapper EXPORT glslang-targets)
endif()
- install(EXPORT SPIRVTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+ install(TARGETS SPIRV EXPORT glslang-targets)
+
+ # Backward compatibility
+ if (ENABLE_SPVREMAPPER)
+ file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/SPVRemapperTargets.cmake" "
+ message(WARNING \"Using `SPVRemapperTargets.cmake` is deprecated: use `find_package(glslang)` to find glslang CMake targets.\")
+
+ if (NOT TARGET glslang::SPVRemapper)
+ include(\"\${CMAKE_CURRENT_LIST_DIR}/../../${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}/glslang-targets.cmake\")
+ endif()
+
+ add_library(SPVRemapper ALIAS glslang::SPVRemapper)
+ ")
+ install(FILES "${CMAKE_CURRENT_BINARY_DIR}/SPVRemapperTargets.cmake" DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+ endif()
+
+ file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/SPIRVTargets.cmake" "
+ message(WARNING \"Using `SPIRVTargets.cmake` is deprecated: use `find_package(glslang)` to find glslang CMake targets.\")
+
+ if (NOT TARGET glslang::SPIRV)
+ include(\"\${CMAKE_CURRENT_LIST_DIR}/../../${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}/glslang-targets.cmake\")
+ endif()
+
+ add_library(SPIRV ALIAS glslang::SPIRV)
+ ")
+ install(FILES "${CMAKE_CURRENT_BINARY_DIR}/SPIRVTargets.cmake" DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
install(FILES ${HEADERS} ${SPVREMAP_HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/glslang/SPIRV/)
endif()
diff --git a/SPIRV/GLSL.ext.EXT.h b/SPIRV/GLSL.ext.EXT.h
index f48f130..a247b4c 100644
--- a/SPIRV/GLSL.ext.EXT.h
+++ b/SPIRV/GLSL.ext.EXT.h
@@ -39,5 +39,6 @@
static const char* const E_SPV_EXT_shader_atomic_float16_add = "SPV_EXT_shader_atomic_float16_add";
static const char* const E_SPV_EXT_shader_atomic_float_min_max = "SPV_EXT_shader_atomic_float_min_max";
static const char* const E_SPV_EXT_shader_image_int64 = "SPV_EXT_shader_image_int64";
+static const char* const E_SPV_EXT_mesh_shader = "SPV_EXT_mesh_shader";
#endif // #ifndef GLSLextEXT_H
diff --git a/SPIRV/GLSL.ext.KHR.h b/SPIRV/GLSL.ext.KHR.h
index 5eb3e94..d5c670f 100644
--- a/SPIRV/GLSL.ext.KHR.h
+++ b/SPIRV/GLSL.ext.KHR.h
@@ -29,7 +29,7 @@
#define GLSLextKHR_H
static const int GLSLextKHRVersion = 100;
-static const int GLSLextKHRRevision = 2;
+static const int GLSLextKHRRevision = 3;
static const char* const E_SPV_KHR_shader_ballot = "SPV_KHR_shader_ballot";
static const char* const E_SPV_KHR_subgroup_vote = "SPV_KHR_subgroup_vote";
@@ -52,5 +52,7 @@
static const char* const E_SPV_KHR_terminate_invocation = "SPV_KHR_terminate_invocation";
static const char* const E_SPV_KHR_workgroup_memory_explicit_layout = "SPV_KHR_workgroup_memory_explicit_layout";
static const char* const E_SPV_KHR_subgroup_uniform_control_flow = "SPV_KHR_subgroup_uniform_control_flow";
+static const char* const E_SPV_KHR_fragment_shader_barycentric = "SPV_KHR_fragment_shader_barycentric";
+static const char* const E_SPV_AMD_shader_early_and_late_fragment_tests = "SPV_AMD_shader_early_and_late_fragment_tests";
#endif // #ifndef GLSLextKHR_H
diff --git a/SPIRV/GlslangToSpv.cpp b/SPIRV/GlslangToSpv.cpp
index 43aba9c..ccb4602 100644
--- a/SPIRV/GlslangToSpv.cpp
+++ b/SPIRV/GlslangToSpv.cpp
@@ -260,6 +260,7 @@
std::unordered_map<std::string, spv::Id> extBuiltinMap;
std::unordered_map<long long, spv::Id> symbolValues;
+ std::unordered_map<uint32_t, spv::Id> builtInVariableIds;
std::unordered_set<long long> rValueParameters; // set of formal function parameters passed as rValues,
// rather than a pointer
std::unordered_map<std::string, spv::Function*> functionMap;
@@ -279,6 +280,9 @@
// Used later for generating OpTraceKHR/OpExecuteCallableKHR
std::unordered_map<unsigned int, glslang::TIntermSymbol *> locationToSymbol[2];
+
+ // Used by Task shader while generating opearnds for OpEmitMeshTasksEXT
+ spv::Id taskPayloadID;
};
//
@@ -314,7 +318,7 @@
}
// Translate glslang language (stage) to SPIR-V execution model.
-spv::ExecutionModel TranslateExecutionModel(EShLanguage stage)
+spv::ExecutionModel TranslateExecutionModel(EShLanguage stage, bool isMeshShaderEXT = false)
{
switch (stage) {
case EShLangVertex: return spv::ExecutionModelVertex;
@@ -330,8 +334,8 @@
case EShLangClosestHit: return spv::ExecutionModelClosestHitKHR;
case EShLangMiss: return spv::ExecutionModelMissKHR;
case EShLangCallable: return spv::ExecutionModelCallableKHR;
- case EShLangTaskNV: return spv::ExecutionModelTaskNV;
- case EShLangMeshNV: return spv::ExecutionModelMeshNV;
+ case EShLangTask: return (isMeshShaderEXT)? spv::ExecutionModelTaskEXT : spv::ExecutionModelTaskNV;
+ case EShLangMesh: return (isMeshShaderEXT)? spv::ExecutionModelMeshEXT: spv::ExecutionModelMeshNV;
#endif
default:
assert(0);
@@ -762,7 +766,7 @@
return spv::BuiltInSampleMask;
case glslang::EbvLayer:
- if (glslangIntermediate->getStage() == EShLangMeshNV) {
+ if (glslangIntermediate->getStage() == EShLangMesh) {
return spv::BuiltInLayer;
}
if (glslangIntermediate->getStage() == EShLangGeometry ||
@@ -1007,6 +1011,8 @@
return spv::BuiltInRayTminKHR;
case glslang::EbvRayTmax:
return spv::BuiltInRayTmaxKHR;
+ case glslang::EbvCullMask:
+ return spv::BuiltInCullMaskKHR;
case glslang::EbvInstanceCustomIndex:
return spv::BuiltInInstanceCustomIndexKHR;
case glslang::EbvHitT:
@@ -1048,6 +1054,15 @@
builder.addCapability(spv::CapabilityFragmentBarycentricNV);
return spv::BuiltInBaryCoordNoPerspNV;
+ case glslang::EbvBaryCoordEXT:
+ builder.addExtension(spv::E_SPV_KHR_fragment_shader_barycentric);
+ builder.addCapability(spv::CapabilityFragmentBarycentricKHR);
+ return spv::BuiltInBaryCoordKHR;
+ case glslang::EbvBaryCoordNoPerspEXT:
+ builder.addExtension(spv::E_SPV_KHR_fragment_shader_barycentric);
+ builder.addCapability(spv::CapabilityFragmentBarycentricKHR);
+ return spv::BuiltInBaryCoordNoPerspKHR;
+
// mesh shaders
case glslang::EbvTaskCountNV:
return spv::BuiltInTaskCountNV;
@@ -1066,6 +1081,16 @@
case glslang::EbvMeshViewIndicesNV:
return spv::BuiltInMeshViewIndicesNV;
+ // SPV_EXT_mesh_shader
+ case glslang::EbvPrimitivePointIndicesEXT:
+ return spv::BuiltInPrimitivePointIndicesEXT;
+ case glslang::EbvPrimitiveLineIndicesEXT:
+ return spv::BuiltInPrimitiveLineIndicesEXT;
+ case glslang::EbvPrimitiveTriangleIndicesEXT:
+ return spv::BuiltInPrimitiveTriangleIndicesEXT;
+ case glslang::EbvCullPrimitiveEXT:
+ return spv::BuiltInCullPrimitiveEXT;
+
// sm builtins
case glslang::EbvWarpsPerSM:
builder.addExtension(spv::E_SPV_NV_shader_sm_builtins);
@@ -1256,8 +1281,10 @@
if (type.getBasicType() == glslang::EbtRayQuery)
return spv::StorageClassPrivate;
#ifndef GLSLANG_WEB
- if (type.getQualifier().isSpirvByReference())
- return spv::StorageClassFunction;
+ if (type.getQualifier().isSpirvByReference()) {
+ if (type.getQualifier().isParamInput() || type.getQualifier().isParamOutput())
+ return spv::StorageClassFunction;
+ }
#endif
if (type.getQualifier().isPipeInput())
return spv::StorageClassInput;
@@ -1307,6 +1334,7 @@
case glslang::EvqHitAttr: return spv::StorageClassHitAttributeKHR;
case glslang::EvqCallableData: return spv::StorageClassCallableDataKHR;
case glslang::EvqCallableDataIn: return spv::StorageClassIncomingCallableDataKHR;
+ case glslang::EvqtaskPayloadSharedEXT : return spv::StorageClassTaskPayloadWorkgroupEXT;
case glslang::EvqSpirvStorageClass: return static_cast<spv::StorageClass>(type.getQualifier().spirvStorageClass);
#endif
default:
@@ -1324,7 +1352,9 @@
for (auto constant : constants) {
if (constant->getBasicType() == glslang::EbtFloat) {
float floatValue = static_cast<float>(constant->getConstArray()[0].getDConst());
- unsigned literal = *reinterpret_cast<unsigned*>(&floatValue);
+ unsigned literal;
+ static_assert(sizeof(literal) == sizeof(floatValue), "sizeof(unsigned) != sizeof(float)");
+ memcpy(&literal, &floatValue, sizeof(literal));
literals.push_back(literal);
} else if (constant->getBasicType() == glslang::EbtInt) {
unsigned literal = constant->getConstArray()[0].getIConst();
@@ -1450,6 +1480,8 @@
child.perViewNV = true;
if (parent.perTaskNV)
child.perTaskNV = true;
+ if (parent.storage == glslang::EvqtaskPayloadSharedEXT)
+ child.storage = glslang::EvqtaskPayloadSharedEXT;
if (parent.patch)
child.patch = true;
if (parent.sample)
@@ -1509,9 +1541,12 @@
inEntryPoint(false), entryPointTerminated(false), linkageOnly(false),
glslangIntermediate(glslangIntermediate),
nanMinMaxClamp(glslangIntermediate->getNanMinMaxClamp()),
- nonSemanticDebugPrintf(0)
+ nonSemanticDebugPrintf(0),
+ taskPayloadID(0)
{
- spv::ExecutionModel executionModel = TranslateExecutionModel(glslangIntermediate->getStage());
+ bool isMeshShaderExt = (glslangIntermediate->getRequestedExtensions().find(glslang::E_GL_EXT_mesh_shader) !=
+ glslangIntermediate->getRequestedExtensions().end());
+ spv::ExecutionModel executionModel = TranslateExecutionModel(glslangIntermediate->getStage(), isMeshShaderExt);
builder.clearAccessChain();
builder.setSource(TranslateSourceLanguage(glslangIntermediate->getSource(), glslangIntermediate->getProfile()),
@@ -1543,6 +1578,10 @@
for (auto iItr = include_txt.begin(); iItr != include_txt.end(); ++iItr)
builder.addInclude(iItr->first, iItr->second);
}
+
+ builder.setEmitNonSemanticShaderDebugInfo(options.emitNonSemanticShaderDebugInfo);
+ builder.setEmitNonSemanticShaderDebugSource(options.emitNonSemanticShaderDebugSource);
+
stdBuiltins = builder.import("GLSL.std.450");
spv::AddressingModel addressingModel = spv::AddressingModelLogical;
@@ -1609,6 +1648,12 @@
if (glslangIntermediate->getEarlyFragmentTests())
builder.addExecutionMode(shaderEntry, spv::ExecutionModeEarlyFragmentTests);
+ if (glslangIntermediate->getEarlyAndLateFragmentTestsAMD())
+ {
+ builder.addExecutionMode(shaderEntry, spv::ExecutionModeEarlyAndLateFragmentTestsAMD);
+ builder.addExtension(spv::E_SPV_AMD_shader_early_and_late_fragment_tests);
+ }
+
if (glslangIntermediate->getPostDepthCoverage()) {
builder.addCapability(spv::CapabilitySampleMaskPostDepthCoverage);
builder.addExecutionMode(shaderEntry, spv::ExecutionModePostDepthCoverage);
@@ -1618,6 +1663,9 @@
if (glslangIntermediate->isDepthReplacing())
builder.addExecutionMode(shaderEntry, spv::ExecutionModeDepthReplacing);
+ if (glslangIntermediate->isStencilReplacing())
+ builder.addExecutionMode(shaderEntry, spv::ExecutionModeStencilRefReplacingEXT);
+
#ifndef GLSLANG_WEB
switch(glslangIntermediate->getDepth()) {
@@ -1626,6 +1674,20 @@
case glslang::EldUnchanged: mode = spv::ExecutionModeDepthUnchanged; break;
default: mode = spv::ExecutionModeMax; break;
}
+
+ if (mode != spv::ExecutionModeMax)
+ builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
+
+ switch (glslangIntermediate->getStencil()) {
+ case glslang::ElsRefUnchangedFrontAMD: mode = spv::ExecutionModeStencilRefUnchangedFrontAMD; break;
+ case glslang::ElsRefGreaterFrontAMD: mode = spv::ExecutionModeStencilRefGreaterFrontAMD; break;
+ case glslang::ElsRefLessFrontAMD: mode = spv::ExecutionModeStencilRefLessFrontAMD; break;
+ case glslang::ElsRefUnchangedBackAMD: mode = spv::ExecutionModeStencilRefUnchangedBackAMD; break;
+ case glslang::ElsRefGreaterBackAMD: mode = spv::ExecutionModeStencilRefGreaterBackAMD; break;
+ case glslang::ElsRefLessBackAMD: mode = spv::ExecutionModeStencilRefLessBackAMD; break;
+ default: mode = spv::ExecutionModeMax; break;
+ }
+
if (mode != spv::ExecutionModeMax)
builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
switch (glslangIntermediate->getInterlockOrdering()) {
@@ -1662,9 +1724,22 @@
case EShLangCompute:
builder.addCapability(spv::CapabilityShader);
- builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
- glslangIntermediate->getLocalSize(1),
- glslangIntermediate->getLocalSize(2));
+ if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
+ std::vector<spv::Id> dimConstId;
+ for (int dim = 0; dim < 3; ++dim) {
+ bool specConst = (glslangIntermediate->getLocalSizeSpecId(dim) != glslang::TQualifier::layoutNotSet);
+ dimConstId.push_back(builder.makeUintConstant(glslangIntermediate->getLocalSize(dim), specConst));
+ if (specConst) {
+ builder.addDecoration(dimConstId.back(), spv::DecorationSpecId,
+ glslangIntermediate->getLocalSizeSpecId(dim));
+ }
+ }
+ builder.addExecutionModeId(shaderEntry, spv::ExecutionModeLocalSizeId, dimConstId);
+ } else {
+ builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
+ glslangIntermediate->getLocalSize(1),
+ glslangIntermediate->getLocalSize(2));
+ }
if (glslangIntermediate->getLayoutDerivativeModeNone() == glslang::LayoutDerivativeGroupQuads) {
builder.addCapability(spv::CapabilityComputeDerivativeGroupQuadsNV);
builder.addExecutionMode(shaderEntry, spv::ExecutionModeDerivativeGroupQuadsNV);
@@ -1751,7 +1826,7 @@
case EShLangAnyHit:
case EShLangClosestHit:
case EShLangMiss:
- case EShLangCallable:
+ case EShLangCallable:
{
auto& extensions = glslangIntermediate->getRequestedExtensions();
if (extensions.find("GL_NV_ray_tracing") == extensions.end()) {
@@ -1762,16 +1837,41 @@
builder.addCapability(spv::CapabilityRayTracingNV);
builder.addExtension("SPV_NV_ray_tracing");
}
+ if (glslangIntermediate->getStage() != EShLangRayGen && glslangIntermediate->getStage() != EShLangCallable)
+ {
+ if (extensions.find("GL_EXT_ray_cull_mask") != extensions.end()) {
+ builder.addCapability(spv::CapabilityRayCullMaskKHR);
+ builder.addExtension("SPV_KHR_ray_cull_mask");
+ }
+ }
break;
}
- case EShLangTaskNV:
- case EShLangMeshNV:
- builder.addCapability(spv::CapabilityMeshShadingNV);
- builder.addExtension(spv::E_SPV_NV_mesh_shader);
- builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
- glslangIntermediate->getLocalSize(1),
- glslangIntermediate->getLocalSize(2));
- if (glslangIntermediate->getStage() == EShLangMeshNV) {
+ case EShLangTask:
+ case EShLangMesh:
+ if(isMeshShaderExt) {
+ builder.addCapability(spv::CapabilityMeshShadingEXT);
+ builder.addExtension(spv::E_SPV_EXT_mesh_shader);
+ } else {
+ builder.addCapability(spv::CapabilityMeshShadingNV);
+ builder.addExtension(spv::E_SPV_NV_mesh_shader);
+ }
+ if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
+ std::vector<spv::Id> dimConstId;
+ for (int dim = 0; dim < 3; ++dim) {
+ bool specConst = (glslangIntermediate->getLocalSizeSpecId(dim) != glslang::TQualifier::layoutNotSet);
+ dimConstId.push_back(builder.makeUintConstant(glslangIntermediate->getLocalSize(dim), specConst));
+ if (specConst) {
+ builder.addDecoration(dimConstId.back(), spv::DecorationSpecId,
+ glslangIntermediate->getLocalSizeSpecId(dim));
+ }
+ }
+ builder.addExecutionModeId(shaderEntry, spv::ExecutionModeLocalSizeId, dimConstId);
+ } else {
+ builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
+ glslangIntermediate->getLocalSize(1),
+ glslangIntermediate->getLocalSize(2));
+ }
+ if (glslangIntermediate->getStage() == EShLangMesh) {
builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputVertices,
glslangIntermediate->getVertices());
builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputPrimitivesNV,
@@ -1890,7 +1990,6 @@
if (symbol->getType().getQualifier().isSpecConstant())
spec_constant_op_mode_setter.turnOnSpecConstantOpMode();
-
#ifdef ENABLE_HLSL
// Skip symbol handling if it is string-typed
if (symbol->getBasicType() == glslang::EbtString)
@@ -1901,6 +2000,9 @@
// Formal function parameters were mapped during makeFunctions().
spv::Id id = getSymbolId(symbol);
+ if (symbol->getType().getQualifier().isTaskPayload())
+ taskPayloadID = id; // cache the taskPayloadID to be used it as operand for OpEmitMeshTasksEXT
+
if (builder.isPointer(id)) {
if (!symbol->getType().getQualifier().isParamInput() &&
!symbol->getType().getQualifier().isParamOutput()) {
@@ -2428,6 +2530,14 @@
return false;
}
+ // Force variable declaration - Debug Mode Only
+ if (node->getOp() == glslang::EOpDeclare) {
+ builder.clearAccessChain();
+ node->getOperand()->traverse(this);
+ builder.clearAccessChain();
+ return false;
+ }
+
// Start by evaluating the operand
// Does it need a swizzle inversion? If so, evaluation is inverted;
@@ -2444,7 +2554,7 @@
operandNode = node->getOperand()->getAsBinaryNode()->getLeft();
else
operandNode = node->getOperand();
-
+
operandNode->traverse(this);
spv::Id operand = spv::NoResult;
@@ -2688,32 +2798,38 @@
spv::Decoration precision = TranslatePrecisionDecoration(node->getOperationPrecision());
switch (node->getOp()) {
+ case glslang::EOpScope:
case glslang::EOpSequence:
{
- if (preVisit)
+ if (visit == glslang::EvPreVisit) {
++sequenceDepth;
- else
+ if (sequenceDepth == 1) {
+ // If this is the parent node of all the functions, we want to see them
+ // early, so all call points have actual SPIR-V functions to reference.
+ // In all cases, still let the traverser visit the children for us.
+ makeFunctions(node->getAsAggregate()->getSequence());
+
+ // Also, we want all globals initializers to go into the beginning of the entry point, before
+ // anything else gets there, so visit out of order, doing them all now.
+ makeGlobalInitializers(node->getAsAggregate()->getSequence());
+
+ //Pre process linker objects for ray tracing stages
+ if (glslangIntermediate->isRayTracingStage())
+ collectRayTracingLinkerObjects();
+
+ // Initializers are done, don't want to visit again, but functions and link objects need to be processed,
+ // so do them manually.
+ visitFunctions(node->getAsAggregate()->getSequence());
+
+ return false;
+ } else {
+ if (node->getOp() == glslang::EOpScope)
+ builder.enterScope(0);
+ }
+ } else {
+ if (sequenceDepth > 1 && node->getOp() == glslang::EOpScope)
+ builder.leaveScope();
--sequenceDepth;
-
- if (sequenceDepth == 1) {
- // If this is the parent node of all the functions, we want to see them
- // early, so all call points have actual SPIR-V functions to reference.
- // In all cases, still let the traverser visit the children for us.
- makeFunctions(node->getAsAggregate()->getSequence());
-
- // Also, we want all globals initializers to go into the beginning of the entry point, before
- // anything else gets there, so visit out of order, doing them all now.
- makeGlobalInitializers(node->getAsAggregate()->getSequence());
-
- //Pre process linker objects for ray tracing stages
- if (glslangIntermediate->isRayTracingStage())
- collectRayTracingLinkerObjects();
-
- // Initializers are done, don't want to visit again, but functions and link objects need to be processed,
- // so do them manually.
- visitFunctions(node->getAsAggregate()->getSequence());
-
- return false;
}
return true;
@@ -2742,10 +2858,17 @@
if (isShaderEntryPoint(node)) {
inEntryPoint = true;
builder.setBuildPoint(shaderEntry->getLastBlock());
+ builder.enterFunction(shaderEntry);
currentFunction = shaderEntry;
} else {
handleFunctionEntry(node);
}
+ if (options.generateDebugInfo) {
+ const auto& loc = node->getLoc();
+ const char* sourceFileName = loc.getFilename();
+ spv::Id sourceFileId = sourceFileName ? builder.getStringId(sourceFileName) : builder.getSourceFile();
+ currentFunction->setDebugLineInfo(sourceFileId, loc.line, loc.column);
+ }
} else {
if (inEntryPoint)
entryPointTerminated = true;
@@ -2885,9 +3008,17 @@
std::vector<spv::Id> arguments;
translateArguments(*node, arguments, lvalueCoherentFlags);
spv::Id constructed;
- if (node->getOp() == glslang::EOpConstructTextureSampler)
- constructed = builder.createOp(spv::OpSampledImage, resultType(), arguments);
- else if (node->getOp() == glslang::EOpConstructStruct ||
+ if (node->getOp() == glslang::EOpConstructTextureSampler) {
+ const glslang::TType& texType = node->getSequence()[0]->getAsTyped()->getType();
+ if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6 &&
+ texType.getSampler().isBuffer()) {
+ // SamplerBuffer is not supported in spirv1.6 so
+ // `samplerBuffer(textureBuffer, sampler)` is a no-op
+ // and textureBuffer is the result going forward
+ constructed = arguments[0];
+ } else
+ constructed = builder.createOp(spv::OpSampledImage, resultType(), arguments);
+ } else if (node->getOp() == glslang::EOpConstructStruct ||
node->getOp() == glslang::EOpConstructCooperativeMatrix ||
node->getType().isArray()) {
std::vector<spv::Id> constituents;
@@ -3027,6 +3158,8 @@
case glslang::EOpExecuteCallableNV:
case glslang::EOpExecuteCallableKHR:
case glslang::EOpWritePackedPrimitiveIndices4x8NV:
+ case glslang::EOpEmitMeshTasksEXT:
+ case glslang::EOpSetMeshOutputsEXT:
noReturnValue = true;
break;
case glslang::EOpRayQueryInitialize:
@@ -3421,7 +3554,7 @@
break;
case 1:
{
- OpDecorations decorations = { precision,
+ OpDecorations decorations = { precision,
TranslateNoContractionDecoration(node->getType().getQualifier()),
TranslateNonUniformDecoration(node->getType().getQualifier()) };
result = createUnaryOperation(
@@ -3543,7 +3676,7 @@
// smear condition to vector, if necessary (AST is always scalar)
// Before 1.4, smear like for mix(), starting with 1.4, keep it scalar
if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_4 && builder.isVector(trueValue)) {
- condition = builder.smearScalar(spv::NoPrecision, condition,
+ condition = builder.smearScalar(spv::NoPrecision, condition,
builder.makeVectorType(builder.makeBoolType(),
builder.getNumComponents(trueValue)));
}
@@ -3714,8 +3847,8 @@
// by a block-ending branch. But we don't want to put any other body/test
// instructions in it, since the body/test may have arbitrary instructions,
// including merges of its own.
- builder.setLine(node->getLoc().line, node->getLoc().getFilename());
builder.setBuildPoint(&blocks.head);
+ builder.setLine(node->getLoc().line, node->getLoc().getFilename());
builder.createLoopMerge(&blocks.merge, &blocks.continue_target, control, operands);
if (node->testFirst() && node->getTest()) {
spv::Block& test = builder.makeNewBlock();
@@ -3777,7 +3910,16 @@
switch (node->getFlowOp()) {
case glslang::EOpKill:
- builder.makeStatementTerminator(spv::OpKill, "post-discard");
+ if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
+ if (glslangIntermediate->getSource() == glslang::EShSourceHlsl) {
+ builder.addCapability(spv::CapabilityDemoteToHelperInvocation);
+ builder.createNoResultOp(spv::OpDemoteToHelperInvocationEXT);
+ } else {
+ builder.makeStatementTerminator(spv::OpTerminateInvocation, "post-terminate-invocation");
+ }
+ } else {
+ builder.makeStatementTerminator(spv::OpKill, "post-discard");
+ }
break;
case glslang::EOpTerminateInvocation:
builder.addExtension(spv::E_SPV_KHR_terminate_invocation);
@@ -3925,7 +4067,7 @@
initializer = builder.makeNullConstant(spvType);
}
- return builder.createVariable(spv::NoPrecision, storageClass, spvType, name, initializer);
+ return builder.createVariable(spv::NoPrecision, storageClass, spvType, name, initializer, false);
}
// Return type Id of the sampled type.
@@ -4013,7 +4155,7 @@
if (explicitLayout != glslang::ElpNone)
spvType = builder.makeUintType(32);
else
- spvType = builder.makeBoolType();
+ spvType = builder.makeBoolType(false);
break;
case glslang::EbtInt:
spvType = builder.makeIntType(32);
@@ -4113,8 +4255,10 @@
spvType = builder.makeImageType(getSampledType(sampler), TranslateDimensionality(sampler),
sampler.isShadow(), sampler.isArrayed(), sampler.isMultiSample(),
sampler.isImageClass() ? 2 : 1, TranslateImageFormat(type));
- if (sampler.isCombined()) {
- // already has both image and sampler, make the combined type
+ if (sampler.isCombined() &&
+ (!sampler.isBuffer() || glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_6)) {
+ // Already has both image and sampler, make the combined type. Only combine sampler to
+ // buffer if before SPIR-V 1.6.
spvType = builder.makeSampledImageType(spvType);
}
}
@@ -4148,23 +4292,25 @@
const auto& spirvType = type.getSpirvType();
const auto& spirvInst = spirvType.spirvInst;
- std::vector<spv::Id> operands;
+ std::vector<spv::IdImmediate> operands;
for (const auto& typeParam : spirvType.typeParams) {
// Constant expression
if (typeParam.constant->isLiteral()) {
if (typeParam.constant->getBasicType() == glslang::EbtFloat) {
float floatValue = static_cast<float>(typeParam.constant->getConstArray()[0].getDConst());
- unsigned literal = *reinterpret_cast<unsigned*>(&floatValue);
- operands.push_back(literal);
+ unsigned literal;
+ static_assert(sizeof(literal) == sizeof(floatValue), "sizeof(unsigned) != sizeof(float)");
+ memcpy(&literal, &floatValue, sizeof(literal));
+ operands.push_back({false, literal});
} else if (typeParam.constant->getBasicType() == glslang::EbtInt) {
unsigned literal = typeParam.constant->getConstArray()[0].getIConst();
- operands.push_back(literal);
+ operands.push_back({false, literal});
} else if (typeParam.constant->getBasicType() == glslang::EbtUint) {
unsigned literal = typeParam.constant->getConstArray()[0].getUConst();
- operands.push_back(literal);
+ operands.push_back({false, literal});
} else if (typeParam.constant->getBasicType() == glslang::EbtBool) {
unsigned literal = typeParam.constant->getConstArray()[0].getBConst();
- operands.push_back(literal);
+ operands.push_back({false, literal});
} else if (typeParam.constant->getBasicType() == glslang::EbtString) {
auto str = typeParam.constant->getConstArray()[0].getSConst()->c_str();
unsigned literal = 0;
@@ -4176,7 +4322,7 @@
*(literalPtr++) = ch;
++charCount;
if (charCount == 4) {
- operands.push_back(literal);
+ operands.push_back({false, literal});
literalPtr = reinterpret_cast<char*>(&literal);
charCount = 0;
}
@@ -4186,20 +4332,17 @@
if (charCount > 0) {
for (; charCount < 4; ++charCount)
*(literalPtr++) = 0;
- operands.push_back(literal);
+ operands.push_back({false, literal});
}
} else
assert(0); // Unexpected type
} else
- operands.push_back(createSpvConstant(*typeParam.constant));
+ operands.push_back({true, createSpvConstant(*typeParam.constant)});
}
- if (spirvInst.set == "")
- spvType = builder.createOp(static_cast<spv::Op>(spirvInst.id), spv::NoType, operands);
- else {
- spvType = builder.createBuiltinCall(
- spv::NoType, getExtBuiltins(spirvInst.set.c_str()), spirvInst.id, operands);
- }
+ assert(spirvInst.set == ""); // Currently, couldn't be extended instructions.
+ spvType = builder.makeGenericType(static_cast<spv::Op>(spirvInst.id), operands);
+
break;
}
#endif
@@ -4302,7 +4445,7 @@
extensions.find("GL_NV_stereo_view_rendering") == extensions.end())
return true;
- if (glslangIntermediate->getStage() != EShLangMeshNV) {
+ if (glslangIntermediate->getStage() != EShLangMesh) {
if (member.getFieldName() == "gl_ViewportMask" &&
extensions.find("GL_NV_viewport_array2") == extensions.end())
return true;
@@ -4332,14 +4475,14 @@
// except sometimes for blocks
std::vector<std::pair<glslang::TType*, glslang::TQualifier> > deferredForwardPointers;
for (int i = 0; i < (int)glslangMembers->size(); i++) {
- glslang::TType& glslangMember = *(*glslangMembers)[i].type;
- if (glslangMember.hiddenMember()) {
+ auto& glslangMember = (*glslangMembers)[i];
+ if (glslangMember.type->hiddenMember()) {
++memberDelta;
if (type.getBasicType() == glslang::EbtBlock)
memberRemapper[glslangTypeToIdMap[glslangMembers]][i] = -1;
} else {
if (type.getBasicType() == glslang::EbtBlock) {
- if (filterMember(glslangMember)) {
+ if (filterMember(*glslangMember.type)) {
memberDelta++;
memberRemapper[glslangTypeToIdMap[glslangMembers]][i] = -1;
continue;
@@ -4347,7 +4490,7 @@
memberRemapper[glslangTypeToIdMap[glslangMembers]][i] = i - memberDelta;
}
// modify just this child's view of the qualifier
- glslang::TQualifier memberQualifier = glslangMember.getQualifier();
+ glslang::TQualifier memberQualifier = glslangMember.type->getQualifier();
InheritQualifiers(memberQualifier, qualifier);
// manually inherit location
@@ -4358,25 +4501,38 @@
bool lastBufferBlockMember = qualifier.storage == glslang::EvqBuffer &&
i == (int)glslangMembers->size() - 1;
- // Make forward pointers for any pointer members, and create a list of members to
- // convert to spirv types after creating the struct.
- if (glslangMember.isReference()) {
- if (forwardPointers.find(glslangMember.getReferentType()) == forwardPointers.end()) {
- deferredForwardPointers.push_back(std::make_pair(&glslangMember, memberQualifier));
- }
- spvMembers.push_back(
- convertGlslangToSpvType(glslangMember, explicitLayout, memberQualifier, lastBufferBlockMember,
- true));
- } else {
- spvMembers.push_back(
- convertGlslangToSpvType(glslangMember, explicitLayout, memberQualifier, lastBufferBlockMember,
- false));
+ // Make forward pointers for any pointer members.
+ if (glslangMember.type->isReference() &&
+ forwardPointers.find(glslangMember.type->getReferentType()) == forwardPointers.end()) {
+ deferredForwardPointers.push_back(std::make_pair(glslangMember.type, memberQualifier));
+ }
+
+ // Create the member type.
+ auto const spvMember = convertGlslangToSpvType(*glslangMember.type, explicitLayout, memberQualifier, lastBufferBlockMember,
+ glslangMember.type->isReference());
+ spvMembers.push_back(spvMember);
+
+ // Update the builder with the type's location so that we can create debug types for the structure members.
+ // There doesn't exist a "clean" entry point for this information to be passed along to the builder so, for now,
+ // it is stored in the builder and consumed during the construction of composite debug types.
+ // TODO: This probably warrants further investigation. This approach was decided to be the least ugly of the
+ // quick and dirty approaches that were tried.
+ // Advantages of this approach:
+ // + Relatively clean. No direct calls into debug type system.
+ // + Handles nested recursive structures.
+ // Disadvantages of this approach:
+ // + Not as clean as desired. Traverser queries/sets persistent state. This is fragile.
+ // + Table lookup during creation of composite debug types. This really shouldn't be necessary.
+ if(options.emitNonSemanticShaderDebugInfo) {
+ builder.debugTypeLocs[spvMember].name = glslangMember.type->getFieldName().c_str();
+ builder.debugTypeLocs[spvMember].line = glslangMember.loc.line;
+ builder.debugTypeLocs[spvMember].column = glslangMember.loc.column;
}
}
}
// Make the SPIR-V type
- spv::Id spvType = builder.makeStructType(spvMembers, type.getTypeName().c_str());
+ spv::Id spvType = builder.makeStructType(spvMembers, type.getTypeName().c_str(), false);
if (! HasNonLayoutQualifiers(type, qualifier))
structMap[explicitLayout][qualifier.layoutMatrix][glslangMembers] = spvType;
@@ -4970,6 +5126,7 @@
// GLSL has copy-in/copy-out semantics. They can be handled though with a pointer to a copy.
std::vector<spv::Id> paramTypes;
+ std::vector<char const*> paramNames;
std::vector<std::vector<spv::Decoration>> paramDecorations; // list of decorations per parameter
glslang::TIntermSequence& parameters = glslFunction->getSequence()[0]->getAsAggregate()->getSequence();
@@ -4994,10 +5151,14 @@
paramTypes.push_back(typeId);
}
+ for (auto const parameter:parameters) {
+ paramNames.push_back(parameter->getAsSymbolNode()->getName().c_str());
+ }
+
spv::Block* functionBlock;
spv::Function *function = builder.makeFunctionEntry(TranslatePrecisionDecoration(glslFunction->getType()),
convertGlslangToSpvType(glslFunction->getType()),
- glslFunction->getName().c_str(), paramTypes,
+ glslFunction->getName().c_str(), paramTypes, paramNames,
paramDecorations, &functionBlock);
if (implicitThis)
function->setImplicitThis();
@@ -5087,6 +5248,7 @@
currentFunction = functionMap[node->getName().c_str()];
spv::Block* functionBlock = currentFunction->getEntryBlock();
builder.setBuildPoint(functionBlock);
+ builder.enterFunction(currentFunction);
}
void TGlslangToSpvTraverser::translateArguments(const glslang::TIntermAggregate& node, std::vector<spv::Id>& arguments,
@@ -5514,10 +5676,12 @@
operands.push_back(sample);
spv::Id resultTypeId;
+ glslang::TBasicType typeProxy = node->getBasicType();
// imageAtomicStore has a void return type so base the pointer type on
// the type of the value operand.
if (node->getOp() == glslang::EOpImageAtomicStore) {
resultTypeId = builder.makePointer(spv::StorageClassImage, builder.getTypeId(*opIt));
+ typeProxy = node->getAsAggregate()->getSequence()[0]->getAsTyped()->getType().getSampler().type;
} else {
resultTypeId = builder.makePointer(spv::StorageClassImage, resultType());
}
@@ -5531,7 +5695,7 @@
for (; opIt != arguments.end(); ++opIt)
operands.push_back(*opIt);
- return createAtomicOperation(node->getOp(), precision, resultType(), operands, node->getBasicType(),
+ return createAtomicOperation(node->getOp(), precision, resultType(), operands, typeProxy,
lvalueCoherentFlags);
}
}
@@ -5735,10 +5899,10 @@
assert(builder.isStructType(resultStructType));
//resType (SPIR-V type) contains 6 elements:
- //Member 0 must be a Boolean type scalar(LOD),
- //Member 1 must be a vector of integer type, whose Signedness operand is 0(anchor),
- //Member 2 must be a vector of integer type, whose Signedness operand is 0(offset),
- //Member 3 must be a vector of integer type, whose Signedness operand is 0(mask),
+ //Member 0 must be a Boolean type scalar(LOD),
+ //Member 1 must be a vector of integer type, whose Signedness operand is 0(anchor),
+ //Member 2 must be a vector of integer type, whose Signedness operand is 0(offset),
+ //Member 3 must be a vector of integer type, whose Signedness operand is 0(mask),
//Member 4 must be a scalar of integer type, whose Signedness operand is 0(lod),
//Member 5 must be a scalar of integer type, whose Signedness operand is 0(granularity).
std::vector<spv::Id> members;
@@ -5751,7 +5915,7 @@
//call ImageFootprintNV
spv::Id res = builder.createTextureCall(precision, resType, sparse, cracked.fetch, cracked.proj,
cracked.gather, noImplicitLod, params, signExtensionMask());
-
+
//copy resType (SPIR-V type) to resultStructType(OpenGL type)
for (int i = 0; i < 5; i++) {
builder.clearAccessChain();
@@ -5804,7 +5968,7 @@
}
#endif
- std::vector<spv::Id> result( 1,
+ std::vector<spv::Id> result( 1,
builder.createTextureCall(precision, resultType(), sparse, cracked.fetch, cracked.proj, cracked.gather,
noImplicitLod, params, signExtensionMask())
);
@@ -7327,7 +7491,7 @@
} else {
scopeId = builder.makeUintConstant(spv::ScopeDevice);
}
- // semantics default to relaxed
+ // semantics default to relaxed
spv::Id semanticsId = builder.makeUintConstant(lvalueCoherentFlags.isVolatile() &&
glslangIntermediate->usingVulkanMemoryModel() ?
spv::MemorySemanticsVolatileMask :
@@ -8431,6 +8595,15 @@
case glslang::EOpWritePackedPrimitiveIndices4x8NV:
builder.createNoResultOp(spv::OpWritePackedPrimitiveIndices4x8NV, operands);
return 0;
+ case glslang::EOpEmitMeshTasksEXT:
+ if (taskPayloadID)
+ operands.push_back(taskPayloadID);
+ // As per SPV_EXT_mesh_shader make it a terminating instruction in the current block
+ builder.makeStatementTerminator(spv::OpEmitMeshTasksEXT, operands, "post-OpEmitMeshTasksEXT");
+ return 0;
+ case glslang::EOpSetMeshOutputsEXT:
+ builder.createNoResultOp(spv::OpSetMeshOutputsEXT, operands);
+ return 0;
case glslang::EOpCooperativeMatrixMulAdd:
opCode = spv::OpCooperativeMatrixMulAddNV;
break;
@@ -8694,7 +8867,32 @@
// it was not found, create it
spv::BuiltIn builtIn = TranslateBuiltInDecoration(symbol->getQualifier().builtIn, false);
auto forcedType = getForcedType(symbol->getQualifier().builtIn, symbol->getType());
+
+ // There are pairs of symbols that map to the same SPIR-V built-in:
+ // gl_ObjectToWorldEXT and gl_ObjectToWorld3x4EXT, and gl_WorldToObjectEXT
+ // and gl_WorldToObject3x4EXT. SPIR-V forbids having two OpVariables
+ // with the same BuiltIn in the same storage class, so we must re-use one.
+ const bool mayNeedToReuseBuiltIn =
+ builtIn == spv::BuiltInObjectToWorldKHR ||
+ builtIn == spv::BuiltInWorldToObjectKHR;
+
+ if (mayNeedToReuseBuiltIn) {
+ auto iter = builtInVariableIds.find(uint32_t(builtIn));
+ if (builtInVariableIds.end() != iter) {
+ id = iter->second;
+ symbolValues[symbol->getId()] = id;
+ if (forcedType.second != spv::NoType)
+ forceType[id] = forcedType.second;
+ return id;
+ }
+ }
+
id = createSpvVariable(symbol, forcedType.first);
+
+ if (mayNeedToReuseBuiltIn) {
+ builtInVariableIds.insert({uint32_t(builtIn), id});
+ }
+
symbolValues[symbol->getId()] = id;
if (forcedType.second != spv::NoType)
forceType[id] = forcedType.second;
@@ -8717,8 +8915,18 @@
builder.addDecoration(id, spv::DecorationOffset, symbol->getQualifier().layoutOffset);
}
- if (symbol->getQualifier().hasLocation())
- builder.addDecoration(id, spv::DecorationLocation, symbol->getQualifier().layoutLocation);
+ if (symbol->getQualifier().hasLocation()) {
+ if (!(glslangIntermediate->isRayTracingStage() && glslangIntermediate->IsRequestedExtension(glslang::E_GL_EXT_ray_tracing)
+ && (builder.getStorageClass(id) == spv::StorageClassRayPayloadKHR ||
+ builder.getStorageClass(id) == spv::StorageClassIncomingRayPayloadKHR ||
+ builder.getStorageClass(id) == spv::StorageClassCallableDataKHR ||
+ builder.getStorageClass(id) == spv::StorageClassIncomingCallableDataKHR))) {
+ // Location values are used to link TraceRayKHR and ExecuteCallableKHR to corresponding variables
+ // but are not valid in SPIRV since they are supported only for Input/Output Storage classes.
+ builder.addDecoration(id, spv::DecorationLocation, symbol->getQualifier().layoutLocation);
+ }
+ }
+
builder.addDecoration(id, TranslateInvariantDecoration(symbol->getType().getQualifier()));
if (symbol->getQualifier().hasStream() && glslangIntermediate->isMultiStream()) {
builder.addCapability(spv::CapabilityGeometryStreams);
@@ -8752,7 +8960,16 @@
// add built-in variable decoration
if (builtIn != spv::BuiltInMax) {
- builder.addDecoration(id, spv::DecorationBuiltIn, (int)builtIn);
+ // WorkgroupSize deprecated in spirv1.6
+ if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_6 ||
+ builtIn != spv::BuiltInWorkgroupSize)
+ builder.addDecoration(id, spv::DecorationBuiltIn, (int)builtIn);
+ }
+
+ // Add volatile decoration to HelperInvocation for spirv1.6 and beyond
+ if (builtIn == spv::BuiltInHelperInvocation &&
+ glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
+ builder.addDecoration(id, spv::DecorationVolatile);
}
#ifndef GLSLANG_WEB
@@ -8804,6 +9021,12 @@
builder.addExtension(spv::E_SPV_NV_fragment_shader_barycentric);
}
+ if (symbol->getQualifier().pervertexEXT) {
+ builder.addDecoration(id, spv::DecorationPerVertexKHR);
+ builder.addCapability(spv::CapabilityFragmentBarycentricKHR);
+ builder.addExtension(spv::E_SPV_KHR_fragment_shader_barycentric);
+ }
+
if (glslangIntermediate->getHlslFunctionality1() && symbol->getType().getQualifier().semanticName != nullptr) {
builder.addExtension("SPV_GOOGLE_hlsl_functionality1");
builder.addDecoration(id, (spv::Decoration)spv::DecorationHlslSemanticGOOGLE,
@@ -8865,13 +9088,21 @@
// add per-primitive, per-view. per-task decorations to a struct member (member >= 0) or an object
void TGlslangToSpvTraverser::addMeshNVDecoration(spv::Id id, int member, const glslang::TQualifier& qualifier)
{
+ bool isMeshShaderExt = (glslangIntermediate->getRequestedExtensions().find(glslang::E_GL_EXT_mesh_shader) !=
+ glslangIntermediate->getRequestedExtensions().end());
+
if (member >= 0) {
if (qualifier.perPrimitiveNV) {
// Need to add capability/extension for fragment shader.
// Mesh shader already adds this by default.
if (glslangIntermediate->getStage() == EShLangFragment) {
- builder.addCapability(spv::CapabilityMeshShadingNV);
- builder.addExtension(spv::E_SPV_NV_mesh_shader);
+ if(isMeshShaderExt) {
+ builder.addCapability(spv::CapabilityMeshShadingEXT);
+ builder.addExtension(spv::E_SPV_EXT_mesh_shader);
+ } else {
+ builder.addCapability(spv::CapabilityMeshShadingNV);
+ builder.addExtension(spv::E_SPV_NV_mesh_shader);
+ }
}
builder.addMemberDecoration(id, (unsigned)member, spv::DecorationPerPrimitiveNV);
}
@@ -8884,8 +9115,13 @@
// Need to add capability/extension for fragment shader.
// Mesh shader already adds this by default.
if (glslangIntermediate->getStage() == EShLangFragment) {
- builder.addCapability(spv::CapabilityMeshShadingNV);
- builder.addExtension(spv::E_SPV_NV_mesh_shader);
+ if(isMeshShaderExt) {
+ builder.addCapability(spv::CapabilityMeshShadingEXT);
+ builder.addExtension(spv::E_SPV_EXT_mesh_shader);
+ } else {
+ builder.addCapability(spv::CapabilityMeshShadingNV);
+ builder.addExtension(spv::E_SPV_NV_mesh_shader);
+ }
}
builder.addDecoration(id, spv::DecorationPerPrimitiveNV);
}
@@ -9025,15 +9261,19 @@
break;
#ifndef GLSLANG_WEB
case glslang::EbtInt8:
+ builder.addCapability(spv::CapabilityInt8);
spvConsts.push_back(builder.makeInt8Constant(zero ? 0 : consts[nextConst].getI8Const()));
break;
case glslang::EbtUint8:
+ builder.addCapability(spv::CapabilityInt8);
spvConsts.push_back(builder.makeUint8Constant(zero ? 0 : consts[nextConst].getU8Const()));
break;
case glslang::EbtInt16:
+ builder.addCapability(spv::CapabilityInt16);
spvConsts.push_back(builder.makeInt16Constant(zero ? 0 : consts[nextConst].getI16Const()));
break;
case glslang::EbtUint16:
+ builder.addCapability(spv::CapabilityInt16);
spvConsts.push_back(builder.makeUint16Constant(zero ? 0 : consts[nextConst].getU16Const()));
break;
case glslang::EbtInt64:
@@ -9046,6 +9286,7 @@
spvConsts.push_back(builder.makeDoubleConstant(zero ? 0.0 : consts[nextConst].getDConst()));
break;
case glslang::EbtFloat16:
+ builder.addCapability(spv::CapabilityFloat16);
spvConsts.push_back(builder.makeFloat16Constant(zero ? 0.0F : (float)consts[nextConst].getDConst()));
break;
#endif
@@ -9074,15 +9315,19 @@
break;
#ifndef GLSLANG_WEB
case glslang::EbtInt8:
+ builder.addCapability(spv::CapabilityInt8);
scalar = builder.makeInt8Constant(zero ? 0 : consts[nextConst].getI8Const(), specConstant);
break;
case glslang::EbtUint8:
+ builder.addCapability(spv::CapabilityInt8);
scalar = builder.makeUint8Constant(zero ? 0 : consts[nextConst].getU8Const(), specConstant);
break;
case glslang::EbtInt16:
+ builder.addCapability(spv::CapabilityInt16);
scalar = builder.makeInt16Constant(zero ? 0 : consts[nextConst].getI16Const(), specConstant);
break;
case glslang::EbtUint16:
+ builder.addCapability(spv::CapabilityInt16);
scalar = builder.makeUint16Constant(zero ? 0 : consts[nextConst].getU16Const(), specConstant);
break;
case glslang::EbtInt64:
@@ -9095,6 +9340,7 @@
scalar = builder.makeDoubleConstant(zero ? 0.0 : consts[nextConst].getDConst(), specConstant);
break;
case glslang::EbtFloat16:
+ builder.addCapability(spv::CapabilityFloat16);
scalar = builder.makeFloat16Constant(zero ? 0.0F : (float)consts[nextConst].getDConst(), specConstant);
break;
case glslang::EbtReference:
@@ -9292,7 +9538,8 @@
// return 7; // GLSL volatile keyword maps to both SPIR-V decorations Volatile and Coherent
// return 8; // switch to new dead block eliminator; use OpUnreachable
// return 9; // don't include opaque function parameters in OpEntryPoint global's operand list
- return 10; // Generate OpFUnordNotEqual for != comparisons
+ // return 10; // Generate OpFUnordNotEqual for != comparisons
+ return 11; // Make OpEmitMeshTasksEXT a terminal instruction
}
// Write SPIR-V out to a binary file
diff --git a/SPIRV/NonSemanticShaderDebugInfo100.h b/SPIRV/NonSemanticShaderDebugInfo100.h
new file mode 100644
index 0000000..c52f32f
--- /dev/null
+++ b/SPIRV/NonSemanticShaderDebugInfo100.h
@@ -0,0 +1,171 @@
+// Copyright (c) 2018 The Khronos Group Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and/or associated documentation files (the "Materials"),
+// to deal in the Materials without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Materials, and to permit persons to whom the
+// Materials are 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 Materials.
+//
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
+//
+// THE MATERIALS ARE 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 MATERIALS OR THE USE OR OTHER DEALINGS
+// IN THE MATERIALS.
+
+#ifndef SPIRV_UNIFIED1_NonSemanticShaderDebugInfo100_H_
+#define SPIRV_UNIFIED1_NonSemanticShaderDebugInfo100_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+ NonSemanticShaderDebugInfo100Version = 100,
+ NonSemanticShaderDebugInfo100Version_BitWidthPadding = 0x7fffffff
+};
+enum {
+ NonSemanticShaderDebugInfo100Revision = 6,
+ NonSemanticShaderDebugInfo100Revision_BitWidthPadding = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100Instructions {
+ NonSemanticShaderDebugInfo100DebugInfoNone = 0,
+ NonSemanticShaderDebugInfo100DebugCompilationUnit = 1,
+ NonSemanticShaderDebugInfo100DebugTypeBasic = 2,
+ NonSemanticShaderDebugInfo100DebugTypePointer = 3,
+ NonSemanticShaderDebugInfo100DebugTypeQualifier = 4,
+ NonSemanticShaderDebugInfo100DebugTypeArray = 5,
+ NonSemanticShaderDebugInfo100DebugTypeVector = 6,
+ NonSemanticShaderDebugInfo100DebugTypedef = 7,
+ NonSemanticShaderDebugInfo100DebugTypeFunction = 8,
+ NonSemanticShaderDebugInfo100DebugTypeEnum = 9,
+ NonSemanticShaderDebugInfo100DebugTypeComposite = 10,
+ NonSemanticShaderDebugInfo100DebugTypeMember = 11,
+ NonSemanticShaderDebugInfo100DebugTypeInheritance = 12,
+ NonSemanticShaderDebugInfo100DebugTypePtrToMember = 13,
+ NonSemanticShaderDebugInfo100DebugTypeTemplate = 14,
+ NonSemanticShaderDebugInfo100DebugTypeTemplateParameter = 15,
+ NonSemanticShaderDebugInfo100DebugTypeTemplateTemplateParameter = 16,
+ NonSemanticShaderDebugInfo100DebugTypeTemplateParameterPack = 17,
+ NonSemanticShaderDebugInfo100DebugGlobalVariable = 18,
+ NonSemanticShaderDebugInfo100DebugFunctionDeclaration = 19,
+ NonSemanticShaderDebugInfo100DebugFunction = 20,
+ NonSemanticShaderDebugInfo100DebugLexicalBlock = 21,
+ NonSemanticShaderDebugInfo100DebugLexicalBlockDiscriminator = 22,
+ NonSemanticShaderDebugInfo100DebugScope = 23,
+ NonSemanticShaderDebugInfo100DebugNoScope = 24,
+ NonSemanticShaderDebugInfo100DebugInlinedAt = 25,
+ NonSemanticShaderDebugInfo100DebugLocalVariable = 26,
+ NonSemanticShaderDebugInfo100DebugInlinedVariable = 27,
+ NonSemanticShaderDebugInfo100DebugDeclare = 28,
+ NonSemanticShaderDebugInfo100DebugValue = 29,
+ NonSemanticShaderDebugInfo100DebugOperation = 30,
+ NonSemanticShaderDebugInfo100DebugExpression = 31,
+ NonSemanticShaderDebugInfo100DebugMacroDef = 32,
+ NonSemanticShaderDebugInfo100DebugMacroUndef = 33,
+ NonSemanticShaderDebugInfo100DebugImportedEntity = 34,
+ NonSemanticShaderDebugInfo100DebugSource = 35,
+ NonSemanticShaderDebugInfo100DebugFunctionDefinition = 101,
+ NonSemanticShaderDebugInfo100DebugSourceContinued = 102,
+ NonSemanticShaderDebugInfo100DebugLine = 103,
+ NonSemanticShaderDebugInfo100DebugNoLine = 104,
+ NonSemanticShaderDebugInfo100DebugBuildIdentifier = 105,
+ NonSemanticShaderDebugInfo100DebugStoragePath = 106,
+ NonSemanticShaderDebugInfo100DebugEntryPoint = 107,
+ NonSemanticShaderDebugInfo100DebugTypeMatrix = 108,
+ NonSemanticShaderDebugInfo100InstructionsMax = 0x7fffffff
+};
+
+
+enum NonSemanticShaderDebugInfo100DebugInfoFlags {
+ NonSemanticShaderDebugInfo100None = 0x0000,
+ NonSemanticShaderDebugInfo100FlagIsProtected = 0x01,
+ NonSemanticShaderDebugInfo100FlagIsPrivate = 0x02,
+ NonSemanticShaderDebugInfo100FlagIsPublic = 0x03,
+ NonSemanticShaderDebugInfo100FlagIsLocal = 0x04,
+ NonSemanticShaderDebugInfo100FlagIsDefinition = 0x08,
+ NonSemanticShaderDebugInfo100FlagFwdDecl = 0x10,
+ NonSemanticShaderDebugInfo100FlagArtificial = 0x20,
+ NonSemanticShaderDebugInfo100FlagExplicit = 0x40,
+ NonSemanticShaderDebugInfo100FlagPrototyped = 0x80,
+ NonSemanticShaderDebugInfo100FlagObjectPointer = 0x100,
+ NonSemanticShaderDebugInfo100FlagStaticMember = 0x200,
+ NonSemanticShaderDebugInfo100FlagIndirectVariable = 0x400,
+ NonSemanticShaderDebugInfo100FlagLValueReference = 0x800,
+ NonSemanticShaderDebugInfo100FlagRValueReference = 0x1000,
+ NonSemanticShaderDebugInfo100FlagIsOptimized = 0x2000,
+ NonSemanticShaderDebugInfo100FlagIsEnumClass = 0x4000,
+ NonSemanticShaderDebugInfo100FlagTypePassByValue = 0x8000,
+ NonSemanticShaderDebugInfo100FlagTypePassByReference = 0x10000,
+ NonSemanticShaderDebugInfo100FlagUnknownPhysicalLayout = 0x20000,
+ NonSemanticShaderDebugInfo100DebugInfoFlagsMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100BuildIdentifierFlags {
+ NonSemanticShaderDebugInfo100IdentifierPossibleDuplicates = 0x01,
+ NonSemanticShaderDebugInfo100BuildIdentifierFlagsMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100DebugBaseTypeAttributeEncoding {
+ NonSemanticShaderDebugInfo100Unspecified = 0,
+ NonSemanticShaderDebugInfo100Address = 1,
+ NonSemanticShaderDebugInfo100Boolean = 2,
+ NonSemanticShaderDebugInfo100Float = 3,
+ NonSemanticShaderDebugInfo100Signed = 4,
+ NonSemanticShaderDebugInfo100SignedChar = 5,
+ NonSemanticShaderDebugInfo100Unsigned = 6,
+ NonSemanticShaderDebugInfo100UnsignedChar = 7,
+ NonSemanticShaderDebugInfo100DebugBaseTypeAttributeEncodingMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100DebugCompositeType {
+ NonSemanticShaderDebugInfo100Class = 0,
+ NonSemanticShaderDebugInfo100Structure = 1,
+ NonSemanticShaderDebugInfo100Union = 2,
+ NonSemanticShaderDebugInfo100DebugCompositeTypeMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100DebugTypeQualifier {
+ NonSemanticShaderDebugInfo100ConstType = 0,
+ NonSemanticShaderDebugInfo100VolatileType = 1,
+ NonSemanticShaderDebugInfo100RestrictType = 2,
+ NonSemanticShaderDebugInfo100AtomicType = 3,
+ NonSemanticShaderDebugInfo100DebugTypeQualifierMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100DebugOperation {
+ NonSemanticShaderDebugInfo100Deref = 0,
+ NonSemanticShaderDebugInfo100Plus = 1,
+ NonSemanticShaderDebugInfo100Minus = 2,
+ NonSemanticShaderDebugInfo100PlusUconst = 3,
+ NonSemanticShaderDebugInfo100BitPiece = 4,
+ NonSemanticShaderDebugInfo100Swap = 5,
+ NonSemanticShaderDebugInfo100Xderef = 6,
+ NonSemanticShaderDebugInfo100StackValue = 7,
+ NonSemanticShaderDebugInfo100Constu = 8,
+ NonSemanticShaderDebugInfo100Fragment = 9,
+ NonSemanticShaderDebugInfo100DebugOperationMax = 0x7fffffff
+};
+
+enum NonSemanticShaderDebugInfo100DebugImportedEntity {
+ NonSemanticShaderDebugInfo100ImportedModule = 0,
+ NonSemanticShaderDebugInfo100ImportedDeclaration = 1,
+ NonSemanticShaderDebugInfo100DebugImportedEntityMax = 0x7fffffff
+};
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // SPIRV_UNIFIED1_NonSemanticShaderDebugInfo100_H_
diff --git a/SPIRV/SPVRemapper.cpp b/SPIRV/SPVRemapper.cpp
index 56d6d5d..6aca8cb 100644
--- a/SPIRV/SPVRemapper.cpp
+++ b/SPIRV/SPVRemapper.cpp
@@ -160,15 +160,29 @@
}
// Is this an opcode we should remove when using --strip?
- bool spirvbin_t::isStripOp(spv::Op opCode) const
+ bool spirvbin_t::isStripOp(spv::Op opCode, unsigned start) const
{
switch (opCode) {
case spv::OpSource:
case spv::OpSourceExtension:
case spv::OpName:
case spv::OpMemberName:
- case spv::OpLine: return true;
- default: return false;
+ case spv::OpLine :
+ {
+ const std::string name = literalString(start + 2);
+
+ std::vector<std::string>::const_iterator it;
+ for (it = stripWhiteList.begin(); it < stripWhiteList.end(); it++)
+ {
+ if (name.find(*it) != std::string::npos) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+ default :
+ return false;
}
}
@@ -297,15 +311,21 @@
std::string spirvbin_t::literalString(unsigned word) const
{
std::string literal;
+ const spirword_t * pos = spv.data() + word;
literal.reserve(16);
- const char* bytes = reinterpret_cast<const char*>(spv.data() + word);
-
- while (bytes && *bytes)
- literal += *bytes++;
-
- return literal;
+ do {
+ spirword_t word = *pos;
+ for (int i = 0; i < 4; i++) {
+ char c = word & 0xff;
+ if (c == '\0')
+ return literal;
+ literal += c;
+ word >>= 8;
+ }
+ pos++;
+ } while (true);
}
void spirvbin_t::applyMap()
@@ -366,7 +386,7 @@
process(
[&](spv::Op opCode, unsigned start) {
// remember opcodes we want to strip later
- if (isStripOp(opCode))
+ if (isStripOp(opCode, start))
stripInst(start);
return true;
},
@@ -1488,13 +1508,24 @@
}
// remap from a memory image
- void spirvbin_t::remap(std::vector<std::uint32_t>& in_spv, std::uint32_t opts)
+ void spirvbin_t::remap(std::vector<std::uint32_t>& in_spv, const std::vector<std::string>& whiteListStrings,
+ std::uint32_t opts)
{
+ stripWhiteList = whiteListStrings;
spv.swap(in_spv);
remap(opts);
spv.swap(in_spv);
}
+ // remap from a memory image - legacy interface without white list
+ void spirvbin_t::remap(std::vector<std::uint32_t>& in_spv, std::uint32_t opts)
+ {
+ stripWhiteList.clear();
+ spv.swap(in_spv);
+ remap(opts);
+ spv.swap(in_spv);
+ }
+
} // namespace SPV
#endif // defined (use_cpp11)
diff --git a/SPIRV/SPVRemapper.h b/SPIRV/SPVRemapper.h
index d6b9c34..d216946 100644
--- a/SPIRV/SPVRemapper.h
+++ b/SPIRV/SPVRemapper.h
@@ -118,6 +118,10 @@
virtual ~spirvbin_t() { }
// remap on an existing binary in memory
+ void remap(std::vector<std::uint32_t>& spv, const std::vector<std::string>& whiteListStrings,
+ std::uint32_t opts = DO_EVERYTHING);
+
+ // remap on an existing binary in memory - legacy interface without white list
void remap(std::vector<std::uint32_t>& spv, std::uint32_t opts = DO_EVERYTHING);
// Type for error/log handler functions
@@ -180,6 +184,8 @@
unsigned typeSizeInWords(spv::Id id) const;
unsigned idTypeSizeInWords(spv::Id id) const;
+ bool isStripOp(spv::Op opCode, unsigned start) const;
+
spv::Id& asId(unsigned word) { return spv[word]; }
const spv::Id& asId(unsigned word) const { return spv[word]; }
spv::Op asOpCode(unsigned word) const { return opOpCode(spv[word]); }
@@ -249,6 +255,8 @@
std::vector<spirword_t> spv; // SPIR words
+ std::vector<std::string> stripWhiteList;
+
namemap_t nameMap; // ID names from OpName
// Since we want to also do binary ops, we can't use std::vector<bool>. we could use
diff --git a/SPIRV/SpvBuilder.cpp b/SPIRV/SpvBuilder.cpp
index e83306e..7c5ea87 100644
--- a/SPIRV/SpvBuilder.cpp
+++ b/SPIRV/SpvBuilder.cpp
@@ -59,12 +59,15 @@
Builder::Builder(unsigned int spvVersion, unsigned int magicNumber, SpvBuildLogger* buildLogger) :
spvVersion(spvVersion),
- source(SourceLanguageUnknown),
+ sourceLang(SourceLanguageUnknown),
sourceVersion(0),
sourceFileStringId(NoResult),
currentLine(0),
currentFile(nullptr),
+ currentFileId(NoResult),
+ lastDebugScopeId(NoResult),
emitOpLines(false),
+ emitNonSemanticShaderDebugInfo(false),
addressModel(AddressingModelLogical),
memoryModel(MemoryModelGLSL450),
builderNumber(magicNumber),
@@ -98,8 +101,12 @@
{
if (lineNum != 0 && lineNum != currentLine) {
currentLine = lineNum;
- if (emitOpLines)
- addLine(sourceFileStringId, currentLine, 0);
+ if (emitOpLines) {
+ if (emitNonSemanticShaderDebugInfo)
+ addDebugScopeAndLine(currentFileId, currentLine, 0);
+ else
+ addLine(sourceFileStringId, currentLine, 0);
+ }
}
}
@@ -118,7 +125,10 @@
currentFile = filename;
if (emitOpLines) {
spv::Id strId = getStringId(filename);
- addLine(strId, currentLine, 0);
+ if (emitNonSemanticShaderDebugInfo)
+ addDebugScopeAndLine(strId, currentLine, 0);
+ else
+ addLine(strId, currentLine, 0);
}
}
}
@@ -132,22 +142,49 @@
buildPoint->addInstruction(std::unique_ptr<Instruction>(line));
}
+void Builder::addDebugScopeAndLine(Id fileName, int lineNum, int column)
+{
+ if (currentDebugScopeId.top() != lastDebugScopeId) {
+ spv::Id resultId = getUniqueId();
+ Instruction* scopeInst = new Instruction(resultId, makeVoidType(), OpExtInst);
+ scopeInst->addIdOperand(nonSemanticShaderDebugInfo);
+ scopeInst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugScope);
+ scopeInst->addIdOperand(currentDebugScopeId.top());
+ buildPoint->addInstruction(std::unique_ptr<Instruction>(scopeInst));
+ lastDebugScopeId = currentDebugScopeId.top();
+ }
+ spv::Id resultId = getUniqueId();
+ Instruction* lineInst = new Instruction(resultId, makeVoidType(), OpExtInst);
+ lineInst->addIdOperand(nonSemanticShaderDebugInfo);
+ lineInst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugLine);
+ lineInst->addIdOperand(makeDebugSource(fileName));
+ lineInst->addIdOperand(makeUintConstant(lineNum));
+ lineInst->addIdOperand(makeUintConstant(lineNum));
+ lineInst->addIdOperand(makeUintConstant(column));
+ lineInst->addIdOperand(makeUintConstant(column));
+ buildPoint->addInstruction(std::unique_ptr<Instruction>(lineInst));
+}
+
// For creating new groupedTypes (will return old type if the requested one was already made).
Id Builder::makeVoidType()
{
Instruction* type;
if (groupedTypes[OpTypeVoid].size() == 0) {
- type = new Instruction(getUniqueId(), NoType, OpTypeVoid);
+ Id typeId = getUniqueId();
+ type = new Instruction(typeId, NoType, OpTypeVoid);
groupedTypes[OpTypeVoid].push_back(type);
constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
module.mapInstruction(type);
+ // Core OpTypeVoid used for debug void type
+ if (emitNonSemanticShaderDebugInfo)
+ debugId[typeId] = typeId;
} else
type = groupedTypes[OpTypeVoid].back();
return type->getResultId();
}
-Id Builder::makeBoolType()
+Id Builder::makeBoolType(bool const compilerGenerated)
{
Instruction* type;
if (groupedTypes[OpTypeBool].size() == 0) {
@@ -158,6 +195,12 @@
} else
type = groupedTypes[OpTypeBool].back();
+ if (emitNonSemanticShaderDebugInfo && !compilerGenerated)
+ {
+ auto const debugResultId = makeBoolDebugType(32);
+ debugId[type->getResultId()] = debugResultId;
+ }
+
return type->getResultId();
}
@@ -172,6 +215,12 @@
} else
type = groupedTypes[OpTypeSampler].back();
+ if (emitNonSemanticShaderDebugInfo)
+ {
+ auto const debugResultId = makeCompositeDebugType({}, "type.sampler", NonSemanticShaderDebugInfo100Structure, true);
+ debugId[type->getResultId()] = debugResultId;
+ }
+
return type->getResultId();
}
@@ -268,6 +317,12 @@
break;
}
+ if (emitNonSemanticShaderDebugInfo)
+ {
+ auto const debugResultId = makeIntegerDebugType(width, hasSign);
+ debugId[type->getResultId()] = debugResultId;
+ }
+
return type->getResultId();
}
@@ -305,6 +360,12 @@
break;
}
+ if (emitNonSemanticShaderDebugInfo)
+ {
+ auto const debugResultId = makeFloatDebugType(width);
+ debugId[type->getResultId()] = debugResultId;
+ }
+
return type->getResultId();
}
@@ -312,7 +373,7 @@
// See makeStructResultType() for non-decorated structs
// needed as the result of some instructions, which does
// check for duplicates.
-Id Builder::makeStructType(const std::vector<Id>& members, const char* name)
+Id Builder::makeStructType(const std::vector<Id>& members, const char* name, bool const compilerGenerated)
{
// Don't look for previous one, because in the general case,
// structs can be duplicated except for decorations.
@@ -326,6 +387,12 @@
module.mapInstruction(type);
addName(type->getResultId(), name);
+ if (emitNonSemanticShaderDebugInfo && !compilerGenerated)
+ {
+ auto const debugResultId = makeCompositeDebugType(members, name, NonSemanticShaderDebugInfo100Structure);
+ debugId[type->getResultId()] = debugResultId;
+ }
+
return type->getResultId();
}
@@ -372,6 +439,12 @@
constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
module.mapInstruction(type);
+ if (emitNonSemanticShaderDebugInfo)
+ {
+ auto const debugResultId = makeVectorDebugType(component, size);
+ debugId[type->getResultId()] = debugResultId;
+ }
+
return type->getResultId();
}
@@ -398,6 +471,12 @@
constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
module.mapInstruction(type);
+ if (emitNonSemanticShaderDebugInfo)
+ {
+ auto const debugResultId = makeMatrixDebugType(column, cols);
+ debugId[type->getResultId()] = debugResultId;
+ }
+
return type->getResultId();
}
@@ -427,6 +506,37 @@
return type->getResultId();
}
+Id Builder::makeGenericType(spv::Op opcode, std::vector<spv::IdImmediate>& operands)
+{
+ // try to find it
+ Instruction* type;
+ for (int t = 0; t < (int)groupedTypes[opcode].size(); ++t) {
+ type = groupedTypes[opcode][t];
+ if (static_cast<size_t>(type->getNumOperands()) != operands.size())
+ continue; // Number mismatch, find next
+
+ bool match = true;
+ for (int op = 0; match && op < (int)operands.size(); ++op) {
+ match = (operands[op].isId ? type->getIdOperand(op) : type->getImmediateOperand(op)) == operands[op].word;
+ }
+ if (match)
+ return type->getResultId();
+ }
+
+ // not found, make it
+ type = new Instruction(getUniqueId(), NoType, opcode);
+ for (size_t op = 0; op < operands.size(); ++op) {
+ if (operands[op].isId)
+ type->addIdOperand(operands[op].word);
+ else
+ type->addImmediateOperand(operands[op].word);
+ }
+ groupedTypes[opcode].push_back(type);
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+ module.mapInstruction(type);
+
+ return type->getResultId();
+}
// TODO: performance: track arrays per stride
// If a stride is supplied (non-zero) make an array.
@@ -453,6 +563,12 @@
constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
module.mapInstruction(type);
+ if (emitNonSemanticShaderDebugInfo)
+ {
+ auto const debugResultId = makeArrayDebugType(element, sizeId);
+ debugId[type->getResultId()] = debugResultId;
+ }
+
return type->getResultId();
}
@@ -463,6 +579,12 @@
constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
module.mapInstruction(type);
+ if (emitNonSemanticShaderDebugInfo)
+ {
+ auto const debugResultId = makeArrayDebugType(element, makeUintConstant(0));
+ debugId[type->getResultId()] = debugResultId;
+ }
+
return type->getResultId();
}
@@ -482,11 +604,25 @@
}
}
if (! mismatch)
+ {
+ // If compiling HLSL, glslang will create a wrapper function around the entrypoint. Accordingly, a void(void)
+ // function type is created for the wrapper function. However, nonsemantic shader debug information is disabled
+ // while creating the HLSL wrapper. Consequently, if we encounter another void(void) function, we need to create
+ // the associated debug function type if it hasn't been created yet.
+ if(emitNonSemanticShaderDebugInfo && debugId[type->getResultId()] == 0) {
+ assert(sourceLang == spv::SourceLanguageHLSL);
+ assert(getTypeClass(returnType) == OpTypeVoid && paramTypes.size() == 0);
+
+ Id debugTypeId = makeDebugFunctionType(returnType, {});
+ debugId[type->getResultId()] = debugTypeId;
+ }
return type->getResultId();
+ }
}
// not found, make it
- type = new Instruction(getUniqueId(), NoType, OpTypeFunction);
+ Id typeId = getUniqueId();
+ type = new Instruction(typeId, NoType, OpTypeFunction);
type->addIdOperand(returnType);
for (int p = 0; p < (int)paramTypes.size(); ++p)
type->addIdOperand(paramTypes[p]);
@@ -494,9 +630,34 @@
constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
module.mapInstruction(type);
+ // make debug type and map it
+ if (emitNonSemanticShaderDebugInfo) {
+ Id debugTypeId = makeDebugFunctionType(returnType, paramTypes);
+ debugId[typeId] = debugTypeId;
+ }
+
return type->getResultId();
}
+Id Builder::makeDebugFunctionType(Id returnType, const std::vector<Id>& paramTypes)
+{
+ assert(debugId[returnType] != 0);
+
+ Id typeId = getUniqueId();
+ auto type = new Instruction(typeId, makeVoidType(), OpExtInst);
+ type->addIdOperand(nonSemanticShaderDebugInfo);
+ type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeFunction);
+ type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsPublic));
+ type->addIdOperand(debugId[returnType]);
+ for (auto const paramType : paramTypes) {
+ assert(isPointerType(paramType) || isArrayType(paramType));
+ type->addIdOperand(debugId[getContainedTypeId(paramType)]);
+ }
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+ module.mapInstruction(type);
+ return typeId;
+}
+
Id Builder::makeImageType(Id sampledType, Dim dim, bool depth, bool arrayed, bool ms, unsigned sampled,
ImageFormat format)
{
@@ -578,6 +739,22 @@
}
#endif
+ if (emitNonSemanticShaderDebugInfo)
+ {
+ auto TypeName = [&dim]() -> char const* {
+ switch (dim) {
+ case Dim1D: return "type.1d.image";
+ case Dim2D: return "type.2d.image";
+ case Dim3D: return "type.3d.image";
+ case DimCube: return "type.cube.image";
+ default: return "type.image";
+ }
+ };
+
+ auto const debugResultId = makeCompositeDebugType({}, TypeName(), NonSemanticShaderDebugInfo100Class, true);
+ debugId[type->getResultId()] = debugResultId;
+ }
+
return type->getResultId();
}
@@ -599,9 +776,376 @@
constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
module.mapInstruction(type);
+ if (emitNonSemanticShaderDebugInfo)
+ {
+ auto const debugResultId = makeCompositeDebugType({}, "type.sampled.image", NonSemanticShaderDebugInfo100Class, true);
+ debugId[type->getResultId()] = debugResultId;
+ }
+
return type->getResultId();
}
+Id Builder::makeDebugInfoNone()
+{
+ if (debugInfoNone != 0)
+ return debugInfoNone;
+
+ Instruction* inst = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+ inst->addIdOperand(nonSemanticShaderDebugInfo);
+ inst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugInfoNone);
+
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(inst));
+ module.mapInstruction(inst);
+
+ debugInfoNone = inst->getResultId();
+
+ return debugInfoNone;
+}
+
+Id Builder::makeBoolDebugType(int const size)
+{
+ // try to find it
+ Instruction* type;
+ for (int t = 0; t < (int)groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic].size(); ++t) {
+ type = groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic][t];
+ if (type->getIdOperand(0) == getStringId("bool") &&
+ type->getIdOperand(1) == static_cast<unsigned int>(size) &&
+ type->getIdOperand(2) == NonSemanticShaderDebugInfo100Boolean)
+ return type->getResultId();
+ }
+
+ type = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+ type->addIdOperand(nonSemanticShaderDebugInfo);
+ type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeBasic);
+
+ type->addIdOperand(getStringId("bool")); // name id
+ type->addIdOperand(makeUintConstant(size)); // size id
+ type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100Boolean)); // encoding id
+ type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100None)); // flags id
+
+ groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic].push_back(type);
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+ module.mapInstruction(type);
+
+ return type->getResultId();
+}
+
+Id Builder::makeIntegerDebugType(int const width, bool const hasSign)
+{
+ // try to find it
+ Instruction* type;
+ for (int t = 0; t < (int)groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic].size(); ++t) {
+ type = groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic][t];
+ if (type->getIdOperand(0) == (hasSign ? getStringId("int") : getStringId("uint")) &&
+ type->getIdOperand(1) == static_cast<unsigned int>(width) &&
+ type->getIdOperand(2) == (hasSign ? NonSemanticShaderDebugInfo100Signed : NonSemanticShaderDebugInfo100Unsigned))
+ return type->getResultId();
+ }
+
+ // not found, make it
+ type = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+ type->addIdOperand(nonSemanticShaderDebugInfo);
+ type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeBasic);
+ if(hasSign == true) {
+ type->addIdOperand(getStringId("int")); // name id
+ } else {
+ type->addIdOperand(getStringId("uint")); // name id
+ }
+ type->addIdOperand(makeUintConstant(width)); // size id
+ if(hasSign == true) {
+ type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100Signed)); // encoding id
+ } else {
+ type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100Unsigned)); // encoding id
+ }
+ type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100None)); // flags id
+
+ groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic].push_back(type);
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+ module.mapInstruction(type);
+
+ return type->getResultId();
+}
+
+Id Builder::makeFloatDebugType(int const width)
+{
+ // try to find it
+ Instruction* type;
+ for (int t = 0; t < (int)groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic].size(); ++t) {
+ type = groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic][t];
+ if (type->getIdOperand(0) == getStringId("float") &&
+ type->getIdOperand(1) == static_cast<unsigned int>(width) &&
+ type->getIdOperand(2) == NonSemanticShaderDebugInfo100Float)
+ return type->getResultId();
+ }
+
+ // not found, make it
+ type = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+ type->addIdOperand(nonSemanticShaderDebugInfo);
+ type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeBasic);
+ type->addIdOperand(getStringId("float")); // name id
+ type->addIdOperand(makeUintConstant(width)); // size id
+ type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100Float)); // encoding id
+ type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100None)); // flags id
+
+ groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeBasic].push_back(type);
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+ module.mapInstruction(type);
+
+ return type->getResultId();
+}
+
+Id Builder::makeSequentialDebugType(Id const baseType, Id const componentCount, NonSemanticShaderDebugInfo100Instructions const sequenceType)
+{
+ assert(sequenceType == NonSemanticShaderDebugInfo100DebugTypeArray ||
+ sequenceType == NonSemanticShaderDebugInfo100DebugTypeVector);
+
+ // try to find it
+ Instruction* type;
+ for (int t = 0; t < (int)groupedDebugTypes[sequenceType].size(); ++t) {
+ type = groupedDebugTypes[sequenceType][t];
+ if (type->getIdOperand(0) == baseType &&
+ type->getIdOperand(1) == makeUintConstant(componentCount))
+ return type->getResultId();
+ }
+
+ // not found, make it
+ type = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+ type->addIdOperand(nonSemanticShaderDebugInfo);
+ type->addImmediateOperand(sequenceType);
+ type->addIdOperand(debugId[baseType]); // base type
+ type->addIdOperand(componentCount); // component count
+
+ groupedDebugTypes[sequenceType].push_back(type);
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+ module.mapInstruction(type);
+
+ return type->getResultId();
+}
+
+Id Builder::makeArrayDebugType(Id const baseType, Id const componentCount)
+{
+ return makeSequentialDebugType(baseType, componentCount, NonSemanticShaderDebugInfo100DebugTypeArray);
+}
+
+Id Builder::makeVectorDebugType(Id const baseType, int const componentCount)
+{
+ return makeSequentialDebugType(baseType, makeUintConstant(componentCount), NonSemanticShaderDebugInfo100DebugTypeVector);;
+}
+
+Id Builder::makeMatrixDebugType(Id const vectorType, int const vectorCount, bool columnMajor)
+{
+ // try to find it
+ Instruction* type;
+ for (int t = 0; t < (int)groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeMatrix].size(); ++t) {
+ type = groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeMatrix][t];
+ if (type->getIdOperand(0) == vectorType &&
+ type->getIdOperand(1) == makeUintConstant(vectorCount))
+ return type->getResultId();
+ }
+
+ // not found, make it
+ type = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+ type->addIdOperand(nonSemanticShaderDebugInfo);
+ type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeMatrix);
+ type->addIdOperand(debugId[vectorType]); // vector type id
+ type->addIdOperand(makeUintConstant(vectorCount)); // component count id
+ type->addIdOperand(makeBoolConstant(columnMajor)); // column-major id
+
+ groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeMatrix].push_back(type);
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+ module.mapInstruction(type);
+
+ return type->getResultId();
+}
+
+Id Builder::makeMemberDebugType(Id const memberType, DebugTypeLoc const& debugTypeLoc)
+{
+ assert(debugId[memberType] != 0);
+
+ Instruction* type = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+ type->addIdOperand(nonSemanticShaderDebugInfo);
+ type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeMember);
+ type->addIdOperand(getStringId(debugTypeLoc.name)); // name id
+ type->addIdOperand(debugId[memberType]); // type id
+ type->addIdOperand(makeDebugSource(sourceFileStringId)); // source id TODO: verify this works across include directives
+ type->addIdOperand(makeUintConstant(debugTypeLoc.line)); // line id TODO: currentLine is always zero
+ type->addIdOperand(makeUintConstant(debugTypeLoc.column)); // TODO: column id
+ type->addIdOperand(makeUintConstant(0)); // TODO: offset id
+ type->addIdOperand(makeUintConstant(0)); // TODO: size id
+ type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsPublic)); // flags id
+
+ groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeMember].push_back(type);
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+ module.mapInstruction(type);
+
+ return type->getResultId();
+}
+
+// Note: To represent a source language opaque type, this instruction must have no Members operands, Size operand must be
+// DebugInfoNone, and Name must start with @ to avoid clashes with user defined names.
+Id Builder::makeCompositeDebugType(std::vector<Id> const& memberTypes, char const*const name,
+ NonSemanticShaderDebugInfo100DebugCompositeType const tag, bool const isOpaqueType)
+{
+ // Create the debug member types.
+ std::vector<Id> memberDebugTypes;
+ for(auto const memberType : memberTypes) {
+ assert(debugTypeLocs.find(memberType) != debugTypeLocs.end());
+
+ memberDebugTypes.emplace_back(makeMemberDebugType(memberType, debugTypeLocs[memberType]));
+
+ // TODO: Need to rethink this method of passing location information.
+ // debugTypeLocs.erase(memberType);
+ }
+
+ // Create The structure debug type.
+ Instruction* type = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+ type->addIdOperand(nonSemanticShaderDebugInfo);
+ type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugTypeComposite);
+ type->addIdOperand(getStringId(name)); // name id
+ type->addIdOperand(makeUintConstant(tag)); // tag id
+ type->addIdOperand(makeDebugSource(sourceFileStringId)); // source id TODO: verify this works across include directives
+ type->addIdOperand(makeUintConstant(currentLine)); // line id TODO: currentLine always zero?
+ type->addIdOperand(makeUintConstant(0)); // TODO: column id
+ type->addIdOperand(makeDebugCompilationUnit()); // scope id
+ if(isOpaqueType == true) {
+ // Prepend '@' to opaque types.
+ type->addIdOperand(getStringId('@' + std::string(name))); // linkage name id
+ type->addIdOperand(makeDebugInfoNone()); // size id
+ } else {
+ type->addIdOperand(getStringId(name)); // linkage name id
+ type->addIdOperand(makeUintConstant(0)); // TODO: size id
+ }
+ type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsPublic)); // flags id
+ assert(isOpaqueType == false || (isOpaqueType == true && memberDebugTypes.empty()));
+ for(auto const memberDebugType : memberDebugTypes) {
+ type->addIdOperand(memberDebugType);
+ }
+
+ groupedDebugTypes[NonSemanticShaderDebugInfo100DebugTypeComposite].push_back(type);
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+ module.mapInstruction(type);
+
+ return type->getResultId();
+}
+
+Id Builder::makeDebugSource(const Id fileName) {
+ if (debugSourceId.find(fileName) != debugSourceId.end())
+ return debugSourceId[fileName];
+ spv::Id resultId = getUniqueId();
+ Instruction* sourceInst = new Instruction(resultId, makeVoidType(), OpExtInst);
+ sourceInst->addIdOperand(nonSemanticShaderDebugInfo);
+ sourceInst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugSource);
+ sourceInst->addIdOperand(fileName);
+ if (emitNonSemanticShaderDebugSource) {
+ spv::Id sourceId = 0;
+ if (fileName == sourceFileStringId) {
+ sourceId = getStringId(sourceText);
+ } else {
+ auto incItr = includeFiles.find(fileName);
+ assert(incItr != includeFiles.end());
+ sourceId = getStringId(*incItr->second);
+ }
+ sourceInst->addIdOperand(sourceId);
+ }
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(sourceInst));
+ module.mapInstruction(sourceInst);
+ debugSourceId[fileName] = resultId;
+ return resultId;
+}
+
+Id Builder::makeDebugCompilationUnit() {
+ if (nonSemanticShaderCompilationUnitId != 0)
+ return nonSemanticShaderCompilationUnitId;
+ spv::Id resultId = getUniqueId();
+ Instruction* sourceInst = new Instruction(resultId, makeVoidType(), OpExtInst);
+ sourceInst->addIdOperand(nonSemanticShaderDebugInfo);
+ sourceInst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugCompilationUnit);
+ sourceInst->addIdOperand(makeUintConstant(1)); // TODO(greg-lunarg): Get rid of magic number
+ sourceInst->addIdOperand(makeUintConstant(4)); // TODO(greg-lunarg): Get rid of magic number
+ sourceInst->addIdOperand(makeDebugSource(sourceFileStringId));
+ sourceInst->addIdOperand(makeUintConstant(sourceLang));
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(sourceInst));
+ module.mapInstruction(sourceInst);
+ nonSemanticShaderCompilationUnitId = resultId;
+ return resultId;
+}
+
+Id Builder::createDebugGlobalVariable(Id const type, char const*const name, Id const variable)
+{
+ assert(type != 0);
+
+ Instruction* inst = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+ inst->addIdOperand(nonSemanticShaderDebugInfo);
+ inst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugGlobalVariable);
+ inst->addIdOperand(getStringId(name)); // name id
+ inst->addIdOperand(type); // type id
+ inst->addIdOperand(makeDebugSource(sourceFileStringId)); // source id
+ inst->addIdOperand(makeUintConstant(currentLine)); // line id TODO: currentLine always zero?
+ inst->addIdOperand(makeUintConstant(0)); // TODO: column id
+ inst->addIdOperand(makeDebugCompilationUnit()); // scope id
+ inst->addIdOperand(getStringId(name)); // linkage name id
+ inst->addIdOperand(variable); // variable id
+ inst->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsDefinition)); // flags id
+
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(inst));
+ module.mapInstruction(inst);
+
+ return inst->getResultId();
+}
+
+Id Builder::createDebugLocalVariable(Id type, char const*const name, size_t const argNumber)
+{
+ assert(name != nullptr);
+ Instruction* inst = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+ inst->addIdOperand(nonSemanticShaderDebugInfo);
+ inst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugLocalVariable);
+ inst->addIdOperand(getStringId(name)); // name id
+ inst->addIdOperand(type); // type id
+ inst->addIdOperand(makeDebugSource(sourceFileStringId)); // source id
+ inst->addIdOperand(makeUintConstant(currentLine)); // line id
+ inst->addIdOperand(makeUintConstant(0)); // TODO: column id
+ inst->addIdOperand(currentDebugScopeId.top()); // scope id
+ inst->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsLocal)); // flags id
+ if(argNumber != 0) {
+ inst->addIdOperand(makeUintConstant(argNumber));
+ }
+
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(inst));
+ module.mapInstruction(inst);
+
+ return inst->getResultId();
+}
+
+Id Builder::makeDebugExpression()
+{
+ if (debugExpression != 0)
+ return debugExpression;
+
+ Instruction* inst = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+ inst->addIdOperand(nonSemanticShaderDebugInfo);
+ inst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugExpression);
+
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(inst));
+ module.mapInstruction(inst);
+
+ debugExpression = inst->getResultId();
+
+ return debugExpression;
+}
+
+Id Builder::makeDebugDeclare(Id const debugLocalVariable, Id const localVariable)
+{
+ Instruction* inst = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
+ inst->addIdOperand(nonSemanticShaderDebugInfo);
+ inst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugDeclare);
+ inst->addIdOperand(debugLocalVariable); // debug local variable id
+ inst->addIdOperand(localVariable); // local variable id
+ inst->addIdOperand(makeDebugExpression()); // expression id
+ buildPoint->addInstruction(std::unique_ptr<Instruction>(inst));
+
+ return inst->getResultId();
+}
+
#ifndef GLSLANG_WEB
Id Builder::makeAccelerationStructureType()
{
@@ -889,6 +1433,17 @@
}
}
+bool Builder::isRayTracingOpCode(Op opcode) const
+{
+ switch (opcode) {
+ case OpTypeAccelerationStructureKHR:
+ case OpTypeRayQueryKHR:
+ return true;
+ default:
+ return false;
+ }
+}
+
Id Builder::makeNullConstant(Id typeId)
{
Instruction* constant;
@@ -1105,6 +1660,19 @@
return NoResult;
}
+Id Builder::importNonSemanticShaderDebugInfoInstructions()
+{
+ assert(emitNonSemanticShaderDebugInfo == true);
+
+ if(nonSemanticShaderDebugInfo == 0)
+ {
+ this->addExtension(spv::E_SPV_KHR_non_semantic_info);
+ nonSemanticShaderDebugInfo = this->import("NonSemantic.Shader.DebugInfo.100");
+ }
+
+ return nonSemanticShaderDebugInfo;
+}
+
Id Builder::findCompositeConstant(Op typeClass, Id typeId, const std::vector<Id>& comps)
{
Instruction* constant = 0;
@@ -1416,23 +1984,34 @@
assert(! entryPointFunction);
Block* entry;
- std::vector<Id> params;
+ std::vector<Id> paramsTypes;
+ std::vector<char const*> paramNames;
std::vector<std::vector<Decoration>> decorations;
- entryPointFunction = makeFunctionEntry(NoPrecision, makeVoidType(), entryPoint, params, decorations, &entry);
+ auto const returnType = makeVoidType();
+
+ restoreNonSemanticShaderDebugInfo = emitNonSemanticShaderDebugInfo;
+ if(sourceLang == spv::SourceLanguageHLSL) {
+ emitNonSemanticShaderDebugInfo = false;
+ }
+
+ entryPointFunction = makeFunctionEntry(NoPrecision, returnType, entryPoint, paramsTypes, paramNames, decorations, &entry);
+
+ emitNonSemanticShaderDebugInfo = restoreNonSemanticShaderDebugInfo;
return entryPointFunction;
}
// Comments in header
Function* Builder::makeFunctionEntry(Decoration precision, Id returnType, const char* name,
- const std::vector<Id>& paramTypes,
+ const std::vector<Id>& paramTypes, const std::vector<char const*>& paramNames,
const std::vector<std::vector<Decoration>>& decorations, Block **entry)
{
// Make the function and initial instructions in it
Id typeId = makeFunctionType(returnType, paramTypes);
Id firstParamId = paramTypes.size() == 0 ? 0 : getUniqueIds((int)paramTypes.size());
- Function* function = new Function(getUniqueId(), returnType, typeId, firstParamId, module);
+ Id funcId = getUniqueId();
+ Function* function = new Function(funcId, returnType, typeId, firstParamId, module);
// Set up the precisions
setPrecision(function->getId(), precision);
@@ -1444,11 +2023,39 @@
}
}
+ // Make the debug function instruction
+ if (emitNonSemanticShaderDebugInfo) {
+ Id nameId = getStringId(unmangleFunctionName(name));
+ Id debugFuncId = makeDebugFunction(function, nameId, typeId);
+ debugId[funcId] = debugFuncId;
+ currentDebugScopeId.push(debugFuncId);
+ lastDebugScopeId = NoResult;
+ }
+
// CFG
- if (entry) {
- *entry = new Block(getUniqueId(), *function);
- function->addBlock(*entry);
- setBuildPoint(*entry);
+ assert(entry != nullptr);
+ *entry = new Block(getUniqueId(), *function);
+ function->addBlock(*entry);
+ setBuildPoint(*entry);
+
+ // DebugScope and DebugLine for parameter DebugDeclares
+ if (emitNonSemanticShaderDebugInfo && (int)paramTypes.size() > 0) {
+ addDebugScopeAndLine(currentFileId, currentLine, 0);
+ }
+
+ if (emitNonSemanticShaderDebugInfo) {
+ assert(paramTypes.size() == paramNames.size());
+ for(size_t p = 0; p < paramTypes.size(); ++p)
+ {
+ auto const& paramType = paramTypes[p];
+ assert(isPointerType(paramType) || isArrayType(paramType));
+ assert(debugId[getContainedTypeId(paramType)] != 0);
+ auto const& paramName = paramNames[p];
+ auto const debugLocalVariableId = createDebugLocalVariable(debugId[getContainedTypeId(paramType)], paramName, p+1);
+ debugId[firstParamId + p] = debugLocalVariableId;
+
+ makeDebugDeclare(debugLocalVariableId, firstParamId + p);
+ }
}
if (name)
@@ -1456,9 +2063,62 @@
functions.push_back(std::unique_ptr<Function>(function));
+ // Clear debug scope stack
+ if (emitNonSemanticShaderDebugInfo)
+ currentDebugScopeId.pop();
+
return function;
}
+Id Builder::makeDebugFunction(Function* function, Id nameId, Id funcTypeId) {
+ assert(function != nullptr);
+ assert(nameId != 0);
+ assert(funcTypeId != 0);
+ assert(debugId[funcTypeId] != 0);
+
+ Id funcId = getUniqueId();
+ auto type = new Instruction(funcId, makeVoidType(), OpExtInst);
+ type->addIdOperand(nonSemanticShaderDebugInfo);
+ type->addImmediateOperand(NonSemanticShaderDebugInfo100DebugFunction);
+ type->addIdOperand(nameId);
+ type->addIdOperand(debugId[funcTypeId]);
+ type->addIdOperand(makeDebugSource(currentFileId)); // Will be fixed later when true filename available
+ type->addIdOperand(makeUintConstant(currentLine)); // Will be fixed later when true line available
+ type->addIdOperand(makeUintConstant(0)); // column
+ type->addIdOperand(makeDebugCompilationUnit()); // scope
+ type->addIdOperand(nameId); // linkage name
+ type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsPublic));
+ type->addIdOperand(makeUintConstant(currentLine)); // TODO(greg-lunarg): correct scope line
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+ module.mapInstruction(type);
+ return funcId;
+}
+
+Id Builder::makeDebugLexicalBlock(uint32_t line) {
+ Id lexId = getUniqueId();
+ auto lex = new Instruction(lexId, makeVoidType(), OpExtInst);
+ lex->addIdOperand(nonSemanticShaderDebugInfo);
+ lex->addImmediateOperand(NonSemanticShaderDebugInfo100DebugLexicalBlock);
+ lex->addIdOperand(makeDebugSource(currentFileId));
+ lex->addIdOperand(makeUintConstant(line));
+ lex->addIdOperand(makeUintConstant(0)); // column
+ lex->addIdOperand(currentDebugScopeId.top()); // scope
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(lex));
+ module.mapInstruction(lex);
+ return lexId;
+}
+
+std::string Builder::unmangleFunctionName(std::string const& name) const
+{
+ assert(name.length() > 0);
+
+ if(name.rfind('(') != std::string::npos) {
+ return name.substr(0, name.rfind('('));
+ } else {
+ return name;
+ }
+}
+
// Comments in header
void Builder::makeReturn(bool implicit, Id retVal)
{
@@ -1474,6 +2134,48 @@
}
// Comments in header
+void Builder::enterScope(uint32_t line)
+{
+ // Generate new lexical scope debug instruction
+ Id lexId = makeDebugLexicalBlock(line);
+ currentDebugScopeId.push(lexId);
+ lastDebugScopeId = NoResult;
+}
+
+// Comments in header
+void Builder::leaveScope()
+{
+ // Pop current scope from stack and clear current scope
+ currentDebugScopeId.pop();
+ lastDebugScopeId = NoResult;
+}
+
+// Comments in header
+void Builder::enterFunction(Function const* function)
+{
+ // Save and disable debugInfo for HLSL entry point function. It is a wrapper
+ // function with no user code in it.
+ restoreNonSemanticShaderDebugInfo = emitNonSemanticShaderDebugInfo;
+ if (sourceLang == spv::SourceLanguageHLSL && function == entryPointFunction) {
+ emitNonSemanticShaderDebugInfo = false;
+ }
+
+ if (emitNonSemanticShaderDebugInfo) {
+ // Initialize scope state
+ Id funcId = function->getFuncId();
+ currentDebugScopeId.push(debugId[funcId]);
+ // Create DebugFunctionDefinition
+ spv::Id resultId = getUniqueId();
+ Instruction* defInst = new Instruction(resultId, makeVoidType(), OpExtInst);
+ defInst->addIdOperand(nonSemanticShaderDebugInfo);
+ defInst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugFunctionDefinition);
+ defInst->addIdOperand(debugId[funcId]);
+ defInst->addIdOperand(funcId);
+ buildPoint->addInstruction(std::unique_ptr<Instruction>(defInst));
+ }
+}
+
+// Comments in header
void Builder::leaveFunction()
{
Block* block = buildPoint;
@@ -1488,6 +2190,12 @@
makeReturn(true, createUndefined(function.getReturnType()));
}
}
+
+ // Clear function scope from debug scope stack
+ if (emitNonSemanticShaderDebugInfo)
+ currentDebugScopeId.pop();
+
+ emitNonSemanticShaderDebugInfo = restoreNonSemanticShaderDebugInfo;
}
// Comments in header
@@ -1498,7 +2206,18 @@
}
// Comments in header
-Id Builder::createVariable(Decoration precision, StorageClass storageClass, Id type, const char* name, Id initializer)
+void Builder::makeStatementTerminator(spv::Op opcode, const std::vector<Id>& operands, const char* name)
+{
+ // It's assumed that the terminator instruction is always of void return type
+ // However in future if there is a need for non void return type, new helper
+ // methods can be created.
+ createNoResultOp(opcode, operands);
+ createAndSetNoPredecessorBlock(name);
+}
+
+// Comments in header
+Id Builder::createVariable(Decoration precision, StorageClass storageClass, Id type, const char* name, Id initializer,
+ bool const compilerGenerated)
{
Id pointerType = makePointer(storageClass, type);
Instruction* inst = new Instruction(getUniqueId(), pointerType, OpVariable);
@@ -1510,11 +2229,26 @@
case StorageClassFunction:
// Validation rules require the declaration in the entry block
buildPoint->getParent().addLocalVariable(std::unique_ptr<Instruction>(inst));
+
+ if (emitNonSemanticShaderDebugInfo && !compilerGenerated)
+ {
+ auto const debugLocalVariableId = createDebugLocalVariable(debugId[type], name);
+ debugId[inst->getResultId()] = debugLocalVariableId;
+
+ makeDebugDeclare(debugLocalVariableId, inst->getResultId());
+ }
+
break;
default:
constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(inst));
module.mapInstruction(inst);
+
+ if (emitNonSemanticShaderDebugInfo && !isRayTracingOpCode(getOpCode(type)))
+ {
+ auto const debugResultId = createDebugGlobalVariable(debugId[type], name, inst->getResultId());
+ debugId[inst->getResultId()] = debugResultId;
+ }
break;
}
@@ -1544,7 +2278,7 @@
case spv::StorageClassPhysicalStorageBufferEXT:
break;
default:
- memoryAccess = spv::MemoryAccessMask(memoryAccess &
+ memoryAccess = spv::MemoryAccessMask(memoryAccess &
~(spv::MemoryAccessMakePointerAvailableKHRMask |
spv::MemoryAccessMakePointerVisibleKHRMask |
spv::MemoryAccessNonPrivatePointerKHRMask));
@@ -2020,7 +2754,7 @@
texArgs[numArgs++] = parameters.granularity;
if (parameters.coarse != NoResult)
texArgs[numArgs++] = parameters.coarse;
-#endif
+#endif
//
// Set up the optional arguments
@@ -3240,10 +3974,10 @@
const int opSourceWordCount = 4;
const int nonNullBytesPerInstruction = 4 * (maxWordCount - opSourceWordCount) - 1;
- if (source != SourceLanguageUnknown) {
+ if (sourceLang != SourceLanguageUnknown) {
// OpSource Language Version File Source
Instruction sourceInst(NoResult, NoType, OpSource);
- sourceInst.addImmediateOperand(source);
+ sourceInst.addImmediateOperand(sourceLang);
sourceInst.addImmediateOperand(sourceVersion);
// File operand
if (fileId != NoResult) {
@@ -3276,6 +4010,7 @@
// Dump an OpSource[Continued] sequence for the source and every include file
void Builder::dumpSourceInstructions(std::vector<unsigned int>& out) const
{
+ if (emitNonSemanticShaderDebugInfo) return;
dumpSourceInstructions(sourceFileStringId, sourceText, out);
for (auto iItr = includeFiles.begin(); iItr != includeFiles.end(); ++iItr)
dumpSourceInstructions(iItr->first, *iItr->second, out);
diff --git a/SPIRV/SpvBuilder.h b/SPIRV/SpvBuilder.h
index 251b9ee..f7fdc6a 100644
--- a/SPIRV/SpvBuilder.h
+++ b/SPIRV/SpvBuilder.h
@@ -50,6 +50,10 @@
#include "Logger.h"
#include "spirv.hpp"
#include "spvIR.h"
+namespace spv {
+ #include "GLSL.ext.KHR.h"
+ #include "NonSemanticShaderDebugInfo100.h"
+}
#include <algorithm>
#include <map>
@@ -82,7 +86,7 @@
void setSource(spv::SourceLanguage lang, int version)
{
- source = lang;
+ sourceLang = lang;
sourceVersion = version;
}
spv::Id getStringId(const std::string& str)
@@ -99,14 +103,32 @@
stringIds[file_c_str] = strId;
return strId;
}
+ spv::Id getSourceFile() const
+ {
+ return sourceFileStringId;
+ }
void setSourceFile(const std::string& file)
{
sourceFileStringId = getStringId(file);
+ currentFileId = sourceFileStringId;
}
void setSourceText(const std::string& text) { sourceText = text; }
void addSourceExtension(const char* ext) { sourceExtensions.push_back(ext); }
void addModuleProcessed(const std::string& p) { moduleProcesses.push_back(p.c_str()); }
void setEmitOpLines() { emitOpLines = true; }
+ void setEmitNonSemanticShaderDebugInfo(bool const emit)
+ {
+ emitNonSemanticShaderDebugInfo = emit;
+
+ if(emit)
+ {
+ importNonSemanticShaderDebugInfoInstructions();
+ }
+ }
+ void setEmitNonSemanticShaderDebugSource(bool const src)
+ {
+ emitNonSemanticShaderDebugSource = src;
+ }
void addExtension(const char* ext) { extensions.insert(ext); }
void removeExtension(const char* ext)
{
@@ -159,10 +181,11 @@
void setLine(int line, const char* filename);
// Low-level OpLine. See setLine() for a layered helper.
void addLine(Id fileName, int line, int column);
+ void addDebugScopeAndLine(Id fileName, int line, int column);
// For creating new types (will return old type if the requested one was already made).
Id makeVoidType();
- Id makeBoolType();
+ Id makeBoolType(bool const compilerGenerated = true);
Id makePointer(StorageClass, Id pointee);
Id makeForwardPointer(StorageClass);
Id makePointerFromForwardPointer(StorageClass, Id forwardPointerType, Id pointee);
@@ -170,7 +193,7 @@
Id makeIntType(int width) { return makeIntegerType(width, true); }
Id makeUintType(int width) { return makeIntegerType(width, false); }
Id makeFloatType(int width);
- Id makeStructType(const std::vector<Id>& members, const char*);
+ Id makeStructType(const std::vector<Id>& members, const char* name, bool const compilerGenerated = true);
Id makeStructResultType(Id type0, Id type1);
Id makeVectorType(Id component, int size);
Id makeMatrixType(Id component, int cols, int rows);
@@ -181,6 +204,37 @@
Id makeSamplerType();
Id makeSampledImageType(Id imageType);
Id makeCooperativeMatrixType(Id component, Id scope, Id rows, Id cols);
+ Id makeGenericType(spv::Op opcode, std::vector<spv::IdImmediate>& operands);
+
+ // SPIR-V NonSemantic Shader DebugInfo Instructions
+ struct DebugTypeLoc {
+ std::string name {};
+ int line {0};
+ int column {0};
+ };
+ std::unordered_map<Id, DebugTypeLoc> debugTypeLocs;
+ Id makeDebugInfoNone();
+ Id makeBoolDebugType(int const size);
+ Id makeIntegerDebugType(int const width, bool const hasSign);
+ Id makeFloatDebugType(int const width);
+ Id makeSequentialDebugType(Id const baseType, Id const componentCount, NonSemanticShaderDebugInfo100Instructions const sequenceType);
+ Id makeArrayDebugType(Id const baseType, Id const componentCount);
+ Id makeVectorDebugType(Id const baseType, int const componentCount);
+ Id makeMatrixDebugType(Id const vectorType, int const vectorCount, bool columnMajor = true);
+ Id makeMemberDebugType(Id const memberType, DebugTypeLoc const& debugTypeLoc);
+ Id makeCompositeDebugType(std::vector<Id> const& memberTypes, char const*const name,
+ NonSemanticShaderDebugInfo100DebugCompositeType const tag, bool const isOpaqueType = false);
+ Id makeDebugSource(const Id fileName);
+ Id makeDebugCompilationUnit();
+ Id createDebugGlobalVariable(Id const type, char const*const name, Id const variable);
+ Id createDebugLocalVariable(Id type, char const*const name, size_t const argNumber = 0);
+ Id makeDebugExpression();
+ Id makeDebugDeclare(Id const debugLocalVariable, Id const localVariable);
+ Id makeDebugValue(Id const debugLocalVariable, Id const value);
+ Id makeDebugFunctionType(Id returnType, const std::vector<Id>& paramTypes);
+ Id makeDebugFunction(Function* function, Id nameId, Id funcTypeId);
+ Id makeDebugLexicalBlock(uint32_t line);
+ std::string unmangleFunctionName(std::string const& name) const;
// accelerationStructureNV type
Id makeAccelerationStructureType();
@@ -256,6 +310,8 @@
// See if a resultId is valid for use as an initializer.
bool isValidInitializer(Id resultId) const { return isConstant(resultId) || isGlobalVariable(resultId); }
+ bool isRayTracingOpCode(Op opcode) const;
+
int getScalarTypeWidth(Id typeId) const
{
Id scalarTypeId = getScalarTypeId(typeId);
@@ -317,6 +373,8 @@
Id makeFloat16Constant(float f16, bool specConstant = false);
Id makeFpConstant(Id type, double d, bool specConstant = false);
+ Id importNonSemanticShaderDebugInfoInstructions();
+
// Turn the array of constants into a proper spv constant of the requested type.
Id makeCompositeConstant(Id type, const std::vector<Id>& comps, bool specConst = false);
@@ -339,7 +397,12 @@
void addMemberDecoration(Id, unsigned int member, Decoration, const std::vector<const char*>& strings);
// At the end of what block do the next create*() instructions go?
- void setBuildPoint(Block* bp) { buildPoint = bp; }
+ // Also reset current last DebugScope and current source line to unknown
+ void setBuildPoint(Block* bp) {
+ buildPoint = bp;
+ lastDebugScopeId = NoResult;
+ currentLine = 0;
+ }
Block* getBuildPoint() const { return buildPoint; }
// Make the entry-point function. The returned pointer is only valid
@@ -350,12 +413,22 @@
// Return the function, pass back the entry.
// The returned pointer is only valid for the lifetime of this builder.
Function* makeFunctionEntry(Decoration precision, Id returnType, const char* name,
- const std::vector<Id>& paramTypes, const std::vector<std::vector<Decoration>>& precisions, Block **entry = 0);
+ const std::vector<Id>& paramTypes, const std::vector<char const*>& paramNames,
+ const std::vector<std::vector<Decoration>>& precisions, Block **entry = 0);
// Create a return. An 'implicit' return is one not appearing in the source
// code. In the case of an implicit return, no post-return block is inserted.
void makeReturn(bool implicit, Id retVal = 0);
+ // Initialize state and generate instructions for new lexical scope
+ void enterScope(uint32_t line);
+
+ // Set state and generate instructions to exit current lexical scope
+ void leaveScope();
+
+ // Prepare builder for generation of instructions for a function.
+ void enterFunction(Function const* function);
+
// Generate all the code needed to finish up a function.
void leaveFunction();
@@ -363,9 +436,13 @@
// discard, terminate-invocation, terminateRayEXT, or ignoreIntersectionEXT
void makeStatementTerminator(spv::Op opcode, const char *name);
+ // Create block terminator instruction for statements that have input operands
+ // such as OpEmitMeshTasksEXT
+ void makeStatementTerminator(spv::Op opcode, const std::vector<Id>& operands, const char* name);
+
// Create a global or function local or IO variable.
- Id createVariable(Decoration precision, StorageClass, Id type, const char* name = nullptr,
- Id initializer = NoResult);
+ Id createVariable(Decoration precision, StorageClass storageClass, Id type, const char* name = nullptr,
+ Id initializer = NoResult, bool const compilerGenerated = true);
// Create an intermediate with an undefined value.
Id createUndefined(Id type);
@@ -800,13 +877,23 @@
const;
unsigned int spvVersion; // the version of SPIR-V to emit in the header
- SourceLanguage source;
+ SourceLanguage sourceLang;
int sourceVersion;
spv::Id sourceFileStringId;
+ spv::Id nonSemanticShaderCompilationUnitId {0};
+ spv::Id nonSemanticShaderDebugInfo {0};
+ spv::Id debugInfoNone {0};
+ spv::Id debugExpression {0}; // Debug expression with zero operations.
std::string sourceText;
int currentLine;
const char* currentFile;
+ spv::Id currentFileId;
+ std::stack<spv::Id> currentDebugScopeId;
+ spv::Id lastDebugScopeId;
bool emitOpLines;
+ bool emitNonSemanticShaderDebugInfo;
+ bool restoreNonSemanticShaderDebugInfo;
+ bool emitNonSemanticShaderDebugSource;
std::set<std::string> extensions;
std::vector<const char*> sourceExtensions;
std::vector<const char*> moduleProcesses;
@@ -840,6 +927,8 @@
std::unordered_map<unsigned int, std::vector<Instruction*>> groupedStructConstants;
// map type opcodes to type instructions
std::unordered_map<unsigned int, std::vector<Instruction*>> groupedTypes;
+ // map type opcodes to debug type instructions
+ std::unordered_map<unsigned int, std::vector<Instruction*>> groupedDebugTypes;
// list of OpConstantNull instructions
std::vector<Instruction*> nullConstants;
@@ -855,6 +944,12 @@
// map from include file name ids to their contents
std::map<spv::Id, const std::string*> includeFiles;
+ // map from core id to debug id
+ std::map <spv::Id, spv::Id> debugId;
+
+ // map from file name string id to DebugSource id
+ std::unordered_map<spv::Id, spv::Id> debugSourceId;
+
// The stream for outputting warnings and errors.
SpvBuildLogger* logger;
}; // end Builder class
diff --git a/SPIRV/SpvTools.cpp b/SPIRV/SpvTools.cpp
index 8acf9b1..2529993 100644
--- a/SPIRV/SpvTools.cpp
+++ b/SPIRV/SpvTools.cpp
@@ -68,6 +68,8 @@
}
case glslang::EShTargetVulkan_1_2:
return spv_target_env::SPV_ENV_VULKAN_1_2;
+ case glslang::EShTargetVulkan_1_3:
+ return spv_target_env::SPV_ENV_VULKAN_1_3;
default:
break;
}
@@ -210,6 +212,8 @@
optimizer.RegisterPass(spvtools::CreateInterpolateFixupPass());
if (options->optimizeSize) {
optimizer.RegisterPass(spvtools::CreateRedundancyEliminationPass());
+ if (intermediate.getStage() == EShLanguage::EShLangVertex)
+ optimizer.RegisterPass(spvtools::CreateEliminateDeadInputComponentsPass());
}
optimizer.RegisterPass(spvtools::CreateAggressiveDCEPass());
optimizer.RegisterPass(spvtools::CreateCFGCleanupPass());
diff --git a/SPIRV/SpvTools.h b/SPIRV/SpvTools.h
index 3fb3cba..5386048 100644
--- a/SPIRV/SpvTools.h
+++ b/SPIRV/SpvTools.h
@@ -53,14 +53,14 @@
namespace glslang {
struct SpvOptions {
- SpvOptions() : generateDebugInfo(false), stripDebugInfo(false), disableOptimizer(true),
- optimizeSize(false), disassemble(false), validate(false) { }
- bool generateDebugInfo;
- bool stripDebugInfo;
- bool disableOptimizer;
- bool optimizeSize;
- bool disassemble;
- bool validate;
+ bool generateDebugInfo {false};
+ bool stripDebugInfo {false};
+ bool disableOptimizer {true};
+ bool optimizeSize {false};
+ bool disassemble {false};
+ bool validate {false};
+ bool emitNonSemanticShaderDebugInfo {false};
+ bool emitNonSemanticShaderDebugSource{ false };
};
#if ENABLE_OPT
diff --git a/SPIRV/disassemble.cpp b/SPIRV/disassemble.cpp
index 73c988c..74dd605 100644
--- a/SPIRV/disassemble.cpp
+++ b/SPIRV/disassemble.cpp
@@ -43,6 +43,7 @@
#include <stack>
#include <sstream>
#include <cstring>
+#include <utility>
#include "disassemble.h"
#include "doc.h"
@@ -100,6 +101,7 @@
void outputMask(OperandClass operandClass, unsigned mask);
void disassembleImmediates(int numOperands);
void disassembleIds(int numOperands);
+ std::pair<int, std::string> decodeString();
int disassembleString();
void disassembleInstruction(Id resultId, Id typeId, Op opCode, int numOperands);
@@ -290,31 +292,44 @@
}
}
-// return the number of operands consumed by the string
-int SpirvStream::disassembleString()
+// decode string from words at current position (non-consuming)
+std::pair<int, std::string> SpirvStream::decodeString()
{
- int startWord = word;
-
- out << " \"";
-
- const char* wordString;
+ std::string res;
+ int wordPos = word;
+ char c;
bool done = false;
+
do {
- unsigned int content = stream[word];
- wordString = (const char*)&content;
+ unsigned int content = stream[wordPos];
for (int charCount = 0; charCount < 4; ++charCount) {
- if (*wordString == 0) {
+ c = content & 0xff;
+ content >>= 8;
+ if (c == '\0') {
done = true;
break;
}
- out << *(wordString++);
+ res += c;
}
- ++word;
- } while (! done);
+ ++wordPos;
+ } while(! done);
+ return std::make_pair(wordPos - word, res);
+}
+
+// return the number of operands consumed by the string
+int SpirvStream::disassembleString()
+{
+ out << " \"";
+
+ std::pair<int, std::string> decoderes = decodeString();
+
+ out << decoderes.second;
out << "\"";
- return word - startWord;
+ word += decoderes.first;
+
+ return decoderes.first;
}
void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode, int numOperands)
@@ -331,7 +346,7 @@
nextNestedControl = 0;
}
} else if (opCode == OpExtInstImport) {
- idDescriptor[resultId] = (const char*)(&stream[word]);
+ idDescriptor[resultId] = decodeString().second;
}
else {
if (resultId != 0 && idDescriptor[resultId].size() == 0) {
@@ -428,7 +443,7 @@
--numOperands;
// Get names for printing "(XXX)" for readability, *after* this id
if (opCode == OpName)
- idDescriptor[stream[word - 1]] = (const char*)(&stream[word]);
+ idDescriptor[stream[word - 1]] = decodeString().second;
break;
case OperandVariableIds:
disassembleIds(numOperands);
diff --git a/SPIRV/doc.cpp b/SPIRV/doc.cpp
index dbdf707..b7fe3e7 100644
--- a/SPIRV/doc.cpp
+++ b/SPIRV/doc.cpp
@@ -97,6 +97,8 @@
case 6: return "Kernel";
case ExecutionModelTaskNV: return "TaskNV";
case ExecutionModelMeshNV: return "MeshNV";
+ case ExecutionModelTaskEXT: return "TaskEXT";
+ case ExecutionModelMeshEXT: return "MeshEXT";
default: return "Bad";
@@ -173,28 +175,32 @@
case 31: return "ContractionOff";
case 32: return "Bad";
- case ExecutionModeInitializer: return "Initializer";
- case ExecutionModeFinalizer: return "Finalizer";
- case ExecutionModeSubgroupSize: return "SubgroupSize";
- case ExecutionModeSubgroupsPerWorkgroup: return "SubgroupsPerWorkgroup";
- case ExecutionModeSubgroupsPerWorkgroupId: return "SubgroupsPerWorkgroupId";
- case ExecutionModeLocalSizeId: return "LocalSizeId";
- case ExecutionModeLocalSizeHintId: return "LocalSizeHintId";
+ case ExecutionModeInitializer: return "Initializer";
+ case ExecutionModeFinalizer: return "Finalizer";
+ case ExecutionModeSubgroupSize: return "SubgroupSize";
+ case ExecutionModeSubgroupsPerWorkgroup: return "SubgroupsPerWorkgroup";
+ case ExecutionModeSubgroupsPerWorkgroupId: return "SubgroupsPerWorkgroupId";
+ case ExecutionModeLocalSizeId: return "LocalSizeId";
+ case ExecutionModeLocalSizeHintId: return "LocalSizeHintId";
- case ExecutionModePostDepthCoverage: return "PostDepthCoverage";
- case ExecutionModeDenormPreserve: return "DenormPreserve";
- case ExecutionModeDenormFlushToZero: return "DenormFlushToZero";
- case ExecutionModeSignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve";
- case ExecutionModeRoundingModeRTE: return "RoundingModeRTE";
- case ExecutionModeRoundingModeRTZ: return "RoundingModeRTZ";
- case ExecutionModeStencilRefReplacingEXT: return "StencilRefReplacingEXT";
+ case ExecutionModePostDepthCoverage: return "PostDepthCoverage";
+ case ExecutionModeDenormPreserve: return "DenormPreserve";
+ case ExecutionModeDenormFlushToZero: return "DenormFlushToZero";
+ case ExecutionModeSignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve";
+ case ExecutionModeRoundingModeRTE: return "RoundingModeRTE";
+ case ExecutionModeRoundingModeRTZ: return "RoundingModeRTZ";
+ case ExecutionModeEarlyAndLateFragmentTestsAMD: return "EarlyAndLateFragmentTestsAMD";
+ case ExecutionModeStencilRefUnchangedFrontAMD: return "StencilRefUnchangedFrontAMD";
+ case ExecutionModeStencilRefLessFrontAMD: return "StencilRefLessFrontAMD";
+ case ExecutionModeStencilRefGreaterBackAMD: return "StencilRefGreaterBackAMD";
+ case ExecutionModeStencilRefReplacingEXT: return "StencilRefReplacingEXT";
case ExecutionModeSubgroupUniformControlFlowKHR: return "SubgroupUniformControlFlow";
- case ExecutionModeOutputLinesNV: return "OutputLinesNV";
- case ExecutionModeOutputPrimitivesNV: return "OutputPrimitivesNV";
- case ExecutionModeOutputTrianglesNV: return "OutputTrianglesNV";
- case ExecutionModeDerivativeGroupQuadsNV: return "DerivativeGroupQuadsNV";
- case ExecutionModeDerivativeGroupLinearNV: return "DerivativeGroupLinearNV";
+ case ExecutionModeOutputLinesNV: return "OutputLinesNV";
+ case ExecutionModeOutputPrimitivesNV: return "OutputPrimitivesNV";
+ case ExecutionModeOutputTrianglesNV: return "OutputTrianglesNV";
+ case ExecutionModeDerivativeGroupQuadsNV: return "DerivativeGroupQuadsNV";
+ case ExecutionModeDerivativeGroupLinearNV: return "DerivativeGroupLinearNV";
case ExecutionModePixelInterlockOrderedEXT: return "PixelInterlockOrderedEXT";
case ExecutionModePixelInterlockUnorderedEXT: return "PixelInterlockUnorderedEXT";
@@ -238,7 +244,7 @@
case StorageClassIncomingCallableDataKHR: return "IncomingCallableDataKHR";
case StorageClassPhysicalStorageBufferEXT: return "PhysicalStorageBufferEXT";
-
+ case StorageClassTaskPayloadWorkgroupEXT: return "TaskPayloadWorkgroupEXT";
default: return "Bad";
}
}
@@ -305,7 +311,8 @@
case DecorationPerPrimitiveNV: return "PerPrimitiveNV";
case DecorationPerViewNV: return "PerViewNV";
case DecorationPerTaskNV: return "PerTaskNV";
- case DecorationPerVertexNV: return "PerVertexNV";
+
+ case DecorationPerVertexKHR: return "PerVertexKHR";
case DecorationNonUniformEXT: return "DecorationNonUniformEXT";
case DecorationHlslCounterBufferGOOGLE: return "DecorationHlslCounterBufferGOOGLE";
@@ -392,6 +399,7 @@
case BuiltInObjectRayDirectionKHR: return "ObjectRayDirectionKHR";
case BuiltInRayTminKHR: return "RayTminKHR";
case BuiltInRayTmaxKHR: return "RayTmaxKHR";
+ case BuiltInCullMaskKHR: return "CullMaskKHR";
case BuiltInInstanceCustomIndexKHR: return "InstanceCustomIndexKHR";
case BuiltInRayGeometryIndexKHR: return "RayGeometryIndexKHR";
case BuiltInObjectToWorldKHR: return "ObjectToWorldKHR";
@@ -406,8 +414,8 @@
case BuiltInViewportMaskPerViewNV: return "ViewportMaskPerViewNV";
// case BuiltInFragmentSizeNV: return "FragmentSizeNV"; // superseded by BuiltInFragSizeEXT
// case BuiltInInvocationsPerPixelNV: return "InvocationsPerPixelNV"; // superseded by BuiltInFragInvocationCountEXT
- case BuiltInBaryCoordNV: return "BaryCoordNV";
- case BuiltInBaryCoordNoPerspNV: return "BaryCoordNoPerspNV";
+ case BuiltInBaryCoordKHR: return "BaryCoordKHR";
+ case BuiltInBaryCoordNoPerspKHR: return "BaryCoordNoPerspKHR";
case BuiltInFragSizeEXT: return "FragSizeEXT";
case BuiltInFragInvocationCountEXT: return "FragInvocationCountEXT";
@@ -427,6 +435,10 @@
case BuiltInWarpIDNV: return "WarpIDNV";
case BuiltInSMIDNV: return "SMIDNV";
case BuiltInCurrentRayTimeNV: return "CurrentRayTimeNV";
+ case BuiltInPrimitivePointIndicesEXT: return "PrimitivePointIndicesEXT";
+ case BuiltInPrimitiveLineIndicesEXT: return "PrimitiveLineIndicesEXT";
+ case BuiltInPrimitiveTriangleIndicesEXT: return "PrimitiveTriangleIndicesEXT";
+ case BuiltInCullPrimitiveEXT: return "CullPrimitiveEXT";
default: return "Bad";
}
@@ -900,6 +912,12 @@
case CapabilityDeviceGroup: return "DeviceGroup";
case CapabilityMultiView: return "MultiView";
+ case CapabilityDenormPreserve: return "DenormPreserve";
+ case CapabilityDenormFlushToZero: return "DenormFlushToZero";
+ case CapabilitySignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve";
+ case CapabilityRoundingModeRTE: return "RoundingModeRTE";
+ case CapabilityRoundingModeRTZ: return "RoundingModeRTZ";
+
case CapabilityStencilExportEXT: return "StencilExportEXT";
case CapabilityFloat16ImageAMD: return "Float16ImageAMD";
@@ -919,14 +937,16 @@
case CapabilityRayTracingNV: return "RayTracingNV";
case CapabilityRayTracingMotionBlurNV: return "RayTracingMotionBlurNV";
case CapabilityRayTracingKHR: return "RayTracingKHR";
+ case CapabilityRayCullMaskKHR: return "RayCullMaskKHR";
case CapabilityRayQueryKHR: return "RayQueryKHR";
case CapabilityRayTracingProvisionalKHR: return "RayTracingProvisionalKHR";
case CapabilityRayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR";
case CapabilityComputeDerivativeGroupQuadsNV: return "ComputeDerivativeGroupQuadsNV";
case CapabilityComputeDerivativeGroupLinearNV: return "ComputeDerivativeGroupLinearNV";
- case CapabilityFragmentBarycentricNV: return "FragmentBarycentricNV";
+ case CapabilityFragmentBarycentricKHR: return "FragmentBarycentricKHR";
case CapabilityMeshShadingNV: return "MeshShadingNV";
case CapabilityImageFootprintNV: return "ImageFootprintNV";
+ case CapabilityMeshShadingEXT: return "MeshShadingEXT";
// case CapabilityShadingRateNV: return "ShadingRateNV"; // superseded by FragmentDensityEXT
case CapabilitySampleMaskOverrideCoverageNV: return "SampleMaskOverrideCoverageNV";
case CapabilityFragmentDensityEXT: return "FragmentDensityEXT";
@@ -1394,6 +1414,8 @@
case OpGroupNonUniformPartitionNV: return "OpGroupNonUniformPartitionNV";
case OpImageSampleFootprintNV: return "OpImageSampleFootprintNV";
case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV";
+ case OpEmitMeshTasksEXT: return "OpEmitMeshTasksEXT";
+ case OpSetMeshOutputsEXT: return "OpSetMeshOutputsEXT";
case OpTypeRayQueryKHR: return "OpTypeRayQueryKHR";
case OpRayQueryInitializeKHR: return "OpRayQueryInitializeKHR";
@@ -2968,6 +2990,17 @@
InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Index Offset'");
InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Packed Indices'");
+ InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'groupCountX'");
+ InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'groupCountY'");
+ InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'groupCountZ'");
+ InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'Payload'");
+ InstructionDesc[OpEmitMeshTasksEXT].setResultAndType(false, false);
+
+ InstructionDesc[OpSetMeshOutputsEXT].operands.push(OperandId, "'vertexCount'");
+ InstructionDesc[OpSetMeshOutputsEXT].operands.push(OperandId, "'primitiveCount'");
+ InstructionDesc[OpSetMeshOutputsEXT].setResultAndType(false, false);
+
+
InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Component Type'");
InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Scope'");
InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Rows'");
diff --git a/SPIRV/spirv.hpp b/SPIRV/spirv.hpp
index f6b7be9..0e40544 100644
--- a/SPIRV/spirv.hpp
+++ b/SPIRV/spirv.hpp
@@ -1,2314 +1,2533 @@
-// Copyright (c) 2014-2020 The Khronos Group Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and/or associated documentation files (the "Materials"),
-// to deal in the Materials without restriction, including without limitation
-// the rights to use, copy, modify, merge, publish, distribute, sublicense,
-// and/or sell copies of the Materials, and to permit persons to whom the
-// Materials are 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 Materials.
-//
-// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
-// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
-// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
-//
-// THE MATERIALS ARE 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 MATERIALS OR THE USE OR OTHER DEALINGS
-// IN THE MATERIALS.
-
-// This header is automatically generated by the same tool that creates
-// the Binary Section of the SPIR-V specification.
-
-// Enumeration tokens for SPIR-V, in various styles:
-// C, C++, C++11, JSON, Lua, Python, C#, D
-//
-// - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
-// - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
-// - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
-// - Lua will use tables, e.g.: spv.SourceLanguage.GLSL
-// - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL']
-// - C# will use enum classes in the Specification class located in the "Spv" namespace,
-// e.g.: Spv.Specification.SourceLanguage.GLSL
-// - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL
-//
-// Some tokens act like mask values, which can be OR'd together,
-// while others are mutually exclusive. The mask-like ones have
-// "Mask" in their name, and a parallel enum that has the shift
-// amount (1 << x) for each corresponding enumerant.
-
-#ifndef spirv_HPP
-#define spirv_HPP
-
-namespace spv {
-
-typedef unsigned int Id;
-
-#define SPV_VERSION 0x10500
-#define SPV_REVISION 4
-
-static const unsigned int MagicNumber = 0x07230203;
-static const unsigned int Version = 0x00010500;
-static const unsigned int Revision = 4;
-static const unsigned int OpCodeMask = 0xffff;
-static const unsigned int WordCountShift = 16;
-
-enum SourceLanguage {
- SourceLanguageUnknown = 0,
- SourceLanguageESSL = 1,
- SourceLanguageGLSL = 2,
- SourceLanguageOpenCL_C = 3,
- SourceLanguageOpenCL_CPP = 4,
- SourceLanguageHLSL = 5,
- SourceLanguageMax = 0x7fffffff,
-};
-
-enum ExecutionModel {
- ExecutionModelVertex = 0,
- ExecutionModelTessellationControl = 1,
- ExecutionModelTessellationEvaluation = 2,
- ExecutionModelGeometry = 3,
- ExecutionModelFragment = 4,
- ExecutionModelGLCompute = 5,
- ExecutionModelKernel = 6,
- ExecutionModelTaskNV = 5267,
- ExecutionModelMeshNV = 5268,
- ExecutionModelRayGenerationKHR = 5313,
- ExecutionModelRayGenerationNV = 5313,
- ExecutionModelIntersectionKHR = 5314,
- ExecutionModelIntersectionNV = 5314,
- ExecutionModelAnyHitKHR = 5315,
- ExecutionModelAnyHitNV = 5315,
- ExecutionModelClosestHitKHR = 5316,
- ExecutionModelClosestHitNV = 5316,
- ExecutionModelMissKHR = 5317,
- ExecutionModelMissNV = 5317,
- ExecutionModelCallableKHR = 5318,
- ExecutionModelCallableNV = 5318,
- ExecutionModelMax = 0x7fffffff,
-};
-
-enum AddressingModel {
- AddressingModelLogical = 0,
- AddressingModelPhysical32 = 1,
- AddressingModelPhysical64 = 2,
- AddressingModelPhysicalStorageBuffer64 = 5348,
- AddressingModelPhysicalStorageBuffer64EXT = 5348,
- AddressingModelMax = 0x7fffffff,
-};
-
-enum MemoryModel {
- MemoryModelSimple = 0,
- MemoryModelGLSL450 = 1,
- MemoryModelOpenCL = 2,
- MemoryModelVulkan = 3,
- MemoryModelVulkanKHR = 3,
- MemoryModelMax = 0x7fffffff,
-};
-
-enum ExecutionMode {
- ExecutionModeInvocations = 0,
- ExecutionModeSpacingEqual = 1,
- ExecutionModeSpacingFractionalEven = 2,
- ExecutionModeSpacingFractionalOdd = 3,
- ExecutionModeVertexOrderCw = 4,
- ExecutionModeVertexOrderCcw = 5,
- ExecutionModePixelCenterInteger = 6,
- ExecutionModeOriginUpperLeft = 7,
- ExecutionModeOriginLowerLeft = 8,
- ExecutionModeEarlyFragmentTests = 9,
- ExecutionModePointMode = 10,
- ExecutionModeXfb = 11,
- ExecutionModeDepthReplacing = 12,
- ExecutionModeDepthGreater = 14,
- ExecutionModeDepthLess = 15,
- ExecutionModeDepthUnchanged = 16,
- ExecutionModeLocalSize = 17,
- ExecutionModeLocalSizeHint = 18,
- ExecutionModeInputPoints = 19,
- ExecutionModeInputLines = 20,
- ExecutionModeInputLinesAdjacency = 21,
- ExecutionModeTriangles = 22,
- ExecutionModeInputTrianglesAdjacency = 23,
- ExecutionModeQuads = 24,
- ExecutionModeIsolines = 25,
- ExecutionModeOutputVertices = 26,
- ExecutionModeOutputPoints = 27,
- ExecutionModeOutputLineStrip = 28,
- ExecutionModeOutputTriangleStrip = 29,
- ExecutionModeVecTypeHint = 30,
- ExecutionModeContractionOff = 31,
- ExecutionModeInitializer = 33,
- ExecutionModeFinalizer = 34,
- ExecutionModeSubgroupSize = 35,
- ExecutionModeSubgroupsPerWorkgroup = 36,
- ExecutionModeSubgroupsPerWorkgroupId = 37,
- ExecutionModeLocalSizeId = 38,
- ExecutionModeLocalSizeHintId = 39,
- ExecutionModeSubgroupUniformControlFlowKHR = 4421,
- ExecutionModePostDepthCoverage = 4446,
- ExecutionModeDenormPreserve = 4459,
- ExecutionModeDenormFlushToZero = 4460,
- ExecutionModeSignedZeroInfNanPreserve = 4461,
- ExecutionModeRoundingModeRTE = 4462,
- ExecutionModeRoundingModeRTZ = 4463,
- ExecutionModeStencilRefReplacingEXT = 5027,
- ExecutionModeOutputLinesNV = 5269,
- ExecutionModeOutputPrimitivesNV = 5270,
- ExecutionModeDerivativeGroupQuadsNV = 5289,
- ExecutionModeDerivativeGroupLinearNV = 5290,
- ExecutionModeOutputTrianglesNV = 5298,
- ExecutionModePixelInterlockOrderedEXT = 5366,
- ExecutionModePixelInterlockUnorderedEXT = 5367,
- ExecutionModeSampleInterlockOrderedEXT = 5368,
- ExecutionModeSampleInterlockUnorderedEXT = 5369,
- ExecutionModeShadingRateInterlockOrderedEXT = 5370,
- ExecutionModeShadingRateInterlockUnorderedEXT = 5371,
- ExecutionModeSharedLocalMemorySizeINTEL = 5618,
- ExecutionModeRoundingModeRTPINTEL = 5620,
- ExecutionModeRoundingModeRTNINTEL = 5621,
- ExecutionModeFloatingPointModeALTINTEL = 5622,
- ExecutionModeFloatingPointModeIEEEINTEL = 5623,
- ExecutionModeMaxWorkgroupSizeINTEL = 5893,
- ExecutionModeMaxWorkDimINTEL = 5894,
- ExecutionModeNoGlobalOffsetINTEL = 5895,
- ExecutionModeNumSIMDWorkitemsINTEL = 5896,
- ExecutionModeSchedulerTargetFmaxMhzINTEL = 5903,
- ExecutionModeMax = 0x7fffffff,
-};
-
-enum StorageClass {
- StorageClassUniformConstant = 0,
- StorageClassInput = 1,
- StorageClassUniform = 2,
- StorageClassOutput = 3,
- StorageClassWorkgroup = 4,
- StorageClassCrossWorkgroup = 5,
- StorageClassPrivate = 6,
- StorageClassFunction = 7,
- StorageClassGeneric = 8,
- StorageClassPushConstant = 9,
- StorageClassAtomicCounter = 10,
- StorageClassImage = 11,
- StorageClassStorageBuffer = 12,
- StorageClassCallableDataKHR = 5328,
- StorageClassCallableDataNV = 5328,
- StorageClassIncomingCallableDataKHR = 5329,
- StorageClassIncomingCallableDataNV = 5329,
- StorageClassRayPayloadKHR = 5338,
- StorageClassRayPayloadNV = 5338,
- StorageClassHitAttributeKHR = 5339,
- StorageClassHitAttributeNV = 5339,
- StorageClassIncomingRayPayloadKHR = 5342,
- StorageClassIncomingRayPayloadNV = 5342,
- StorageClassShaderRecordBufferKHR = 5343,
- StorageClassShaderRecordBufferNV = 5343,
- StorageClassPhysicalStorageBuffer = 5349,
- StorageClassPhysicalStorageBufferEXT = 5349,
- StorageClassCodeSectionINTEL = 5605,
- StorageClassDeviceOnlyINTEL = 5936,
- StorageClassHostOnlyINTEL = 5937,
- StorageClassMax = 0x7fffffff,
-};
-
-enum Dim {
- Dim1D = 0,
- Dim2D = 1,
- Dim3D = 2,
- DimCube = 3,
- DimRect = 4,
- DimBuffer = 5,
- DimSubpassData = 6,
- DimMax = 0x7fffffff,
-};
-
-enum SamplerAddressingMode {
- SamplerAddressingModeNone = 0,
- SamplerAddressingModeClampToEdge = 1,
- SamplerAddressingModeClamp = 2,
- SamplerAddressingModeRepeat = 3,
- SamplerAddressingModeRepeatMirrored = 4,
- SamplerAddressingModeMax = 0x7fffffff,
-};
-
-enum SamplerFilterMode {
- SamplerFilterModeNearest = 0,
- SamplerFilterModeLinear = 1,
- SamplerFilterModeMax = 0x7fffffff,
-};
-
-enum ImageFormat {
- ImageFormatUnknown = 0,
- ImageFormatRgba32f = 1,
- ImageFormatRgba16f = 2,
- ImageFormatR32f = 3,
- ImageFormatRgba8 = 4,
- ImageFormatRgba8Snorm = 5,
- ImageFormatRg32f = 6,
- ImageFormatRg16f = 7,
- ImageFormatR11fG11fB10f = 8,
- ImageFormatR16f = 9,
- ImageFormatRgba16 = 10,
- ImageFormatRgb10A2 = 11,
- ImageFormatRg16 = 12,
- ImageFormatRg8 = 13,
- ImageFormatR16 = 14,
- ImageFormatR8 = 15,
- ImageFormatRgba16Snorm = 16,
- ImageFormatRg16Snorm = 17,
- ImageFormatRg8Snorm = 18,
- ImageFormatR16Snorm = 19,
- ImageFormatR8Snorm = 20,
- ImageFormatRgba32i = 21,
- ImageFormatRgba16i = 22,
- ImageFormatRgba8i = 23,
- ImageFormatR32i = 24,
- ImageFormatRg32i = 25,
- ImageFormatRg16i = 26,
- ImageFormatRg8i = 27,
- ImageFormatR16i = 28,
- ImageFormatR8i = 29,
- ImageFormatRgba32ui = 30,
- ImageFormatRgba16ui = 31,
- ImageFormatRgba8ui = 32,
- ImageFormatR32ui = 33,
- ImageFormatRgb10a2ui = 34,
- ImageFormatRg32ui = 35,
- ImageFormatRg16ui = 36,
- ImageFormatRg8ui = 37,
- ImageFormatR16ui = 38,
- ImageFormatR8ui = 39,
- ImageFormatR64ui = 40,
- ImageFormatR64i = 41,
- ImageFormatMax = 0x7fffffff,
-};
-
-enum ImageChannelOrder {
- ImageChannelOrderR = 0,
- ImageChannelOrderA = 1,
- ImageChannelOrderRG = 2,
- ImageChannelOrderRA = 3,
- ImageChannelOrderRGB = 4,
- ImageChannelOrderRGBA = 5,
- ImageChannelOrderBGRA = 6,
- ImageChannelOrderARGB = 7,
- ImageChannelOrderIntensity = 8,
- ImageChannelOrderLuminance = 9,
- ImageChannelOrderRx = 10,
- ImageChannelOrderRGx = 11,
- ImageChannelOrderRGBx = 12,
- ImageChannelOrderDepth = 13,
- ImageChannelOrderDepthStencil = 14,
- ImageChannelOrdersRGB = 15,
- ImageChannelOrdersRGBx = 16,
- ImageChannelOrdersRGBA = 17,
- ImageChannelOrdersBGRA = 18,
- ImageChannelOrderABGR = 19,
- ImageChannelOrderMax = 0x7fffffff,
-};
-
-enum ImageChannelDataType {
- ImageChannelDataTypeSnormInt8 = 0,
- ImageChannelDataTypeSnormInt16 = 1,
- ImageChannelDataTypeUnormInt8 = 2,
- ImageChannelDataTypeUnormInt16 = 3,
- ImageChannelDataTypeUnormShort565 = 4,
- ImageChannelDataTypeUnormShort555 = 5,
- ImageChannelDataTypeUnormInt101010 = 6,
- ImageChannelDataTypeSignedInt8 = 7,
- ImageChannelDataTypeSignedInt16 = 8,
- ImageChannelDataTypeSignedInt32 = 9,
- ImageChannelDataTypeUnsignedInt8 = 10,
- ImageChannelDataTypeUnsignedInt16 = 11,
- ImageChannelDataTypeUnsignedInt32 = 12,
- ImageChannelDataTypeHalfFloat = 13,
- ImageChannelDataTypeFloat = 14,
- ImageChannelDataTypeUnormInt24 = 15,
- ImageChannelDataTypeUnormInt101010_2 = 16,
- ImageChannelDataTypeMax = 0x7fffffff,
-};
-
-enum ImageOperandsShift {
- ImageOperandsBiasShift = 0,
- ImageOperandsLodShift = 1,
- ImageOperandsGradShift = 2,
- ImageOperandsConstOffsetShift = 3,
- ImageOperandsOffsetShift = 4,
- ImageOperandsConstOffsetsShift = 5,
- ImageOperandsSampleShift = 6,
- ImageOperandsMinLodShift = 7,
- ImageOperandsMakeTexelAvailableShift = 8,
- ImageOperandsMakeTexelAvailableKHRShift = 8,
- ImageOperandsMakeTexelVisibleShift = 9,
- ImageOperandsMakeTexelVisibleKHRShift = 9,
- ImageOperandsNonPrivateTexelShift = 10,
- ImageOperandsNonPrivateTexelKHRShift = 10,
- ImageOperandsVolatileTexelShift = 11,
- ImageOperandsVolatileTexelKHRShift = 11,
- ImageOperandsSignExtendShift = 12,
- ImageOperandsZeroExtendShift = 13,
- ImageOperandsMax = 0x7fffffff,
-};
-
-enum ImageOperandsMask {
- ImageOperandsMaskNone = 0,
- ImageOperandsBiasMask = 0x00000001,
- ImageOperandsLodMask = 0x00000002,
- ImageOperandsGradMask = 0x00000004,
- ImageOperandsConstOffsetMask = 0x00000008,
- ImageOperandsOffsetMask = 0x00000010,
- ImageOperandsConstOffsetsMask = 0x00000020,
- ImageOperandsSampleMask = 0x00000040,
- ImageOperandsMinLodMask = 0x00000080,
- ImageOperandsMakeTexelAvailableMask = 0x00000100,
- ImageOperandsMakeTexelAvailableKHRMask = 0x00000100,
- ImageOperandsMakeTexelVisibleMask = 0x00000200,
- ImageOperandsMakeTexelVisibleKHRMask = 0x00000200,
- ImageOperandsNonPrivateTexelMask = 0x00000400,
- ImageOperandsNonPrivateTexelKHRMask = 0x00000400,
- ImageOperandsVolatileTexelMask = 0x00000800,
- ImageOperandsVolatileTexelKHRMask = 0x00000800,
- ImageOperandsSignExtendMask = 0x00001000,
- ImageOperandsZeroExtendMask = 0x00002000,
-};
-
-enum FPFastMathModeShift {
- FPFastMathModeNotNaNShift = 0,
- FPFastMathModeNotInfShift = 1,
- FPFastMathModeNSZShift = 2,
- FPFastMathModeAllowRecipShift = 3,
- FPFastMathModeFastShift = 4,
- FPFastMathModeAllowContractFastINTELShift = 16,
- FPFastMathModeAllowReassocINTELShift = 17,
- FPFastMathModeMax = 0x7fffffff,
-};
-
-enum FPFastMathModeMask {
- FPFastMathModeMaskNone = 0,
- FPFastMathModeNotNaNMask = 0x00000001,
- FPFastMathModeNotInfMask = 0x00000002,
- FPFastMathModeNSZMask = 0x00000004,
- FPFastMathModeAllowRecipMask = 0x00000008,
- FPFastMathModeFastMask = 0x00000010,
- FPFastMathModeAllowContractFastINTELMask = 0x00010000,
- FPFastMathModeAllowReassocINTELMask = 0x00020000,
-};
-
-enum FPRoundingMode {
- FPRoundingModeRTE = 0,
- FPRoundingModeRTZ = 1,
- FPRoundingModeRTP = 2,
- FPRoundingModeRTN = 3,
- FPRoundingModeMax = 0x7fffffff,
-};
-
-enum LinkageType {
- LinkageTypeExport = 0,
- LinkageTypeImport = 1,
- LinkageTypeLinkOnceODR = 2,
- LinkageTypeMax = 0x7fffffff,
-};
-
-enum AccessQualifier {
- AccessQualifierReadOnly = 0,
- AccessQualifierWriteOnly = 1,
- AccessQualifierReadWrite = 2,
- AccessQualifierMax = 0x7fffffff,
-};
-
-enum FunctionParameterAttribute {
- FunctionParameterAttributeZext = 0,
- FunctionParameterAttributeSext = 1,
- FunctionParameterAttributeByVal = 2,
- FunctionParameterAttributeSret = 3,
- FunctionParameterAttributeNoAlias = 4,
- FunctionParameterAttributeNoCapture = 5,
- FunctionParameterAttributeNoWrite = 6,
- FunctionParameterAttributeNoReadWrite = 7,
- FunctionParameterAttributeMax = 0x7fffffff,
-};
-
-enum Decoration {
- DecorationRelaxedPrecision = 0,
- DecorationSpecId = 1,
- DecorationBlock = 2,
- DecorationBufferBlock = 3,
- DecorationRowMajor = 4,
- DecorationColMajor = 5,
- DecorationArrayStride = 6,
- DecorationMatrixStride = 7,
- DecorationGLSLShared = 8,
- DecorationGLSLPacked = 9,
- DecorationCPacked = 10,
- DecorationBuiltIn = 11,
- DecorationNoPerspective = 13,
- DecorationFlat = 14,
- DecorationPatch = 15,
- DecorationCentroid = 16,
- DecorationSample = 17,
- DecorationInvariant = 18,
- DecorationRestrict = 19,
- DecorationAliased = 20,
- DecorationVolatile = 21,
- DecorationConstant = 22,
- DecorationCoherent = 23,
- DecorationNonWritable = 24,
- DecorationNonReadable = 25,
- DecorationUniform = 26,
- DecorationUniformId = 27,
- DecorationSaturatedConversion = 28,
- DecorationStream = 29,
- DecorationLocation = 30,
- DecorationComponent = 31,
- DecorationIndex = 32,
- DecorationBinding = 33,
- DecorationDescriptorSet = 34,
- DecorationOffset = 35,
- DecorationXfbBuffer = 36,
- DecorationXfbStride = 37,
- DecorationFuncParamAttr = 38,
- DecorationFPRoundingMode = 39,
- DecorationFPFastMathMode = 40,
- DecorationLinkageAttributes = 41,
- DecorationNoContraction = 42,
- DecorationInputAttachmentIndex = 43,
- DecorationAlignment = 44,
- DecorationMaxByteOffset = 45,
- DecorationAlignmentId = 46,
- DecorationMaxByteOffsetId = 47,
- DecorationNoSignedWrap = 4469,
- DecorationNoUnsignedWrap = 4470,
- DecorationExplicitInterpAMD = 4999,
- DecorationOverrideCoverageNV = 5248,
- DecorationPassthroughNV = 5250,
- DecorationViewportRelativeNV = 5252,
- DecorationSecondaryViewportRelativeNV = 5256,
- DecorationPerPrimitiveNV = 5271,
- DecorationPerViewNV = 5272,
- DecorationPerTaskNV = 5273,
- DecorationPerVertexNV = 5285,
- DecorationNonUniform = 5300,
- DecorationNonUniformEXT = 5300,
- DecorationRestrictPointer = 5355,
- DecorationRestrictPointerEXT = 5355,
- DecorationAliasedPointer = 5356,
- DecorationAliasedPointerEXT = 5356,
- DecorationSIMTCallINTEL = 5599,
- DecorationReferencedIndirectlyINTEL = 5602,
- DecorationClobberINTEL = 5607,
- DecorationSideEffectsINTEL = 5608,
- DecorationVectorComputeVariableINTEL = 5624,
- DecorationFuncParamIOKindINTEL = 5625,
- DecorationVectorComputeFunctionINTEL = 5626,
- DecorationStackCallINTEL = 5627,
- DecorationGlobalVariableOffsetINTEL = 5628,
- DecorationCounterBuffer = 5634,
- DecorationHlslCounterBufferGOOGLE = 5634,
- DecorationHlslSemanticGOOGLE = 5635,
- DecorationUserSemantic = 5635,
- DecorationUserTypeGOOGLE = 5636,
- DecorationFunctionRoundingModeINTEL = 5822,
- DecorationFunctionDenormModeINTEL = 5823,
- DecorationRegisterINTEL = 5825,
- DecorationMemoryINTEL = 5826,
- DecorationNumbanksINTEL = 5827,
- DecorationBankwidthINTEL = 5828,
- DecorationMaxPrivateCopiesINTEL = 5829,
- DecorationSinglepumpINTEL = 5830,
- DecorationDoublepumpINTEL = 5831,
- DecorationMaxReplicatesINTEL = 5832,
- DecorationSimpleDualPortINTEL = 5833,
- DecorationMergeINTEL = 5834,
- DecorationBankBitsINTEL = 5835,
- DecorationForcePow2DepthINTEL = 5836,
- DecorationBurstCoalesceINTEL = 5899,
- DecorationCacheSizeINTEL = 5900,
- DecorationDontStaticallyCoalesceINTEL = 5901,
- DecorationPrefetchINTEL = 5902,
- DecorationStallEnableINTEL = 5905,
- DecorationFuseLoopsInFunctionINTEL = 5907,
- DecorationBufferLocationINTEL = 5921,
- DecorationIOPipeStorageINTEL = 5944,
- DecorationFunctionFloatingPointModeINTEL = 6080,
- DecorationSingleElementVectorINTEL = 6085,
- DecorationVectorComputeCallableFunctionINTEL = 6087,
- DecorationMax = 0x7fffffff,
-};
-
-enum BuiltIn {
- BuiltInPosition = 0,
- BuiltInPointSize = 1,
- BuiltInClipDistance = 3,
- BuiltInCullDistance = 4,
- BuiltInVertexId = 5,
- BuiltInInstanceId = 6,
- BuiltInPrimitiveId = 7,
- BuiltInInvocationId = 8,
- BuiltInLayer = 9,
- BuiltInViewportIndex = 10,
- BuiltInTessLevelOuter = 11,
- BuiltInTessLevelInner = 12,
- BuiltInTessCoord = 13,
- BuiltInPatchVertices = 14,
- BuiltInFragCoord = 15,
- BuiltInPointCoord = 16,
- BuiltInFrontFacing = 17,
- BuiltInSampleId = 18,
- BuiltInSamplePosition = 19,
- BuiltInSampleMask = 20,
- BuiltInFragDepth = 22,
- BuiltInHelperInvocation = 23,
- BuiltInNumWorkgroups = 24,
- BuiltInWorkgroupSize = 25,
- BuiltInWorkgroupId = 26,
- BuiltInLocalInvocationId = 27,
- BuiltInGlobalInvocationId = 28,
- BuiltInLocalInvocationIndex = 29,
- BuiltInWorkDim = 30,
- BuiltInGlobalSize = 31,
- BuiltInEnqueuedWorkgroupSize = 32,
- BuiltInGlobalOffset = 33,
- BuiltInGlobalLinearId = 34,
- BuiltInSubgroupSize = 36,
- BuiltInSubgroupMaxSize = 37,
- BuiltInNumSubgroups = 38,
- BuiltInNumEnqueuedSubgroups = 39,
- BuiltInSubgroupId = 40,
- BuiltInSubgroupLocalInvocationId = 41,
- BuiltInVertexIndex = 42,
- BuiltInInstanceIndex = 43,
- BuiltInSubgroupEqMask = 4416,
- BuiltInSubgroupEqMaskKHR = 4416,
- BuiltInSubgroupGeMask = 4417,
- BuiltInSubgroupGeMaskKHR = 4417,
- BuiltInSubgroupGtMask = 4418,
- BuiltInSubgroupGtMaskKHR = 4418,
- BuiltInSubgroupLeMask = 4419,
- BuiltInSubgroupLeMaskKHR = 4419,
- BuiltInSubgroupLtMask = 4420,
- BuiltInSubgroupLtMaskKHR = 4420,
- BuiltInBaseVertex = 4424,
- BuiltInBaseInstance = 4425,
- BuiltInDrawIndex = 4426,
- BuiltInPrimitiveShadingRateKHR = 4432,
- BuiltInDeviceIndex = 4438,
- BuiltInViewIndex = 4440,
- BuiltInShadingRateKHR = 4444,
- BuiltInBaryCoordNoPerspAMD = 4992,
- BuiltInBaryCoordNoPerspCentroidAMD = 4993,
- BuiltInBaryCoordNoPerspSampleAMD = 4994,
- BuiltInBaryCoordSmoothAMD = 4995,
- BuiltInBaryCoordSmoothCentroidAMD = 4996,
- BuiltInBaryCoordSmoothSampleAMD = 4997,
- BuiltInBaryCoordPullModelAMD = 4998,
- BuiltInFragStencilRefEXT = 5014,
- BuiltInViewportMaskNV = 5253,
- BuiltInSecondaryPositionNV = 5257,
- BuiltInSecondaryViewportMaskNV = 5258,
- BuiltInPositionPerViewNV = 5261,
- BuiltInViewportMaskPerViewNV = 5262,
- BuiltInFullyCoveredEXT = 5264,
- BuiltInTaskCountNV = 5274,
- BuiltInPrimitiveCountNV = 5275,
- BuiltInPrimitiveIndicesNV = 5276,
- BuiltInClipDistancePerViewNV = 5277,
- BuiltInCullDistancePerViewNV = 5278,
- BuiltInLayerPerViewNV = 5279,
- BuiltInMeshViewCountNV = 5280,
- BuiltInMeshViewIndicesNV = 5281,
- BuiltInBaryCoordNV = 5286,
- BuiltInBaryCoordNoPerspNV = 5287,
- BuiltInFragSizeEXT = 5292,
- BuiltInFragmentSizeNV = 5292,
- BuiltInFragInvocationCountEXT = 5293,
- BuiltInInvocationsPerPixelNV = 5293,
- BuiltInLaunchIdKHR = 5319,
- BuiltInLaunchIdNV = 5319,
- BuiltInLaunchSizeKHR = 5320,
- BuiltInLaunchSizeNV = 5320,
- BuiltInWorldRayOriginKHR = 5321,
- BuiltInWorldRayOriginNV = 5321,
- BuiltInWorldRayDirectionKHR = 5322,
- BuiltInWorldRayDirectionNV = 5322,
- BuiltInObjectRayOriginKHR = 5323,
- BuiltInObjectRayOriginNV = 5323,
- BuiltInObjectRayDirectionKHR = 5324,
- BuiltInObjectRayDirectionNV = 5324,
- BuiltInRayTminKHR = 5325,
- BuiltInRayTminNV = 5325,
- BuiltInRayTmaxKHR = 5326,
- BuiltInRayTmaxNV = 5326,
- BuiltInInstanceCustomIndexKHR = 5327,
- BuiltInInstanceCustomIndexNV = 5327,
- BuiltInObjectToWorldKHR = 5330,
- BuiltInObjectToWorldNV = 5330,
- BuiltInWorldToObjectKHR = 5331,
- BuiltInWorldToObjectNV = 5331,
- BuiltInHitTNV = 5332,
- BuiltInHitKindKHR = 5333,
- BuiltInHitKindNV = 5333,
- BuiltInCurrentRayTimeNV = 5334,
- BuiltInIncomingRayFlagsKHR = 5351,
- BuiltInIncomingRayFlagsNV = 5351,
- BuiltInRayGeometryIndexKHR = 5352,
- BuiltInWarpsPerSMNV = 5374,
- BuiltInSMCountNV = 5375,
- BuiltInWarpIDNV = 5376,
- BuiltInSMIDNV = 5377,
- BuiltInMax = 0x7fffffff,
-};
-
-enum SelectionControlShift {
- SelectionControlFlattenShift = 0,
- SelectionControlDontFlattenShift = 1,
- SelectionControlMax = 0x7fffffff,
-};
-
-enum SelectionControlMask {
- SelectionControlMaskNone = 0,
- SelectionControlFlattenMask = 0x00000001,
- SelectionControlDontFlattenMask = 0x00000002,
-};
-
-enum LoopControlShift {
- LoopControlUnrollShift = 0,
- LoopControlDontUnrollShift = 1,
- LoopControlDependencyInfiniteShift = 2,
- LoopControlDependencyLengthShift = 3,
- LoopControlMinIterationsShift = 4,
- LoopControlMaxIterationsShift = 5,
- LoopControlIterationMultipleShift = 6,
- LoopControlPeelCountShift = 7,
- LoopControlPartialCountShift = 8,
- LoopControlInitiationIntervalINTELShift = 16,
- LoopControlMaxConcurrencyINTELShift = 17,
- LoopControlDependencyArrayINTELShift = 18,
- LoopControlPipelineEnableINTELShift = 19,
- LoopControlLoopCoalesceINTELShift = 20,
- LoopControlMaxInterleavingINTELShift = 21,
- LoopControlSpeculatedIterationsINTELShift = 22,
- LoopControlNoFusionINTELShift = 23,
- LoopControlMax = 0x7fffffff,
-};
-
-enum LoopControlMask {
- LoopControlMaskNone = 0,
- LoopControlUnrollMask = 0x00000001,
- LoopControlDontUnrollMask = 0x00000002,
- LoopControlDependencyInfiniteMask = 0x00000004,
- LoopControlDependencyLengthMask = 0x00000008,
- LoopControlMinIterationsMask = 0x00000010,
- LoopControlMaxIterationsMask = 0x00000020,
- LoopControlIterationMultipleMask = 0x00000040,
- LoopControlPeelCountMask = 0x00000080,
- LoopControlPartialCountMask = 0x00000100,
- LoopControlInitiationIntervalINTELMask = 0x00010000,
- LoopControlMaxConcurrencyINTELMask = 0x00020000,
- LoopControlDependencyArrayINTELMask = 0x00040000,
- LoopControlPipelineEnableINTELMask = 0x00080000,
- LoopControlLoopCoalesceINTELMask = 0x00100000,
- LoopControlMaxInterleavingINTELMask = 0x00200000,
- LoopControlSpeculatedIterationsINTELMask = 0x00400000,
- LoopControlNoFusionINTELMask = 0x00800000,
-};
-
-enum FunctionControlShift {
- FunctionControlInlineShift = 0,
- FunctionControlDontInlineShift = 1,
- FunctionControlPureShift = 2,
- FunctionControlConstShift = 3,
- FunctionControlMax = 0x7fffffff,
-};
-
-enum FunctionControlMask {
- FunctionControlMaskNone = 0,
- FunctionControlInlineMask = 0x00000001,
- FunctionControlDontInlineMask = 0x00000002,
- FunctionControlPureMask = 0x00000004,
- FunctionControlConstMask = 0x00000008,
-};
-
-enum MemorySemanticsShift {
- MemorySemanticsAcquireShift = 1,
- MemorySemanticsReleaseShift = 2,
- MemorySemanticsAcquireReleaseShift = 3,
- MemorySemanticsSequentiallyConsistentShift = 4,
- MemorySemanticsUniformMemoryShift = 6,
- MemorySemanticsSubgroupMemoryShift = 7,
- MemorySemanticsWorkgroupMemoryShift = 8,
- MemorySemanticsCrossWorkgroupMemoryShift = 9,
- MemorySemanticsAtomicCounterMemoryShift = 10,
- MemorySemanticsImageMemoryShift = 11,
- MemorySemanticsOutputMemoryShift = 12,
- MemorySemanticsOutputMemoryKHRShift = 12,
- MemorySemanticsMakeAvailableShift = 13,
- MemorySemanticsMakeAvailableKHRShift = 13,
- MemorySemanticsMakeVisibleShift = 14,
- MemorySemanticsMakeVisibleKHRShift = 14,
- MemorySemanticsVolatileShift = 15,
- MemorySemanticsMax = 0x7fffffff,
-};
-
-enum MemorySemanticsMask {
- MemorySemanticsMaskNone = 0,
- MemorySemanticsAcquireMask = 0x00000002,
- MemorySemanticsReleaseMask = 0x00000004,
- MemorySemanticsAcquireReleaseMask = 0x00000008,
- MemorySemanticsSequentiallyConsistentMask = 0x00000010,
- MemorySemanticsUniformMemoryMask = 0x00000040,
- MemorySemanticsSubgroupMemoryMask = 0x00000080,
- MemorySemanticsWorkgroupMemoryMask = 0x00000100,
- MemorySemanticsCrossWorkgroupMemoryMask = 0x00000200,
- MemorySemanticsAtomicCounterMemoryMask = 0x00000400,
- MemorySemanticsImageMemoryMask = 0x00000800,
- MemorySemanticsOutputMemoryMask = 0x00001000,
- MemorySemanticsOutputMemoryKHRMask = 0x00001000,
- MemorySemanticsMakeAvailableMask = 0x00002000,
- MemorySemanticsMakeAvailableKHRMask = 0x00002000,
- MemorySemanticsMakeVisibleMask = 0x00004000,
- MemorySemanticsMakeVisibleKHRMask = 0x00004000,
- MemorySemanticsVolatileMask = 0x00008000,
-};
-
-enum MemoryAccessShift {
- MemoryAccessVolatileShift = 0,
- MemoryAccessAlignedShift = 1,
- MemoryAccessNontemporalShift = 2,
- MemoryAccessMakePointerAvailableShift = 3,
- MemoryAccessMakePointerAvailableKHRShift = 3,
- MemoryAccessMakePointerVisibleShift = 4,
- MemoryAccessMakePointerVisibleKHRShift = 4,
- MemoryAccessNonPrivatePointerShift = 5,
- MemoryAccessNonPrivatePointerKHRShift = 5,
- MemoryAccessMax = 0x7fffffff,
-};
-
-enum MemoryAccessMask {
- MemoryAccessMaskNone = 0,
- MemoryAccessVolatileMask = 0x00000001,
- MemoryAccessAlignedMask = 0x00000002,
- MemoryAccessNontemporalMask = 0x00000004,
- MemoryAccessMakePointerAvailableMask = 0x00000008,
- MemoryAccessMakePointerAvailableKHRMask = 0x00000008,
- MemoryAccessMakePointerVisibleMask = 0x00000010,
- MemoryAccessMakePointerVisibleKHRMask = 0x00000010,
- MemoryAccessNonPrivatePointerMask = 0x00000020,
- MemoryAccessNonPrivatePointerKHRMask = 0x00000020,
-};
-
-enum Scope {
- ScopeCrossDevice = 0,
- ScopeDevice = 1,
- ScopeWorkgroup = 2,
- ScopeSubgroup = 3,
- ScopeInvocation = 4,
- ScopeQueueFamily = 5,
- ScopeQueueFamilyKHR = 5,
- ScopeShaderCallKHR = 6,
- ScopeMax = 0x7fffffff,
-};
-
-enum GroupOperation {
- GroupOperationReduce = 0,
- GroupOperationInclusiveScan = 1,
- GroupOperationExclusiveScan = 2,
- GroupOperationClusteredReduce = 3,
- GroupOperationPartitionedReduceNV = 6,
- GroupOperationPartitionedInclusiveScanNV = 7,
- GroupOperationPartitionedExclusiveScanNV = 8,
- GroupOperationMax = 0x7fffffff,
-};
-
-enum KernelEnqueueFlags {
- KernelEnqueueFlagsNoWait = 0,
- KernelEnqueueFlagsWaitKernel = 1,
- KernelEnqueueFlagsWaitWorkGroup = 2,
- KernelEnqueueFlagsMax = 0x7fffffff,
-};
-
-enum KernelProfilingInfoShift {
- KernelProfilingInfoCmdExecTimeShift = 0,
- KernelProfilingInfoMax = 0x7fffffff,
-};
-
-enum KernelProfilingInfoMask {
- KernelProfilingInfoMaskNone = 0,
- KernelProfilingInfoCmdExecTimeMask = 0x00000001,
-};
-
-enum Capability {
- CapabilityMatrix = 0,
- CapabilityShader = 1,
- CapabilityGeometry = 2,
- CapabilityTessellation = 3,
- CapabilityAddresses = 4,
- CapabilityLinkage = 5,
- CapabilityKernel = 6,
- CapabilityVector16 = 7,
- CapabilityFloat16Buffer = 8,
- CapabilityFloat16 = 9,
- CapabilityFloat64 = 10,
- CapabilityInt64 = 11,
- CapabilityInt64Atomics = 12,
- CapabilityImageBasic = 13,
- CapabilityImageReadWrite = 14,
- CapabilityImageMipmap = 15,
- CapabilityPipes = 17,
- CapabilityGroups = 18,
- CapabilityDeviceEnqueue = 19,
- CapabilityLiteralSampler = 20,
- CapabilityAtomicStorage = 21,
- CapabilityInt16 = 22,
- CapabilityTessellationPointSize = 23,
- CapabilityGeometryPointSize = 24,
- CapabilityImageGatherExtended = 25,
- CapabilityStorageImageMultisample = 27,
- CapabilityUniformBufferArrayDynamicIndexing = 28,
- CapabilitySampledImageArrayDynamicIndexing = 29,
- CapabilityStorageBufferArrayDynamicIndexing = 30,
- CapabilityStorageImageArrayDynamicIndexing = 31,
- CapabilityClipDistance = 32,
- CapabilityCullDistance = 33,
- CapabilityImageCubeArray = 34,
- CapabilitySampleRateShading = 35,
- CapabilityImageRect = 36,
- CapabilitySampledRect = 37,
- CapabilityGenericPointer = 38,
- CapabilityInt8 = 39,
- CapabilityInputAttachment = 40,
- CapabilitySparseResidency = 41,
- CapabilityMinLod = 42,
- CapabilitySampled1D = 43,
- CapabilityImage1D = 44,
- CapabilitySampledCubeArray = 45,
- CapabilitySampledBuffer = 46,
- CapabilityImageBuffer = 47,
- CapabilityImageMSArray = 48,
- CapabilityStorageImageExtendedFormats = 49,
- CapabilityImageQuery = 50,
- CapabilityDerivativeControl = 51,
- CapabilityInterpolationFunction = 52,
- CapabilityTransformFeedback = 53,
- CapabilityGeometryStreams = 54,
- CapabilityStorageImageReadWithoutFormat = 55,
- CapabilityStorageImageWriteWithoutFormat = 56,
- CapabilityMultiViewport = 57,
- CapabilitySubgroupDispatch = 58,
- CapabilityNamedBarrier = 59,
- CapabilityPipeStorage = 60,
- CapabilityGroupNonUniform = 61,
- CapabilityGroupNonUniformVote = 62,
- CapabilityGroupNonUniformArithmetic = 63,
- CapabilityGroupNonUniformBallot = 64,
- CapabilityGroupNonUniformShuffle = 65,
- CapabilityGroupNonUniformShuffleRelative = 66,
- CapabilityGroupNonUniformClustered = 67,
- CapabilityGroupNonUniformQuad = 68,
- CapabilityShaderLayer = 69,
- CapabilityShaderViewportIndex = 70,
- CapabilityFragmentShadingRateKHR = 4422,
- CapabilitySubgroupBallotKHR = 4423,
- CapabilityDrawParameters = 4427,
- CapabilityWorkgroupMemoryExplicitLayoutKHR = 4428,
- CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR = 4429,
- CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR = 4430,
- CapabilitySubgroupVoteKHR = 4431,
- CapabilityStorageBuffer16BitAccess = 4433,
- CapabilityStorageUniformBufferBlock16 = 4433,
- CapabilityStorageUniform16 = 4434,
- CapabilityUniformAndStorageBuffer16BitAccess = 4434,
- CapabilityStoragePushConstant16 = 4435,
- CapabilityStorageInputOutput16 = 4436,
- CapabilityDeviceGroup = 4437,
- CapabilityMultiView = 4439,
- CapabilityVariablePointersStorageBuffer = 4441,
- CapabilityVariablePointers = 4442,
- CapabilityAtomicStorageOps = 4445,
- CapabilitySampleMaskPostDepthCoverage = 4447,
- CapabilityStorageBuffer8BitAccess = 4448,
- CapabilityUniformAndStorageBuffer8BitAccess = 4449,
- CapabilityStoragePushConstant8 = 4450,
- CapabilityDenormPreserve = 4464,
- CapabilityDenormFlushToZero = 4465,
- CapabilitySignedZeroInfNanPreserve = 4466,
- CapabilityRoundingModeRTE = 4467,
- CapabilityRoundingModeRTZ = 4468,
- CapabilityRayQueryProvisionalKHR = 4471,
- CapabilityRayQueryKHR = 4472,
- CapabilityRayTraversalPrimitiveCullingKHR = 4478,
- CapabilityRayTracingKHR = 4479,
- CapabilityFloat16ImageAMD = 5008,
- CapabilityImageGatherBiasLodAMD = 5009,
- CapabilityFragmentMaskAMD = 5010,
- CapabilityStencilExportEXT = 5013,
- CapabilityImageReadWriteLodAMD = 5015,
- CapabilityInt64ImageEXT = 5016,
- CapabilityShaderClockKHR = 5055,
- CapabilitySampleMaskOverrideCoverageNV = 5249,
- CapabilityGeometryShaderPassthroughNV = 5251,
- CapabilityShaderViewportIndexLayerEXT = 5254,
- CapabilityShaderViewportIndexLayerNV = 5254,
- CapabilityShaderViewportMaskNV = 5255,
- CapabilityShaderStereoViewNV = 5259,
- CapabilityPerViewAttributesNV = 5260,
- CapabilityFragmentFullyCoveredEXT = 5265,
- CapabilityMeshShadingNV = 5266,
- CapabilityImageFootprintNV = 5282,
- CapabilityFragmentBarycentricNV = 5284,
- CapabilityComputeDerivativeGroupQuadsNV = 5288,
- CapabilityFragmentDensityEXT = 5291,
- CapabilityShadingRateNV = 5291,
- CapabilityGroupNonUniformPartitionedNV = 5297,
- CapabilityShaderNonUniform = 5301,
- CapabilityShaderNonUniformEXT = 5301,
- CapabilityRuntimeDescriptorArray = 5302,
- CapabilityRuntimeDescriptorArrayEXT = 5302,
- CapabilityInputAttachmentArrayDynamicIndexing = 5303,
- CapabilityInputAttachmentArrayDynamicIndexingEXT = 5303,
- CapabilityUniformTexelBufferArrayDynamicIndexing = 5304,
- CapabilityUniformTexelBufferArrayDynamicIndexingEXT = 5304,
- CapabilityStorageTexelBufferArrayDynamicIndexing = 5305,
- CapabilityStorageTexelBufferArrayDynamicIndexingEXT = 5305,
- CapabilityUniformBufferArrayNonUniformIndexing = 5306,
- CapabilityUniformBufferArrayNonUniformIndexingEXT = 5306,
- CapabilitySampledImageArrayNonUniformIndexing = 5307,
- CapabilitySampledImageArrayNonUniformIndexingEXT = 5307,
- CapabilityStorageBufferArrayNonUniformIndexing = 5308,
- CapabilityStorageBufferArrayNonUniformIndexingEXT = 5308,
- CapabilityStorageImageArrayNonUniformIndexing = 5309,
- CapabilityStorageImageArrayNonUniformIndexingEXT = 5309,
- CapabilityInputAttachmentArrayNonUniformIndexing = 5310,
- CapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310,
- CapabilityUniformTexelBufferArrayNonUniformIndexing = 5311,
- CapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311,
- CapabilityStorageTexelBufferArrayNonUniformIndexing = 5312,
- CapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312,
- CapabilityRayTracingNV = 5340,
- CapabilityRayTracingMotionBlurNV = 5341,
- CapabilityVulkanMemoryModel = 5345,
- CapabilityVulkanMemoryModelKHR = 5345,
- CapabilityVulkanMemoryModelDeviceScope = 5346,
- CapabilityVulkanMemoryModelDeviceScopeKHR = 5346,
- CapabilityPhysicalStorageBufferAddresses = 5347,
- CapabilityPhysicalStorageBufferAddressesEXT = 5347,
- CapabilityComputeDerivativeGroupLinearNV = 5350,
- CapabilityRayTracingProvisionalKHR = 5353,
- CapabilityCooperativeMatrixNV = 5357,
- CapabilityFragmentShaderSampleInterlockEXT = 5363,
- CapabilityFragmentShaderShadingRateInterlockEXT = 5372,
- CapabilityShaderSMBuiltinsNV = 5373,
- CapabilityFragmentShaderPixelInterlockEXT = 5378,
- CapabilityDemoteToHelperInvocationEXT = 5379,
- CapabilitySubgroupShuffleINTEL = 5568,
- CapabilitySubgroupBufferBlockIOINTEL = 5569,
- CapabilitySubgroupImageBlockIOINTEL = 5570,
- CapabilitySubgroupImageMediaBlockIOINTEL = 5579,
- CapabilityRoundToInfinityINTEL = 5582,
- CapabilityFloatingPointModeINTEL = 5583,
- CapabilityIntegerFunctions2INTEL = 5584,
- CapabilityFunctionPointersINTEL = 5603,
- CapabilityIndirectReferencesINTEL = 5604,
- CapabilityAsmINTEL = 5606,
- CapabilityAtomicFloat32MinMaxEXT = 5612,
- CapabilityAtomicFloat64MinMaxEXT = 5613,
- CapabilityAtomicFloat16MinMaxEXT = 5616,
- CapabilityVectorComputeINTEL = 5617,
- CapabilityVectorAnyINTEL = 5619,
- CapabilityExpectAssumeKHR = 5629,
- CapabilitySubgroupAvcMotionEstimationINTEL = 5696,
- CapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697,
- CapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698,
- CapabilityVariableLengthArrayINTEL = 5817,
- CapabilityFunctionFloatControlINTEL = 5821,
- CapabilityFPGAMemoryAttributesINTEL = 5824,
- CapabilityFPFastMathModeINTEL = 5837,
- CapabilityArbitraryPrecisionIntegersINTEL = 5844,
- CapabilityUnstructuredLoopControlsINTEL = 5886,
- CapabilityFPGALoopControlsINTEL = 5888,
- CapabilityKernelAttributesINTEL = 5892,
- CapabilityFPGAKernelAttributesINTEL = 5897,
- CapabilityFPGAMemoryAccessesINTEL = 5898,
- CapabilityFPGAClusterAttributesINTEL = 5904,
- CapabilityLoopFuseINTEL = 5906,
- CapabilityFPGABufferLocationINTEL = 5920,
- CapabilityUSMStorageClassesINTEL = 5935,
- CapabilityIOPipesINTEL = 5943,
- CapabilityBlockingPipesINTEL = 5945,
- CapabilityFPGARegINTEL = 5948,
- CapabilityAtomicFloat32AddEXT = 6033,
- CapabilityAtomicFloat64AddEXT = 6034,
- CapabilityLongConstantCompositeINTEL = 6089,
- CapabilityAtomicFloat16AddEXT = 6095,
- CapabilityMax = 0x7fffffff,
-};
-
-enum RayFlagsShift {
- RayFlagsOpaqueKHRShift = 0,
- RayFlagsNoOpaqueKHRShift = 1,
- RayFlagsTerminateOnFirstHitKHRShift = 2,
- RayFlagsSkipClosestHitShaderKHRShift = 3,
- RayFlagsCullBackFacingTrianglesKHRShift = 4,
- RayFlagsCullFrontFacingTrianglesKHRShift = 5,
- RayFlagsCullOpaqueKHRShift = 6,
- RayFlagsCullNoOpaqueKHRShift = 7,
- RayFlagsSkipTrianglesKHRShift = 8,
- RayFlagsSkipAABBsKHRShift = 9,
- RayFlagsMax = 0x7fffffff,
-};
-
-enum RayFlagsMask {
- RayFlagsMaskNone = 0,
- RayFlagsOpaqueKHRMask = 0x00000001,
- RayFlagsNoOpaqueKHRMask = 0x00000002,
- RayFlagsTerminateOnFirstHitKHRMask = 0x00000004,
- RayFlagsSkipClosestHitShaderKHRMask = 0x00000008,
- RayFlagsCullBackFacingTrianglesKHRMask = 0x00000010,
- RayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020,
- RayFlagsCullOpaqueKHRMask = 0x00000040,
- RayFlagsCullNoOpaqueKHRMask = 0x00000080,
- RayFlagsSkipTrianglesKHRMask = 0x00000100,
- RayFlagsSkipAABBsKHRMask = 0x00000200,
-};
-
-enum RayQueryIntersection {
- RayQueryIntersectionRayQueryCandidateIntersectionKHR = 0,
- RayQueryIntersectionRayQueryCommittedIntersectionKHR = 1,
- RayQueryIntersectionMax = 0x7fffffff,
-};
-
-enum RayQueryCommittedIntersectionType {
- RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0,
- RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR = 1,
- RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR = 2,
- RayQueryCommittedIntersectionTypeMax = 0x7fffffff,
-};
-
-enum RayQueryCandidateIntersectionType {
- RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR = 0,
- RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1,
- RayQueryCandidateIntersectionTypeMax = 0x7fffffff,
-};
-
-enum FragmentShadingRateShift {
- FragmentShadingRateVertical2PixelsShift = 0,
- FragmentShadingRateVertical4PixelsShift = 1,
- FragmentShadingRateHorizontal2PixelsShift = 2,
- FragmentShadingRateHorizontal4PixelsShift = 3,
- FragmentShadingRateMax = 0x7fffffff,
-};
-
-enum FragmentShadingRateMask {
- FragmentShadingRateMaskNone = 0,
- FragmentShadingRateVertical2PixelsMask = 0x00000001,
- FragmentShadingRateVertical4PixelsMask = 0x00000002,
- FragmentShadingRateHorizontal2PixelsMask = 0x00000004,
- FragmentShadingRateHorizontal4PixelsMask = 0x00000008,
-};
-
-enum FPDenormMode {
- FPDenormModePreserve = 0,
- FPDenormModeFlushToZero = 1,
- FPDenormModeMax = 0x7fffffff,
-};
-
-enum FPOperationMode {
- FPOperationModeIEEE = 0,
- FPOperationModeALT = 1,
- FPOperationModeMax = 0x7fffffff,
-};
-
-enum Op {
- OpNop = 0,
- OpUndef = 1,
- OpSourceContinued = 2,
- OpSource = 3,
- OpSourceExtension = 4,
- OpName = 5,
- OpMemberName = 6,
- OpString = 7,
- OpLine = 8,
- OpExtension = 10,
- OpExtInstImport = 11,
- OpExtInst = 12,
- OpMemoryModel = 14,
- OpEntryPoint = 15,
- OpExecutionMode = 16,
- OpCapability = 17,
- OpTypeVoid = 19,
- OpTypeBool = 20,
- OpTypeInt = 21,
- OpTypeFloat = 22,
- OpTypeVector = 23,
- OpTypeMatrix = 24,
- OpTypeImage = 25,
- OpTypeSampler = 26,
- OpTypeSampledImage = 27,
- OpTypeArray = 28,
- OpTypeRuntimeArray = 29,
- OpTypeStruct = 30,
- OpTypeOpaque = 31,
- OpTypePointer = 32,
- OpTypeFunction = 33,
- OpTypeEvent = 34,
- OpTypeDeviceEvent = 35,
- OpTypeReserveId = 36,
- OpTypeQueue = 37,
- OpTypePipe = 38,
- OpTypeForwardPointer = 39,
- OpConstantTrue = 41,
- OpConstantFalse = 42,
- OpConstant = 43,
- OpConstantComposite = 44,
- OpConstantSampler = 45,
- OpConstantNull = 46,
- OpSpecConstantTrue = 48,
- OpSpecConstantFalse = 49,
- OpSpecConstant = 50,
- OpSpecConstantComposite = 51,
- OpSpecConstantOp = 52,
- OpFunction = 54,
- OpFunctionParameter = 55,
- OpFunctionEnd = 56,
- OpFunctionCall = 57,
- OpVariable = 59,
- OpImageTexelPointer = 60,
- OpLoad = 61,
- OpStore = 62,
- OpCopyMemory = 63,
- OpCopyMemorySized = 64,
- OpAccessChain = 65,
- OpInBoundsAccessChain = 66,
- OpPtrAccessChain = 67,
- OpArrayLength = 68,
- OpGenericPtrMemSemantics = 69,
- OpInBoundsPtrAccessChain = 70,
- OpDecorate = 71,
- OpMemberDecorate = 72,
- OpDecorationGroup = 73,
- OpGroupDecorate = 74,
- OpGroupMemberDecorate = 75,
- OpVectorExtractDynamic = 77,
- OpVectorInsertDynamic = 78,
- OpVectorShuffle = 79,
- OpCompositeConstruct = 80,
- OpCompositeExtract = 81,
- OpCompositeInsert = 82,
- OpCopyObject = 83,
- OpTranspose = 84,
- OpSampledImage = 86,
- OpImageSampleImplicitLod = 87,
- OpImageSampleExplicitLod = 88,
- OpImageSampleDrefImplicitLod = 89,
- OpImageSampleDrefExplicitLod = 90,
- OpImageSampleProjImplicitLod = 91,
- OpImageSampleProjExplicitLod = 92,
- OpImageSampleProjDrefImplicitLod = 93,
- OpImageSampleProjDrefExplicitLod = 94,
- OpImageFetch = 95,
- OpImageGather = 96,
- OpImageDrefGather = 97,
- OpImageRead = 98,
- OpImageWrite = 99,
- OpImage = 100,
- OpImageQueryFormat = 101,
- OpImageQueryOrder = 102,
- OpImageQuerySizeLod = 103,
- OpImageQuerySize = 104,
- OpImageQueryLod = 105,
- OpImageQueryLevels = 106,
- OpImageQuerySamples = 107,
- OpConvertFToU = 109,
- OpConvertFToS = 110,
- OpConvertSToF = 111,
- OpConvertUToF = 112,
- OpUConvert = 113,
- OpSConvert = 114,
- OpFConvert = 115,
- OpQuantizeToF16 = 116,
- OpConvertPtrToU = 117,
- OpSatConvertSToU = 118,
- OpSatConvertUToS = 119,
- OpConvertUToPtr = 120,
- OpPtrCastToGeneric = 121,
- OpGenericCastToPtr = 122,
- OpGenericCastToPtrExplicit = 123,
- OpBitcast = 124,
- OpSNegate = 126,
- OpFNegate = 127,
- OpIAdd = 128,
- OpFAdd = 129,
- OpISub = 130,
- OpFSub = 131,
- OpIMul = 132,
- OpFMul = 133,
- OpUDiv = 134,
- OpSDiv = 135,
- OpFDiv = 136,
- OpUMod = 137,
- OpSRem = 138,
- OpSMod = 139,
- OpFRem = 140,
- OpFMod = 141,
- OpVectorTimesScalar = 142,
- OpMatrixTimesScalar = 143,
- OpVectorTimesMatrix = 144,
- OpMatrixTimesVector = 145,
- OpMatrixTimesMatrix = 146,
- OpOuterProduct = 147,
- OpDot = 148,
- OpIAddCarry = 149,
- OpISubBorrow = 150,
- OpUMulExtended = 151,
- OpSMulExtended = 152,
- OpAny = 154,
- OpAll = 155,
- OpIsNan = 156,
- OpIsInf = 157,
- OpIsFinite = 158,
- OpIsNormal = 159,
- OpSignBitSet = 160,
- OpLessOrGreater = 161,
- OpOrdered = 162,
- OpUnordered = 163,
- OpLogicalEqual = 164,
- OpLogicalNotEqual = 165,
- OpLogicalOr = 166,
- OpLogicalAnd = 167,
- OpLogicalNot = 168,
- OpSelect = 169,
- OpIEqual = 170,
- OpINotEqual = 171,
- OpUGreaterThan = 172,
- OpSGreaterThan = 173,
- OpUGreaterThanEqual = 174,
- OpSGreaterThanEqual = 175,
- OpULessThan = 176,
- OpSLessThan = 177,
- OpULessThanEqual = 178,
- OpSLessThanEqual = 179,
- OpFOrdEqual = 180,
- OpFUnordEqual = 181,
- OpFOrdNotEqual = 182,
- OpFUnordNotEqual = 183,
- OpFOrdLessThan = 184,
- OpFUnordLessThan = 185,
- OpFOrdGreaterThan = 186,
- OpFUnordGreaterThan = 187,
- OpFOrdLessThanEqual = 188,
- OpFUnordLessThanEqual = 189,
- OpFOrdGreaterThanEqual = 190,
- OpFUnordGreaterThanEqual = 191,
- OpShiftRightLogical = 194,
- OpShiftRightArithmetic = 195,
- OpShiftLeftLogical = 196,
- OpBitwiseOr = 197,
- OpBitwiseXor = 198,
- OpBitwiseAnd = 199,
- OpNot = 200,
- OpBitFieldInsert = 201,
- OpBitFieldSExtract = 202,
- OpBitFieldUExtract = 203,
- OpBitReverse = 204,
- OpBitCount = 205,
- OpDPdx = 207,
- OpDPdy = 208,
- OpFwidth = 209,
- OpDPdxFine = 210,
- OpDPdyFine = 211,
- OpFwidthFine = 212,
- OpDPdxCoarse = 213,
- OpDPdyCoarse = 214,
- OpFwidthCoarse = 215,
- OpEmitVertex = 218,
- OpEndPrimitive = 219,
- OpEmitStreamVertex = 220,
- OpEndStreamPrimitive = 221,
- OpControlBarrier = 224,
- OpMemoryBarrier = 225,
- OpAtomicLoad = 227,
- OpAtomicStore = 228,
- OpAtomicExchange = 229,
- OpAtomicCompareExchange = 230,
- OpAtomicCompareExchangeWeak = 231,
- OpAtomicIIncrement = 232,
- OpAtomicIDecrement = 233,
- OpAtomicIAdd = 234,
- OpAtomicISub = 235,
- OpAtomicSMin = 236,
- OpAtomicUMin = 237,
- OpAtomicSMax = 238,
- OpAtomicUMax = 239,
- OpAtomicAnd = 240,
- OpAtomicOr = 241,
- OpAtomicXor = 242,
- OpPhi = 245,
- OpLoopMerge = 246,
- OpSelectionMerge = 247,
- OpLabel = 248,
- OpBranch = 249,
- OpBranchConditional = 250,
- OpSwitch = 251,
- OpKill = 252,
- OpReturn = 253,
- OpReturnValue = 254,
- OpUnreachable = 255,
- OpLifetimeStart = 256,
- OpLifetimeStop = 257,
- OpGroupAsyncCopy = 259,
- OpGroupWaitEvents = 260,
- OpGroupAll = 261,
- OpGroupAny = 262,
- OpGroupBroadcast = 263,
- OpGroupIAdd = 264,
- OpGroupFAdd = 265,
- OpGroupFMin = 266,
- OpGroupUMin = 267,
- OpGroupSMin = 268,
- OpGroupFMax = 269,
- OpGroupUMax = 270,
- OpGroupSMax = 271,
- OpReadPipe = 274,
- OpWritePipe = 275,
- OpReservedReadPipe = 276,
- OpReservedWritePipe = 277,
- OpReserveReadPipePackets = 278,
- OpReserveWritePipePackets = 279,
- OpCommitReadPipe = 280,
- OpCommitWritePipe = 281,
- OpIsValidReserveId = 282,
- OpGetNumPipePackets = 283,
- OpGetMaxPipePackets = 284,
- OpGroupReserveReadPipePackets = 285,
- OpGroupReserveWritePipePackets = 286,
- OpGroupCommitReadPipe = 287,
- OpGroupCommitWritePipe = 288,
- OpEnqueueMarker = 291,
- OpEnqueueKernel = 292,
- OpGetKernelNDrangeSubGroupCount = 293,
- OpGetKernelNDrangeMaxSubGroupSize = 294,
- OpGetKernelWorkGroupSize = 295,
- OpGetKernelPreferredWorkGroupSizeMultiple = 296,
- OpRetainEvent = 297,
- OpReleaseEvent = 298,
- OpCreateUserEvent = 299,
- OpIsValidEvent = 300,
- OpSetUserEventStatus = 301,
- OpCaptureEventProfilingInfo = 302,
- OpGetDefaultQueue = 303,
- OpBuildNDRange = 304,
- OpImageSparseSampleImplicitLod = 305,
- OpImageSparseSampleExplicitLod = 306,
- OpImageSparseSampleDrefImplicitLod = 307,
- OpImageSparseSampleDrefExplicitLod = 308,
- OpImageSparseSampleProjImplicitLod = 309,
- OpImageSparseSampleProjExplicitLod = 310,
- OpImageSparseSampleProjDrefImplicitLod = 311,
- OpImageSparseSampleProjDrefExplicitLod = 312,
- OpImageSparseFetch = 313,
- OpImageSparseGather = 314,
- OpImageSparseDrefGather = 315,
- OpImageSparseTexelsResident = 316,
- OpNoLine = 317,
- OpAtomicFlagTestAndSet = 318,
- OpAtomicFlagClear = 319,
- OpImageSparseRead = 320,
- OpSizeOf = 321,
- OpTypePipeStorage = 322,
- OpConstantPipeStorage = 323,
- OpCreatePipeFromPipeStorage = 324,
- OpGetKernelLocalSizeForSubgroupCount = 325,
- OpGetKernelMaxNumSubgroups = 326,
- OpTypeNamedBarrier = 327,
- OpNamedBarrierInitialize = 328,
- OpMemoryNamedBarrier = 329,
- OpModuleProcessed = 330,
- OpExecutionModeId = 331,
- OpDecorateId = 332,
- OpGroupNonUniformElect = 333,
- OpGroupNonUniformAll = 334,
- OpGroupNonUniformAny = 335,
- OpGroupNonUniformAllEqual = 336,
- OpGroupNonUniformBroadcast = 337,
- OpGroupNonUniformBroadcastFirst = 338,
- OpGroupNonUniformBallot = 339,
- OpGroupNonUniformInverseBallot = 340,
- OpGroupNonUniformBallotBitExtract = 341,
- OpGroupNonUniformBallotBitCount = 342,
- OpGroupNonUniformBallotFindLSB = 343,
- OpGroupNonUniformBallotFindMSB = 344,
- OpGroupNonUniformShuffle = 345,
- OpGroupNonUniformShuffleXor = 346,
- OpGroupNonUniformShuffleUp = 347,
- OpGroupNonUniformShuffleDown = 348,
- OpGroupNonUniformIAdd = 349,
- OpGroupNonUniformFAdd = 350,
- OpGroupNonUniformIMul = 351,
- OpGroupNonUniformFMul = 352,
- OpGroupNonUniformSMin = 353,
- OpGroupNonUniformUMin = 354,
- OpGroupNonUniformFMin = 355,
- OpGroupNonUniformSMax = 356,
- OpGroupNonUniformUMax = 357,
- OpGroupNonUniformFMax = 358,
- OpGroupNonUniformBitwiseAnd = 359,
- OpGroupNonUniformBitwiseOr = 360,
- OpGroupNonUniformBitwiseXor = 361,
- OpGroupNonUniformLogicalAnd = 362,
- OpGroupNonUniformLogicalOr = 363,
- OpGroupNonUniformLogicalXor = 364,
- OpGroupNonUniformQuadBroadcast = 365,
- OpGroupNonUniformQuadSwap = 366,
- OpCopyLogical = 400,
- OpPtrEqual = 401,
- OpPtrNotEqual = 402,
- OpPtrDiff = 403,
- OpTerminateInvocation = 4416,
- OpSubgroupBallotKHR = 4421,
- OpSubgroupFirstInvocationKHR = 4422,
- OpSubgroupAllKHR = 4428,
- OpSubgroupAnyKHR = 4429,
- OpSubgroupAllEqualKHR = 4430,
- OpSubgroupReadInvocationKHR = 4432,
- OpTraceRayKHR = 4445,
- OpExecuteCallableKHR = 4446,
- OpConvertUToAccelerationStructureKHR = 4447,
- OpIgnoreIntersectionKHR = 4448,
- OpTerminateRayKHR = 4449,
- OpTypeRayQueryKHR = 4472,
- OpRayQueryInitializeKHR = 4473,
- OpRayQueryTerminateKHR = 4474,
- OpRayQueryGenerateIntersectionKHR = 4475,
- OpRayQueryConfirmIntersectionKHR = 4476,
- OpRayQueryProceedKHR = 4477,
- OpRayQueryGetIntersectionTypeKHR = 4479,
- OpGroupIAddNonUniformAMD = 5000,
- OpGroupFAddNonUniformAMD = 5001,
- OpGroupFMinNonUniformAMD = 5002,
- OpGroupUMinNonUniformAMD = 5003,
- OpGroupSMinNonUniformAMD = 5004,
- OpGroupFMaxNonUniformAMD = 5005,
- OpGroupUMaxNonUniformAMD = 5006,
- OpGroupSMaxNonUniformAMD = 5007,
- OpFragmentMaskFetchAMD = 5011,
- OpFragmentFetchAMD = 5012,
- OpReadClockKHR = 5056,
- OpImageSampleFootprintNV = 5283,
- OpGroupNonUniformPartitionNV = 5296,
- OpWritePackedPrimitiveIndices4x8NV = 5299,
- OpReportIntersectionKHR = 5334,
- OpReportIntersectionNV = 5334,
- OpIgnoreIntersectionNV = 5335,
- OpTerminateRayNV = 5336,
- OpTraceNV = 5337,
- OpTraceMotionNV = 5338,
- OpTraceRayMotionNV = 5339,
- OpTypeAccelerationStructureKHR = 5341,
- OpTypeAccelerationStructureNV = 5341,
- OpExecuteCallableNV = 5344,
- OpTypeCooperativeMatrixNV = 5358,
- OpCooperativeMatrixLoadNV = 5359,
- OpCooperativeMatrixStoreNV = 5360,
- OpCooperativeMatrixMulAddNV = 5361,
- OpCooperativeMatrixLengthNV = 5362,
- OpBeginInvocationInterlockEXT = 5364,
- OpEndInvocationInterlockEXT = 5365,
- OpDemoteToHelperInvocationEXT = 5380,
- OpIsHelperInvocationEXT = 5381,
- OpSubgroupShuffleINTEL = 5571,
- OpSubgroupShuffleDownINTEL = 5572,
- OpSubgroupShuffleUpINTEL = 5573,
- OpSubgroupShuffleXorINTEL = 5574,
- OpSubgroupBlockReadINTEL = 5575,
- OpSubgroupBlockWriteINTEL = 5576,
- OpSubgroupImageBlockReadINTEL = 5577,
- OpSubgroupImageBlockWriteINTEL = 5578,
- OpSubgroupImageMediaBlockReadINTEL = 5580,
- OpSubgroupImageMediaBlockWriteINTEL = 5581,
- OpUCountLeadingZerosINTEL = 5585,
- OpUCountTrailingZerosINTEL = 5586,
- OpAbsISubINTEL = 5587,
- OpAbsUSubINTEL = 5588,
- OpIAddSatINTEL = 5589,
- OpUAddSatINTEL = 5590,
- OpIAverageINTEL = 5591,
- OpUAverageINTEL = 5592,
- OpIAverageRoundedINTEL = 5593,
- OpUAverageRoundedINTEL = 5594,
- OpISubSatINTEL = 5595,
- OpUSubSatINTEL = 5596,
- OpIMul32x16INTEL = 5597,
- OpUMul32x16INTEL = 5598,
- OpConstantFunctionPointerINTEL = 5600,
- OpFunctionPointerCallINTEL = 5601,
- OpAsmTargetINTEL = 5609,
- OpAsmINTEL = 5610,
- OpAsmCallINTEL = 5611,
- OpAtomicFMinEXT = 5614,
- OpAtomicFMaxEXT = 5615,
- OpAssumeTrueKHR = 5630,
- OpExpectKHR = 5631,
- OpDecorateString = 5632,
- OpDecorateStringGOOGLE = 5632,
- OpMemberDecorateString = 5633,
- OpMemberDecorateStringGOOGLE = 5633,
- OpVmeImageINTEL = 5699,
- OpTypeVmeImageINTEL = 5700,
- OpTypeAvcImePayloadINTEL = 5701,
- OpTypeAvcRefPayloadINTEL = 5702,
- OpTypeAvcSicPayloadINTEL = 5703,
- OpTypeAvcMcePayloadINTEL = 5704,
- OpTypeAvcMceResultINTEL = 5705,
- OpTypeAvcImeResultINTEL = 5706,
- OpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707,
- OpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708,
- OpTypeAvcImeSingleReferenceStreaminINTEL = 5709,
- OpTypeAvcImeDualReferenceStreaminINTEL = 5710,
- OpTypeAvcRefResultINTEL = 5711,
- OpTypeAvcSicResultINTEL = 5712,
- OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713,
- OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714,
- OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715,
- OpSubgroupAvcMceSetInterShapePenaltyINTEL = 5716,
- OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717,
- OpSubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718,
- OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719,
- OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720,
- OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721,
- OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722,
- OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723,
- OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724,
- OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725,
- OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726,
- OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727,
- OpSubgroupAvcMceSetAcOnlyHaarINTEL = 5728,
- OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729,
- OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730,
- OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731,
- OpSubgroupAvcMceConvertToImePayloadINTEL = 5732,
- OpSubgroupAvcMceConvertToImeResultINTEL = 5733,
- OpSubgroupAvcMceConvertToRefPayloadINTEL = 5734,
- OpSubgroupAvcMceConvertToRefResultINTEL = 5735,
- OpSubgroupAvcMceConvertToSicPayloadINTEL = 5736,
- OpSubgroupAvcMceConvertToSicResultINTEL = 5737,
- OpSubgroupAvcMceGetMotionVectorsINTEL = 5738,
- OpSubgroupAvcMceGetInterDistortionsINTEL = 5739,
- OpSubgroupAvcMceGetBestInterDistortionsINTEL = 5740,
- OpSubgroupAvcMceGetInterMajorShapeINTEL = 5741,
- OpSubgroupAvcMceGetInterMinorShapeINTEL = 5742,
- OpSubgroupAvcMceGetInterDirectionsINTEL = 5743,
- OpSubgroupAvcMceGetInterMotionVectorCountINTEL = 5744,
- OpSubgroupAvcMceGetInterReferenceIdsINTEL = 5745,
- OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746,
- OpSubgroupAvcImeInitializeINTEL = 5747,
- OpSubgroupAvcImeSetSingleReferenceINTEL = 5748,
- OpSubgroupAvcImeSetDualReferenceINTEL = 5749,
- OpSubgroupAvcImeRefWindowSizeINTEL = 5750,
- OpSubgroupAvcImeAdjustRefOffsetINTEL = 5751,
- OpSubgroupAvcImeConvertToMcePayloadINTEL = 5752,
- OpSubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753,
- OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754,
- OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755,
- OpSubgroupAvcImeSetWeightedSadINTEL = 5756,
- OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757,
- OpSubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758,
- OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759,
- OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760,
- OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761,
- OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762,
- OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763,
- OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764,
- OpSubgroupAvcImeConvertToMceResultINTEL = 5765,
- OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766,
- OpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767,
- OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768,
- OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769,
- OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770,
- OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771,
- OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772,
- OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773,
- OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774,
- OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775,
- OpSubgroupAvcImeGetBorderReachedINTEL = 5776,
- OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777,
- OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778,
- OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779,
- OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780,
- OpSubgroupAvcFmeInitializeINTEL = 5781,
- OpSubgroupAvcBmeInitializeINTEL = 5782,
- OpSubgroupAvcRefConvertToMcePayloadINTEL = 5783,
- OpSubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784,
- OpSubgroupAvcRefSetBilinearFilterEnableINTEL = 5785,
- OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786,
- OpSubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787,
- OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788,
- OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789,
- OpSubgroupAvcRefConvertToMceResultINTEL = 5790,
- OpSubgroupAvcSicInitializeINTEL = 5791,
- OpSubgroupAvcSicConfigureSkcINTEL = 5792,
- OpSubgroupAvcSicConfigureIpeLumaINTEL = 5793,
- OpSubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794,
- OpSubgroupAvcSicGetMotionVectorMaskINTEL = 5795,
- OpSubgroupAvcSicConvertToMcePayloadINTEL = 5796,
- OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797,
- OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798,
- OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799,
- OpSubgroupAvcSicSetBilinearFilterEnableINTEL = 5800,
- OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801,
- OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802,
- OpSubgroupAvcSicEvaluateIpeINTEL = 5803,
- OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804,
- OpSubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805,
- OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806,
- OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807,
- OpSubgroupAvcSicConvertToMceResultINTEL = 5808,
- OpSubgroupAvcSicGetIpeLumaShapeINTEL = 5809,
- OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810,
- OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811,
- OpSubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812,
- OpSubgroupAvcSicGetIpeChromaModeINTEL = 5813,
- OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814,
- OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815,
- OpSubgroupAvcSicGetInterRawSadsINTEL = 5816,
- OpVariableLengthArrayINTEL = 5818,
- OpSaveMemoryINTEL = 5819,
- OpRestoreMemoryINTEL = 5820,
- OpLoopControlINTEL = 5887,
- OpPtrCastToCrossWorkgroupINTEL = 5934,
- OpCrossWorkgroupCastToPtrINTEL = 5938,
- OpReadPipeBlockingINTEL = 5946,
- OpWritePipeBlockingINTEL = 5947,
- OpFPGARegINTEL = 5949,
- OpRayQueryGetRayTMinKHR = 6016,
- OpRayQueryGetRayFlagsKHR = 6017,
- OpRayQueryGetIntersectionTKHR = 6018,
- OpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019,
- OpRayQueryGetIntersectionInstanceIdKHR = 6020,
- OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021,
- OpRayQueryGetIntersectionGeometryIndexKHR = 6022,
- OpRayQueryGetIntersectionPrimitiveIndexKHR = 6023,
- OpRayQueryGetIntersectionBarycentricsKHR = 6024,
- OpRayQueryGetIntersectionFrontFaceKHR = 6025,
- OpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026,
- OpRayQueryGetIntersectionObjectRayDirectionKHR = 6027,
- OpRayQueryGetIntersectionObjectRayOriginKHR = 6028,
- OpRayQueryGetWorldRayDirectionKHR = 6029,
- OpRayQueryGetWorldRayOriginKHR = 6030,
- OpRayQueryGetIntersectionObjectToWorldKHR = 6031,
- OpRayQueryGetIntersectionWorldToObjectKHR = 6032,
- OpAtomicFAddEXT = 6035,
- OpTypeBufferSurfaceINTEL = 6086,
- OpTypeStructContinuedINTEL = 6090,
- OpConstantCompositeContinuedINTEL = 6091,
- OpSpecConstantCompositeContinuedINTEL = 6092,
- OpMax = 0x7fffffff,
-};
-
-#ifdef SPV_ENABLE_UTILITY_CODE
-inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
- *hasResult = *hasResultType = false;
- switch (opcode) {
- default: /* unknown opcode */ break;
- case OpNop: *hasResult = false; *hasResultType = false; break;
- case OpUndef: *hasResult = true; *hasResultType = true; break;
- case OpSourceContinued: *hasResult = false; *hasResultType = false; break;
- case OpSource: *hasResult = false; *hasResultType = false; break;
- case OpSourceExtension: *hasResult = false; *hasResultType = false; break;
- case OpName: *hasResult = false; *hasResultType = false; break;
- case OpMemberName: *hasResult = false; *hasResultType = false; break;
- case OpString: *hasResult = true; *hasResultType = false; break;
- case OpLine: *hasResult = false; *hasResultType = false; break;
- case OpExtension: *hasResult = false; *hasResultType = false; break;
- case OpExtInstImport: *hasResult = true; *hasResultType = false; break;
- case OpExtInst: *hasResult = true; *hasResultType = true; break;
- case OpMemoryModel: *hasResult = false; *hasResultType = false; break;
- case OpEntryPoint: *hasResult = false; *hasResultType = false; break;
- case OpExecutionMode: *hasResult = false; *hasResultType = false; break;
- case OpCapability: *hasResult = false; *hasResultType = false; break;
- case OpTypeVoid: *hasResult = true; *hasResultType = false; break;
- case OpTypeBool: *hasResult = true; *hasResultType = false; break;
- case OpTypeInt: *hasResult = true; *hasResultType = false; break;
- case OpTypeFloat: *hasResult = true; *hasResultType = false; break;
- case OpTypeVector: *hasResult = true; *hasResultType = false; break;
- case OpTypeMatrix: *hasResult = true; *hasResultType = false; break;
- case OpTypeImage: *hasResult = true; *hasResultType = false; break;
- case OpTypeSampler: *hasResult = true; *hasResultType = false; break;
- case OpTypeSampledImage: *hasResult = true; *hasResultType = false; break;
- case OpTypeArray: *hasResult = true; *hasResultType = false; break;
- case OpTypeRuntimeArray: *hasResult = true; *hasResultType = false; break;
- case OpTypeStruct: *hasResult = true; *hasResultType = false; break;
- case OpTypeOpaque: *hasResult = true; *hasResultType = false; break;
- case OpTypePointer: *hasResult = true; *hasResultType = false; break;
- case OpTypeFunction: *hasResult = true; *hasResultType = false; break;
- case OpTypeEvent: *hasResult = true; *hasResultType = false; break;
- case OpTypeDeviceEvent: *hasResult = true; *hasResultType = false; break;
- case OpTypeReserveId: *hasResult = true; *hasResultType = false; break;
- case OpTypeQueue: *hasResult = true; *hasResultType = false; break;
- case OpTypePipe: *hasResult = true; *hasResultType = false; break;
- case OpTypeForwardPointer: *hasResult = false; *hasResultType = false; break;
- case OpConstantTrue: *hasResult = true; *hasResultType = true; break;
- case OpConstantFalse: *hasResult = true; *hasResultType = true; break;
- case OpConstant: *hasResult = true; *hasResultType = true; break;
- case OpConstantComposite: *hasResult = true; *hasResultType = true; break;
- case OpConstantSampler: *hasResult = true; *hasResultType = true; break;
- case OpConstantNull: *hasResult = true; *hasResultType = true; break;
- case OpSpecConstantTrue: *hasResult = true; *hasResultType = true; break;
- case OpSpecConstantFalse: *hasResult = true; *hasResultType = true; break;
- case OpSpecConstant: *hasResult = true; *hasResultType = true; break;
- case OpSpecConstantComposite: *hasResult = true; *hasResultType = true; break;
- case OpSpecConstantOp: *hasResult = true; *hasResultType = true; break;
- case OpFunction: *hasResult = true; *hasResultType = true; break;
- case OpFunctionParameter: *hasResult = true; *hasResultType = true; break;
- case OpFunctionEnd: *hasResult = false; *hasResultType = false; break;
- case OpFunctionCall: *hasResult = true; *hasResultType = true; break;
- case OpVariable: *hasResult = true; *hasResultType = true; break;
- case OpImageTexelPointer: *hasResult = true; *hasResultType = true; break;
- case OpLoad: *hasResult = true; *hasResultType = true; break;
- case OpStore: *hasResult = false; *hasResultType = false; break;
- case OpCopyMemory: *hasResult = false; *hasResultType = false; break;
- case OpCopyMemorySized: *hasResult = false; *hasResultType = false; break;
- case OpAccessChain: *hasResult = true; *hasResultType = true; break;
- case OpInBoundsAccessChain: *hasResult = true; *hasResultType = true; break;
- case OpPtrAccessChain: *hasResult = true; *hasResultType = true; break;
- case OpArrayLength: *hasResult = true; *hasResultType = true; break;
- case OpGenericPtrMemSemantics: *hasResult = true; *hasResultType = true; break;
- case OpInBoundsPtrAccessChain: *hasResult = true; *hasResultType = true; break;
- case OpDecorate: *hasResult = false; *hasResultType = false; break;
- case OpMemberDecorate: *hasResult = false; *hasResultType = false; break;
- case OpDecorationGroup: *hasResult = true; *hasResultType = false; break;
- case OpGroupDecorate: *hasResult = false; *hasResultType = false; break;
- case OpGroupMemberDecorate: *hasResult = false; *hasResultType = false; break;
- case OpVectorExtractDynamic: *hasResult = true; *hasResultType = true; break;
- case OpVectorInsertDynamic: *hasResult = true; *hasResultType = true; break;
- case OpVectorShuffle: *hasResult = true; *hasResultType = true; break;
- case OpCompositeConstruct: *hasResult = true; *hasResultType = true; break;
- case OpCompositeExtract: *hasResult = true; *hasResultType = true; break;
- case OpCompositeInsert: *hasResult = true; *hasResultType = true; break;
- case OpCopyObject: *hasResult = true; *hasResultType = true; break;
- case OpTranspose: *hasResult = true; *hasResultType = true; break;
- case OpSampledImage: *hasResult = true; *hasResultType = true; break;
- case OpImageSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
- case OpImageSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
- case OpImageSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
- case OpImageSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
- case OpImageSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
- case OpImageSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
- case OpImageSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
- case OpImageSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
- case OpImageFetch: *hasResult = true; *hasResultType = true; break;
- case OpImageGather: *hasResult = true; *hasResultType = true; break;
- case OpImageDrefGather: *hasResult = true; *hasResultType = true; break;
- case OpImageRead: *hasResult = true; *hasResultType = true; break;
- case OpImageWrite: *hasResult = false; *hasResultType = false; break;
- case OpImage: *hasResult = true; *hasResultType = true; break;
- case OpImageQueryFormat: *hasResult = true; *hasResultType = true; break;
- case OpImageQueryOrder: *hasResult = true; *hasResultType = true; break;
- case OpImageQuerySizeLod: *hasResult = true; *hasResultType = true; break;
- case OpImageQuerySize: *hasResult = true; *hasResultType = true; break;
- case OpImageQueryLod: *hasResult = true; *hasResultType = true; break;
- case OpImageQueryLevels: *hasResult = true; *hasResultType = true; break;
- case OpImageQuerySamples: *hasResult = true; *hasResultType = true; break;
- case OpConvertFToU: *hasResult = true; *hasResultType = true; break;
- case OpConvertFToS: *hasResult = true; *hasResultType = true; break;
- case OpConvertSToF: *hasResult = true; *hasResultType = true; break;
- case OpConvertUToF: *hasResult = true; *hasResultType = true; break;
- case OpUConvert: *hasResult = true; *hasResultType = true; break;
- case OpSConvert: *hasResult = true; *hasResultType = true; break;
- case OpFConvert: *hasResult = true; *hasResultType = true; break;
- case OpQuantizeToF16: *hasResult = true; *hasResultType = true; break;
- case OpConvertPtrToU: *hasResult = true; *hasResultType = true; break;
- case OpSatConvertSToU: *hasResult = true; *hasResultType = true; break;
- case OpSatConvertUToS: *hasResult = true; *hasResultType = true; break;
- case OpConvertUToPtr: *hasResult = true; *hasResultType = true; break;
- case OpPtrCastToGeneric: *hasResult = true; *hasResultType = true; break;
- case OpGenericCastToPtr: *hasResult = true; *hasResultType = true; break;
- case OpGenericCastToPtrExplicit: *hasResult = true; *hasResultType = true; break;
- case OpBitcast: *hasResult = true; *hasResultType = true; break;
- case OpSNegate: *hasResult = true; *hasResultType = true; break;
- case OpFNegate: *hasResult = true; *hasResultType = true; break;
- case OpIAdd: *hasResult = true; *hasResultType = true; break;
- case OpFAdd: *hasResult = true; *hasResultType = true; break;
- case OpISub: *hasResult = true; *hasResultType = true; break;
- case OpFSub: *hasResult = true; *hasResultType = true; break;
- case OpIMul: *hasResult = true; *hasResultType = true; break;
- case OpFMul: *hasResult = true; *hasResultType = true; break;
- case OpUDiv: *hasResult = true; *hasResultType = true; break;
- case OpSDiv: *hasResult = true; *hasResultType = true; break;
- case OpFDiv: *hasResult = true; *hasResultType = true; break;
- case OpUMod: *hasResult = true; *hasResultType = true; break;
- case OpSRem: *hasResult = true; *hasResultType = true; break;
- case OpSMod: *hasResult = true; *hasResultType = true; break;
- case OpFRem: *hasResult = true; *hasResultType = true; break;
- case OpFMod: *hasResult = true; *hasResultType = true; break;
- case OpVectorTimesScalar: *hasResult = true; *hasResultType = true; break;
- case OpMatrixTimesScalar: *hasResult = true; *hasResultType = true; break;
- case OpVectorTimesMatrix: *hasResult = true; *hasResultType = true; break;
- case OpMatrixTimesVector: *hasResult = true; *hasResultType = true; break;
- case OpMatrixTimesMatrix: *hasResult = true; *hasResultType = true; break;
- case OpOuterProduct: *hasResult = true; *hasResultType = true; break;
- case OpDot: *hasResult = true; *hasResultType = true; break;
- case OpIAddCarry: *hasResult = true; *hasResultType = true; break;
- case OpISubBorrow: *hasResult = true; *hasResultType = true; break;
- case OpUMulExtended: *hasResult = true; *hasResultType = true; break;
- case OpSMulExtended: *hasResult = true; *hasResultType = true; break;
- case OpAny: *hasResult = true; *hasResultType = true; break;
- case OpAll: *hasResult = true; *hasResultType = true; break;
- case OpIsNan: *hasResult = true; *hasResultType = true; break;
- case OpIsInf: *hasResult = true; *hasResultType = true; break;
- case OpIsFinite: *hasResult = true; *hasResultType = true; break;
- case OpIsNormal: *hasResult = true; *hasResultType = true; break;
- case OpSignBitSet: *hasResult = true; *hasResultType = true; break;
- case OpLessOrGreater: *hasResult = true; *hasResultType = true; break;
- case OpOrdered: *hasResult = true; *hasResultType = true; break;
- case OpUnordered: *hasResult = true; *hasResultType = true; break;
- case OpLogicalEqual: *hasResult = true; *hasResultType = true; break;
- case OpLogicalNotEqual: *hasResult = true; *hasResultType = true; break;
- case OpLogicalOr: *hasResult = true; *hasResultType = true; break;
- case OpLogicalAnd: *hasResult = true; *hasResultType = true; break;
- case OpLogicalNot: *hasResult = true; *hasResultType = true; break;
- case OpSelect: *hasResult = true; *hasResultType = true; break;
- case OpIEqual: *hasResult = true; *hasResultType = true; break;
- case OpINotEqual: *hasResult = true; *hasResultType = true; break;
- case OpUGreaterThan: *hasResult = true; *hasResultType = true; break;
- case OpSGreaterThan: *hasResult = true; *hasResultType = true; break;
- case OpUGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
- case OpSGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
- case OpULessThan: *hasResult = true; *hasResultType = true; break;
- case OpSLessThan: *hasResult = true; *hasResultType = true; break;
- case OpULessThanEqual: *hasResult = true; *hasResultType = true; break;
- case OpSLessThanEqual: *hasResult = true; *hasResultType = true; break;
- case OpFOrdEqual: *hasResult = true; *hasResultType = true; break;
- case OpFUnordEqual: *hasResult = true; *hasResultType = true; break;
- case OpFOrdNotEqual: *hasResult = true; *hasResultType = true; break;
- case OpFUnordNotEqual: *hasResult = true; *hasResultType = true; break;
- case OpFOrdLessThan: *hasResult = true; *hasResultType = true; break;
- case OpFUnordLessThan: *hasResult = true; *hasResultType = true; break;
- case OpFOrdGreaterThan: *hasResult = true; *hasResultType = true; break;
- case OpFUnordGreaterThan: *hasResult = true; *hasResultType = true; break;
- case OpFOrdLessThanEqual: *hasResult = true; *hasResultType = true; break;
- case OpFUnordLessThanEqual: *hasResult = true; *hasResultType = true; break;
- case OpFOrdGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
- case OpFUnordGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
- case OpShiftRightLogical: *hasResult = true; *hasResultType = true; break;
- case OpShiftRightArithmetic: *hasResult = true; *hasResultType = true; break;
- case OpShiftLeftLogical: *hasResult = true; *hasResultType = true; break;
- case OpBitwiseOr: *hasResult = true; *hasResultType = true; break;
- case OpBitwiseXor: *hasResult = true; *hasResultType = true; break;
- case OpBitwiseAnd: *hasResult = true; *hasResultType = true; break;
- case OpNot: *hasResult = true; *hasResultType = true; break;
- case OpBitFieldInsert: *hasResult = true; *hasResultType = true; break;
- case OpBitFieldSExtract: *hasResult = true; *hasResultType = true; break;
- case OpBitFieldUExtract: *hasResult = true; *hasResultType = true; break;
- case OpBitReverse: *hasResult = true; *hasResultType = true; break;
- case OpBitCount: *hasResult = true; *hasResultType = true; break;
- case OpDPdx: *hasResult = true; *hasResultType = true; break;
- case OpDPdy: *hasResult = true; *hasResultType = true; break;
- case OpFwidth: *hasResult = true; *hasResultType = true; break;
- case OpDPdxFine: *hasResult = true; *hasResultType = true; break;
- case OpDPdyFine: *hasResult = true; *hasResultType = true; break;
- case OpFwidthFine: *hasResult = true; *hasResultType = true; break;
- case OpDPdxCoarse: *hasResult = true; *hasResultType = true; break;
- case OpDPdyCoarse: *hasResult = true; *hasResultType = true; break;
- case OpFwidthCoarse: *hasResult = true; *hasResultType = true; break;
- case OpEmitVertex: *hasResult = false; *hasResultType = false; break;
- case OpEndPrimitive: *hasResult = false; *hasResultType = false; break;
- case OpEmitStreamVertex: *hasResult = false; *hasResultType = false; break;
- case OpEndStreamPrimitive: *hasResult = false; *hasResultType = false; break;
- case OpControlBarrier: *hasResult = false; *hasResultType = false; break;
- case OpMemoryBarrier: *hasResult = false; *hasResultType = false; break;
- case OpAtomicLoad: *hasResult = true; *hasResultType = true; break;
- case OpAtomicStore: *hasResult = false; *hasResultType = false; break;
- case OpAtomicExchange: *hasResult = true; *hasResultType = true; break;
- case OpAtomicCompareExchange: *hasResult = true; *hasResultType = true; break;
- case OpAtomicCompareExchangeWeak: *hasResult = true; *hasResultType = true; break;
- case OpAtomicIIncrement: *hasResult = true; *hasResultType = true; break;
- case OpAtomicIDecrement: *hasResult = true; *hasResultType = true; break;
- case OpAtomicIAdd: *hasResult = true; *hasResultType = true; break;
- case OpAtomicISub: *hasResult = true; *hasResultType = true; break;
- case OpAtomicSMin: *hasResult = true; *hasResultType = true; break;
- case OpAtomicUMin: *hasResult = true; *hasResultType = true; break;
- case OpAtomicSMax: *hasResult = true; *hasResultType = true; break;
- case OpAtomicUMax: *hasResult = true; *hasResultType = true; break;
- case OpAtomicAnd: *hasResult = true; *hasResultType = true; break;
- case OpAtomicOr: *hasResult = true; *hasResultType = true; break;
- case OpAtomicXor: *hasResult = true; *hasResultType = true; break;
- case OpPhi: *hasResult = true; *hasResultType = true; break;
- case OpLoopMerge: *hasResult = false; *hasResultType = false; break;
- case OpSelectionMerge: *hasResult = false; *hasResultType = false; break;
- case OpLabel: *hasResult = true; *hasResultType = false; break;
- case OpBranch: *hasResult = false; *hasResultType = false; break;
- case OpBranchConditional: *hasResult = false; *hasResultType = false; break;
- case OpSwitch: *hasResult = false; *hasResultType = false; break;
- case OpKill: *hasResult = false; *hasResultType = false; break;
- case OpReturn: *hasResult = false; *hasResultType = false; break;
- case OpReturnValue: *hasResult = false; *hasResultType = false; break;
- case OpUnreachable: *hasResult = false; *hasResultType = false; break;
- case OpLifetimeStart: *hasResult = false; *hasResultType = false; break;
- case OpLifetimeStop: *hasResult = false; *hasResultType = false; break;
- case OpGroupAsyncCopy: *hasResult = true; *hasResultType = true; break;
- case OpGroupWaitEvents: *hasResult = false; *hasResultType = false; break;
- case OpGroupAll: *hasResult = true; *hasResultType = true; break;
- case OpGroupAny: *hasResult = true; *hasResultType = true; break;
- case OpGroupBroadcast: *hasResult = true; *hasResultType = true; break;
- case OpGroupIAdd: *hasResult = true; *hasResultType = true; break;
- case OpGroupFAdd: *hasResult = true; *hasResultType = true; break;
- case OpGroupFMin: *hasResult = true; *hasResultType = true; break;
- case OpGroupUMin: *hasResult = true; *hasResultType = true; break;
- case OpGroupSMin: *hasResult = true; *hasResultType = true; break;
- case OpGroupFMax: *hasResult = true; *hasResultType = true; break;
- case OpGroupUMax: *hasResult = true; *hasResultType = true; break;
- case OpGroupSMax: *hasResult = true; *hasResultType = true; break;
- case OpReadPipe: *hasResult = true; *hasResultType = true; break;
- case OpWritePipe: *hasResult = true; *hasResultType = true; break;
- case OpReservedReadPipe: *hasResult = true; *hasResultType = true; break;
- case OpReservedWritePipe: *hasResult = true; *hasResultType = true; break;
- case OpReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
- case OpReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
- case OpCommitReadPipe: *hasResult = false; *hasResultType = false; break;
- case OpCommitWritePipe: *hasResult = false; *hasResultType = false; break;
- case OpIsValidReserveId: *hasResult = true; *hasResultType = true; break;
- case OpGetNumPipePackets: *hasResult = true; *hasResultType = true; break;
- case OpGetMaxPipePackets: *hasResult = true; *hasResultType = true; break;
- case OpGroupReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
- case OpGroupReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
- case OpGroupCommitReadPipe: *hasResult = false; *hasResultType = false; break;
- case OpGroupCommitWritePipe: *hasResult = false; *hasResultType = false; break;
- case OpEnqueueMarker: *hasResult = true; *hasResultType = true; break;
- case OpEnqueueKernel: *hasResult = true; *hasResultType = true; break;
- case OpGetKernelNDrangeSubGroupCount: *hasResult = true; *hasResultType = true; break;
- case OpGetKernelNDrangeMaxSubGroupSize: *hasResult = true; *hasResultType = true; break;
- case OpGetKernelWorkGroupSize: *hasResult = true; *hasResultType = true; break;
- case OpGetKernelPreferredWorkGroupSizeMultiple: *hasResult = true; *hasResultType = true; break;
- case OpRetainEvent: *hasResult = false; *hasResultType = false; break;
- case OpReleaseEvent: *hasResult = false; *hasResultType = false; break;
- case OpCreateUserEvent: *hasResult = true; *hasResultType = true; break;
- case OpIsValidEvent: *hasResult = true; *hasResultType = true; break;
- case OpSetUserEventStatus: *hasResult = false; *hasResultType = false; break;
- case OpCaptureEventProfilingInfo: *hasResult = false; *hasResultType = false; break;
- case OpGetDefaultQueue: *hasResult = true; *hasResultType = true; break;
- case OpBuildNDRange: *hasResult = true; *hasResultType = true; break;
- case OpImageSparseSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
- case OpImageSparseSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
- case OpImageSparseSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
- case OpImageSparseSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
- case OpImageSparseSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
- case OpImageSparseSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
- case OpImageSparseSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
- case OpImageSparseSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
- case OpImageSparseFetch: *hasResult = true; *hasResultType = true; break;
- case OpImageSparseGather: *hasResult = true; *hasResultType = true; break;
- case OpImageSparseDrefGather: *hasResult = true; *hasResultType = true; break;
- case OpImageSparseTexelsResident: *hasResult = true; *hasResultType = true; break;
- case OpNoLine: *hasResult = false; *hasResultType = false; break;
- case OpAtomicFlagTestAndSet: *hasResult = true; *hasResultType = true; break;
- case OpAtomicFlagClear: *hasResult = false; *hasResultType = false; break;
- case OpImageSparseRead: *hasResult = true; *hasResultType = true; break;
- case OpSizeOf: *hasResult = true; *hasResultType = true; break;
- case OpTypePipeStorage: *hasResult = true; *hasResultType = false; break;
- case OpConstantPipeStorage: *hasResult = true; *hasResultType = true; break;
- case OpCreatePipeFromPipeStorage: *hasResult = true; *hasResultType = true; break;
- case OpGetKernelLocalSizeForSubgroupCount: *hasResult = true; *hasResultType = true; break;
- case OpGetKernelMaxNumSubgroups: *hasResult = true; *hasResultType = true; break;
- case OpTypeNamedBarrier: *hasResult = true; *hasResultType = false; break;
- case OpNamedBarrierInitialize: *hasResult = true; *hasResultType = true; break;
- case OpMemoryNamedBarrier: *hasResult = false; *hasResultType = false; break;
- case OpModuleProcessed: *hasResult = false; *hasResultType = false; break;
- case OpExecutionModeId: *hasResult = false; *hasResultType = false; break;
- case OpDecorateId: *hasResult = false; *hasResultType = false; break;
- case OpGroupNonUniformElect: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformAll: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformAny: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformAllEqual: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformBroadcast: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformBroadcastFirst: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformBallot: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformInverseBallot: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformBallotBitExtract: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformBallotBitCount: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformBallotFindLSB: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformBallotFindMSB: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformShuffle: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformShuffleXor: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformShuffleUp: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformShuffleDown: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformIAdd: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformFAdd: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformIMul: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformFMul: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformSMin: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformUMin: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformFMin: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformSMax: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformUMax: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformFMax: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformBitwiseAnd: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformBitwiseOr: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformBitwiseXor: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformLogicalAnd: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformLogicalOr: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformLogicalXor: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformQuadBroadcast: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformQuadSwap: *hasResult = true; *hasResultType = true; break;
- case OpCopyLogical: *hasResult = true; *hasResultType = true; break;
- case OpPtrEqual: *hasResult = true; *hasResultType = true; break;
- case OpPtrNotEqual: *hasResult = true; *hasResultType = true; break;
- case OpPtrDiff: *hasResult = true; *hasResultType = true; break;
- case OpTerminateInvocation: *hasResult = false; *hasResultType = false; break;
- case OpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break;
- case OpTraceRayKHR: *hasResult = false; *hasResultType = false; break;
- case OpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break;
- case OpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break;
- case OpIgnoreIntersectionKHR: *hasResult = false; *hasResultType = false; break;
- case OpTerminateRayKHR: *hasResult = false; *hasResultType = false; break;
- case OpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break;
- case OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break;
- case OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break;
- case OpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break;
- case OpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break;
- case OpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break;
- case OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
- case OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
- case OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
- case OpGroupUMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
- case OpGroupSMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
- case OpGroupFMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
- case OpGroupUMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
- case OpGroupSMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
- case OpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break;
- case OpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break;
- case OpReadClockKHR: *hasResult = true; *hasResultType = true; break;
- case OpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break;
- case OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break;
- case OpReportIntersectionNV: *hasResult = true; *hasResultType = true; break;
- case OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break;
- case OpTerminateRayNV: *hasResult = false; *hasResultType = false; break;
- case OpTraceNV: *hasResult = false; *hasResultType = false; break;
- case OpTraceMotionNV: *hasResult = false; *hasResultType = false; break;
- case OpTraceRayMotionNV: *hasResult = false; *hasResultType = false; break;
- case OpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break;
- case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break;
- case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break;
- case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break;
- case OpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break;
- case OpCooperativeMatrixMulAddNV: *hasResult = true; *hasResultType = true; break;
- case OpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break;
- case OpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
- case OpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
- case OpDemoteToHelperInvocationEXT: *hasResult = false; *hasResultType = false; break;
- case OpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupShuffleXorINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
- case OpSubgroupImageBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupImageBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
- case OpSubgroupImageMediaBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupImageMediaBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
- case OpUCountLeadingZerosINTEL: *hasResult = true; *hasResultType = true; break;
- case OpUCountTrailingZerosINTEL: *hasResult = true; *hasResultType = true; break;
- case OpAbsISubINTEL: *hasResult = true; *hasResultType = true; break;
- case OpAbsUSubINTEL: *hasResult = true; *hasResultType = true; break;
- case OpIAddSatINTEL: *hasResult = true; *hasResultType = true; break;
- case OpUAddSatINTEL: *hasResult = true; *hasResultType = true; break;
- case OpIAverageINTEL: *hasResult = true; *hasResultType = true; break;
- case OpUAverageINTEL: *hasResult = true; *hasResultType = true; break;
- case OpIAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
- case OpUAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
- case OpISubSatINTEL: *hasResult = true; *hasResultType = true; break;
- case OpUSubSatINTEL: *hasResult = true; *hasResultType = true; break;
- case OpIMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
- case OpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
- case OpConstantFunctionPointerINTEL: *hasResult = true; *hasResultType = true; break;
- case OpFunctionPointerCallINTEL: *hasResult = true; *hasResultType = true; break;
- case OpAsmTargetINTEL: *hasResult = true; *hasResultType = true; break;
- case OpAsmINTEL: *hasResult = true; *hasResultType = true; break;
- case OpAsmCallINTEL: *hasResult = true; *hasResultType = true; break;
- case OpAtomicFMinEXT: *hasResult = true; *hasResultType = true; break;
- case OpAtomicFMaxEXT: *hasResult = true; *hasResultType = true; break;
- case OpAssumeTrueKHR: *hasResult = false; *hasResultType = false; break;
- case OpExpectKHR: *hasResult = true; *hasResultType = true; break;
- case OpDecorateString: *hasResult = false; *hasResultType = false; break;
- case OpMemberDecorateString: *hasResult = false; *hasResultType = false; break;
- case OpVmeImageINTEL: *hasResult = true; *hasResultType = true; break;
- case OpTypeVmeImageINTEL: *hasResult = true; *hasResultType = false; break;
- case OpTypeAvcImePayloadINTEL: *hasResult = true; *hasResultType = false; break;
- case OpTypeAvcRefPayloadINTEL: *hasResult = true; *hasResultType = false; break;
- case OpTypeAvcSicPayloadINTEL: *hasResult = true; *hasResultType = false; break;
- case OpTypeAvcMcePayloadINTEL: *hasResult = true; *hasResultType = false; break;
- case OpTypeAvcMceResultINTEL: *hasResult = true; *hasResultType = false; break;
- case OpTypeAvcImeResultINTEL: *hasResult = true; *hasResultType = false; break;
- case OpTypeAvcImeResultSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
- case OpTypeAvcImeResultDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
- case OpTypeAvcImeSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
- case OpTypeAvcImeDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
- case OpTypeAvcRefResultINTEL: *hasResult = true; *hasResultType = false; break;
- case OpTypeAvcSicResultINTEL: *hasResult = true; *hasResultType = false; break;
- case OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceSetInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceSetAcOnlyHaarINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceConvertToImePayloadINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceConvertToImeResultINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceConvertToRefPayloadINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceConvertToRefResultINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceConvertToSicPayloadINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceConvertToSicResultINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetBestInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetInterMajorShapeINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetInterMinorShapeINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetInterDirectionsINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetInterMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetInterReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeSetSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeSetDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeRefWindowSizeINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeAdjustRefOffsetINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeSetWeightedSadINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeGetDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeGetBorderReachedINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcFmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcBmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcRefConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcRefSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break;
- case OpVariableLengthArrayINTEL: *hasResult = true; *hasResultType = true; break;
- case OpSaveMemoryINTEL: *hasResult = true; *hasResultType = true; break;
- case OpRestoreMemoryINTEL: *hasResult = false; *hasResultType = false; break;
- case OpLoopControlINTEL: *hasResult = false; *hasResultType = false; break;
- case OpPtrCastToCrossWorkgroupINTEL: *hasResult = true; *hasResultType = true; break;
- case OpCrossWorkgroupCastToPtrINTEL: *hasResult = true; *hasResultType = true; break;
- case OpReadPipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
- case OpWritePipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
- case OpFPGARegINTEL: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break;
- case OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break;
- case OpAtomicFAddEXT: *hasResult = true; *hasResultType = true; break;
- case OpTypeBufferSurfaceINTEL: *hasResult = true; *hasResultType = false; break;
- case OpTypeStructContinuedINTEL: *hasResult = false; *hasResultType = false; break;
- case OpConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
- case OpSpecConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
- }
-}
-#endif /* SPV_ENABLE_UTILITY_CODE */
-
-// Overload operator| for mask bit combining
-
-inline ImageOperandsMask operator|(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) | unsigned(b)); }
-inline FPFastMathModeMask operator|(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) | unsigned(b)); }
-inline SelectionControlMask operator|(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) | unsigned(b)); }
-inline LoopControlMask operator|(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) | unsigned(b)); }
-inline FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) | unsigned(b)); }
-inline MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); }
-inline MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); }
-inline KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); }
-inline RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) | unsigned(b)); }
-inline FragmentShadingRateMask operator|(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) | unsigned(b)); }
-
-} // end namespace spv
-
-#endif // #ifndef spirv_HPP
-
+// Copyright (c) 2014-2020 The Khronos Group Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and/or associated documentation files (the "Materials"),
+// to deal in the Materials without restriction, including without limitation
+// the rights to use, copy, modify, merge, publish, distribute, sublicense,
+// and/or sell copies of the Materials, and to permit persons to whom the
+// Materials are 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 Materials.
+//
+// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
+//
+// THE MATERIALS ARE 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 MATERIALS OR THE USE OR OTHER DEALINGS
+// IN THE MATERIALS.
+
+// This header is automatically generated by the same tool that creates
+// the Binary Section of the SPIR-V specification.
+
+// Enumeration tokens for SPIR-V, in various styles:
+// C, C++, C++11, JSON, Lua, Python, C#, D
+//
+// - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
+// - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
+// - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
+// - Lua will use tables, e.g.: spv.SourceLanguage.GLSL
+// - Python will use dictionaries, e.g.: spv['SourceLanguage']['GLSL']
+// - C# will use enum classes in the Specification class located in the "Spv" namespace,
+// e.g.: Spv.Specification.SourceLanguage.GLSL
+// - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL
+//
+// Some tokens act like mask values, which can be OR'd together,
+// while others are mutually exclusive. The mask-like ones have
+// "Mask" in their name, and a parallel enum that has the shift
+// amount (1 << x) for each corresponding enumerant.
+
+#ifndef spirv_HPP
+#define spirv_HPP
+
+namespace spv {
+
+typedef unsigned int Id;
+
+#define SPV_VERSION 0x10600
+#define SPV_REVISION 1
+
+static const unsigned int MagicNumber = 0x07230203;
+static const unsigned int Version = 0x00010600;
+static const unsigned int Revision = 1;
+static const unsigned int OpCodeMask = 0xffff;
+static const unsigned int WordCountShift = 16;
+
+enum SourceLanguage {
+ SourceLanguageUnknown = 0,
+ SourceLanguageESSL = 1,
+ SourceLanguageGLSL = 2,
+ SourceLanguageOpenCL_C = 3,
+ SourceLanguageOpenCL_CPP = 4,
+ SourceLanguageHLSL = 5,
+ SourceLanguageCPP_for_OpenCL = 6,
+ SourceLanguageMax = 0x7fffffff,
+};
+
+enum ExecutionModel {
+ ExecutionModelVertex = 0,
+ ExecutionModelTessellationControl = 1,
+ ExecutionModelTessellationEvaluation = 2,
+ ExecutionModelGeometry = 3,
+ ExecutionModelFragment = 4,
+ ExecutionModelGLCompute = 5,
+ ExecutionModelKernel = 6,
+ ExecutionModelTaskNV = 5267,
+ ExecutionModelMeshNV = 5268,
+ ExecutionModelRayGenerationKHR = 5313,
+ ExecutionModelRayGenerationNV = 5313,
+ ExecutionModelIntersectionKHR = 5314,
+ ExecutionModelIntersectionNV = 5314,
+ ExecutionModelAnyHitKHR = 5315,
+ ExecutionModelAnyHitNV = 5315,
+ ExecutionModelClosestHitKHR = 5316,
+ ExecutionModelClosestHitNV = 5316,
+ ExecutionModelMissKHR = 5317,
+ ExecutionModelMissNV = 5317,
+ ExecutionModelCallableKHR = 5318,
+ ExecutionModelCallableNV = 5318,
+ ExecutionModelTaskEXT = 5364,
+ ExecutionModelMeshEXT = 5365,
+ ExecutionModelMax = 0x7fffffff,
+};
+
+enum AddressingModel {
+ AddressingModelLogical = 0,
+ AddressingModelPhysical32 = 1,
+ AddressingModelPhysical64 = 2,
+ AddressingModelPhysicalStorageBuffer64 = 5348,
+ AddressingModelPhysicalStorageBuffer64EXT = 5348,
+ AddressingModelMax = 0x7fffffff,
+};
+
+enum MemoryModel {
+ MemoryModelSimple = 0,
+ MemoryModelGLSL450 = 1,
+ MemoryModelOpenCL = 2,
+ MemoryModelVulkan = 3,
+ MemoryModelVulkanKHR = 3,
+ MemoryModelMax = 0x7fffffff,
+};
+
+enum ExecutionMode {
+ ExecutionModeInvocations = 0,
+ ExecutionModeSpacingEqual = 1,
+ ExecutionModeSpacingFractionalEven = 2,
+ ExecutionModeSpacingFractionalOdd = 3,
+ ExecutionModeVertexOrderCw = 4,
+ ExecutionModeVertexOrderCcw = 5,
+ ExecutionModePixelCenterInteger = 6,
+ ExecutionModeOriginUpperLeft = 7,
+ ExecutionModeOriginLowerLeft = 8,
+ ExecutionModeEarlyFragmentTests = 9,
+ ExecutionModePointMode = 10,
+ ExecutionModeXfb = 11,
+ ExecutionModeDepthReplacing = 12,
+ ExecutionModeDepthGreater = 14,
+ ExecutionModeDepthLess = 15,
+ ExecutionModeDepthUnchanged = 16,
+ ExecutionModeLocalSize = 17,
+ ExecutionModeLocalSizeHint = 18,
+ ExecutionModeInputPoints = 19,
+ ExecutionModeInputLines = 20,
+ ExecutionModeInputLinesAdjacency = 21,
+ ExecutionModeTriangles = 22,
+ ExecutionModeInputTrianglesAdjacency = 23,
+ ExecutionModeQuads = 24,
+ ExecutionModeIsolines = 25,
+ ExecutionModeOutputVertices = 26,
+ ExecutionModeOutputPoints = 27,
+ ExecutionModeOutputLineStrip = 28,
+ ExecutionModeOutputTriangleStrip = 29,
+ ExecutionModeVecTypeHint = 30,
+ ExecutionModeContractionOff = 31,
+ ExecutionModeInitializer = 33,
+ ExecutionModeFinalizer = 34,
+ ExecutionModeSubgroupSize = 35,
+ ExecutionModeSubgroupsPerWorkgroup = 36,
+ ExecutionModeSubgroupsPerWorkgroupId = 37,
+ ExecutionModeLocalSizeId = 38,
+ ExecutionModeLocalSizeHintId = 39,
+ ExecutionModeSubgroupUniformControlFlowKHR = 4421,
+ ExecutionModePostDepthCoverage = 4446,
+ ExecutionModeDenormPreserve = 4459,
+ ExecutionModeDenormFlushToZero = 4460,
+ ExecutionModeSignedZeroInfNanPreserve = 4461,
+ ExecutionModeRoundingModeRTE = 4462,
+ ExecutionModeRoundingModeRTZ = 4463,
+ ExecutionModeEarlyAndLateFragmentTestsAMD = 5017,
+ ExecutionModeStencilRefReplacingEXT = 5027,
+ ExecutionModeStencilRefUnchangedFrontAMD = 5079,
+ ExecutionModeStencilRefGreaterFrontAMD = 5080,
+ ExecutionModeStencilRefLessFrontAMD = 5081,
+ ExecutionModeStencilRefUnchangedBackAMD = 5082,
+ ExecutionModeStencilRefGreaterBackAMD = 5083,
+ ExecutionModeStencilRefLessBackAMD = 5084,
+ ExecutionModeOutputLinesEXT = 5269,
+ ExecutionModeOutputLinesNV = 5269,
+ ExecutionModeOutputPrimitivesEXT = 5270,
+ ExecutionModeOutputPrimitivesNV = 5270,
+ ExecutionModeDerivativeGroupQuadsNV = 5289,
+ ExecutionModeDerivativeGroupLinearNV = 5290,
+ ExecutionModeOutputTrianglesEXT = 5298,
+ ExecutionModeOutputTrianglesNV = 5298,
+ ExecutionModePixelInterlockOrderedEXT = 5366,
+ ExecutionModePixelInterlockUnorderedEXT = 5367,
+ ExecutionModeSampleInterlockOrderedEXT = 5368,
+ ExecutionModeSampleInterlockUnorderedEXT = 5369,
+ ExecutionModeShadingRateInterlockOrderedEXT = 5370,
+ ExecutionModeShadingRateInterlockUnorderedEXT = 5371,
+ ExecutionModeSharedLocalMemorySizeINTEL = 5618,
+ ExecutionModeRoundingModeRTPINTEL = 5620,
+ ExecutionModeRoundingModeRTNINTEL = 5621,
+ ExecutionModeFloatingPointModeALTINTEL = 5622,
+ ExecutionModeFloatingPointModeIEEEINTEL = 5623,
+ ExecutionModeMaxWorkgroupSizeINTEL = 5893,
+ ExecutionModeMaxWorkDimINTEL = 5894,
+ ExecutionModeNoGlobalOffsetINTEL = 5895,
+ ExecutionModeNumSIMDWorkitemsINTEL = 5896,
+ ExecutionModeSchedulerTargetFmaxMhzINTEL = 5903,
+ ExecutionModeMax = 0x7fffffff,
+};
+
+enum StorageClass {
+ StorageClassUniformConstant = 0,
+ StorageClassInput = 1,
+ StorageClassUniform = 2,
+ StorageClassOutput = 3,
+ StorageClassWorkgroup = 4,
+ StorageClassCrossWorkgroup = 5,
+ StorageClassPrivate = 6,
+ StorageClassFunction = 7,
+ StorageClassGeneric = 8,
+ StorageClassPushConstant = 9,
+ StorageClassAtomicCounter = 10,
+ StorageClassImage = 11,
+ StorageClassStorageBuffer = 12,
+ StorageClassCallableDataKHR = 5328,
+ StorageClassCallableDataNV = 5328,
+ StorageClassIncomingCallableDataKHR = 5329,
+ StorageClassIncomingCallableDataNV = 5329,
+ StorageClassRayPayloadKHR = 5338,
+ StorageClassRayPayloadNV = 5338,
+ StorageClassHitAttributeKHR = 5339,
+ StorageClassHitAttributeNV = 5339,
+ StorageClassIncomingRayPayloadKHR = 5342,
+ StorageClassIncomingRayPayloadNV = 5342,
+ StorageClassShaderRecordBufferKHR = 5343,
+ StorageClassShaderRecordBufferNV = 5343,
+ StorageClassPhysicalStorageBuffer = 5349,
+ StorageClassPhysicalStorageBufferEXT = 5349,
+ StorageClassTaskPayloadWorkgroupEXT = 5402,
+ StorageClassCodeSectionINTEL = 5605,
+ StorageClassDeviceOnlyINTEL = 5936,
+ StorageClassHostOnlyINTEL = 5937,
+ StorageClassMax = 0x7fffffff,
+};
+
+enum Dim {
+ Dim1D = 0,
+ Dim2D = 1,
+ Dim3D = 2,
+ DimCube = 3,
+ DimRect = 4,
+ DimBuffer = 5,
+ DimSubpassData = 6,
+ DimMax = 0x7fffffff,
+};
+
+enum SamplerAddressingMode {
+ SamplerAddressingModeNone = 0,
+ SamplerAddressingModeClampToEdge = 1,
+ SamplerAddressingModeClamp = 2,
+ SamplerAddressingModeRepeat = 3,
+ SamplerAddressingModeRepeatMirrored = 4,
+ SamplerAddressingModeMax = 0x7fffffff,
+};
+
+enum SamplerFilterMode {
+ SamplerFilterModeNearest = 0,
+ SamplerFilterModeLinear = 1,
+ SamplerFilterModeMax = 0x7fffffff,
+};
+
+enum ImageFormat {
+ ImageFormatUnknown = 0,
+ ImageFormatRgba32f = 1,
+ ImageFormatRgba16f = 2,
+ ImageFormatR32f = 3,
+ ImageFormatRgba8 = 4,
+ ImageFormatRgba8Snorm = 5,
+ ImageFormatRg32f = 6,
+ ImageFormatRg16f = 7,
+ ImageFormatR11fG11fB10f = 8,
+ ImageFormatR16f = 9,
+ ImageFormatRgba16 = 10,
+ ImageFormatRgb10A2 = 11,
+ ImageFormatRg16 = 12,
+ ImageFormatRg8 = 13,
+ ImageFormatR16 = 14,
+ ImageFormatR8 = 15,
+ ImageFormatRgba16Snorm = 16,
+ ImageFormatRg16Snorm = 17,
+ ImageFormatRg8Snorm = 18,
+ ImageFormatR16Snorm = 19,
+ ImageFormatR8Snorm = 20,
+ ImageFormatRgba32i = 21,
+ ImageFormatRgba16i = 22,
+ ImageFormatRgba8i = 23,
+ ImageFormatR32i = 24,
+ ImageFormatRg32i = 25,
+ ImageFormatRg16i = 26,
+ ImageFormatRg8i = 27,
+ ImageFormatR16i = 28,
+ ImageFormatR8i = 29,
+ ImageFormatRgba32ui = 30,
+ ImageFormatRgba16ui = 31,
+ ImageFormatRgba8ui = 32,
+ ImageFormatR32ui = 33,
+ ImageFormatRgb10a2ui = 34,
+ ImageFormatRg32ui = 35,
+ ImageFormatRg16ui = 36,
+ ImageFormatRg8ui = 37,
+ ImageFormatR16ui = 38,
+ ImageFormatR8ui = 39,
+ ImageFormatR64ui = 40,
+ ImageFormatR64i = 41,
+ ImageFormatMax = 0x7fffffff,
+};
+
+enum ImageChannelOrder {
+ ImageChannelOrderR = 0,
+ ImageChannelOrderA = 1,
+ ImageChannelOrderRG = 2,
+ ImageChannelOrderRA = 3,
+ ImageChannelOrderRGB = 4,
+ ImageChannelOrderRGBA = 5,
+ ImageChannelOrderBGRA = 6,
+ ImageChannelOrderARGB = 7,
+ ImageChannelOrderIntensity = 8,
+ ImageChannelOrderLuminance = 9,
+ ImageChannelOrderRx = 10,
+ ImageChannelOrderRGx = 11,
+ ImageChannelOrderRGBx = 12,
+ ImageChannelOrderDepth = 13,
+ ImageChannelOrderDepthStencil = 14,
+ ImageChannelOrdersRGB = 15,
+ ImageChannelOrdersRGBx = 16,
+ ImageChannelOrdersRGBA = 17,
+ ImageChannelOrdersBGRA = 18,
+ ImageChannelOrderABGR = 19,
+ ImageChannelOrderMax = 0x7fffffff,
+};
+
+enum ImageChannelDataType {
+ ImageChannelDataTypeSnormInt8 = 0,
+ ImageChannelDataTypeSnormInt16 = 1,
+ ImageChannelDataTypeUnormInt8 = 2,
+ ImageChannelDataTypeUnormInt16 = 3,
+ ImageChannelDataTypeUnormShort565 = 4,
+ ImageChannelDataTypeUnormShort555 = 5,
+ ImageChannelDataTypeUnormInt101010 = 6,
+ ImageChannelDataTypeSignedInt8 = 7,
+ ImageChannelDataTypeSignedInt16 = 8,
+ ImageChannelDataTypeSignedInt32 = 9,
+ ImageChannelDataTypeUnsignedInt8 = 10,
+ ImageChannelDataTypeUnsignedInt16 = 11,
+ ImageChannelDataTypeUnsignedInt32 = 12,
+ ImageChannelDataTypeHalfFloat = 13,
+ ImageChannelDataTypeFloat = 14,
+ ImageChannelDataTypeUnormInt24 = 15,
+ ImageChannelDataTypeUnormInt101010_2 = 16,
+ ImageChannelDataTypeMax = 0x7fffffff,
+};
+
+enum ImageOperandsShift {
+ ImageOperandsBiasShift = 0,
+ ImageOperandsLodShift = 1,
+ ImageOperandsGradShift = 2,
+ ImageOperandsConstOffsetShift = 3,
+ ImageOperandsOffsetShift = 4,
+ ImageOperandsConstOffsetsShift = 5,
+ ImageOperandsSampleShift = 6,
+ ImageOperandsMinLodShift = 7,
+ ImageOperandsMakeTexelAvailableShift = 8,
+ ImageOperandsMakeTexelAvailableKHRShift = 8,
+ ImageOperandsMakeTexelVisibleShift = 9,
+ ImageOperandsMakeTexelVisibleKHRShift = 9,
+ ImageOperandsNonPrivateTexelShift = 10,
+ ImageOperandsNonPrivateTexelKHRShift = 10,
+ ImageOperandsVolatileTexelShift = 11,
+ ImageOperandsVolatileTexelKHRShift = 11,
+ ImageOperandsSignExtendShift = 12,
+ ImageOperandsZeroExtendShift = 13,
+ ImageOperandsNontemporalShift = 14,
+ ImageOperandsOffsetsShift = 16,
+ ImageOperandsMax = 0x7fffffff,
+};
+
+enum ImageOperandsMask {
+ ImageOperandsMaskNone = 0,
+ ImageOperandsBiasMask = 0x00000001,
+ ImageOperandsLodMask = 0x00000002,
+ ImageOperandsGradMask = 0x00000004,
+ ImageOperandsConstOffsetMask = 0x00000008,
+ ImageOperandsOffsetMask = 0x00000010,
+ ImageOperandsConstOffsetsMask = 0x00000020,
+ ImageOperandsSampleMask = 0x00000040,
+ ImageOperandsMinLodMask = 0x00000080,
+ ImageOperandsMakeTexelAvailableMask = 0x00000100,
+ ImageOperandsMakeTexelAvailableKHRMask = 0x00000100,
+ ImageOperandsMakeTexelVisibleMask = 0x00000200,
+ ImageOperandsMakeTexelVisibleKHRMask = 0x00000200,
+ ImageOperandsNonPrivateTexelMask = 0x00000400,
+ ImageOperandsNonPrivateTexelKHRMask = 0x00000400,
+ ImageOperandsVolatileTexelMask = 0x00000800,
+ ImageOperandsVolatileTexelKHRMask = 0x00000800,
+ ImageOperandsSignExtendMask = 0x00001000,
+ ImageOperandsZeroExtendMask = 0x00002000,
+ ImageOperandsNontemporalMask = 0x00004000,
+ ImageOperandsOffsetsMask = 0x00010000,
+};
+
+enum FPFastMathModeShift {
+ FPFastMathModeNotNaNShift = 0,
+ FPFastMathModeNotInfShift = 1,
+ FPFastMathModeNSZShift = 2,
+ FPFastMathModeAllowRecipShift = 3,
+ FPFastMathModeFastShift = 4,
+ FPFastMathModeAllowContractFastINTELShift = 16,
+ FPFastMathModeAllowReassocINTELShift = 17,
+ FPFastMathModeMax = 0x7fffffff,
+};
+
+enum FPFastMathModeMask {
+ FPFastMathModeMaskNone = 0,
+ FPFastMathModeNotNaNMask = 0x00000001,
+ FPFastMathModeNotInfMask = 0x00000002,
+ FPFastMathModeNSZMask = 0x00000004,
+ FPFastMathModeAllowRecipMask = 0x00000008,
+ FPFastMathModeFastMask = 0x00000010,
+ FPFastMathModeAllowContractFastINTELMask = 0x00010000,
+ FPFastMathModeAllowReassocINTELMask = 0x00020000,
+};
+
+enum FPRoundingMode {
+ FPRoundingModeRTE = 0,
+ FPRoundingModeRTZ = 1,
+ FPRoundingModeRTP = 2,
+ FPRoundingModeRTN = 3,
+ FPRoundingModeMax = 0x7fffffff,
+};
+
+enum LinkageType {
+ LinkageTypeExport = 0,
+ LinkageTypeImport = 1,
+ LinkageTypeLinkOnceODR = 2,
+ LinkageTypeMax = 0x7fffffff,
+};
+
+enum AccessQualifier {
+ AccessQualifierReadOnly = 0,
+ AccessQualifierWriteOnly = 1,
+ AccessQualifierReadWrite = 2,
+ AccessQualifierMax = 0x7fffffff,
+};
+
+enum FunctionParameterAttribute {
+ FunctionParameterAttributeZext = 0,
+ FunctionParameterAttributeSext = 1,
+ FunctionParameterAttributeByVal = 2,
+ FunctionParameterAttributeSret = 3,
+ FunctionParameterAttributeNoAlias = 4,
+ FunctionParameterAttributeNoCapture = 5,
+ FunctionParameterAttributeNoWrite = 6,
+ FunctionParameterAttributeNoReadWrite = 7,
+ FunctionParameterAttributeMax = 0x7fffffff,
+};
+
+enum Decoration {
+ DecorationRelaxedPrecision = 0,
+ DecorationSpecId = 1,
+ DecorationBlock = 2,
+ DecorationBufferBlock = 3,
+ DecorationRowMajor = 4,
+ DecorationColMajor = 5,
+ DecorationArrayStride = 6,
+ DecorationMatrixStride = 7,
+ DecorationGLSLShared = 8,
+ DecorationGLSLPacked = 9,
+ DecorationCPacked = 10,
+ DecorationBuiltIn = 11,
+ DecorationNoPerspective = 13,
+ DecorationFlat = 14,
+ DecorationPatch = 15,
+ DecorationCentroid = 16,
+ DecorationSample = 17,
+ DecorationInvariant = 18,
+ DecorationRestrict = 19,
+ DecorationAliased = 20,
+ DecorationVolatile = 21,
+ DecorationConstant = 22,
+ DecorationCoherent = 23,
+ DecorationNonWritable = 24,
+ DecorationNonReadable = 25,
+ DecorationUniform = 26,
+ DecorationUniformId = 27,
+ DecorationSaturatedConversion = 28,
+ DecorationStream = 29,
+ DecorationLocation = 30,
+ DecorationComponent = 31,
+ DecorationIndex = 32,
+ DecorationBinding = 33,
+ DecorationDescriptorSet = 34,
+ DecorationOffset = 35,
+ DecorationXfbBuffer = 36,
+ DecorationXfbStride = 37,
+ DecorationFuncParamAttr = 38,
+ DecorationFPRoundingMode = 39,
+ DecorationFPFastMathMode = 40,
+ DecorationLinkageAttributes = 41,
+ DecorationNoContraction = 42,
+ DecorationInputAttachmentIndex = 43,
+ DecorationAlignment = 44,
+ DecorationMaxByteOffset = 45,
+ DecorationAlignmentId = 46,
+ DecorationMaxByteOffsetId = 47,
+ DecorationNoSignedWrap = 4469,
+ DecorationNoUnsignedWrap = 4470,
+ DecorationExplicitInterpAMD = 4999,
+ DecorationOverrideCoverageNV = 5248,
+ DecorationPassthroughNV = 5250,
+ DecorationViewportRelativeNV = 5252,
+ DecorationSecondaryViewportRelativeNV = 5256,
+ DecorationPerPrimitiveEXT = 5271,
+ DecorationPerPrimitiveNV = 5271,
+ DecorationPerViewNV = 5272,
+ DecorationPerTaskNV = 5273,
+ DecorationPerVertexKHR = 5285,
+ DecorationPerVertexNV = 5285,
+ DecorationNonUniform = 5300,
+ DecorationNonUniformEXT = 5300,
+ DecorationRestrictPointer = 5355,
+ DecorationRestrictPointerEXT = 5355,
+ DecorationAliasedPointer = 5356,
+ DecorationAliasedPointerEXT = 5356,
+ DecorationBindlessSamplerNV = 5398,
+ DecorationBindlessImageNV = 5399,
+ DecorationBoundSamplerNV = 5400,
+ DecorationBoundImageNV = 5401,
+ DecorationSIMTCallINTEL = 5599,
+ DecorationReferencedIndirectlyINTEL = 5602,
+ DecorationClobberINTEL = 5607,
+ DecorationSideEffectsINTEL = 5608,
+ DecorationVectorComputeVariableINTEL = 5624,
+ DecorationFuncParamIOKindINTEL = 5625,
+ DecorationVectorComputeFunctionINTEL = 5626,
+ DecorationStackCallINTEL = 5627,
+ DecorationGlobalVariableOffsetINTEL = 5628,
+ DecorationCounterBuffer = 5634,
+ DecorationHlslCounterBufferGOOGLE = 5634,
+ DecorationHlslSemanticGOOGLE = 5635,
+ DecorationUserSemantic = 5635,
+ DecorationUserTypeGOOGLE = 5636,
+ DecorationFunctionRoundingModeINTEL = 5822,
+ DecorationFunctionDenormModeINTEL = 5823,
+ DecorationRegisterINTEL = 5825,
+ DecorationMemoryINTEL = 5826,
+ DecorationNumbanksINTEL = 5827,
+ DecorationBankwidthINTEL = 5828,
+ DecorationMaxPrivateCopiesINTEL = 5829,
+ DecorationSinglepumpINTEL = 5830,
+ DecorationDoublepumpINTEL = 5831,
+ DecorationMaxReplicatesINTEL = 5832,
+ DecorationSimpleDualPortINTEL = 5833,
+ DecorationMergeINTEL = 5834,
+ DecorationBankBitsINTEL = 5835,
+ DecorationForcePow2DepthINTEL = 5836,
+ DecorationBurstCoalesceINTEL = 5899,
+ DecorationCacheSizeINTEL = 5900,
+ DecorationDontStaticallyCoalesceINTEL = 5901,
+ DecorationPrefetchINTEL = 5902,
+ DecorationStallEnableINTEL = 5905,
+ DecorationFuseLoopsInFunctionINTEL = 5907,
+ DecorationBufferLocationINTEL = 5921,
+ DecorationIOPipeStorageINTEL = 5944,
+ DecorationFunctionFloatingPointModeINTEL = 6080,
+ DecorationSingleElementVectorINTEL = 6085,
+ DecorationVectorComputeCallableFunctionINTEL = 6087,
+ DecorationMediaBlockIOINTEL = 6140,
+ DecorationMax = 0x7fffffff,
+};
+
+enum BuiltIn {
+ BuiltInPosition = 0,
+ BuiltInPointSize = 1,
+ BuiltInClipDistance = 3,
+ BuiltInCullDistance = 4,
+ BuiltInVertexId = 5,
+ BuiltInInstanceId = 6,
+ BuiltInPrimitiveId = 7,
+ BuiltInInvocationId = 8,
+ BuiltInLayer = 9,
+ BuiltInViewportIndex = 10,
+ BuiltInTessLevelOuter = 11,
+ BuiltInTessLevelInner = 12,
+ BuiltInTessCoord = 13,
+ BuiltInPatchVertices = 14,
+ BuiltInFragCoord = 15,
+ BuiltInPointCoord = 16,
+ BuiltInFrontFacing = 17,
+ BuiltInSampleId = 18,
+ BuiltInSamplePosition = 19,
+ BuiltInSampleMask = 20,
+ BuiltInFragDepth = 22,
+ BuiltInHelperInvocation = 23,
+ BuiltInNumWorkgroups = 24,
+ BuiltInWorkgroupSize = 25,
+ BuiltInWorkgroupId = 26,
+ BuiltInLocalInvocationId = 27,
+ BuiltInGlobalInvocationId = 28,
+ BuiltInLocalInvocationIndex = 29,
+ BuiltInWorkDim = 30,
+ BuiltInGlobalSize = 31,
+ BuiltInEnqueuedWorkgroupSize = 32,
+ BuiltInGlobalOffset = 33,
+ BuiltInGlobalLinearId = 34,
+ BuiltInSubgroupSize = 36,
+ BuiltInSubgroupMaxSize = 37,
+ BuiltInNumSubgroups = 38,
+ BuiltInNumEnqueuedSubgroups = 39,
+ BuiltInSubgroupId = 40,
+ BuiltInSubgroupLocalInvocationId = 41,
+ BuiltInVertexIndex = 42,
+ BuiltInInstanceIndex = 43,
+ BuiltInSubgroupEqMask = 4416,
+ BuiltInSubgroupEqMaskKHR = 4416,
+ BuiltInSubgroupGeMask = 4417,
+ BuiltInSubgroupGeMaskKHR = 4417,
+ BuiltInSubgroupGtMask = 4418,
+ BuiltInSubgroupGtMaskKHR = 4418,
+ BuiltInSubgroupLeMask = 4419,
+ BuiltInSubgroupLeMaskKHR = 4419,
+ BuiltInSubgroupLtMask = 4420,
+ BuiltInSubgroupLtMaskKHR = 4420,
+ BuiltInBaseVertex = 4424,
+ BuiltInBaseInstance = 4425,
+ BuiltInDrawIndex = 4426,
+ BuiltInPrimitiveShadingRateKHR = 4432,
+ BuiltInDeviceIndex = 4438,
+ BuiltInViewIndex = 4440,
+ BuiltInShadingRateKHR = 4444,
+ BuiltInBaryCoordNoPerspAMD = 4992,
+ BuiltInBaryCoordNoPerspCentroidAMD = 4993,
+ BuiltInBaryCoordNoPerspSampleAMD = 4994,
+ BuiltInBaryCoordSmoothAMD = 4995,
+ BuiltInBaryCoordSmoothCentroidAMD = 4996,
+ BuiltInBaryCoordSmoothSampleAMD = 4997,
+ BuiltInBaryCoordPullModelAMD = 4998,
+ BuiltInFragStencilRefEXT = 5014,
+ BuiltInViewportMaskNV = 5253,
+ BuiltInSecondaryPositionNV = 5257,
+ BuiltInSecondaryViewportMaskNV = 5258,
+ BuiltInPositionPerViewNV = 5261,
+ BuiltInViewportMaskPerViewNV = 5262,
+ BuiltInFullyCoveredEXT = 5264,
+ BuiltInTaskCountNV = 5274,
+ BuiltInPrimitiveCountNV = 5275,
+ BuiltInPrimitiveIndicesNV = 5276,
+ BuiltInClipDistancePerViewNV = 5277,
+ BuiltInCullDistancePerViewNV = 5278,
+ BuiltInLayerPerViewNV = 5279,
+ BuiltInMeshViewCountNV = 5280,
+ BuiltInMeshViewIndicesNV = 5281,
+ BuiltInBaryCoordKHR = 5286,
+ BuiltInBaryCoordNV = 5286,
+ BuiltInBaryCoordNoPerspKHR = 5287,
+ BuiltInBaryCoordNoPerspNV = 5287,
+ BuiltInFragSizeEXT = 5292,
+ BuiltInFragmentSizeNV = 5292,
+ BuiltInFragInvocationCountEXT = 5293,
+ BuiltInInvocationsPerPixelNV = 5293,
+ BuiltInPrimitivePointIndicesEXT = 5294,
+ BuiltInPrimitiveLineIndicesEXT = 5295,
+ BuiltInPrimitiveTriangleIndicesEXT = 5296,
+ BuiltInCullPrimitiveEXT = 5299,
+ BuiltInLaunchIdKHR = 5319,
+ BuiltInLaunchIdNV = 5319,
+ BuiltInLaunchSizeKHR = 5320,
+ BuiltInLaunchSizeNV = 5320,
+ BuiltInWorldRayOriginKHR = 5321,
+ BuiltInWorldRayOriginNV = 5321,
+ BuiltInWorldRayDirectionKHR = 5322,
+ BuiltInWorldRayDirectionNV = 5322,
+ BuiltInObjectRayOriginKHR = 5323,
+ BuiltInObjectRayOriginNV = 5323,
+ BuiltInObjectRayDirectionKHR = 5324,
+ BuiltInObjectRayDirectionNV = 5324,
+ BuiltInRayTminKHR = 5325,
+ BuiltInRayTminNV = 5325,
+ BuiltInRayTmaxKHR = 5326,
+ BuiltInRayTmaxNV = 5326,
+ BuiltInInstanceCustomIndexKHR = 5327,
+ BuiltInInstanceCustomIndexNV = 5327,
+ BuiltInObjectToWorldKHR = 5330,
+ BuiltInObjectToWorldNV = 5330,
+ BuiltInWorldToObjectKHR = 5331,
+ BuiltInWorldToObjectNV = 5331,
+ BuiltInHitTNV = 5332,
+ BuiltInHitKindKHR = 5333,
+ BuiltInHitKindNV = 5333,
+ BuiltInCurrentRayTimeNV = 5334,
+ BuiltInIncomingRayFlagsKHR = 5351,
+ BuiltInIncomingRayFlagsNV = 5351,
+ BuiltInRayGeometryIndexKHR = 5352,
+ BuiltInWarpsPerSMNV = 5374,
+ BuiltInSMCountNV = 5375,
+ BuiltInWarpIDNV = 5376,
+ BuiltInSMIDNV = 5377,
+ BuiltInCullMaskKHR = 6021,
+ BuiltInMax = 0x7fffffff,
+};
+
+enum SelectionControlShift {
+ SelectionControlFlattenShift = 0,
+ SelectionControlDontFlattenShift = 1,
+ SelectionControlMax = 0x7fffffff,
+};
+
+enum SelectionControlMask {
+ SelectionControlMaskNone = 0,
+ SelectionControlFlattenMask = 0x00000001,
+ SelectionControlDontFlattenMask = 0x00000002,
+};
+
+enum LoopControlShift {
+ LoopControlUnrollShift = 0,
+ LoopControlDontUnrollShift = 1,
+ LoopControlDependencyInfiniteShift = 2,
+ LoopControlDependencyLengthShift = 3,
+ LoopControlMinIterationsShift = 4,
+ LoopControlMaxIterationsShift = 5,
+ LoopControlIterationMultipleShift = 6,
+ LoopControlPeelCountShift = 7,
+ LoopControlPartialCountShift = 8,
+ LoopControlInitiationIntervalINTELShift = 16,
+ LoopControlMaxConcurrencyINTELShift = 17,
+ LoopControlDependencyArrayINTELShift = 18,
+ LoopControlPipelineEnableINTELShift = 19,
+ LoopControlLoopCoalesceINTELShift = 20,
+ LoopControlMaxInterleavingINTELShift = 21,
+ LoopControlSpeculatedIterationsINTELShift = 22,
+ LoopControlNoFusionINTELShift = 23,
+ LoopControlMax = 0x7fffffff,
+};
+
+enum LoopControlMask {
+ LoopControlMaskNone = 0,
+ LoopControlUnrollMask = 0x00000001,
+ LoopControlDontUnrollMask = 0x00000002,
+ LoopControlDependencyInfiniteMask = 0x00000004,
+ LoopControlDependencyLengthMask = 0x00000008,
+ LoopControlMinIterationsMask = 0x00000010,
+ LoopControlMaxIterationsMask = 0x00000020,
+ LoopControlIterationMultipleMask = 0x00000040,
+ LoopControlPeelCountMask = 0x00000080,
+ LoopControlPartialCountMask = 0x00000100,
+ LoopControlInitiationIntervalINTELMask = 0x00010000,
+ LoopControlMaxConcurrencyINTELMask = 0x00020000,
+ LoopControlDependencyArrayINTELMask = 0x00040000,
+ LoopControlPipelineEnableINTELMask = 0x00080000,
+ LoopControlLoopCoalesceINTELMask = 0x00100000,
+ LoopControlMaxInterleavingINTELMask = 0x00200000,
+ LoopControlSpeculatedIterationsINTELMask = 0x00400000,
+ LoopControlNoFusionINTELMask = 0x00800000,
+};
+
+enum FunctionControlShift {
+ FunctionControlInlineShift = 0,
+ FunctionControlDontInlineShift = 1,
+ FunctionControlPureShift = 2,
+ FunctionControlConstShift = 3,
+ FunctionControlOptNoneINTELShift = 16,
+ FunctionControlMax = 0x7fffffff,
+};
+
+enum FunctionControlMask {
+ FunctionControlMaskNone = 0,
+ FunctionControlInlineMask = 0x00000001,
+ FunctionControlDontInlineMask = 0x00000002,
+ FunctionControlPureMask = 0x00000004,
+ FunctionControlConstMask = 0x00000008,
+ FunctionControlOptNoneINTELMask = 0x00010000,
+};
+
+enum MemorySemanticsShift {
+ MemorySemanticsAcquireShift = 1,
+ MemorySemanticsReleaseShift = 2,
+ MemorySemanticsAcquireReleaseShift = 3,
+ MemorySemanticsSequentiallyConsistentShift = 4,
+ MemorySemanticsUniformMemoryShift = 6,
+ MemorySemanticsSubgroupMemoryShift = 7,
+ MemorySemanticsWorkgroupMemoryShift = 8,
+ MemorySemanticsCrossWorkgroupMemoryShift = 9,
+ MemorySemanticsAtomicCounterMemoryShift = 10,
+ MemorySemanticsImageMemoryShift = 11,
+ MemorySemanticsOutputMemoryShift = 12,
+ MemorySemanticsOutputMemoryKHRShift = 12,
+ MemorySemanticsMakeAvailableShift = 13,
+ MemorySemanticsMakeAvailableKHRShift = 13,
+ MemorySemanticsMakeVisibleShift = 14,
+ MemorySemanticsMakeVisibleKHRShift = 14,
+ MemorySemanticsVolatileShift = 15,
+ MemorySemanticsMax = 0x7fffffff,
+};
+
+enum MemorySemanticsMask {
+ MemorySemanticsMaskNone = 0,
+ MemorySemanticsAcquireMask = 0x00000002,
+ MemorySemanticsReleaseMask = 0x00000004,
+ MemorySemanticsAcquireReleaseMask = 0x00000008,
+ MemorySemanticsSequentiallyConsistentMask = 0x00000010,
+ MemorySemanticsUniformMemoryMask = 0x00000040,
+ MemorySemanticsSubgroupMemoryMask = 0x00000080,
+ MemorySemanticsWorkgroupMemoryMask = 0x00000100,
+ MemorySemanticsCrossWorkgroupMemoryMask = 0x00000200,
+ MemorySemanticsAtomicCounterMemoryMask = 0x00000400,
+ MemorySemanticsImageMemoryMask = 0x00000800,
+ MemorySemanticsOutputMemoryMask = 0x00001000,
+ MemorySemanticsOutputMemoryKHRMask = 0x00001000,
+ MemorySemanticsMakeAvailableMask = 0x00002000,
+ MemorySemanticsMakeAvailableKHRMask = 0x00002000,
+ MemorySemanticsMakeVisibleMask = 0x00004000,
+ MemorySemanticsMakeVisibleKHRMask = 0x00004000,
+ MemorySemanticsVolatileMask = 0x00008000,
+};
+
+enum MemoryAccessShift {
+ MemoryAccessVolatileShift = 0,
+ MemoryAccessAlignedShift = 1,
+ MemoryAccessNontemporalShift = 2,
+ MemoryAccessMakePointerAvailableShift = 3,
+ MemoryAccessMakePointerAvailableKHRShift = 3,
+ MemoryAccessMakePointerVisibleShift = 4,
+ MemoryAccessMakePointerVisibleKHRShift = 4,
+ MemoryAccessNonPrivatePointerShift = 5,
+ MemoryAccessNonPrivatePointerKHRShift = 5,
+ MemoryAccessMax = 0x7fffffff,
+};
+
+enum MemoryAccessMask {
+ MemoryAccessMaskNone = 0,
+ MemoryAccessVolatileMask = 0x00000001,
+ MemoryAccessAlignedMask = 0x00000002,
+ MemoryAccessNontemporalMask = 0x00000004,
+ MemoryAccessMakePointerAvailableMask = 0x00000008,
+ MemoryAccessMakePointerAvailableKHRMask = 0x00000008,
+ MemoryAccessMakePointerVisibleMask = 0x00000010,
+ MemoryAccessMakePointerVisibleKHRMask = 0x00000010,
+ MemoryAccessNonPrivatePointerMask = 0x00000020,
+ MemoryAccessNonPrivatePointerKHRMask = 0x00000020,
+};
+
+enum Scope {
+ ScopeCrossDevice = 0,
+ ScopeDevice = 1,
+ ScopeWorkgroup = 2,
+ ScopeSubgroup = 3,
+ ScopeInvocation = 4,
+ ScopeQueueFamily = 5,
+ ScopeQueueFamilyKHR = 5,
+ ScopeShaderCallKHR = 6,
+ ScopeMax = 0x7fffffff,
+};
+
+enum GroupOperation {
+ GroupOperationReduce = 0,
+ GroupOperationInclusiveScan = 1,
+ GroupOperationExclusiveScan = 2,
+ GroupOperationClusteredReduce = 3,
+ GroupOperationPartitionedReduceNV = 6,
+ GroupOperationPartitionedInclusiveScanNV = 7,
+ GroupOperationPartitionedExclusiveScanNV = 8,
+ GroupOperationMax = 0x7fffffff,
+};
+
+enum KernelEnqueueFlags {
+ KernelEnqueueFlagsNoWait = 0,
+ KernelEnqueueFlagsWaitKernel = 1,
+ KernelEnqueueFlagsWaitWorkGroup = 2,
+ KernelEnqueueFlagsMax = 0x7fffffff,
+};
+
+enum KernelProfilingInfoShift {
+ KernelProfilingInfoCmdExecTimeShift = 0,
+ KernelProfilingInfoMax = 0x7fffffff,
+};
+
+enum KernelProfilingInfoMask {
+ KernelProfilingInfoMaskNone = 0,
+ KernelProfilingInfoCmdExecTimeMask = 0x00000001,
+};
+
+enum Capability {
+ CapabilityMatrix = 0,
+ CapabilityShader = 1,
+ CapabilityGeometry = 2,
+ CapabilityTessellation = 3,
+ CapabilityAddresses = 4,
+ CapabilityLinkage = 5,
+ CapabilityKernel = 6,
+ CapabilityVector16 = 7,
+ CapabilityFloat16Buffer = 8,
+ CapabilityFloat16 = 9,
+ CapabilityFloat64 = 10,
+ CapabilityInt64 = 11,
+ CapabilityInt64Atomics = 12,
+ CapabilityImageBasic = 13,
+ CapabilityImageReadWrite = 14,
+ CapabilityImageMipmap = 15,
+ CapabilityPipes = 17,
+ CapabilityGroups = 18,
+ CapabilityDeviceEnqueue = 19,
+ CapabilityLiteralSampler = 20,
+ CapabilityAtomicStorage = 21,
+ CapabilityInt16 = 22,
+ CapabilityTessellationPointSize = 23,
+ CapabilityGeometryPointSize = 24,
+ CapabilityImageGatherExtended = 25,
+ CapabilityStorageImageMultisample = 27,
+ CapabilityUniformBufferArrayDynamicIndexing = 28,
+ CapabilitySampledImageArrayDynamicIndexing = 29,
+ CapabilityStorageBufferArrayDynamicIndexing = 30,
+ CapabilityStorageImageArrayDynamicIndexing = 31,
+ CapabilityClipDistance = 32,
+ CapabilityCullDistance = 33,
+ CapabilityImageCubeArray = 34,
+ CapabilitySampleRateShading = 35,
+ CapabilityImageRect = 36,
+ CapabilitySampledRect = 37,
+ CapabilityGenericPointer = 38,
+ CapabilityInt8 = 39,
+ CapabilityInputAttachment = 40,
+ CapabilitySparseResidency = 41,
+ CapabilityMinLod = 42,
+ CapabilitySampled1D = 43,
+ CapabilityImage1D = 44,
+ CapabilitySampledCubeArray = 45,
+ CapabilitySampledBuffer = 46,
+ CapabilityImageBuffer = 47,
+ CapabilityImageMSArray = 48,
+ CapabilityStorageImageExtendedFormats = 49,
+ CapabilityImageQuery = 50,
+ CapabilityDerivativeControl = 51,
+ CapabilityInterpolationFunction = 52,
+ CapabilityTransformFeedback = 53,
+ CapabilityGeometryStreams = 54,
+ CapabilityStorageImageReadWithoutFormat = 55,
+ CapabilityStorageImageWriteWithoutFormat = 56,
+ CapabilityMultiViewport = 57,
+ CapabilitySubgroupDispatch = 58,
+ CapabilityNamedBarrier = 59,
+ CapabilityPipeStorage = 60,
+ CapabilityGroupNonUniform = 61,
+ CapabilityGroupNonUniformVote = 62,
+ CapabilityGroupNonUniformArithmetic = 63,
+ CapabilityGroupNonUniformBallot = 64,
+ CapabilityGroupNonUniformShuffle = 65,
+ CapabilityGroupNonUniformShuffleRelative = 66,
+ CapabilityGroupNonUniformClustered = 67,
+ CapabilityGroupNonUniformQuad = 68,
+ CapabilityShaderLayer = 69,
+ CapabilityShaderViewportIndex = 70,
+ CapabilityUniformDecoration = 71,
+ CapabilityFragmentShadingRateKHR = 4422,
+ CapabilitySubgroupBallotKHR = 4423,
+ CapabilityDrawParameters = 4427,
+ CapabilityWorkgroupMemoryExplicitLayoutKHR = 4428,
+ CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR = 4429,
+ CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR = 4430,
+ CapabilitySubgroupVoteKHR = 4431,
+ CapabilityStorageBuffer16BitAccess = 4433,
+ CapabilityStorageUniformBufferBlock16 = 4433,
+ CapabilityStorageUniform16 = 4434,
+ CapabilityUniformAndStorageBuffer16BitAccess = 4434,
+ CapabilityStoragePushConstant16 = 4435,
+ CapabilityStorageInputOutput16 = 4436,
+ CapabilityDeviceGroup = 4437,
+ CapabilityMultiView = 4439,
+ CapabilityVariablePointersStorageBuffer = 4441,
+ CapabilityVariablePointers = 4442,
+ CapabilityAtomicStorageOps = 4445,
+ CapabilitySampleMaskPostDepthCoverage = 4447,
+ CapabilityStorageBuffer8BitAccess = 4448,
+ CapabilityUniformAndStorageBuffer8BitAccess = 4449,
+ CapabilityStoragePushConstant8 = 4450,
+ CapabilityDenormPreserve = 4464,
+ CapabilityDenormFlushToZero = 4465,
+ CapabilitySignedZeroInfNanPreserve = 4466,
+ CapabilityRoundingModeRTE = 4467,
+ CapabilityRoundingModeRTZ = 4468,
+ CapabilityRayQueryProvisionalKHR = 4471,
+ CapabilityRayQueryKHR = 4472,
+ CapabilityRayTraversalPrimitiveCullingKHR = 4478,
+ CapabilityRayTracingKHR = 4479,
+ CapabilityFloat16ImageAMD = 5008,
+ CapabilityImageGatherBiasLodAMD = 5009,
+ CapabilityFragmentMaskAMD = 5010,
+ CapabilityStencilExportEXT = 5013,
+ CapabilityImageReadWriteLodAMD = 5015,
+ CapabilityInt64ImageEXT = 5016,
+ CapabilityShaderClockKHR = 5055,
+ CapabilitySampleMaskOverrideCoverageNV = 5249,
+ CapabilityGeometryShaderPassthroughNV = 5251,
+ CapabilityShaderViewportIndexLayerEXT = 5254,
+ CapabilityShaderViewportIndexLayerNV = 5254,
+ CapabilityShaderViewportMaskNV = 5255,
+ CapabilityShaderStereoViewNV = 5259,
+ CapabilityPerViewAttributesNV = 5260,
+ CapabilityFragmentFullyCoveredEXT = 5265,
+ CapabilityMeshShadingNV = 5266,
+ CapabilityImageFootprintNV = 5282,
+ CapabilityMeshShadingEXT = 5283,
+ CapabilityFragmentBarycentricKHR = 5284,
+ CapabilityFragmentBarycentricNV = 5284,
+ CapabilityComputeDerivativeGroupQuadsNV = 5288,
+ CapabilityFragmentDensityEXT = 5291,
+ CapabilityShadingRateNV = 5291,
+ CapabilityGroupNonUniformPartitionedNV = 5297,
+ CapabilityShaderNonUniform = 5301,
+ CapabilityShaderNonUniformEXT = 5301,
+ CapabilityRuntimeDescriptorArray = 5302,
+ CapabilityRuntimeDescriptorArrayEXT = 5302,
+ CapabilityInputAttachmentArrayDynamicIndexing = 5303,
+ CapabilityInputAttachmentArrayDynamicIndexingEXT = 5303,
+ CapabilityUniformTexelBufferArrayDynamicIndexing = 5304,
+ CapabilityUniformTexelBufferArrayDynamicIndexingEXT = 5304,
+ CapabilityStorageTexelBufferArrayDynamicIndexing = 5305,
+ CapabilityStorageTexelBufferArrayDynamicIndexingEXT = 5305,
+ CapabilityUniformBufferArrayNonUniformIndexing = 5306,
+ CapabilityUniformBufferArrayNonUniformIndexingEXT = 5306,
+ CapabilitySampledImageArrayNonUniformIndexing = 5307,
+ CapabilitySampledImageArrayNonUniformIndexingEXT = 5307,
+ CapabilityStorageBufferArrayNonUniformIndexing = 5308,
+ CapabilityStorageBufferArrayNonUniformIndexingEXT = 5308,
+ CapabilityStorageImageArrayNonUniformIndexing = 5309,
+ CapabilityStorageImageArrayNonUniformIndexingEXT = 5309,
+ CapabilityInputAttachmentArrayNonUniformIndexing = 5310,
+ CapabilityInputAttachmentArrayNonUniformIndexingEXT = 5310,
+ CapabilityUniformTexelBufferArrayNonUniformIndexing = 5311,
+ CapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311,
+ CapabilityStorageTexelBufferArrayNonUniformIndexing = 5312,
+ CapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312,
+ CapabilityRayTracingNV = 5340,
+ CapabilityRayTracingMotionBlurNV = 5341,
+ CapabilityVulkanMemoryModel = 5345,
+ CapabilityVulkanMemoryModelKHR = 5345,
+ CapabilityVulkanMemoryModelDeviceScope = 5346,
+ CapabilityVulkanMemoryModelDeviceScopeKHR = 5346,
+ CapabilityPhysicalStorageBufferAddresses = 5347,
+ CapabilityPhysicalStorageBufferAddressesEXT = 5347,
+ CapabilityComputeDerivativeGroupLinearNV = 5350,
+ CapabilityRayTracingProvisionalKHR = 5353,
+ CapabilityCooperativeMatrixNV = 5357,
+ CapabilityFragmentShaderSampleInterlockEXT = 5363,
+ CapabilityFragmentShaderShadingRateInterlockEXT = 5372,
+ CapabilityShaderSMBuiltinsNV = 5373,
+ CapabilityFragmentShaderPixelInterlockEXT = 5378,
+ CapabilityDemoteToHelperInvocation = 5379,
+ CapabilityDemoteToHelperInvocationEXT = 5379,
+ CapabilityBindlessTextureNV = 5390,
+ CapabilitySubgroupShuffleINTEL = 5568,
+ CapabilitySubgroupBufferBlockIOINTEL = 5569,
+ CapabilitySubgroupImageBlockIOINTEL = 5570,
+ CapabilitySubgroupImageMediaBlockIOINTEL = 5579,
+ CapabilityRoundToInfinityINTEL = 5582,
+ CapabilityFloatingPointModeINTEL = 5583,
+ CapabilityIntegerFunctions2INTEL = 5584,
+ CapabilityFunctionPointersINTEL = 5603,
+ CapabilityIndirectReferencesINTEL = 5604,
+ CapabilityAsmINTEL = 5606,
+ CapabilityAtomicFloat32MinMaxEXT = 5612,
+ CapabilityAtomicFloat64MinMaxEXT = 5613,
+ CapabilityAtomicFloat16MinMaxEXT = 5616,
+ CapabilityVectorComputeINTEL = 5617,
+ CapabilityVectorAnyINTEL = 5619,
+ CapabilityExpectAssumeKHR = 5629,
+ CapabilitySubgroupAvcMotionEstimationINTEL = 5696,
+ CapabilitySubgroupAvcMotionEstimationIntraINTEL = 5697,
+ CapabilitySubgroupAvcMotionEstimationChromaINTEL = 5698,
+ CapabilityVariableLengthArrayINTEL = 5817,
+ CapabilityFunctionFloatControlINTEL = 5821,
+ CapabilityFPGAMemoryAttributesINTEL = 5824,
+ CapabilityFPFastMathModeINTEL = 5837,
+ CapabilityArbitraryPrecisionIntegersINTEL = 5844,
+ CapabilityArbitraryPrecisionFloatingPointINTEL = 5845,
+ CapabilityUnstructuredLoopControlsINTEL = 5886,
+ CapabilityFPGALoopControlsINTEL = 5888,
+ CapabilityKernelAttributesINTEL = 5892,
+ CapabilityFPGAKernelAttributesINTEL = 5897,
+ CapabilityFPGAMemoryAccessesINTEL = 5898,
+ CapabilityFPGAClusterAttributesINTEL = 5904,
+ CapabilityLoopFuseINTEL = 5906,
+ CapabilityFPGABufferLocationINTEL = 5920,
+ CapabilityArbitraryPrecisionFixedPointINTEL = 5922,
+ CapabilityUSMStorageClassesINTEL = 5935,
+ CapabilityIOPipesINTEL = 5943,
+ CapabilityBlockingPipesINTEL = 5945,
+ CapabilityFPGARegINTEL = 5948,
+ CapabilityDotProductInputAll = 6016,
+ CapabilityDotProductInputAllKHR = 6016,
+ CapabilityDotProductInput4x8Bit = 6017,
+ CapabilityDotProductInput4x8BitKHR = 6017,
+ CapabilityDotProductInput4x8BitPacked = 6018,
+ CapabilityDotProductInput4x8BitPackedKHR = 6018,
+ CapabilityDotProduct = 6019,
+ CapabilityDotProductKHR = 6019,
+ CapabilityRayCullMaskKHR = 6020,
+ CapabilityBitInstructions = 6025,
+ CapabilityAtomicFloat32AddEXT = 6033,
+ CapabilityAtomicFloat64AddEXT = 6034,
+ CapabilityLongConstantCompositeINTEL = 6089,
+ CapabilityOptNoneINTEL = 6094,
+ CapabilityAtomicFloat16AddEXT = 6095,
+ CapabilityDebugInfoModuleINTEL = 6114,
+ CapabilityMax = 0x7fffffff,
+};
+
+enum RayFlagsShift {
+ RayFlagsOpaqueKHRShift = 0,
+ RayFlagsNoOpaqueKHRShift = 1,
+ RayFlagsTerminateOnFirstHitKHRShift = 2,
+ RayFlagsSkipClosestHitShaderKHRShift = 3,
+ RayFlagsCullBackFacingTrianglesKHRShift = 4,
+ RayFlagsCullFrontFacingTrianglesKHRShift = 5,
+ RayFlagsCullOpaqueKHRShift = 6,
+ RayFlagsCullNoOpaqueKHRShift = 7,
+ RayFlagsSkipTrianglesKHRShift = 8,
+ RayFlagsSkipAABBsKHRShift = 9,
+ RayFlagsMax = 0x7fffffff,
+};
+
+enum RayFlagsMask {
+ RayFlagsMaskNone = 0,
+ RayFlagsOpaqueKHRMask = 0x00000001,
+ RayFlagsNoOpaqueKHRMask = 0x00000002,
+ RayFlagsTerminateOnFirstHitKHRMask = 0x00000004,
+ RayFlagsSkipClosestHitShaderKHRMask = 0x00000008,
+ RayFlagsCullBackFacingTrianglesKHRMask = 0x00000010,
+ RayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020,
+ RayFlagsCullOpaqueKHRMask = 0x00000040,
+ RayFlagsCullNoOpaqueKHRMask = 0x00000080,
+ RayFlagsSkipTrianglesKHRMask = 0x00000100,
+ RayFlagsSkipAABBsKHRMask = 0x00000200,
+};
+
+enum RayQueryIntersection {
+ RayQueryIntersectionRayQueryCandidateIntersectionKHR = 0,
+ RayQueryIntersectionRayQueryCommittedIntersectionKHR = 1,
+ RayQueryIntersectionMax = 0x7fffffff,
+};
+
+enum RayQueryCommittedIntersectionType {
+ RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0,
+ RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR = 1,
+ RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR = 2,
+ RayQueryCommittedIntersectionTypeMax = 0x7fffffff,
+};
+
+enum RayQueryCandidateIntersectionType {
+ RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR = 0,
+ RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1,
+ RayQueryCandidateIntersectionTypeMax = 0x7fffffff,
+};
+
+enum FragmentShadingRateShift {
+ FragmentShadingRateVertical2PixelsShift = 0,
+ FragmentShadingRateVertical4PixelsShift = 1,
+ FragmentShadingRateHorizontal2PixelsShift = 2,
+ FragmentShadingRateHorizontal4PixelsShift = 3,
+ FragmentShadingRateMax = 0x7fffffff,
+};
+
+enum FragmentShadingRateMask {
+ FragmentShadingRateMaskNone = 0,
+ FragmentShadingRateVertical2PixelsMask = 0x00000001,
+ FragmentShadingRateVertical4PixelsMask = 0x00000002,
+ FragmentShadingRateHorizontal2PixelsMask = 0x00000004,
+ FragmentShadingRateHorizontal4PixelsMask = 0x00000008,
+};
+
+enum FPDenormMode {
+ FPDenormModePreserve = 0,
+ FPDenormModeFlushToZero = 1,
+ FPDenormModeMax = 0x7fffffff,
+};
+
+enum FPOperationMode {
+ FPOperationModeIEEE = 0,
+ FPOperationModeALT = 1,
+ FPOperationModeMax = 0x7fffffff,
+};
+
+enum QuantizationModes {
+ QuantizationModesTRN = 0,
+ QuantizationModesTRN_ZERO = 1,
+ QuantizationModesRND = 2,
+ QuantizationModesRND_ZERO = 3,
+ QuantizationModesRND_INF = 4,
+ QuantizationModesRND_MIN_INF = 5,
+ QuantizationModesRND_CONV = 6,
+ QuantizationModesRND_CONV_ODD = 7,
+ QuantizationModesMax = 0x7fffffff,
+};
+
+enum OverflowModes {
+ OverflowModesWRAP = 0,
+ OverflowModesSAT = 1,
+ OverflowModesSAT_ZERO = 2,
+ OverflowModesSAT_SYM = 3,
+ OverflowModesMax = 0x7fffffff,
+};
+
+enum PackedVectorFormat {
+ PackedVectorFormatPackedVectorFormat4x8Bit = 0,
+ PackedVectorFormatPackedVectorFormat4x8BitKHR = 0,
+ PackedVectorFormatMax = 0x7fffffff,
+};
+
+enum Op {
+ OpNop = 0,
+ OpUndef = 1,
+ OpSourceContinued = 2,
+ OpSource = 3,
+ OpSourceExtension = 4,
+ OpName = 5,
+ OpMemberName = 6,
+ OpString = 7,
+ OpLine = 8,
+ OpExtension = 10,
+ OpExtInstImport = 11,
+ OpExtInst = 12,
+ OpMemoryModel = 14,
+ OpEntryPoint = 15,
+ OpExecutionMode = 16,
+ OpCapability = 17,
+ OpTypeVoid = 19,
+ OpTypeBool = 20,
+ OpTypeInt = 21,
+ OpTypeFloat = 22,
+ OpTypeVector = 23,
+ OpTypeMatrix = 24,
+ OpTypeImage = 25,
+ OpTypeSampler = 26,
+ OpTypeSampledImage = 27,
+ OpTypeArray = 28,
+ OpTypeRuntimeArray = 29,
+ OpTypeStruct = 30,
+ OpTypeOpaque = 31,
+ OpTypePointer = 32,
+ OpTypeFunction = 33,
+ OpTypeEvent = 34,
+ OpTypeDeviceEvent = 35,
+ OpTypeReserveId = 36,
+ OpTypeQueue = 37,
+ OpTypePipe = 38,
+ OpTypeForwardPointer = 39,
+ OpConstantTrue = 41,
+ OpConstantFalse = 42,
+ OpConstant = 43,
+ OpConstantComposite = 44,
+ OpConstantSampler = 45,
+ OpConstantNull = 46,
+ OpSpecConstantTrue = 48,
+ OpSpecConstantFalse = 49,
+ OpSpecConstant = 50,
+ OpSpecConstantComposite = 51,
+ OpSpecConstantOp = 52,
+ OpFunction = 54,
+ OpFunctionParameter = 55,
+ OpFunctionEnd = 56,
+ OpFunctionCall = 57,
+ OpVariable = 59,
+ OpImageTexelPointer = 60,
+ OpLoad = 61,
+ OpStore = 62,
+ OpCopyMemory = 63,
+ OpCopyMemorySized = 64,
+ OpAccessChain = 65,
+ OpInBoundsAccessChain = 66,
+ OpPtrAccessChain = 67,
+ OpArrayLength = 68,
+ OpGenericPtrMemSemantics = 69,
+ OpInBoundsPtrAccessChain = 70,
+ OpDecorate = 71,
+ OpMemberDecorate = 72,
+ OpDecorationGroup = 73,
+ OpGroupDecorate = 74,
+ OpGroupMemberDecorate = 75,
+ OpVectorExtractDynamic = 77,
+ OpVectorInsertDynamic = 78,
+ OpVectorShuffle = 79,
+ OpCompositeConstruct = 80,
+ OpCompositeExtract = 81,
+ OpCompositeInsert = 82,
+ OpCopyObject = 83,
+ OpTranspose = 84,
+ OpSampledImage = 86,
+ OpImageSampleImplicitLod = 87,
+ OpImageSampleExplicitLod = 88,
+ OpImageSampleDrefImplicitLod = 89,
+ OpImageSampleDrefExplicitLod = 90,
+ OpImageSampleProjImplicitLod = 91,
+ OpImageSampleProjExplicitLod = 92,
+ OpImageSampleProjDrefImplicitLod = 93,
+ OpImageSampleProjDrefExplicitLod = 94,
+ OpImageFetch = 95,
+ OpImageGather = 96,
+ OpImageDrefGather = 97,
+ OpImageRead = 98,
+ OpImageWrite = 99,
+ OpImage = 100,
+ OpImageQueryFormat = 101,
+ OpImageQueryOrder = 102,
+ OpImageQuerySizeLod = 103,
+ OpImageQuerySize = 104,
+ OpImageQueryLod = 105,
+ OpImageQueryLevels = 106,
+ OpImageQuerySamples = 107,
+ OpConvertFToU = 109,
+ OpConvertFToS = 110,
+ OpConvertSToF = 111,
+ OpConvertUToF = 112,
+ OpUConvert = 113,
+ OpSConvert = 114,
+ OpFConvert = 115,
+ OpQuantizeToF16 = 116,
+ OpConvertPtrToU = 117,
+ OpSatConvertSToU = 118,
+ OpSatConvertUToS = 119,
+ OpConvertUToPtr = 120,
+ OpPtrCastToGeneric = 121,
+ OpGenericCastToPtr = 122,
+ OpGenericCastToPtrExplicit = 123,
+ OpBitcast = 124,
+ OpSNegate = 126,
+ OpFNegate = 127,
+ OpIAdd = 128,
+ OpFAdd = 129,
+ OpISub = 130,
+ OpFSub = 131,
+ OpIMul = 132,
+ OpFMul = 133,
+ OpUDiv = 134,
+ OpSDiv = 135,
+ OpFDiv = 136,
+ OpUMod = 137,
+ OpSRem = 138,
+ OpSMod = 139,
+ OpFRem = 140,
+ OpFMod = 141,
+ OpVectorTimesScalar = 142,
+ OpMatrixTimesScalar = 143,
+ OpVectorTimesMatrix = 144,
+ OpMatrixTimesVector = 145,
+ OpMatrixTimesMatrix = 146,
+ OpOuterProduct = 147,
+ OpDot = 148,
+ OpIAddCarry = 149,
+ OpISubBorrow = 150,
+ OpUMulExtended = 151,
+ OpSMulExtended = 152,
+ OpAny = 154,
+ OpAll = 155,
+ OpIsNan = 156,
+ OpIsInf = 157,
+ OpIsFinite = 158,
+ OpIsNormal = 159,
+ OpSignBitSet = 160,
+ OpLessOrGreater = 161,
+ OpOrdered = 162,
+ OpUnordered = 163,
+ OpLogicalEqual = 164,
+ OpLogicalNotEqual = 165,
+ OpLogicalOr = 166,
+ OpLogicalAnd = 167,
+ OpLogicalNot = 168,
+ OpSelect = 169,
+ OpIEqual = 170,
+ OpINotEqual = 171,
+ OpUGreaterThan = 172,
+ OpSGreaterThan = 173,
+ OpUGreaterThanEqual = 174,
+ OpSGreaterThanEqual = 175,
+ OpULessThan = 176,
+ OpSLessThan = 177,
+ OpULessThanEqual = 178,
+ OpSLessThanEqual = 179,
+ OpFOrdEqual = 180,
+ OpFUnordEqual = 181,
+ OpFOrdNotEqual = 182,
+ OpFUnordNotEqual = 183,
+ OpFOrdLessThan = 184,
+ OpFUnordLessThan = 185,
+ OpFOrdGreaterThan = 186,
+ OpFUnordGreaterThan = 187,
+ OpFOrdLessThanEqual = 188,
+ OpFUnordLessThanEqual = 189,
+ OpFOrdGreaterThanEqual = 190,
+ OpFUnordGreaterThanEqual = 191,
+ OpShiftRightLogical = 194,
+ OpShiftRightArithmetic = 195,
+ OpShiftLeftLogical = 196,
+ OpBitwiseOr = 197,
+ OpBitwiseXor = 198,
+ OpBitwiseAnd = 199,
+ OpNot = 200,
+ OpBitFieldInsert = 201,
+ OpBitFieldSExtract = 202,
+ OpBitFieldUExtract = 203,
+ OpBitReverse = 204,
+ OpBitCount = 205,
+ OpDPdx = 207,
+ OpDPdy = 208,
+ OpFwidth = 209,
+ OpDPdxFine = 210,
+ OpDPdyFine = 211,
+ OpFwidthFine = 212,
+ OpDPdxCoarse = 213,
+ OpDPdyCoarse = 214,
+ OpFwidthCoarse = 215,
+ OpEmitVertex = 218,
+ OpEndPrimitive = 219,
+ OpEmitStreamVertex = 220,
+ OpEndStreamPrimitive = 221,
+ OpControlBarrier = 224,
+ OpMemoryBarrier = 225,
+ OpAtomicLoad = 227,
+ OpAtomicStore = 228,
+ OpAtomicExchange = 229,
+ OpAtomicCompareExchange = 230,
+ OpAtomicCompareExchangeWeak = 231,
+ OpAtomicIIncrement = 232,
+ OpAtomicIDecrement = 233,
+ OpAtomicIAdd = 234,
+ OpAtomicISub = 235,
+ OpAtomicSMin = 236,
+ OpAtomicUMin = 237,
+ OpAtomicSMax = 238,
+ OpAtomicUMax = 239,
+ OpAtomicAnd = 240,
+ OpAtomicOr = 241,
+ OpAtomicXor = 242,
+ OpPhi = 245,
+ OpLoopMerge = 246,
+ OpSelectionMerge = 247,
+ OpLabel = 248,
+ OpBranch = 249,
+ OpBranchConditional = 250,
+ OpSwitch = 251,
+ OpKill = 252,
+ OpReturn = 253,
+ OpReturnValue = 254,
+ OpUnreachable = 255,
+ OpLifetimeStart = 256,
+ OpLifetimeStop = 257,
+ OpGroupAsyncCopy = 259,
+ OpGroupWaitEvents = 260,
+ OpGroupAll = 261,
+ OpGroupAny = 262,
+ OpGroupBroadcast = 263,
+ OpGroupIAdd = 264,
+ OpGroupFAdd = 265,
+ OpGroupFMin = 266,
+ OpGroupUMin = 267,
+ OpGroupSMin = 268,
+ OpGroupFMax = 269,
+ OpGroupUMax = 270,
+ OpGroupSMax = 271,
+ OpReadPipe = 274,
+ OpWritePipe = 275,
+ OpReservedReadPipe = 276,
+ OpReservedWritePipe = 277,
+ OpReserveReadPipePackets = 278,
+ OpReserveWritePipePackets = 279,
+ OpCommitReadPipe = 280,
+ OpCommitWritePipe = 281,
+ OpIsValidReserveId = 282,
+ OpGetNumPipePackets = 283,
+ OpGetMaxPipePackets = 284,
+ OpGroupReserveReadPipePackets = 285,
+ OpGroupReserveWritePipePackets = 286,
+ OpGroupCommitReadPipe = 287,
+ OpGroupCommitWritePipe = 288,
+ OpEnqueueMarker = 291,
+ OpEnqueueKernel = 292,
+ OpGetKernelNDrangeSubGroupCount = 293,
+ OpGetKernelNDrangeMaxSubGroupSize = 294,
+ OpGetKernelWorkGroupSize = 295,
+ OpGetKernelPreferredWorkGroupSizeMultiple = 296,
+ OpRetainEvent = 297,
+ OpReleaseEvent = 298,
+ OpCreateUserEvent = 299,
+ OpIsValidEvent = 300,
+ OpSetUserEventStatus = 301,
+ OpCaptureEventProfilingInfo = 302,
+ OpGetDefaultQueue = 303,
+ OpBuildNDRange = 304,
+ OpImageSparseSampleImplicitLod = 305,
+ OpImageSparseSampleExplicitLod = 306,
+ OpImageSparseSampleDrefImplicitLod = 307,
+ OpImageSparseSampleDrefExplicitLod = 308,
+ OpImageSparseSampleProjImplicitLod = 309,
+ OpImageSparseSampleProjExplicitLod = 310,
+ OpImageSparseSampleProjDrefImplicitLod = 311,
+ OpImageSparseSampleProjDrefExplicitLod = 312,
+ OpImageSparseFetch = 313,
+ OpImageSparseGather = 314,
+ OpImageSparseDrefGather = 315,
+ OpImageSparseTexelsResident = 316,
+ OpNoLine = 317,
+ OpAtomicFlagTestAndSet = 318,
+ OpAtomicFlagClear = 319,
+ OpImageSparseRead = 320,
+ OpSizeOf = 321,
+ OpTypePipeStorage = 322,
+ OpConstantPipeStorage = 323,
+ OpCreatePipeFromPipeStorage = 324,
+ OpGetKernelLocalSizeForSubgroupCount = 325,
+ OpGetKernelMaxNumSubgroups = 326,
+ OpTypeNamedBarrier = 327,
+ OpNamedBarrierInitialize = 328,
+ OpMemoryNamedBarrier = 329,
+ OpModuleProcessed = 330,
+ OpExecutionModeId = 331,
+ OpDecorateId = 332,
+ OpGroupNonUniformElect = 333,
+ OpGroupNonUniformAll = 334,
+ OpGroupNonUniformAny = 335,
+ OpGroupNonUniformAllEqual = 336,
+ OpGroupNonUniformBroadcast = 337,
+ OpGroupNonUniformBroadcastFirst = 338,
+ OpGroupNonUniformBallot = 339,
+ OpGroupNonUniformInverseBallot = 340,
+ OpGroupNonUniformBallotBitExtract = 341,
+ OpGroupNonUniformBallotBitCount = 342,
+ OpGroupNonUniformBallotFindLSB = 343,
+ OpGroupNonUniformBallotFindMSB = 344,
+ OpGroupNonUniformShuffle = 345,
+ OpGroupNonUniformShuffleXor = 346,
+ OpGroupNonUniformShuffleUp = 347,
+ OpGroupNonUniformShuffleDown = 348,
+ OpGroupNonUniformIAdd = 349,
+ OpGroupNonUniformFAdd = 350,
+ OpGroupNonUniformIMul = 351,
+ OpGroupNonUniformFMul = 352,
+ OpGroupNonUniformSMin = 353,
+ OpGroupNonUniformUMin = 354,
+ OpGroupNonUniformFMin = 355,
+ OpGroupNonUniformSMax = 356,
+ OpGroupNonUniformUMax = 357,
+ OpGroupNonUniformFMax = 358,
+ OpGroupNonUniformBitwiseAnd = 359,
+ OpGroupNonUniformBitwiseOr = 360,
+ OpGroupNonUniformBitwiseXor = 361,
+ OpGroupNonUniformLogicalAnd = 362,
+ OpGroupNonUniformLogicalOr = 363,
+ OpGroupNonUniformLogicalXor = 364,
+ OpGroupNonUniformQuadBroadcast = 365,
+ OpGroupNonUniformQuadSwap = 366,
+ OpCopyLogical = 400,
+ OpPtrEqual = 401,
+ OpPtrNotEqual = 402,
+ OpPtrDiff = 403,
+ OpTerminateInvocation = 4416,
+ OpSubgroupBallotKHR = 4421,
+ OpSubgroupFirstInvocationKHR = 4422,
+ OpSubgroupAllKHR = 4428,
+ OpSubgroupAnyKHR = 4429,
+ OpSubgroupAllEqualKHR = 4430,
+ OpSubgroupReadInvocationKHR = 4432,
+ OpTraceRayKHR = 4445,
+ OpExecuteCallableKHR = 4446,
+ OpConvertUToAccelerationStructureKHR = 4447,
+ OpIgnoreIntersectionKHR = 4448,
+ OpTerminateRayKHR = 4449,
+ OpSDot = 4450,
+ OpSDotKHR = 4450,
+ OpUDot = 4451,
+ OpUDotKHR = 4451,
+ OpSUDot = 4452,
+ OpSUDotKHR = 4452,
+ OpSDotAccSat = 4453,
+ OpSDotAccSatKHR = 4453,
+ OpUDotAccSat = 4454,
+ OpUDotAccSatKHR = 4454,
+ OpSUDotAccSat = 4455,
+ OpSUDotAccSatKHR = 4455,
+ OpTypeRayQueryKHR = 4472,
+ OpRayQueryInitializeKHR = 4473,
+ OpRayQueryTerminateKHR = 4474,
+ OpRayQueryGenerateIntersectionKHR = 4475,
+ OpRayQueryConfirmIntersectionKHR = 4476,
+ OpRayQueryProceedKHR = 4477,
+ OpRayQueryGetIntersectionTypeKHR = 4479,
+ OpGroupIAddNonUniformAMD = 5000,
+ OpGroupFAddNonUniformAMD = 5001,
+ OpGroupFMinNonUniformAMD = 5002,
+ OpGroupUMinNonUniformAMD = 5003,
+ OpGroupSMinNonUniformAMD = 5004,
+ OpGroupFMaxNonUniformAMD = 5005,
+ OpGroupUMaxNonUniformAMD = 5006,
+ OpGroupSMaxNonUniformAMD = 5007,
+ OpFragmentMaskFetchAMD = 5011,
+ OpFragmentFetchAMD = 5012,
+ OpReadClockKHR = 5056,
+ OpImageSampleFootprintNV = 5283,
+ OpEmitMeshTasksEXT = 5294,
+ OpSetMeshOutputsEXT = 5295,
+ OpGroupNonUniformPartitionNV = 5296,
+ OpWritePackedPrimitiveIndices4x8NV = 5299,
+ OpReportIntersectionKHR = 5334,
+ OpReportIntersectionNV = 5334,
+ OpIgnoreIntersectionNV = 5335,
+ OpTerminateRayNV = 5336,
+ OpTraceNV = 5337,
+ OpTraceMotionNV = 5338,
+ OpTraceRayMotionNV = 5339,
+ OpTypeAccelerationStructureKHR = 5341,
+ OpTypeAccelerationStructureNV = 5341,
+ OpExecuteCallableNV = 5344,
+ OpTypeCooperativeMatrixNV = 5358,
+ OpCooperativeMatrixLoadNV = 5359,
+ OpCooperativeMatrixStoreNV = 5360,
+ OpCooperativeMatrixMulAddNV = 5361,
+ OpCooperativeMatrixLengthNV = 5362,
+ OpBeginInvocationInterlockEXT = 5364,
+ OpEndInvocationInterlockEXT = 5365,
+ OpDemoteToHelperInvocation = 5380,
+ OpDemoteToHelperInvocationEXT = 5380,
+ OpIsHelperInvocationEXT = 5381,
+ OpConvertUToImageNV = 5391,
+ OpConvertUToSamplerNV = 5392,
+ OpConvertImageToUNV = 5393,
+ OpConvertSamplerToUNV = 5394,
+ OpConvertUToSampledImageNV = 5395,
+ OpConvertSampledImageToUNV = 5396,
+ OpSamplerImageAddressingModeNV = 5397,
+ OpSubgroupShuffleINTEL = 5571,
+ OpSubgroupShuffleDownINTEL = 5572,
+ OpSubgroupShuffleUpINTEL = 5573,
+ OpSubgroupShuffleXorINTEL = 5574,
+ OpSubgroupBlockReadINTEL = 5575,
+ OpSubgroupBlockWriteINTEL = 5576,
+ OpSubgroupImageBlockReadINTEL = 5577,
+ OpSubgroupImageBlockWriteINTEL = 5578,
+ OpSubgroupImageMediaBlockReadINTEL = 5580,
+ OpSubgroupImageMediaBlockWriteINTEL = 5581,
+ OpUCountLeadingZerosINTEL = 5585,
+ OpUCountTrailingZerosINTEL = 5586,
+ OpAbsISubINTEL = 5587,
+ OpAbsUSubINTEL = 5588,
+ OpIAddSatINTEL = 5589,
+ OpUAddSatINTEL = 5590,
+ OpIAverageINTEL = 5591,
+ OpUAverageINTEL = 5592,
+ OpIAverageRoundedINTEL = 5593,
+ OpUAverageRoundedINTEL = 5594,
+ OpISubSatINTEL = 5595,
+ OpUSubSatINTEL = 5596,
+ OpIMul32x16INTEL = 5597,
+ OpUMul32x16INTEL = 5598,
+ OpConstantFunctionPointerINTEL = 5600,
+ OpFunctionPointerCallINTEL = 5601,
+ OpAsmTargetINTEL = 5609,
+ OpAsmINTEL = 5610,
+ OpAsmCallINTEL = 5611,
+ OpAtomicFMinEXT = 5614,
+ OpAtomicFMaxEXT = 5615,
+ OpAssumeTrueKHR = 5630,
+ OpExpectKHR = 5631,
+ OpDecorateString = 5632,
+ OpDecorateStringGOOGLE = 5632,
+ OpMemberDecorateString = 5633,
+ OpMemberDecorateStringGOOGLE = 5633,
+ OpVmeImageINTEL = 5699,
+ OpTypeVmeImageINTEL = 5700,
+ OpTypeAvcImePayloadINTEL = 5701,
+ OpTypeAvcRefPayloadINTEL = 5702,
+ OpTypeAvcSicPayloadINTEL = 5703,
+ OpTypeAvcMcePayloadINTEL = 5704,
+ OpTypeAvcMceResultINTEL = 5705,
+ OpTypeAvcImeResultINTEL = 5706,
+ OpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707,
+ OpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708,
+ OpTypeAvcImeSingleReferenceStreaminINTEL = 5709,
+ OpTypeAvcImeDualReferenceStreaminINTEL = 5710,
+ OpTypeAvcRefResultINTEL = 5711,
+ OpTypeAvcSicResultINTEL = 5712,
+ OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL = 5713,
+ OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL = 5714,
+ OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL = 5715,
+ OpSubgroupAvcMceSetInterShapePenaltyINTEL = 5716,
+ OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL = 5717,
+ OpSubgroupAvcMceSetInterDirectionPenaltyINTEL = 5718,
+ OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL = 5719,
+ OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL = 5720,
+ OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL = 5721,
+ OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL = 5722,
+ OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL = 5723,
+ OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL = 5724,
+ OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL = 5725,
+ OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL = 5726,
+ OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL = 5727,
+ OpSubgroupAvcMceSetAcOnlyHaarINTEL = 5728,
+ OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL = 5729,
+ OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL = 5730,
+ OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL = 5731,
+ OpSubgroupAvcMceConvertToImePayloadINTEL = 5732,
+ OpSubgroupAvcMceConvertToImeResultINTEL = 5733,
+ OpSubgroupAvcMceConvertToRefPayloadINTEL = 5734,
+ OpSubgroupAvcMceConvertToRefResultINTEL = 5735,
+ OpSubgroupAvcMceConvertToSicPayloadINTEL = 5736,
+ OpSubgroupAvcMceConvertToSicResultINTEL = 5737,
+ OpSubgroupAvcMceGetMotionVectorsINTEL = 5738,
+ OpSubgroupAvcMceGetInterDistortionsINTEL = 5739,
+ OpSubgroupAvcMceGetBestInterDistortionsINTEL = 5740,
+ OpSubgroupAvcMceGetInterMajorShapeINTEL = 5741,
+ OpSubgroupAvcMceGetInterMinorShapeINTEL = 5742,
+ OpSubgroupAvcMceGetInterDirectionsINTEL = 5743,
+ OpSubgroupAvcMceGetInterMotionVectorCountINTEL = 5744,
+ OpSubgroupAvcMceGetInterReferenceIdsINTEL = 5745,
+ OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL = 5746,
+ OpSubgroupAvcImeInitializeINTEL = 5747,
+ OpSubgroupAvcImeSetSingleReferenceINTEL = 5748,
+ OpSubgroupAvcImeSetDualReferenceINTEL = 5749,
+ OpSubgroupAvcImeRefWindowSizeINTEL = 5750,
+ OpSubgroupAvcImeAdjustRefOffsetINTEL = 5751,
+ OpSubgroupAvcImeConvertToMcePayloadINTEL = 5752,
+ OpSubgroupAvcImeSetMaxMotionVectorCountINTEL = 5753,
+ OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL = 5754,
+ OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL = 5755,
+ OpSubgroupAvcImeSetWeightedSadINTEL = 5756,
+ OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL = 5757,
+ OpSubgroupAvcImeEvaluateWithDualReferenceINTEL = 5758,
+ OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759,
+ OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760,
+ OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761,
+ OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762,
+ OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763,
+ OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764,
+ OpSubgroupAvcImeConvertToMceResultINTEL = 5765,
+ OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766,
+ OpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767,
+ OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768,
+ OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769,
+ OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770,
+ OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771,
+ OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772,
+ OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773,
+ OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774,
+ OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775,
+ OpSubgroupAvcImeGetBorderReachedINTEL = 5776,
+ OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL = 5777,
+ OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL = 5778,
+ OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL = 5779,
+ OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL = 5780,
+ OpSubgroupAvcFmeInitializeINTEL = 5781,
+ OpSubgroupAvcBmeInitializeINTEL = 5782,
+ OpSubgroupAvcRefConvertToMcePayloadINTEL = 5783,
+ OpSubgroupAvcRefSetBidirectionalMixDisableINTEL = 5784,
+ OpSubgroupAvcRefSetBilinearFilterEnableINTEL = 5785,
+ OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL = 5786,
+ OpSubgroupAvcRefEvaluateWithDualReferenceINTEL = 5787,
+ OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL = 5788,
+ OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL = 5789,
+ OpSubgroupAvcRefConvertToMceResultINTEL = 5790,
+ OpSubgroupAvcSicInitializeINTEL = 5791,
+ OpSubgroupAvcSicConfigureSkcINTEL = 5792,
+ OpSubgroupAvcSicConfigureIpeLumaINTEL = 5793,
+ OpSubgroupAvcSicConfigureIpeLumaChromaINTEL = 5794,
+ OpSubgroupAvcSicGetMotionVectorMaskINTEL = 5795,
+ OpSubgroupAvcSicConvertToMcePayloadINTEL = 5796,
+ OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL = 5797,
+ OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL = 5798,
+ OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL = 5799,
+ OpSubgroupAvcSicSetBilinearFilterEnableINTEL = 5800,
+ OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL = 5801,
+ OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL = 5802,
+ OpSubgroupAvcSicEvaluateIpeINTEL = 5803,
+ OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL = 5804,
+ OpSubgroupAvcSicEvaluateWithDualReferenceINTEL = 5805,
+ OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL = 5806,
+ OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL = 5807,
+ OpSubgroupAvcSicConvertToMceResultINTEL = 5808,
+ OpSubgroupAvcSicGetIpeLumaShapeINTEL = 5809,
+ OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL = 5810,
+ OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL = 5811,
+ OpSubgroupAvcSicGetPackedIpeLumaModesINTEL = 5812,
+ OpSubgroupAvcSicGetIpeChromaModeINTEL = 5813,
+ OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814,
+ OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815,
+ OpSubgroupAvcSicGetInterRawSadsINTEL = 5816,
+ OpVariableLengthArrayINTEL = 5818,
+ OpSaveMemoryINTEL = 5819,
+ OpRestoreMemoryINTEL = 5820,
+ OpArbitraryFloatSinCosPiINTEL = 5840,
+ OpArbitraryFloatCastINTEL = 5841,
+ OpArbitraryFloatCastFromIntINTEL = 5842,
+ OpArbitraryFloatCastToIntINTEL = 5843,
+ OpArbitraryFloatAddINTEL = 5846,
+ OpArbitraryFloatSubINTEL = 5847,
+ OpArbitraryFloatMulINTEL = 5848,
+ OpArbitraryFloatDivINTEL = 5849,
+ OpArbitraryFloatGTINTEL = 5850,
+ OpArbitraryFloatGEINTEL = 5851,
+ OpArbitraryFloatLTINTEL = 5852,
+ OpArbitraryFloatLEINTEL = 5853,
+ OpArbitraryFloatEQINTEL = 5854,
+ OpArbitraryFloatRecipINTEL = 5855,
+ OpArbitraryFloatRSqrtINTEL = 5856,
+ OpArbitraryFloatCbrtINTEL = 5857,
+ OpArbitraryFloatHypotINTEL = 5858,
+ OpArbitraryFloatSqrtINTEL = 5859,
+ OpArbitraryFloatLogINTEL = 5860,
+ OpArbitraryFloatLog2INTEL = 5861,
+ OpArbitraryFloatLog10INTEL = 5862,
+ OpArbitraryFloatLog1pINTEL = 5863,
+ OpArbitraryFloatExpINTEL = 5864,
+ OpArbitraryFloatExp2INTEL = 5865,
+ OpArbitraryFloatExp10INTEL = 5866,
+ OpArbitraryFloatExpm1INTEL = 5867,
+ OpArbitraryFloatSinINTEL = 5868,
+ OpArbitraryFloatCosINTEL = 5869,
+ OpArbitraryFloatSinCosINTEL = 5870,
+ OpArbitraryFloatSinPiINTEL = 5871,
+ OpArbitraryFloatCosPiINTEL = 5872,
+ OpArbitraryFloatASinINTEL = 5873,
+ OpArbitraryFloatASinPiINTEL = 5874,
+ OpArbitraryFloatACosINTEL = 5875,
+ OpArbitraryFloatACosPiINTEL = 5876,
+ OpArbitraryFloatATanINTEL = 5877,
+ OpArbitraryFloatATanPiINTEL = 5878,
+ OpArbitraryFloatATan2INTEL = 5879,
+ OpArbitraryFloatPowINTEL = 5880,
+ OpArbitraryFloatPowRINTEL = 5881,
+ OpArbitraryFloatPowNINTEL = 5882,
+ OpLoopControlINTEL = 5887,
+ OpFixedSqrtINTEL = 5923,
+ OpFixedRecipINTEL = 5924,
+ OpFixedRsqrtINTEL = 5925,
+ OpFixedSinINTEL = 5926,
+ OpFixedCosINTEL = 5927,
+ OpFixedSinCosINTEL = 5928,
+ OpFixedSinPiINTEL = 5929,
+ OpFixedCosPiINTEL = 5930,
+ OpFixedSinCosPiINTEL = 5931,
+ OpFixedLogINTEL = 5932,
+ OpFixedExpINTEL = 5933,
+ OpPtrCastToCrossWorkgroupINTEL = 5934,
+ OpCrossWorkgroupCastToPtrINTEL = 5938,
+ OpReadPipeBlockingINTEL = 5946,
+ OpWritePipeBlockingINTEL = 5947,
+ OpFPGARegINTEL = 5949,
+ OpRayQueryGetRayTMinKHR = 6016,
+ OpRayQueryGetRayFlagsKHR = 6017,
+ OpRayQueryGetIntersectionTKHR = 6018,
+ OpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019,
+ OpRayQueryGetIntersectionInstanceIdKHR = 6020,
+ OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021,
+ OpRayQueryGetIntersectionGeometryIndexKHR = 6022,
+ OpRayQueryGetIntersectionPrimitiveIndexKHR = 6023,
+ OpRayQueryGetIntersectionBarycentricsKHR = 6024,
+ OpRayQueryGetIntersectionFrontFaceKHR = 6025,
+ OpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026,
+ OpRayQueryGetIntersectionObjectRayDirectionKHR = 6027,
+ OpRayQueryGetIntersectionObjectRayOriginKHR = 6028,
+ OpRayQueryGetWorldRayDirectionKHR = 6029,
+ OpRayQueryGetWorldRayOriginKHR = 6030,
+ OpRayQueryGetIntersectionObjectToWorldKHR = 6031,
+ OpRayQueryGetIntersectionWorldToObjectKHR = 6032,
+ OpAtomicFAddEXT = 6035,
+ OpTypeBufferSurfaceINTEL = 6086,
+ OpTypeStructContinuedINTEL = 6090,
+ OpConstantCompositeContinuedINTEL = 6091,
+ OpSpecConstantCompositeContinuedINTEL = 6092,
+ OpMax = 0x7fffffff,
+};
+
+#ifdef SPV_ENABLE_UTILITY_CODE
+inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
+ *hasResult = *hasResultType = false;
+ switch (opcode) {
+ default: /* unknown opcode */ break;
+ case OpNop: *hasResult = false; *hasResultType = false; break;
+ case OpUndef: *hasResult = true; *hasResultType = true; break;
+ case OpSourceContinued: *hasResult = false; *hasResultType = false; break;
+ case OpSource: *hasResult = false; *hasResultType = false; break;
+ case OpSourceExtension: *hasResult = false; *hasResultType = false; break;
+ case OpName: *hasResult = false; *hasResultType = false; break;
+ case OpMemberName: *hasResult = false; *hasResultType = false; break;
+ case OpString: *hasResult = true; *hasResultType = false; break;
+ case OpLine: *hasResult = false; *hasResultType = false; break;
+ case OpExtension: *hasResult = false; *hasResultType = false; break;
+ case OpExtInstImport: *hasResult = true; *hasResultType = false; break;
+ case OpExtInst: *hasResult = true; *hasResultType = true; break;
+ case OpMemoryModel: *hasResult = false; *hasResultType = false; break;
+ case OpEntryPoint: *hasResult = false; *hasResultType = false; break;
+ case OpExecutionMode: *hasResult = false; *hasResultType = false; break;
+ case OpCapability: *hasResult = false; *hasResultType = false; break;
+ case OpTypeVoid: *hasResult = true; *hasResultType = false; break;
+ case OpTypeBool: *hasResult = true; *hasResultType = false; break;
+ case OpTypeInt: *hasResult = true; *hasResultType = false; break;
+ case OpTypeFloat: *hasResult = true; *hasResultType = false; break;
+ case OpTypeVector: *hasResult = true; *hasResultType = false; break;
+ case OpTypeMatrix: *hasResult = true; *hasResultType = false; break;
+ case OpTypeImage: *hasResult = true; *hasResultType = false; break;
+ case OpTypeSampler: *hasResult = true; *hasResultType = false; break;
+ case OpTypeSampledImage: *hasResult = true; *hasResultType = false; break;
+ case OpTypeArray: *hasResult = true; *hasResultType = false; break;
+ case OpTypeRuntimeArray: *hasResult = true; *hasResultType = false; break;
+ case OpTypeStruct: *hasResult = true; *hasResultType = false; break;
+ case OpTypeOpaque: *hasResult = true; *hasResultType = false; break;
+ case OpTypePointer: *hasResult = true; *hasResultType = false; break;
+ case OpTypeFunction: *hasResult = true; *hasResultType = false; break;
+ case OpTypeEvent: *hasResult = true; *hasResultType = false; break;
+ case OpTypeDeviceEvent: *hasResult = true; *hasResultType = false; break;
+ case OpTypeReserveId: *hasResult = true; *hasResultType = false; break;
+ case OpTypeQueue: *hasResult = true; *hasResultType = false; break;
+ case OpTypePipe: *hasResult = true; *hasResultType = false; break;
+ case OpTypeForwardPointer: *hasResult = false; *hasResultType = false; break;
+ case OpConstantTrue: *hasResult = true; *hasResultType = true; break;
+ case OpConstantFalse: *hasResult = true; *hasResultType = true; break;
+ case OpConstant: *hasResult = true; *hasResultType = true; break;
+ case OpConstantComposite: *hasResult = true; *hasResultType = true; break;
+ case OpConstantSampler: *hasResult = true; *hasResultType = true; break;
+ case OpConstantNull: *hasResult = true; *hasResultType = true; break;
+ case OpSpecConstantTrue: *hasResult = true; *hasResultType = true; break;
+ case OpSpecConstantFalse: *hasResult = true; *hasResultType = true; break;
+ case OpSpecConstant: *hasResult = true; *hasResultType = true; break;
+ case OpSpecConstantComposite: *hasResult = true; *hasResultType = true; break;
+ case OpSpecConstantOp: *hasResult = true; *hasResultType = true; break;
+ case OpFunction: *hasResult = true; *hasResultType = true; break;
+ case OpFunctionParameter: *hasResult = true; *hasResultType = true; break;
+ case OpFunctionEnd: *hasResult = false; *hasResultType = false; break;
+ case OpFunctionCall: *hasResult = true; *hasResultType = true; break;
+ case OpVariable: *hasResult = true; *hasResultType = true; break;
+ case OpImageTexelPointer: *hasResult = true; *hasResultType = true; break;
+ case OpLoad: *hasResult = true; *hasResultType = true; break;
+ case OpStore: *hasResult = false; *hasResultType = false; break;
+ case OpCopyMemory: *hasResult = false; *hasResultType = false; break;
+ case OpCopyMemorySized: *hasResult = false; *hasResultType = false; break;
+ case OpAccessChain: *hasResult = true; *hasResultType = true; break;
+ case OpInBoundsAccessChain: *hasResult = true; *hasResultType = true; break;
+ case OpPtrAccessChain: *hasResult = true; *hasResultType = true; break;
+ case OpArrayLength: *hasResult = true; *hasResultType = true; break;
+ case OpGenericPtrMemSemantics: *hasResult = true; *hasResultType = true; break;
+ case OpInBoundsPtrAccessChain: *hasResult = true; *hasResultType = true; break;
+ case OpDecorate: *hasResult = false; *hasResultType = false; break;
+ case OpMemberDecorate: *hasResult = false; *hasResultType = false; break;
+ case OpDecorationGroup: *hasResult = true; *hasResultType = false; break;
+ case OpGroupDecorate: *hasResult = false; *hasResultType = false; break;
+ case OpGroupMemberDecorate: *hasResult = false; *hasResultType = false; break;
+ case OpVectorExtractDynamic: *hasResult = true; *hasResultType = true; break;
+ case OpVectorInsertDynamic: *hasResult = true; *hasResultType = true; break;
+ case OpVectorShuffle: *hasResult = true; *hasResultType = true; break;
+ case OpCompositeConstruct: *hasResult = true; *hasResultType = true; break;
+ case OpCompositeExtract: *hasResult = true; *hasResultType = true; break;
+ case OpCompositeInsert: *hasResult = true; *hasResultType = true; break;
+ case OpCopyObject: *hasResult = true; *hasResultType = true; break;
+ case OpTranspose: *hasResult = true; *hasResultType = true; break;
+ case OpSampledImage: *hasResult = true; *hasResultType = true; break;
+ case OpImageSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageFetch: *hasResult = true; *hasResultType = true; break;
+ case OpImageGather: *hasResult = true; *hasResultType = true; break;
+ case OpImageDrefGather: *hasResult = true; *hasResultType = true; break;
+ case OpImageRead: *hasResult = true; *hasResultType = true; break;
+ case OpImageWrite: *hasResult = false; *hasResultType = false; break;
+ case OpImage: *hasResult = true; *hasResultType = true; break;
+ case OpImageQueryFormat: *hasResult = true; *hasResultType = true; break;
+ case OpImageQueryOrder: *hasResult = true; *hasResultType = true; break;
+ case OpImageQuerySizeLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageQuerySize: *hasResult = true; *hasResultType = true; break;
+ case OpImageQueryLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageQueryLevels: *hasResult = true; *hasResultType = true; break;
+ case OpImageQuerySamples: *hasResult = true; *hasResultType = true; break;
+ case OpConvertFToU: *hasResult = true; *hasResultType = true; break;
+ case OpConvertFToS: *hasResult = true; *hasResultType = true; break;
+ case OpConvertSToF: *hasResult = true; *hasResultType = true; break;
+ case OpConvertUToF: *hasResult = true; *hasResultType = true; break;
+ case OpUConvert: *hasResult = true; *hasResultType = true; break;
+ case OpSConvert: *hasResult = true; *hasResultType = true; break;
+ case OpFConvert: *hasResult = true; *hasResultType = true; break;
+ case OpQuantizeToF16: *hasResult = true; *hasResultType = true; break;
+ case OpConvertPtrToU: *hasResult = true; *hasResultType = true; break;
+ case OpSatConvertSToU: *hasResult = true; *hasResultType = true; break;
+ case OpSatConvertUToS: *hasResult = true; *hasResultType = true; break;
+ case OpConvertUToPtr: *hasResult = true; *hasResultType = true; break;
+ case OpPtrCastToGeneric: *hasResult = true; *hasResultType = true; break;
+ case OpGenericCastToPtr: *hasResult = true; *hasResultType = true; break;
+ case OpGenericCastToPtrExplicit: *hasResult = true; *hasResultType = true; break;
+ case OpBitcast: *hasResult = true; *hasResultType = true; break;
+ case OpSNegate: *hasResult = true; *hasResultType = true; break;
+ case OpFNegate: *hasResult = true; *hasResultType = true; break;
+ case OpIAdd: *hasResult = true; *hasResultType = true; break;
+ case OpFAdd: *hasResult = true; *hasResultType = true; break;
+ case OpISub: *hasResult = true; *hasResultType = true; break;
+ case OpFSub: *hasResult = true; *hasResultType = true; break;
+ case OpIMul: *hasResult = true; *hasResultType = true; break;
+ case OpFMul: *hasResult = true; *hasResultType = true; break;
+ case OpUDiv: *hasResult = true; *hasResultType = true; break;
+ case OpSDiv: *hasResult = true; *hasResultType = true; break;
+ case OpFDiv: *hasResult = true; *hasResultType = true; break;
+ case OpUMod: *hasResult = true; *hasResultType = true; break;
+ case OpSRem: *hasResult = true; *hasResultType = true; break;
+ case OpSMod: *hasResult = true; *hasResultType = true; break;
+ case OpFRem: *hasResult = true; *hasResultType = true; break;
+ case OpFMod: *hasResult = true; *hasResultType = true; break;
+ case OpVectorTimesScalar: *hasResult = true; *hasResultType = true; break;
+ case OpMatrixTimesScalar: *hasResult = true; *hasResultType = true; break;
+ case OpVectorTimesMatrix: *hasResult = true; *hasResultType = true; break;
+ case OpMatrixTimesVector: *hasResult = true; *hasResultType = true; break;
+ case OpMatrixTimesMatrix: *hasResult = true; *hasResultType = true; break;
+ case OpOuterProduct: *hasResult = true; *hasResultType = true; break;
+ case OpDot: *hasResult = true; *hasResultType = true; break;
+ case OpIAddCarry: *hasResult = true; *hasResultType = true; break;
+ case OpISubBorrow: *hasResult = true; *hasResultType = true; break;
+ case OpUMulExtended: *hasResult = true; *hasResultType = true; break;
+ case OpSMulExtended: *hasResult = true; *hasResultType = true; break;
+ case OpAny: *hasResult = true; *hasResultType = true; break;
+ case OpAll: *hasResult = true; *hasResultType = true; break;
+ case OpIsNan: *hasResult = true; *hasResultType = true; break;
+ case OpIsInf: *hasResult = true; *hasResultType = true; break;
+ case OpIsFinite: *hasResult = true; *hasResultType = true; break;
+ case OpIsNormal: *hasResult = true; *hasResultType = true; break;
+ case OpSignBitSet: *hasResult = true; *hasResultType = true; break;
+ case OpLessOrGreater: *hasResult = true; *hasResultType = true; break;
+ case OpOrdered: *hasResult = true; *hasResultType = true; break;
+ case OpUnordered: *hasResult = true; *hasResultType = true; break;
+ case OpLogicalEqual: *hasResult = true; *hasResultType = true; break;
+ case OpLogicalNotEqual: *hasResult = true; *hasResultType = true; break;
+ case OpLogicalOr: *hasResult = true; *hasResultType = true; break;
+ case OpLogicalAnd: *hasResult = true; *hasResultType = true; break;
+ case OpLogicalNot: *hasResult = true; *hasResultType = true; break;
+ case OpSelect: *hasResult = true; *hasResultType = true; break;
+ case OpIEqual: *hasResult = true; *hasResultType = true; break;
+ case OpINotEqual: *hasResult = true; *hasResultType = true; break;
+ case OpUGreaterThan: *hasResult = true; *hasResultType = true; break;
+ case OpSGreaterThan: *hasResult = true; *hasResultType = true; break;
+ case OpUGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+ case OpSGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+ case OpULessThan: *hasResult = true; *hasResultType = true; break;
+ case OpSLessThan: *hasResult = true; *hasResultType = true; break;
+ case OpULessThanEqual: *hasResult = true; *hasResultType = true; break;
+ case OpSLessThanEqual: *hasResult = true; *hasResultType = true; break;
+ case OpFOrdEqual: *hasResult = true; *hasResultType = true; break;
+ case OpFUnordEqual: *hasResult = true; *hasResultType = true; break;
+ case OpFOrdNotEqual: *hasResult = true; *hasResultType = true; break;
+ case OpFUnordNotEqual: *hasResult = true; *hasResultType = true; break;
+ case OpFOrdLessThan: *hasResult = true; *hasResultType = true; break;
+ case OpFUnordLessThan: *hasResult = true; *hasResultType = true; break;
+ case OpFOrdGreaterThan: *hasResult = true; *hasResultType = true; break;
+ case OpFUnordGreaterThan: *hasResult = true; *hasResultType = true; break;
+ case OpFOrdLessThanEqual: *hasResult = true; *hasResultType = true; break;
+ case OpFUnordLessThanEqual: *hasResult = true; *hasResultType = true; break;
+ case OpFOrdGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+ case OpFUnordGreaterThanEqual: *hasResult = true; *hasResultType = true; break;
+ case OpShiftRightLogical: *hasResult = true; *hasResultType = true; break;
+ case OpShiftRightArithmetic: *hasResult = true; *hasResultType = true; break;
+ case OpShiftLeftLogical: *hasResult = true; *hasResultType = true; break;
+ case OpBitwiseOr: *hasResult = true; *hasResultType = true; break;
+ case OpBitwiseXor: *hasResult = true; *hasResultType = true; break;
+ case OpBitwiseAnd: *hasResult = true; *hasResultType = true; break;
+ case OpNot: *hasResult = true; *hasResultType = true; break;
+ case OpBitFieldInsert: *hasResult = true; *hasResultType = true; break;
+ case OpBitFieldSExtract: *hasResult = true; *hasResultType = true; break;
+ case OpBitFieldUExtract: *hasResult = true; *hasResultType = true; break;
+ case OpBitReverse: *hasResult = true; *hasResultType = true; break;
+ case OpBitCount: *hasResult = true; *hasResultType = true; break;
+ case OpDPdx: *hasResult = true; *hasResultType = true; break;
+ case OpDPdy: *hasResult = true; *hasResultType = true; break;
+ case OpFwidth: *hasResult = true; *hasResultType = true; break;
+ case OpDPdxFine: *hasResult = true; *hasResultType = true; break;
+ case OpDPdyFine: *hasResult = true; *hasResultType = true; break;
+ case OpFwidthFine: *hasResult = true; *hasResultType = true; break;
+ case OpDPdxCoarse: *hasResult = true; *hasResultType = true; break;
+ case OpDPdyCoarse: *hasResult = true; *hasResultType = true; break;
+ case OpFwidthCoarse: *hasResult = true; *hasResultType = true; break;
+ case OpEmitVertex: *hasResult = false; *hasResultType = false; break;
+ case OpEndPrimitive: *hasResult = false; *hasResultType = false; break;
+ case OpEmitStreamVertex: *hasResult = false; *hasResultType = false; break;
+ case OpEndStreamPrimitive: *hasResult = false; *hasResultType = false; break;
+ case OpControlBarrier: *hasResult = false; *hasResultType = false; break;
+ case OpMemoryBarrier: *hasResult = false; *hasResultType = false; break;
+ case OpAtomicLoad: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicStore: *hasResult = false; *hasResultType = false; break;
+ case OpAtomicExchange: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicCompareExchange: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicCompareExchangeWeak: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicIIncrement: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicIDecrement: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicIAdd: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicISub: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicSMin: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicUMin: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicSMax: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicUMax: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicAnd: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicOr: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicXor: *hasResult = true; *hasResultType = true; break;
+ case OpPhi: *hasResult = true; *hasResultType = true; break;
+ case OpLoopMerge: *hasResult = false; *hasResultType = false; break;
+ case OpSelectionMerge: *hasResult = false; *hasResultType = false; break;
+ case OpLabel: *hasResult = true; *hasResultType = false; break;
+ case OpBranch: *hasResult = false; *hasResultType = false; break;
+ case OpBranchConditional: *hasResult = false; *hasResultType = false; break;
+ case OpSwitch: *hasResult = false; *hasResultType = false; break;
+ case OpKill: *hasResult = false; *hasResultType = false; break;
+ case OpReturn: *hasResult = false; *hasResultType = false; break;
+ case OpReturnValue: *hasResult = false; *hasResultType = false; break;
+ case OpUnreachable: *hasResult = false; *hasResultType = false; break;
+ case OpLifetimeStart: *hasResult = false; *hasResultType = false; break;
+ case OpLifetimeStop: *hasResult = false; *hasResultType = false; break;
+ case OpGroupAsyncCopy: *hasResult = true; *hasResultType = true; break;
+ case OpGroupWaitEvents: *hasResult = false; *hasResultType = false; break;
+ case OpGroupAll: *hasResult = true; *hasResultType = true; break;
+ case OpGroupAny: *hasResult = true; *hasResultType = true; break;
+ case OpGroupBroadcast: *hasResult = true; *hasResultType = true; break;
+ case OpGroupIAdd: *hasResult = true; *hasResultType = true; break;
+ case OpGroupFAdd: *hasResult = true; *hasResultType = true; break;
+ case OpGroupFMin: *hasResult = true; *hasResultType = true; break;
+ case OpGroupUMin: *hasResult = true; *hasResultType = true; break;
+ case OpGroupSMin: *hasResult = true; *hasResultType = true; break;
+ case OpGroupFMax: *hasResult = true; *hasResultType = true; break;
+ case OpGroupUMax: *hasResult = true; *hasResultType = true; break;
+ case OpGroupSMax: *hasResult = true; *hasResultType = true; break;
+ case OpReadPipe: *hasResult = true; *hasResultType = true; break;
+ case OpWritePipe: *hasResult = true; *hasResultType = true; break;
+ case OpReservedReadPipe: *hasResult = true; *hasResultType = true; break;
+ case OpReservedWritePipe: *hasResult = true; *hasResultType = true; break;
+ case OpReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
+ case OpReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
+ case OpCommitReadPipe: *hasResult = false; *hasResultType = false; break;
+ case OpCommitWritePipe: *hasResult = false; *hasResultType = false; break;
+ case OpIsValidReserveId: *hasResult = true; *hasResultType = true; break;
+ case OpGetNumPipePackets: *hasResult = true; *hasResultType = true; break;
+ case OpGetMaxPipePackets: *hasResult = true; *hasResultType = true; break;
+ case OpGroupReserveReadPipePackets: *hasResult = true; *hasResultType = true; break;
+ case OpGroupReserveWritePipePackets: *hasResult = true; *hasResultType = true; break;
+ case OpGroupCommitReadPipe: *hasResult = false; *hasResultType = false; break;
+ case OpGroupCommitWritePipe: *hasResult = false; *hasResultType = false; break;
+ case OpEnqueueMarker: *hasResult = true; *hasResultType = true; break;
+ case OpEnqueueKernel: *hasResult = true; *hasResultType = true; break;
+ case OpGetKernelNDrangeSubGroupCount: *hasResult = true; *hasResultType = true; break;
+ case OpGetKernelNDrangeMaxSubGroupSize: *hasResult = true; *hasResultType = true; break;
+ case OpGetKernelWorkGroupSize: *hasResult = true; *hasResultType = true; break;
+ case OpGetKernelPreferredWorkGroupSizeMultiple: *hasResult = true; *hasResultType = true; break;
+ case OpRetainEvent: *hasResult = false; *hasResultType = false; break;
+ case OpReleaseEvent: *hasResult = false; *hasResultType = false; break;
+ case OpCreateUserEvent: *hasResult = true; *hasResultType = true; break;
+ case OpIsValidEvent: *hasResult = true; *hasResultType = true; break;
+ case OpSetUserEventStatus: *hasResult = false; *hasResultType = false; break;
+ case OpCaptureEventProfilingInfo: *hasResult = false; *hasResultType = false; break;
+ case OpGetDefaultQueue: *hasResult = true; *hasResultType = true; break;
+ case OpBuildNDRange: *hasResult = true; *hasResultType = true; break;
+ case OpImageSparseSampleImplicitLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageSparseSampleExplicitLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageSparseSampleDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageSparseSampleDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageSparseSampleProjImplicitLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageSparseSampleProjExplicitLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageSparseSampleProjDrefImplicitLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageSparseSampleProjDrefExplicitLod: *hasResult = true; *hasResultType = true; break;
+ case OpImageSparseFetch: *hasResult = true; *hasResultType = true; break;
+ case OpImageSparseGather: *hasResult = true; *hasResultType = true; break;
+ case OpImageSparseDrefGather: *hasResult = true; *hasResultType = true; break;
+ case OpImageSparseTexelsResident: *hasResult = true; *hasResultType = true; break;
+ case OpNoLine: *hasResult = false; *hasResultType = false; break;
+ case OpAtomicFlagTestAndSet: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicFlagClear: *hasResult = false; *hasResultType = false; break;
+ case OpImageSparseRead: *hasResult = true; *hasResultType = true; break;
+ case OpSizeOf: *hasResult = true; *hasResultType = true; break;
+ case OpTypePipeStorage: *hasResult = true; *hasResultType = false; break;
+ case OpConstantPipeStorage: *hasResult = true; *hasResultType = true; break;
+ case OpCreatePipeFromPipeStorage: *hasResult = true; *hasResultType = true; break;
+ case OpGetKernelLocalSizeForSubgroupCount: *hasResult = true; *hasResultType = true; break;
+ case OpGetKernelMaxNumSubgroups: *hasResult = true; *hasResultType = true; break;
+ case OpTypeNamedBarrier: *hasResult = true; *hasResultType = false; break;
+ case OpNamedBarrierInitialize: *hasResult = true; *hasResultType = true; break;
+ case OpMemoryNamedBarrier: *hasResult = false; *hasResultType = false; break;
+ case OpModuleProcessed: *hasResult = false; *hasResultType = false; break;
+ case OpExecutionModeId: *hasResult = false; *hasResultType = false; break;
+ case OpDecorateId: *hasResult = false; *hasResultType = false; break;
+ case OpGroupNonUniformElect: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformAll: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformAny: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformAllEqual: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformBroadcast: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformBroadcastFirst: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformBallot: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformInverseBallot: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformBallotBitExtract: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformBallotBitCount: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformBallotFindLSB: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformBallotFindMSB: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformShuffle: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformShuffleXor: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformShuffleUp: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformShuffleDown: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformIAdd: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformFAdd: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformIMul: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformFMul: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformSMin: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformUMin: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformFMin: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformSMax: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformUMax: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformFMax: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformBitwiseAnd: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformBitwiseOr: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformBitwiseXor: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformLogicalAnd: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformLogicalOr: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformLogicalXor: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformQuadBroadcast: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformQuadSwap: *hasResult = true; *hasResultType = true; break;
+ case OpCopyLogical: *hasResult = true; *hasResultType = true; break;
+ case OpPtrEqual: *hasResult = true; *hasResultType = true; break;
+ case OpPtrNotEqual: *hasResult = true; *hasResultType = true; break;
+ case OpPtrDiff: *hasResult = true; *hasResultType = true; break;
+ case OpTerminateInvocation: *hasResult = false; *hasResultType = false; break;
+ case OpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break;
+ case OpTraceRayKHR: *hasResult = false; *hasResultType = false; break;
+ case OpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break;
+ case OpConvertUToAccelerationStructureKHR: *hasResult = true; *hasResultType = true; break;
+ case OpIgnoreIntersectionKHR: *hasResult = false; *hasResultType = false; break;
+ case OpTerminateRayKHR: *hasResult = false; *hasResultType = false; break;
+ case OpSDot: *hasResult = true; *hasResultType = true; break;
+ case OpUDot: *hasResult = true; *hasResultType = true; break;
+ case OpSUDot: *hasResult = true; *hasResultType = true; break;
+ case OpSDotAccSat: *hasResult = true; *hasResultType = true; break;
+ case OpUDotAccSat: *hasResult = true; *hasResultType = true; break;
+ case OpSUDotAccSat: *hasResult = true; *hasResultType = true; break;
+ case OpTypeRayQueryKHR: *hasResult = true; *hasResultType = false; break;
+ case OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break;
+ case OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break;
+ case OpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break;
+ case OpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break;
+ case OpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break;
+ case OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+ case OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+ case OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+ case OpGroupUMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+ case OpGroupSMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+ case OpGroupFMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+ case OpGroupUMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+ case OpGroupSMaxNonUniformAMD: *hasResult = true; *hasResultType = true; break;
+ case OpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break;
+ case OpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break;
+ case OpReadClockKHR: *hasResult = true; *hasResultType = true; break;
+ case OpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break;
+ case OpEmitMeshTasksEXT: *hasResult = false; *hasResultType = false; break;
+ case OpSetMeshOutputsEXT: *hasResult = false; *hasResultType = false; break;
+ case OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break;
+ case OpReportIntersectionNV: *hasResult = true; *hasResultType = true; break;
+ case OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break;
+ case OpTerminateRayNV: *hasResult = false; *hasResultType = false; break;
+ case OpTraceNV: *hasResult = false; *hasResultType = false; break;
+ case OpTraceMotionNV: *hasResult = false; *hasResultType = false; break;
+ case OpTraceRayMotionNV: *hasResult = false; *hasResultType = false; break;
+ case OpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break;
+ case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break;
+ case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break;
+ case OpCooperativeMatrixLoadNV: *hasResult = true; *hasResultType = true; break;
+ case OpCooperativeMatrixStoreNV: *hasResult = false; *hasResultType = false; break;
+ case OpCooperativeMatrixMulAddNV: *hasResult = true; *hasResultType = true; break;
+ case OpCooperativeMatrixLengthNV: *hasResult = true; *hasResultType = true; break;
+ case OpBeginInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
+ case OpEndInvocationInterlockEXT: *hasResult = false; *hasResultType = false; break;
+ case OpDemoteToHelperInvocation: *hasResult = false; *hasResultType = false; break;
+ case OpIsHelperInvocationEXT: *hasResult = true; *hasResultType = true; break;
+ case OpConvertUToImageNV: *hasResult = true; *hasResultType = true; break;
+ case OpConvertUToSamplerNV: *hasResult = true; *hasResultType = true; break;
+ case OpConvertImageToUNV: *hasResult = true; *hasResultType = true; break;
+ case OpConvertSamplerToUNV: *hasResult = true; *hasResultType = true; break;
+ case OpConvertUToSampledImageNV: *hasResult = true; *hasResultType = true; break;
+ case OpConvertSampledImageToUNV: *hasResult = true; *hasResultType = true; break;
+ case OpSamplerImageAddressingModeNV: *hasResult = false; *hasResultType = false; break;
+ case OpSubgroupShuffleINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupShuffleDownINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupShuffleUpINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupShuffleXorINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
+ case OpSubgroupImageBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupImageBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
+ case OpSubgroupImageMediaBlockReadINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupImageMediaBlockWriteINTEL: *hasResult = false; *hasResultType = false; break;
+ case OpUCountLeadingZerosINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpUCountTrailingZerosINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpAbsISubINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpAbsUSubINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpIAddSatINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpUAddSatINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpIAverageINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpUAverageINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpIAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpUAverageRoundedINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpISubSatINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpUSubSatINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpIMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
+ case OpUMul32x16INTEL: *hasResult = true; *hasResultType = true; break;
+ case OpConstantFunctionPointerINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpFunctionPointerCallINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpAsmTargetINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpAsmINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpAsmCallINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicFMinEXT: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicFMaxEXT: *hasResult = true; *hasResultType = true; break;
+ case OpAssumeTrueKHR: *hasResult = false; *hasResultType = false; break;
+ case OpExpectKHR: *hasResult = true; *hasResultType = true; break;
+ case OpDecorateString: *hasResult = false; *hasResultType = false; break;
+ case OpMemberDecorateString: *hasResult = false; *hasResultType = false; break;
+ case OpVmeImageINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpTypeVmeImageINTEL: *hasResult = true; *hasResultType = false; break;
+ case OpTypeAvcImePayloadINTEL: *hasResult = true; *hasResultType = false; break;
+ case OpTypeAvcRefPayloadINTEL: *hasResult = true; *hasResultType = false; break;
+ case OpTypeAvcSicPayloadINTEL: *hasResult = true; *hasResultType = false; break;
+ case OpTypeAvcMcePayloadINTEL: *hasResult = true; *hasResultType = false; break;
+ case OpTypeAvcMceResultINTEL: *hasResult = true; *hasResultType = false; break;
+ case OpTypeAvcImeResultINTEL: *hasResult = true; *hasResultType = false; break;
+ case OpTypeAvcImeResultSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
+ case OpTypeAvcImeResultDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = false; break;
+ case OpTypeAvcImeSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
+ case OpTypeAvcImeDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = false; break;
+ case OpTypeAvcRefResultINTEL: *hasResult = true; *hasResultType = false; break;
+ case OpTypeAvcSicResultINTEL: *hasResult = true; *hasResultType = false; break;
+ case OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceSetInterShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceSetInterDirectionPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceSetAcOnlyHaarINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceConvertToImePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceConvertToImeResultINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceConvertToRefPayloadINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceConvertToRefResultINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceConvertToSicPayloadINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceConvertToSicResultINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetBestInterDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetInterMajorShapeINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetInterMinorShapeINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetInterDirectionsINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetInterMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetInterReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeSetSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeSetDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeRefWindowSizeINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeAdjustRefOffsetINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeSetMaxMotionVectorCountINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeSetWeightedSadINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeGetSingleReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeGetDualReferenceStreaminINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeStripDualReferenceStreamoutINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeGetBorderReachedINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcFmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcBmeInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcRefConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcRefSetBidirectionalMixDisableINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcRefSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcRefEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcRefConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicInitializeINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicConfigureSkcINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicConfigureIpeLumaINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicConfigureIpeLumaChromaINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicGetMotionVectorMaskINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicConvertToMcePayloadINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicSetBilinearFilterEnableINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicEvaluateIpeINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicEvaluateWithDualReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicConvertToMceResultINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicGetIpeLumaShapeINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicGetPackedIpeLumaModesINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicGetIpeChromaModeINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpVariableLengthArrayINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpSaveMemoryINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpRestoreMemoryINTEL: *hasResult = false; *hasResultType = false; break;
+ case OpArbitraryFloatSinCosPiINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatCastINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatCastFromIntINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatCastToIntINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatAddINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatSubINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatMulINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatDivINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatGTINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatGEINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatLTINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatLEINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatEQINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatRecipINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatRSqrtINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatCbrtINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatHypotINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatSqrtINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatLogINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatLog2INTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatLog10INTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatLog1pINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatExpINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatExp2INTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatExp10INTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatExpm1INTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatSinINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatCosINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatSinCosINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatSinPiINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatCosPiINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatASinINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatASinPiINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatACosINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatACosPiINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatATanINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatATanPiINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatATan2INTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatPowINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatPowRINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpArbitraryFloatPowNINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpLoopControlINTEL: *hasResult = false; *hasResultType = false; break;
+ case OpFixedSqrtINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpFixedRecipINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpFixedRsqrtINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpFixedSinINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpFixedCosINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpFixedSinCosINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpFixedSinPiINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpFixedCosPiINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpFixedSinCosPiINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpFixedLogINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpFixedExpINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpPtrCastToCrossWorkgroupINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpCrossWorkgroupCastToPtrINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpReadPipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpWritePipeBlockingINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpFPGARegINTEL: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break;
+ case OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break;
+ case OpAtomicFAddEXT: *hasResult = true; *hasResultType = true; break;
+ case OpTypeBufferSurfaceINTEL: *hasResult = true; *hasResultType = false; break;
+ case OpTypeStructContinuedINTEL: *hasResult = false; *hasResultType = false; break;
+ case OpConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
+ case OpSpecConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
+ }
+}
+#endif /* SPV_ENABLE_UTILITY_CODE */
+
+// Overload operator| for mask bit combining
+
+inline ImageOperandsMask operator|(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) | unsigned(b)); }
+inline FPFastMathModeMask operator|(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) | unsigned(b)); }
+inline SelectionControlMask operator|(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) | unsigned(b)); }
+inline LoopControlMask operator|(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) | unsigned(b)); }
+inline FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) | unsigned(b)); }
+inline MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); }
+inline MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); }
+inline KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); }
+inline RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) | unsigned(b)); }
+inline FragmentShadingRateMask operator|(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) | unsigned(b)); }
+
+} // end namespace spv
+
+#endif // #ifndef spirv_HPP
diff --git a/SPIRV/spvIR.h b/SPIRV/spvIR.h
index 486e80d..0969127 100644
--- a/SPIRV/spvIR.h
+++ b/SPIRV/spvIR.h
@@ -111,27 +111,23 @@
void addStringOperand(const char* str)
{
- unsigned int word;
- char* wordString = (char*)&word;
- char* wordPtr = wordString;
- int charCount = 0;
+ unsigned int word = 0;
+ unsigned int shiftAmount = 0;
char c;
+
do {
c = *(str++);
- *(wordPtr++) = c;
- ++charCount;
- if (charCount == 4) {
+ word |= ((unsigned int)c) << shiftAmount;
+ shiftAmount += 8;
+ if (shiftAmount == 32) {
addImmediateOperand(word);
- wordPtr = wordString;
- charCount = 0;
+ word = 0;
+ shiftAmount = 0;
}
} while (c != 0);
// deal with partial last word
- if (charCount > 0) {
- // pad with 0s
- for (; charCount < 4; ++charCount)
- *(wordPtr++) = 0;
+ if (shiftAmount > 0) {
addImmediateOperand(word);
}
}
@@ -353,6 +349,7 @@
const std::vector<Block*>& getBlocks() const { return blocks; }
void addLocalVariable(std::unique_ptr<Instruction> inst);
Id getReturnType() const { return functionInstruction.getTypeId(); }
+ Id getFuncId() const { return functionInstruction.getResultId(); }
void setReturnPrecision(Decoration precision)
{
if (precision == DecorationRelaxedPrecision)
@@ -361,6 +358,14 @@
Decoration getReturnPrecision() const
{ return reducedPrecisionReturn ? DecorationRelaxedPrecision : NoPrecision; }
+ void setDebugLineInfo(Id fileName, int line, int column) {
+ lineInstruction = std::unique_ptr<Instruction>{new Instruction(OpLine)};
+ lineInstruction->addIdOperand(fileName);
+ lineInstruction->addImmediateOperand(line);
+ lineInstruction->addImmediateOperand(column);
+ }
+ bool hasDebugLineInfo() const { return lineInstruction != nullptr; }
+
void setImplicitThis() { implicitThis = true; }
bool hasImplicitThis() const { return implicitThis; }
@@ -377,6 +382,11 @@
void dump(std::vector<unsigned int>& out) const
{
+ // OpLine
+ if (lineInstruction != nullptr) {
+ lineInstruction->dump(out);
+ }
+
// OpFunction
functionInstruction.dump(out);
@@ -395,6 +405,7 @@
Function& operator=(Function&);
Module& parent;
+ std::unique_ptr<Instruction> lineInstruction;
Instruction functionInstruction;
std::vector<Instruction*> parameterInstructions;
std::vector<Block*> blocks;
@@ -461,7 +472,8 @@
// - the OpFunction instruction
// - all the OpFunctionParameter instructions
__inline Function::Function(Id id, Id resultType, Id functionType, Id firstParamId, Module& parent)
- : parent(parent), functionInstruction(id, resultType, OpFunction), implicitThis(false),
+ : parent(parent), lineInstruction(nullptr),
+ functionInstruction(id, resultType, OpFunction), implicitThis(false),
reducedPrecisionReturn(false)
{
// OpFunction
diff --git a/StandAlone/CMakeLists.txt b/StandAlone/CMakeLists.txt
index 2b163e7..d54a1df 100644
--- a/StandAlone/CMakeLists.txt
+++ b/StandAlone/CMakeLists.txt
@@ -104,24 +104,48 @@
endif()
if(ENABLE_GLSLANG_INSTALL)
- install(TARGETS glslangValidator EXPORT glslangValidatorTargets
- RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
- install(EXPORT glslangValidatorTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+ install(TARGETS glslangValidator EXPORT glslang-targets)
+
+ # Backward compatibility
+ file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/glslangValidatorTargets.cmake" "
+ message(WARNING \"Using `glslangValidatorTargets.cmake` is deprecated: use `find_package(glslang)` to find glslang CMake targets.\")
+
+ if (NOT TARGET glslang::glslangValidator)
+ include(\"\${CMAKE_CURRENT_LIST_DIR}/../../${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}/glslang-targets.cmake\")
+ endif()
+
+ add_library(glslangValidator ALIAS glslang::glslangValidator)
+ ")
+ install(FILES "${CMAKE_CURRENT_BINARY_DIR}/glslangValidatorTargets.cmake" DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
if(ENABLE_SPVREMAPPER)
- install(TARGETS spirv-remap EXPORT spirv-remapTargets
- RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
- install(EXPORT spirv-remapTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+ install(TARGETS spirv-remap EXPORT glslang-targets)
+
+ # Backward compatibility
+ file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/spirv-remapTargets.cmake" "
+ message(WARNING \"Using `spirv-remapTargets.cmake` is deprecated: use `find_package(glslang)` to find glslang CMake targets.\")
+
+ if (NOT TARGET glslang::spirv-remap)
+ include(\"\${CMAKE_CURRENT_LIST_DIR}/../../${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}/glslang-targets.cmake\")
+ endif()
+
+ add_library(spirv-remap ALIAS glslang::spirv-remap)
+ ")
+ install(FILES "${CMAKE_CURRENT_BINARY_DIR}/spirv-remapTargets.cmake" DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
endif()
- if(BUILD_SHARED_LIBS)
- install(TARGETS glslang-default-resource-limits EXPORT glslang-default-resource-limitsTargets
- ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
- LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
- RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
- else()
- install(TARGETS glslang-default-resource-limits EXPORT glslang-default-resource-limitsTargets
- ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
- endif()
- install(EXPORT glslang-default-resource-limitsTargets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+ install(TARGETS glslang-default-resource-limits EXPORT glslang-targets)
+
+ # Backward compatibility
+ file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/glslang-default-resource-limitsTargets.cmake" "
+ message(WARNING \"Using `glslang-default-resource-limitsTargets.cmake` is deprecated: use `find_package(glslang)` to find glslang CMake targets.\")
+
+ if (NOT TARGET glslang::glslang-default-resource-limits)
+ include(\"\${CMAKE_CURRENT_LIST_DIR}/../../${CMAKE_INSTALL_LIBDIR}/${PROJECT_NAME}/glslang-targets.cmake\")
+ endif()
+
+ add_library(glslang-default-resource-limits ALIAS glslang::glslang-default-resource-limits)
+ ")
+ install(FILES "${CMAKE_CURRENT_BINARY_DIR}/glslang-default-resource-limitsTargets.cmake" DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
+
endif()
diff --git a/StandAlone/ResourceLimits.cpp b/StandAlone/ResourceLimits.cpp
index 7c7f4c4..1a76bf6 100644
--- a/StandAlone/ResourceLimits.cpp
+++ b/StandAlone/ResourceLimits.cpp
@@ -134,6 +134,15 @@
/* .maxTaskWorkGroupSizeY_NV = */ 1,
/* .maxTaskWorkGroupSizeZ_NV = */ 1,
/* .maxMeshViewCountNV = */ 4,
+ /* .maxMeshOutputVerticesEXT = */ 256,
+ /* .maxMeshOutputPrimitivesEXT = */ 256,
+ /* .maxMeshWorkGroupSizeX_EXT = */ 128,
+ /* .maxMeshWorkGroupSizeY_EXT = */ 128,
+ /* .maxMeshWorkGroupSizeZ_EXT = */ 128,
+ /* .maxTaskWorkGroupSizeX_EXT = */ 128,
+ /* .maxTaskWorkGroupSizeY_EXT = */ 128,
+ /* .maxTaskWorkGroupSizeZ_EXT = */ 128,
+ /* .maxMeshViewCountEXT = */ 4,
/* .maxDualSourceDrawBuffersEXT = */ 1,
/* .limits = */ {
@@ -244,6 +253,15 @@
<< "MaxTaskWorkGroupSizeY_NV " << DefaultTBuiltInResource.maxTaskWorkGroupSizeY_NV << "\n"
<< "MaxTaskWorkGroupSizeZ_NV " << DefaultTBuiltInResource.maxTaskWorkGroupSizeZ_NV << "\n"
<< "MaxMeshViewCountNV " << DefaultTBuiltInResource.maxMeshViewCountNV << "\n"
+ << "MaxMeshOutputVerticesEXT " << DefaultTBuiltInResource.maxMeshOutputVerticesEXT << "\n"
+ << "MaxMeshOutputPrimitivesEXT " << DefaultTBuiltInResource.maxMeshOutputPrimitivesEXT << "\n"
+ << "MaxMeshWorkGroupSizeX_EXT " << DefaultTBuiltInResource.maxMeshWorkGroupSizeX_EXT << "\n"
+ << "MaxMeshWorkGroupSizeY_EXT " << DefaultTBuiltInResource.maxMeshWorkGroupSizeY_EXT << "\n"
+ << "MaxMeshWorkGroupSizeZ_EXT " << DefaultTBuiltInResource.maxMeshWorkGroupSizeZ_EXT << "\n"
+ << "MaxTaskWorkGroupSizeX_EXT " << DefaultTBuiltInResource.maxTaskWorkGroupSizeX_EXT << "\n"
+ << "MaxTaskWorkGroupSizeY_EXT " << DefaultTBuiltInResource.maxTaskWorkGroupSizeY_EXT << "\n"
+ << "MaxTaskWorkGroupSizeZ_EXT " << DefaultTBuiltInResource.maxTaskWorkGroupSizeZ_EXT << "\n"
+ << "MaxMeshViewCountEXT " << DefaultTBuiltInResource.maxMeshViewCountEXT << "\n"
<< "MaxDualSourceDrawBuffersEXT " << DefaultTBuiltInResource.maxDualSourceDrawBuffersEXT << "\n"
<< "nonInductiveForLoops " << DefaultTBuiltInResource.limits.nonInductiveForLoops << "\n"
<< "whileLoops " << DefaultTBuiltInResource.limits.whileLoops << "\n"
@@ -469,6 +487,24 @@
resources->maxTaskWorkGroupSizeZ_NV = value;
else if (tokenStr == "MaxMeshViewCountNV")
resources->maxMeshViewCountNV = value;
+ else if (tokenStr == "MaxMeshOutputVerticesEXT")
+ resources->maxMeshOutputVerticesEXT = value;
+ else if (tokenStr == "MaxMeshOutputPrimitivesEXT")
+ resources->maxMeshOutputPrimitivesEXT = value;
+ else if (tokenStr == "MaxMeshWorkGroupSizeX_EXT")
+ resources->maxMeshWorkGroupSizeX_EXT = value;
+ else if (tokenStr == "MaxMeshWorkGroupSizeY_EXT")
+ resources->maxMeshWorkGroupSizeY_EXT = value;
+ else if (tokenStr == "MaxMeshWorkGroupSizeZ_EXT")
+ resources->maxMeshWorkGroupSizeZ_EXT = value;
+ else if (tokenStr == "MaxTaskWorkGroupSizeX_EXT")
+ resources->maxTaskWorkGroupSizeX_EXT = value;
+ else if (tokenStr == "MaxTaskWorkGroupSizeY_EXT")
+ resources->maxTaskWorkGroupSizeY_EXT = value;
+ else if (tokenStr == "MaxTaskWorkGroupSizeZ_EXT")
+ resources->maxTaskWorkGroupSizeZ_EXT = value;
+ else if (tokenStr == "MaxMeshViewCountEXT")
+ resources->maxMeshViewCountEXT = value;
else if (tokenStr == "nonInductiveForLoops")
resources->limits.nonInductiveForLoops = (value != 0);
else if (tokenStr == "whileLoops")
diff --git a/StandAlone/StandAlone.cpp b/StandAlone/StandAlone.cpp
index 23e510c..edde81e 100644
--- a/StandAlone/StandAlone.cpp
+++ b/StandAlone/StandAlone.cpp
@@ -113,6 +113,8 @@
bool SpvToolsValidate = false;
bool NaNClamp = false;
bool stripDebugInfo = false;
+bool emitNonSemanticShaderDebugInfo = false;
+bool emitNonSemanticShaderDebugSource = false;
bool beQuiet = false;
bool VulkanRulesRelaxed = false;
bool autoSampledTextures = false;
@@ -177,6 +179,8 @@
const char* variableName = nullptr;
bool HlslEnable16BitTypes = false;
bool HlslDX9compatible = false;
+bool HlslDxPositionW = false;
+bool EnhancedMsgs = false;
bool DumpBuiltinSymbols = false;
std::vector<std::string> IncludeDirectoryList;
@@ -190,6 +194,9 @@
glslang::EShTargetLanguage TargetLanguage = glslang::EShTargetNone;
glslang::EShTargetLanguageVersion TargetVersion; // not valid until TargetLanguage is set
+// GLSL version
+int GlslVersion = 0; // GLSL version specified on CLI, overrides #version in shader source
+
std::vector<std::string> Processes; // what should be recorded by OpModuleProcessed, or equivalent
// Per descriptor-set binding base data
@@ -288,8 +295,8 @@
case EShLangClosestHit: name = "rchit.spv"; break;
case EShLangMiss: name = "rmiss.spv"; break;
case EShLangCallable: name = "rcall.spv"; break;
- case EShLangMeshNV: name = "mesh.spv"; break;
- case EShLangTaskNV: name = "task.spv"; break;
+ case EShLangMesh : name = "mesh.spv"; break;
+ case EShLangTask : name = "task.spv"; break;
default: name = "unknown"; break;
}
} else
@@ -652,6 +659,48 @@
lowerword == "flatten-uniform-array" ||
lowerword == "fua") {
Options |= EOptionFlattenUniformArrays;
+ } else if (lowerword == "glsl-version") {
+ if (argc > 1) {
+ if (strcmp(argv[1], "100") == 0) {
+ GlslVersion = 100;
+ } else if (strcmp(argv[1], "110") == 0) {
+ GlslVersion = 110;
+ } else if (strcmp(argv[1], "120") == 0) {
+ GlslVersion = 120;
+ } else if (strcmp(argv[1], "130") == 0) {
+ GlslVersion = 130;
+ } else if (strcmp(argv[1], "140") == 0) {
+ GlslVersion = 140;
+ } else if (strcmp(argv[1], "150") == 0) {
+ GlslVersion = 150;
+ } else if (strcmp(argv[1], "300es") == 0) {
+ GlslVersion = 300;
+ } else if (strcmp(argv[1], "310es") == 0) {
+ GlslVersion = 310;
+ } else if (strcmp(argv[1], "320es") == 0) {
+ GlslVersion = 320;
+ } else if (strcmp(argv[1], "330") == 0) {
+ GlslVersion = 330;
+ } else if (strcmp(argv[1], "400") == 0) {
+ GlslVersion = 400;
+ } else if (strcmp(argv[1], "410") == 0) {
+ GlslVersion = 410;
+ } else if (strcmp(argv[1], "420") == 0) {
+ GlslVersion = 420;
+ } else if (strcmp(argv[1], "430") == 0) {
+ GlslVersion = 430;
+ } else if (strcmp(argv[1], "440") == 0) {
+ GlslVersion = 440;
+ } else if (strcmp(argv[1], "450") == 0) {
+ GlslVersion = 450;
+ } else if (strcmp(argv[1], "460") == 0) {
+ GlslVersion = 460;
+ } else
+ Error("--glsl-version expected one of: 100, 110, 120, 130, 140, 150,\n"
+ "300es, 310es, 320es, 330\n"
+ "400, 410, 420, 430, 440, 450, 460");
+ }
+ bumpArg();
} else if (lowerword == "hlsl-offsets") {
Options |= EOptionHlslOffsets;
} else if (lowerword == "hlsl-iomap" ||
@@ -662,6 +711,10 @@
HlslEnable16BitTypes = true;
} else if (lowerword == "hlsl-dx9-compatible") {
HlslDX9compatible = true;
+ } else if (lowerword == "hlsl-dx-position-w") {
+ HlslDxPositionW = true;
+ } else if (lowerword == "enhanced-msgs") {
+ EnhancedMsgs = true;
} else if (lowerword == "auto-sampled-textures") {
autoSampledTextures = true;
} else if (lowerword == "invert-y" || // synonyms
@@ -764,6 +817,9 @@
} else if (strcmp(argv[1], "vulkan1.2") == 0) {
setVulkanSpv();
ClientVersion = glslang::EShTargetVulkan_1_2;
+ } else if (strcmp(argv[1], "vulkan1.3") == 0) {
+ setVulkanSpv();
+ ClientVersion = glslang::EShTargetVulkan_1_3;
} else if (strcmp(argv[1], "opengl") == 0) {
setOpenGlSpv();
ClientVersion = glslang::EShTargetOpenGL_450;
@@ -785,9 +841,13 @@
} else if (strcmp(argv[1], "spirv1.5") == 0) {
TargetLanguage = glslang::EShTargetSpv;
TargetVersion = glslang::EShTargetSpv_1_5;
+ } else if (strcmp(argv[1], "spirv1.6") == 0) {
+ TargetLanguage = glslang::EShTargetSpv;
+ TargetVersion = glslang::EShTargetSpv_1_6;
} else
- Error("--target-env expected one of: vulkan1.0, vulkan1.1, vulkan1.2, opengl,\n"
- "spirv1.0, spirv1.1, spirv1.2, spirv1.3, spirv1.4, or spirv1.5");
+ Error("--target-env expected one of: vulkan1.0, vulkan1.1, vulkan1.2,\n"
+ "vulkan1.3, opengl, spirv1.0, spirv1.1, spirv1.2, spirv1.3,\n"
+ "spirv1.4, spirv1.5 or spirv1.6");
}
bumpArg();
} else if (lowerword == "undef-macro" ||
@@ -911,11 +971,21 @@
case 'g':
// Override previous -g or -g0 argument
stripDebugInfo = false;
+ emitNonSemanticShaderDebugInfo = false;
Options &= ~EOptionDebug;
if (argv[0][2] == '0')
stripDebugInfo = true;
- else
+ else {
Options |= EOptionDebug;
+ if (argv[0][2] == 'V') {
+ emitNonSemanticShaderDebugInfo = true;
+ if (argv[0][3] == 'S') {
+ emitNonSemanticShaderDebugSource = true;
+ } else {
+ emitNonSemanticShaderDebugSource = false;
+ }
+ }
+ }
break;
case 'h':
usage();
@@ -1012,6 +1082,10 @@
TargetLanguage = glslang::EShTargetSpv;
TargetVersion = glslang::EShTargetSpv_1_5;
break;
+ case glslang::EShTargetVulkan_1_3:
+ TargetLanguage = glslang::EShTargetSpv;
+ TargetVersion = glslang::EShTargetSpv_1_6;
+ break;
case glslang::EShTargetOpenGL_450:
TargetLanguage = glslang::EShTargetSpv;
TargetVersion = glslang::EShTargetSpv_1_0;
@@ -1059,6 +1133,8 @@
messages = (EShMessages)(messages | EShMsgHlslDX9Compatible);
if (DumpBuiltinSymbols)
messages = (EShMessages)(messages | EShMsgBuiltinSymbolTable);
+ if (EnhancedMsgs)
+ messages = (EShMessages)(messages | EShMsgEnhanced);
}
//
@@ -1149,6 +1225,27 @@
}
};
+// Writes a string into a depfile, escaping some special characters following the Makefile rules.
+static void writeEscapedDepString(std::ofstream& file, const std::string& str)
+{
+ for (char c : str) {
+ switch (c) {
+ case ' ':
+ case ':':
+ case '#':
+ case '[':
+ case ']':
+ case '\\':
+ file << '\\';
+ break;
+ case '$':
+ file << '$';
+ break;
+ }
+ file << c;
+ }
+}
+
// Writes a depfile similar to gcc -MMD foo.c
bool writeDepFile(std::string depfile, std::vector<std::string>& binaryFiles, const std::vector<std::string>& sources)
{
@@ -1156,10 +1253,12 @@
if (file.fail())
return false;
- for (auto it = binaryFiles.begin(); it != binaryFiles.end(); it++) {
- file << *it << ":";
- for (auto it = sources.begin(); it != sources.end(); it++) {
- file << " " << *it;
+ for (auto binaryFile = binaryFiles.begin(); binaryFile != binaryFiles.end(); binaryFile++) {
+ writeEscapedDepString(file, *binaryFile);
+ file << ":";
+ for (auto sourceFile = sources.begin(); sourceFile != sources.end(); sourceFile++) {
+ file << " ";
+ writeEscapedDepString(file, *sourceFile);
}
file << std::endl;
}
@@ -1209,6 +1308,8 @@
shader->setSourceEntryPoint(sourceEntryPointName);
}
+ shader->setOverrideVersion(GlslVersion);
+
std::string intrinsicString = getIntrinsic(compUnit.text, compUnit.count);
PreambleString = "";
@@ -1284,6 +1385,15 @@
if (Options & EOptionInvertY)
shader->setInvertY(true);
+ if (HlslDxPositionW)
+ shader->setDxPositionW(true);
+
+ if (EnhancedMsgs)
+ shader->setEnhancedMsgs();
+
+ if (emitNonSemanticShaderDebugInfo)
+ shader->setDebugInfo(true);
+
// Set up the environment, some subsettings take precedence over earlier
// ways of setting things.
if (Options & EOptionSpv) {
@@ -1375,9 +1485,15 @@
std::vector<unsigned int> spirv;
spv::SpvBuildLogger logger;
glslang::SpvOptions spvOptions;
- if (Options & EOptionDebug)
+ if (Options & EOptionDebug) {
spvOptions.generateDebugInfo = true;
- else if (stripDebugInfo)
+ if (emitNonSemanticShaderDebugInfo) {
+ spvOptions.emitNonSemanticShaderDebugInfo = true;
+ if (emitNonSemanticShaderDebugSource) {
+ spvOptions.emitNonSemanticShaderDebugSource = true;
+ }
+ }
+ } else if (stripDebugInfo)
spvOptions.stripDebugInfo = true;
spvOptions.disableOptimizer = (Options & EOptionOptimizeDisable) != 0;
spvOptions.optimizeSize = (Options & EOptionOptimizeSize) != 0;
@@ -1685,9 +1801,9 @@
else if (stageName == "rcall")
return EShLangCallable;
else if (stageName == "mesh")
- return EShLangMeshNV;
+ return EShLangMesh;
else if (stageName == "task")
- return EShLangTaskNV;
+ return EShLangTask;
usage();
return EShLangVertex;
@@ -1811,6 +1927,8 @@
" SPV_GOOGLE_hlsl_functionality1 extension\n"
" -g generate debug information\n"
" -g0 strip debug information\n"
+ " -gV generate nonsemantic shader debug information\n"
+ " -gVS generate nonsemantic shader debug information with source\n"
" -h print this usage message\n"
" -i intermediate tree (glslang AST) is printed out\n"
" -l link all input files together to form a single module\n"
@@ -1840,6 +1958,11 @@
" -dumpfullversion | -dumpversion print bare major.minor.patchlevel\n"
" --flatten-uniform-arrays | --fua flatten uniform texture/sampler arrays to\n"
" scalars\n"
+ " --glsl-version {100 | 110 | 120 | 130 | 140 | 150 |\n"
+ " 300es | 310es | 320es | 330\n"
+ " 400 | 410 | 420 | 430 | 440 | 450 | 460}\n"
+ " set GLSL version, overrides #version\n"
+ " in shader sourcen\n"
" --hlsl-offsets allow block offsets to follow HLSL rules\n"
" works independently of source language\n"
" --hlsl-iomap perform IO mapping in HLSL register space\n"
@@ -1847,7 +1970,10 @@
" --hlsl-dx9-compatible interprets sampler declarations as a\n"
" texture/sampler combo like DirectX9 would,\n"
" and recognizes DirectX9-specific semantics\n"
+ " --hlsl-dx-position-w W component of SV_Position in HLSL fragment\n"
+ " shaders compatible with DirectX\n"
" --invert-y | --iy invert position.Y output in vertex shader\n"
+ " --enhanced-msgs print more readable error messages (GLSL only)\n"
" --keep-uncalled | --ku don't eliminate uncalled functions\n"
" --nan-clamp favor non-NaN operand in min, max, and clamp\n"
" --no-storage-format | --nsf use Unknown image format\n"
@@ -1922,8 +2048,9 @@
" --sep synonym for --source-entrypoint\n"
" --stdin read from stdin instead of from a file;\n"
" requires providing the shader stage using -S\n"
- " --target-env {vulkan1.0 | vulkan1.1 | vulkan1.2 | opengl | \n"
- " spirv1.0 | spirv1.1 | spirv1.2 | spirv1.3 | spirv1.4 | spirv1.5}\n"
+ " --target-env {vulkan1.0 | vulkan1.1 | vulkan1.2 | vulkan1.3 | opengl |\n"
+ " spirv1.0 | spirv1.1 | spirv1.2 | spirv1.3 | spirv1.4 |\n"
+ " spirv1.5 | spirv1.6}\n"
" Set the execution environment that the\n"
" generated code will be executed in.\n"
" Defaults to:\n"
@@ -1932,6 +2059,7 @@
" * spirv1.0 under --target-env vulkan1.0\n"
" * spirv1.3 under --target-env vulkan1.1\n"
" * spirv1.5 under --target-env vulkan1.2\n"
+ " * spirv1.6 under --target-env vulkan1.3\n"
" Multiple --target-env can be specified.\n"
" --variable-name <name>\n"
" --vn <name> creates a C header file that contains a\n"
diff --git a/StandAlone/spirv-remap.cpp b/StandAlone/spirv-remap.cpp
index 48878c3..15c3ac5 100644
--- a/StandAlone/spirv-remap.cpp
+++ b/StandAlone/spirv-remap.cpp
@@ -105,6 +105,32 @@
}
}
+ // Read strings from a file
+ void read(std::vector<std::string>& strings, const std::string& inFilename, int verbosity)
+ {
+ std::ifstream fp;
+
+ if (verbosity > 0)
+ logHandler(std::string(" reading: ") + inFilename);
+
+ strings.clear();
+ fp.open(inFilename, std::fstream::in);
+
+ if (fp.fail())
+ errHandler("error opening file for read: ");
+
+ std::string line;
+ while (std::getline(fp, line))
+ {
+ // Ignore empty lines and lines starting with the comment marker '#'.
+ if (line.length() == 0 || line[0] == '#') {
+ continue;
+ }
+
+ strings.push_back(line);
+ }
+ }
+
void write(std::vector<SpvWord>& spv, const std::string& outFile, int verbosity)
{
if (outFile.empty())
@@ -144,6 +170,7 @@
<< " [--dce (all|types|funcs)]"
<< " [--opt (all|loadstore)]"
<< " [--strip-all | --strip all | -s]"
+ << " [--strip-white-list]"
<< " [--do-everything]"
<< " --input | -i file1 [file2...] --output|-o DESTDIR"
<< std::endl;
@@ -156,16 +183,18 @@
// grind through each SPIR in turn
void execute(const std::vector<std::string>& inputFile, const std::string& outputDir,
- int opts, int verbosity)
+ const std::string& whiteListFile, int opts, int verbosity)
{
+ std::vector<std::string> whiteListStrings;
+ if(!whiteListFile.empty())
+ read(whiteListStrings, whiteListFile, verbosity);
+
for (auto it = inputFile.cbegin(); it != inputFile.cend(); ++it) {
const std::string &filename = *it;
std::vector<SpvWord> spv;
read(spv, filename, verbosity);
- spv::spirvbin_t(verbosity).remap(spv, opts);
-
+ spv::spirvbin_t(verbosity).remap(spv, whiteListStrings, opts);
const std::string outfile = outputDir + path_sep_char() + basename(filename);
-
write(spv, outfile, verbosity);
}
@@ -176,6 +205,7 @@
// Parse command line options
void parseCmdLine(int argc, char** argv, std::vector<std::string>& inputFile,
std::string& outputDir,
+ std::string& stripWhiteListFile,
int& options,
int& verbosity)
{
@@ -245,6 +275,9 @@
options = options | spv::spirvbin_t::STRIP;
++a;
}
+ } else if (arg == "--strip-white-list") {
+ ++a;
+ stripWhiteListFile = argv[a++];
} else if (arg == "--dce") {
// Parse comma (or colon, etc) separated list of things to dce
++a;
@@ -315,6 +348,7 @@
{
std::vector<std::string> inputFile;
std::string outputDir;
+ std::string whiteListFile;
int opts;
int verbosity;
@@ -329,13 +363,13 @@
if (argc < 2)
usage(argv[0]);
- parseCmdLine(argc, argv, inputFile, outputDir, opts, verbosity);
+ parseCmdLine(argc, argv, inputFile, outputDir, whiteListFile, opts, verbosity);
if (outputDir.empty())
usage(argv[0], "Output directory required");
// Main operations: read, remap, and write.
- execute(inputFile, outputDir, opts, verbosity);
+ execute(inputFile, outputDir, whiteListFile, opts, verbosity);
// If we get here, everything went OK! Nothing more to be done.
}
diff --git a/Test/150.frag b/Test/150.frag
index 228e4f0..90b1e27 100644
--- a/Test/150.frag
+++ b/Test/150.frag
@@ -111,8 +111,8 @@
vec2 pf2;
vec3 pf3;
- lod = textureQueryLod(samp1D, pf); // ERROR, extension GL_ARB_texture_query_lod needed
- lod = textureQueryLod(samp2Ds, pf2); // ERROR, extension GL_ARB_texture_query_lod needed
+ lod = textureQueryLOD(samp1D, pf); // ERROR, extension GL_ARB_texture_query_lod needed
+ lod = textureQueryLOD(samp2Ds, pf2); // ERROR, extension GL_ARB_texture_query_lod needed
}
#extension GL_ARB_texture_query_lod : enable
@@ -138,21 +138,21 @@
vec2 pf2;
vec3 pf3;
- lod = textureQueryLod(samp1D, pf);
- lod = textureQueryLod(isamp2D, pf2);
- lod = textureQueryLod(usamp3D, pf3);
- lod = textureQueryLod(sampCube, pf3);
- lod = textureQueryLod(isamp1DA, pf);
- lod = textureQueryLod(usamp2DA, pf2);
+ lod = textureQueryLOD(samp1D, pf);
+ lod = textureQueryLOD(isamp2D, pf2);
+ lod = textureQueryLOD(usamp3D, pf3);
+ lod = textureQueryLOD(sampCube, pf3);
+ lod = textureQueryLOD(isamp1DA, pf);
+ lod = textureQueryLOD(usamp2DA, pf2);
- lod = textureQueryLod(samp1Ds, pf);
- lod = textureQueryLod(samp2Ds, pf2);
- lod = textureQueryLod(sampCubes, pf3);
- lod = textureQueryLod(samp1DAs, pf);
- lod = textureQueryLod(samp2DAs, pf2);
+ lod = textureQueryLOD(samp1Ds, pf);
+ lod = textureQueryLOD(samp2Ds, pf2);
+ lod = textureQueryLOD(sampCubes, pf3);
+ lod = textureQueryLOD(samp1DAs, pf);
+ lod = textureQueryLOD(samp2DAs, pf2);
- lod = textureQueryLod(sampBuf, pf); // ERROR
- lod = textureQueryLod(sampRect, pf2); // ERROR
+ lod = textureQueryLOD(sampBuf, pf); // ERROR
+ lod = textureQueryLOD(sampRect, pf2); // ERROR
}
// Test extension GL_EXT_shader_integer_mix
diff --git a/Test/BestMatchFunction.vert b/Test/BestMatchFunction.vert
new file mode 100644
index 0000000..eb09233
--- /dev/null
+++ b/Test/BestMatchFunction.vert
@@ -0,0 +1,20 @@
+#version 150
+#extension GL_ARB_gpu_shader5 : require
+
+uniform ivec4 u1;
+uniform uvec4 u2;
+out vec4 result;
+vec4 f(in vec4 a, in vec4 b){ return a * b;} // choice 1
+vec4 f(in uvec4 a, in uvec4 b){ return vec4(a - b);} // choice 2
+
+void main()
+{
+ result = f(u1, u2); // should match choice 2. which have less implicit conversion.
+ switch (gl_VertexID)
+ {
+ case 0: gl_Position = vec4(-1.0, 1.0, 0.0, 1.0); break;
+ case 1: gl_Position = vec4( 1.0, 1.0, 0.0, 1.0); break;
+ case 2: gl_Position = vec4(-1.0,-1.0, 0.0, 1.0); break;
+ case 3: gl_Position = vec4( 1.0,-1.0, 0.0, 1.0); break;
+ }
+}
diff --git a/Test/EndStreamPrimitive.geom b/Test/EndStreamPrimitive.geom
new file mode 100644
index 0000000..a654ebc
--- /dev/null
+++ b/Test/EndStreamPrimitive.geom
@@ -0,0 +1,20 @@
+#version 150 core
+#extension GL_ARB_gpu_shader5 : require
+layout(points) in;
+layout(points, max_vertices = 1) out;
+layout(stream=0) out float output1;
+layout(stream=0) out float output2;
+layout(stream=1) out float output3;
+layout(stream=1) out float output4;
+uniform uint stream;
+void main() {
+
+ output1 = 1.0;
+ output2 = 2.0;
+ EmitStreamVertex(0);
+ EndStreamPrimitive(0);
+ output3 = 3.0;
+ output4 = 4.0;
+ EmitStreamVertex(1);
+ EndStreamPrimitive(1);
+}
\ No newline at end of file
diff --git a/Test/GL_ARB_fragment_coord_conventions.vert b/Test/GL_ARB_fragment_coord_conventions.vert
new file mode 100644
index 0000000..962734f
--- /dev/null
+++ b/Test/GL_ARB_fragment_coord_conventions.vert
@@ -0,0 +1,27 @@
+#version 140
+
+#extension GL_ARB_fragment_coord_conventions: require
+#extension GL_ARB_explicit_attrib_location : enable
+
+
+#if !defined GL_ARB_fragment_coord_conventions
+# error GL_ARB_fragment_coord_conventions is not defined
+#elif GL_ARB_fragment_coord_conventions != 1
+# error GL_ARB_fragment_coord_conventions is not equal to 1
+#endif
+
+
+layout (location = 0) in vec4 pos;
+out vec4 i;
+
+uniform float gtf_windowWidth;
+uniform float gtf_windowHeight;
+uniform float n;
+uniform float f;
+
+void main()
+{
+ gl_Position = pos;
+ i = vec4((pos.x+1.0)*0.5*gtf_windowWidth, (pos.y+1.0)*0.5*gtf_windowHeight, (f-n)*0.5*pos.z + (f+n)*0.5, pos.w);
+}
+
diff --git a/Test/baseLegalResults/hlsl.aliasOpaque.frag.out b/Test/baseLegalResults/hlsl.aliasOpaque.frag.out
index 2afdb10..100f6d7 100644
--- a/Test/baseLegalResults/hlsl.aliasOpaque.frag.out
+++ b/Test/baseLegalResults/hlsl.aliasOpaque.frag.out
@@ -1,6 +1,6 @@
hlsl.aliasOpaque.frag
// Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
// Id's are bound by 89
Capability Shader
diff --git a/Test/baseLegalResults/hlsl.flattenOpaque.frag.out b/Test/baseLegalResults/hlsl.flattenOpaque.frag.out
index 7bb33e6..be1637f 100644
--- a/Test/baseLegalResults/hlsl.flattenOpaque.frag.out
+++ b/Test/baseLegalResults/hlsl.flattenOpaque.frag.out
@@ -1,6 +1,6 @@
hlsl.flattenOpaque.frag
// Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
// Id's are bound by 190
Capability Shader
diff --git a/Test/baseLegalResults/hlsl.flattenOpaqueInit.vert.out b/Test/baseLegalResults/hlsl.flattenOpaqueInit.vert.out
index 0e8583f..18d7694 100644
--- a/Test/baseLegalResults/hlsl.flattenOpaqueInit.vert.out
+++ b/Test/baseLegalResults/hlsl.flattenOpaqueInit.vert.out
@@ -1,6 +1,6 @@
hlsl.flattenOpaqueInit.vert
// Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
// Id's are bound by 139
Capability Shader
diff --git a/Test/baseLegalResults/hlsl.flattenOpaqueInitMix.vert.out b/Test/baseLegalResults/hlsl.flattenOpaqueInitMix.vert.out
index fe858ef..914d9b5 100644
--- a/Test/baseLegalResults/hlsl.flattenOpaqueInitMix.vert.out
+++ b/Test/baseLegalResults/hlsl.flattenOpaqueInitMix.vert.out
@@ -1,6 +1,6 @@
hlsl.flattenOpaqueInitMix.vert
// Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
// Id's are bound by 99
Capability Shader
diff --git a/Test/baseLegalResults/hlsl.flattenSubset.frag.out b/Test/baseLegalResults/hlsl.flattenSubset.frag.out
index 0edf712..2be41f0 100644
--- a/Test/baseLegalResults/hlsl.flattenSubset.frag.out
+++ b/Test/baseLegalResults/hlsl.flattenSubset.frag.out
@@ -1,24 +1,22 @@
hlsl.flattenSubset.frag
// Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
// Id's are bound by 67
Capability Shader
1: ExtInstImport "GLSL.std.450"
MemoryModel Logical GLSL450
- EntryPoint Fragment 4 "main" 47 50
+ EntryPoint Fragment 4 "main" 50
ExecutionMode 4 OriginUpperLeft
Source HLSL 500
Name 4 "main"
Name 21 "samp"
Name 33 "tex"
- Name 47 "vpos"
Name 50 "@entryPointOutput"
Decorate 21(samp) DescriptorSet 0
Decorate 21(samp) Binding 0
Decorate 33(tex) DescriptorSet 0
Decorate 33(tex) Binding 1
- Decorate 47(vpos) Location 0
Decorate 50(@entryPointOutput) Location 0
2: TypeVoid
3: TypeFunction 2
@@ -34,8 +32,6 @@
39: TypeVector 6(float) 2
40: 6(float) Constant 1056964608
41: 39(fvec2) ConstantComposite 40 40
- 46: TypePointer Input 7(fvec4)
- 47(vpos): 46(ptr) Variable Input
49: TypePointer Output 7(fvec4)
50(@entryPointOutput): 49(ptr) Variable Output
4(main): 2 Function None 3
diff --git a/Test/baseLegalResults/hlsl.flattenSubset2.frag.out b/Test/baseLegalResults/hlsl.flattenSubset2.frag.out
index 00bd55b..656ff73 100644
--- a/Test/baseLegalResults/hlsl.flattenSubset2.frag.out
+++ b/Test/baseLegalResults/hlsl.flattenSubset2.frag.out
@@ -1,18 +1,16 @@
hlsl.flattenSubset2.frag
// Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
// Id's are bound by 53
Capability Shader
1: ExtInstImport "GLSL.std.450"
MemoryModel Logical GLSL450
- EntryPoint Fragment 4 "main" 49 52
+ EntryPoint Fragment 4 "main" 52
ExecutionMode 4 OriginUpperLeft
Source HLSL 500
Name 4 "main"
- Name 49 "vpos"
Name 52 "@entryPointOutput"
- Decorate 49(vpos) Location 0
Decorate 52(@entryPointOutput) Location 0
2: TypeVoid
3: TypeFunction 2
@@ -20,8 +18,6 @@
7: TypeVector 6(float) 4
43: 6(float) Constant 0
44: 7(fvec4) ConstantComposite 43 43 43 43
- 48: TypePointer Input 7(fvec4)
- 49(vpos): 48(ptr) Variable Input
51: TypePointer Output 7(fvec4)
52(@entryPointOutput): 51(ptr) Variable Output
4(main): 2 Function None 3
diff --git a/Test/baseLegalResults/hlsl.intrinsics.evalfns.frag.out b/Test/baseLegalResults/hlsl.intrinsics.evalfns.frag.out
index 564f0f4..936df71 100644
--- a/Test/baseLegalResults/hlsl.intrinsics.evalfns.frag.out
+++ b/Test/baseLegalResults/hlsl.intrinsics.evalfns.frag.out
@@ -1,6 +1,6 @@
hlsl.intrinsics.evalfns.frag
// Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
// Id's are bound by 274
Capability Shader
diff --git a/Test/baseLegalResults/hlsl.partialFlattenLocal.vert.out b/Test/baseLegalResults/hlsl.partialFlattenLocal.vert.out
index f45a768..b664098 100644
--- a/Test/baseLegalResults/hlsl.partialFlattenLocal.vert.out
+++ b/Test/baseLegalResults/hlsl.partialFlattenLocal.vert.out
@@ -1,6 +1,6 @@
hlsl.partialFlattenLocal.vert
// Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
// Id's are bound by 164
Capability Shader
diff --git a/Test/baseLegalResults/hlsl.partialFlattenMixed.vert.out b/Test/baseLegalResults/hlsl.partialFlattenMixed.vert.out
index 8975ed2..8f3ac26 100644
--- a/Test/baseLegalResults/hlsl.partialFlattenMixed.vert.out
+++ b/Test/baseLegalResults/hlsl.partialFlattenMixed.vert.out
@@ -1,6 +1,6 @@
hlsl.partialFlattenMixed.vert
// Module Version 10000
-// Generated by (magic number): 8000a
+// Generated by (magic number): 8000b
// Id's are bound by 36
Capability Shader
diff --git a/Test/baseResults/150.frag.out b/Test/baseResults/150.frag.out
index 2192e14..ba15b5c 100644
--- a/Test/baseResults/150.frag.out
+++ b/Test/baseResults/150.frag.out
@@ -2,22 +2,23 @@
ERROR: 0:4: 'redeclaration' : cannot redeclare with different qualification: gl_FragCoord
ERROR: 0:5: 'redeclaration' : cannot redeclare with different qualification: gl_FragCoord
ERROR: 0:6: 'layout qualifier' : can only apply origin_upper_left and pixel_center_origin to gl_FragCoord
-ERROR: 0:14: 'gl_FragCoord' : cannot redeclare after use
ERROR: 0:50: 'gl_PerFragment' : undeclared identifier
ERROR: 0:53: 'double' : Reserved word.
ERROR: 0:53: 'double' : not supported for this version or the enabled extensions
ERROR: 0:53: 'double' : must be qualified as flat in
ERROR: 0:57: '=' : cannot convert from ' global double' to ' global int'
-ERROR: 0:80: 'floatBitsToInt' : required extension not requested: GL_ARB_shader_bit_encoding
+ERROR: 0:80: 'floatBitsToInt' : required extension not requested: Possible extensions include:
+GL_ARB_shader_bit_encoding
+GL_ARB_gpu_shader5
ERROR: 0:100: 'packSnorm2x16' : required extension not requested: GL_ARB_shading_language_packing
-ERROR: 0:114: 'textureQueryLod' : required extension not requested: GL_ARB_texture_query_lod
-ERROR: 0:115: 'textureQueryLod' : required extension not requested: GL_ARB_texture_query_lod
-ERROR: 0:154: 'textureQueryLod' : no matching overloaded function found
+ERROR: 0:114: 'textureQueryLOD' : required extension not requested: GL_ARB_texture_query_lod
+ERROR: 0:115: 'textureQueryLOD' : required extension not requested: GL_ARB_texture_query_lod
+ERROR: 0:154: 'textureQueryLOD' : no matching overloaded function found
ERROR: 0:154: 'assign' : cannot convert from ' const float' to ' temp 2-component vector of float'
-ERROR: 0:155: 'textureQueryLod' : no matching overloaded function found
+ERROR: 0:155: 'textureQueryLOD' : no matching overloaded function found
ERROR: 0:155: 'assign' : cannot convert from ' const float' to ' temp 2-component vector of float'
ERROR: 0:183: 'mix' : required extension not requested: GL_EXT_shader_integer_mix
-ERROR: 18 compilation errors. No code generated.
+ERROR: 17 compilation errors. No code generated.
Shader version: 150
diff --git a/Test/baseResults/150.geom.out b/Test/baseResults/150.geom.out
index 92b8e1a..c5a31f5 100644
--- a/Test/baseResults/150.geom.out
+++ b/Test/baseResults/150.geom.out
@@ -2,8 +2,8 @@
ERROR: 0:15: 'fromVertex' : block instance name redefinition
ERROR: 0:19: 'fromVertex' : redefinition
ERROR: 0:21: 'fooC' : block instance name redefinition
-ERROR: 0:29: 'EmitStreamVertex' : no matching overloaded function found
-ERROR: 0:30: 'EndStreamPrimitive' : no matching overloaded function found
+ERROR: 0:29: 'if the verison is 150 , the EmitStreamVertex and EndStreamPrimitive only support at extension GL_ARB_gpu_shader5' : required extension not requested: GL_ARB_gpu_shader5
+ERROR: 0:30: 'if the verison is 150 , the EmitStreamVertex and EndStreamPrimitive only support at extension GL_ARB_gpu_shader5' : required extension not requested: GL_ARB_gpu_shader5
ERROR: 0:44: 'stream' : can only be used on an output
ERROR: 0:45: 'stream' : can only be used on an output
ERROR: 0:46: 'stream' : can only be used on an output
@@ -49,10 +49,12 @@
0:27 Sequence
0:27 EmitVertex ( global void)
0:28 EndPrimitive ( global void)
-0:29 Constant:
-0:29 0.000000
-0:30 Constant:
-0:30 0.000000
+0:29 EmitStreamVertex ( global void)
+0:29 Constant:
+0:29 1 (const int)
+0:30 EndStreamPrimitive ( global void)
+0:30 Constant:
+0:30 0 (const int)
0:32 move second child to first child ( temp 3-component vector of float)
0:32 color: direct index for structure (layout( stream=0) out 3-component vector of float)
0:32 'anon@0' (layout( stream=0) out block{layout( stream=0) out 3-component vector of float color})
@@ -190,10 +192,12 @@
0:27 Sequence
0:27 EmitVertex ( global void)
0:28 EndPrimitive ( global void)
-0:29 Constant:
-0:29 0.000000
-0:30 Constant:
-0:30 0.000000
+0:29 EmitStreamVertex ( global void)
+0:29 Constant:
+0:29 1 (const int)
+0:30 EndStreamPrimitive ( global void)
+0:30 Constant:
+0:30 0 (const int)
0:32 move second child to first child ( temp 3-component vector of float)
0:32 color: direct index for structure (layout( stream=0) out 3-component vector of float)
0:32 'anon@0' (layout( stream=0) out block{layout( stream=0) out 3-component vector of float color})
diff --git a/Test/baseResults/150.tesc.out b/Test/baseResults/150.tesc.out
index 535a8a6..78b32da 100644
--- a/Test/baseResults/150.tesc.out
+++ b/Test/baseResults/150.tesc.out
@@ -627,7 +627,7 @@
ERROR: 0:7: 'vertices' : inconsistent output number of vertices for array size of gl_out
ERROR: 0:11: 'vertices' : inconsistent output number of vertices for array size of a
ERROR: 0:12: 'vertices' : inconsistent output number of vertices for array size of outb
-ERROR: 0:26: 'gl_PointSize' : no such field in structure
+ERROR: 0:26: 'gl_PointSize' : no such field in structure 'gl_out'
ERROR: 0:26: 'assign' : cannot convert from ' temp float' to ' temp block{ out 4-component vector of float Position gl_Position}'
ERROR: 0:29: 'out' : type must be an array: outf
ERROR: 0:43: 'vertices' : must be greater than 0
@@ -940,8 +940,9 @@
main(
ERROR: Linking tessellation control stage: Multiple function bodies in multiple compilation units for the same signature in the same stage:
main(
-ERROR: Linking tessellation control stage: Types must match:
- outa: " global 4-element array of int" versus " global 1-element array of int"
+ERROR: Linking tessellation control and tessellation control stages: Array sizes must be compatible:
+ tessellation control stage: " int outa[4]"
+ tessellation control stage: " int outa[1]"
ERROR: Linking tessellation control stage: can't handle multiple entry points per stage
ERROR: Linking tessellation control stage: Multiple function bodies in multiple compilation units for the same signature in the same stage:
main(
@@ -951,8 +952,9 @@
foo(
ERROR: Linking tessellation control stage: Multiple function bodies in multiple compilation units for the same signature in the same stage:
main(
-ERROR: Linking tessellation control stage: Types must match:
- gl_out: " out 4-element array of block{ out 4-component vector of float Position gl_Position, out float PointSize gl_PointSize, out unsized 2-element array of float ClipDistance gl_ClipDistance}" versus " out 3-element array of block{ out 4-component vector of float Position gl_Position}"
+ERROR: Linking tessellation control and tessellation control stages: tessellation control block member has no corresponding member in tessellation control block:
+ tessellation control stage: Block: gl_PerVertex, Member: gl_PointSize
+ tessellation control stage: Block: gl_PerVertex, Member: n/a
Linked tessellation evaluation stage:
diff --git a/Test/baseResults/310.geom.out b/Test/baseResults/310.geom.out
index b0dabc3..2fa5d11 100644
--- a/Test/baseResults/310.geom.out
+++ b/Test/baseResults/310.geom.out
@@ -6,7 +6,7 @@
ERROR: 0:44: 'EndStreamPrimitive' : no matching overloaded function found
ERROR: 0:47: 'gl_ClipDistance' : undeclared identifier
ERROR: 0:47: 'gl_ClipDistance' : left of '[' is not of type array, matrix, or vector
-ERROR: 0:48: 'gl_ClipDistance' : no such field in structure
+ERROR: 0:48: 'gl_ClipDistance' : no such field in structure 'gl_in'
ERROR: 0:48: 'expression' : left of '[' is not of type array, matrix, or vector
ERROR: 0:47: 'assign' : l-value required (can't modify a const)
ERROR: 0:55: 'selecting output stream' : not supported with this profile: es
diff --git a/Test/baseResults/310.tesc.out b/Test/baseResults/310.tesc.out
index 25ce6ee..bd4c1bd 100644
--- a/Test/baseResults/310.tesc.out
+++ b/Test/baseResults/310.tesc.out
@@ -6,12 +6,12 @@
ERROR: 0:26: 'gl_PointSize' : required extension not requested: Possible extensions include:
GL_EXT_tessellation_point_size
GL_OES_tessellation_point_size
-ERROR: 0:27: 'gl_ClipDistance' : no such field in structure
+ERROR: 0:27: 'gl_ClipDistance' : no such field in structure 'gl_in'
ERROR: 0:27: 'expression' : left of '[' is not of type array, matrix, or vector
ERROR: 0:34: 'gl_PointSize' : required extension not requested: Possible extensions include:
GL_EXT_tessellation_point_size
GL_OES_tessellation_point_size
-ERROR: 0:35: 'gl_ClipDistance' : no such field in structure
+ERROR: 0:35: 'gl_ClipDistance' : no such field in structure 'gl_out'
ERROR: 0:35: 'expression' : left of '[' is not of type array, matrix, or vector
ERROR: 0:35: 'assign' : l-value required (can't modify a const)
ERROR: 0:41: '' : tessellation control barrier() cannot be placed within flow control
diff --git a/Test/baseResults/310.tese.out b/Test/baseResults/310.tese.out
index 2f23d9b..5eecaff 100644
--- a/Test/baseResults/310.tese.out
+++ b/Test/baseResults/310.tese.out
@@ -10,7 +10,7 @@
ERROR: 0:37: 'gl_PointSize' : required extension not requested: Possible extensions include:
GL_EXT_tessellation_point_size
GL_OES_tessellation_point_size
-ERROR: 0:38: 'gl_ClipDistance' : no such field in structure
+ERROR: 0:38: 'gl_ClipDistance' : no such field in structure 'gl_in'
ERROR: 0:38: 'expression' : left of '[' is not of type array, matrix, or vector
ERROR: 0:47: 'gl_PointSize' : required extension not requested: Possible extensions include:
GL_EXT_tessellation_point_size
@@ -43,7 +43,7 @@
ERROR: 0:103: 'location' : overlapping use of location 24
ERROR: 0:105: 'gl_TessLevelOuter' : identifiers starting with "gl_" are reserved
ERROR: 0:113: 'sample' : Reserved word.
-ERROR: 0:119: 'gl_PointSize' : no such field in structure
+ERROR: 0:119: 'gl_PointSize' : no such field in structure 'gl_in'
ERROR: 0:119: '=' : cannot convert from ' temp block{ in highp 4-component vector of float Position gl_Position}' to ' temp highp float'
ERROR: 0:127: 'gl_BoundingBoxOES' : undeclared identifier
ERROR: 43 compilation errors. No code generated.
diff --git a/Test/baseResults/320.geom.out b/Test/baseResults/320.geom.out
index f333766..cdaacb9 100644
--- a/Test/baseResults/320.geom.out
+++ b/Test/baseResults/320.geom.out
@@ -6,7 +6,7 @@
ERROR: 0:34: 'EndStreamPrimitive' : no matching overloaded function found
ERROR: 0:37: 'gl_ClipDistance' : undeclared identifier
ERROR: 0:37: 'gl_ClipDistance' : left of '[' is not of type array, matrix, or vector
-ERROR: 0:38: 'gl_ClipDistance' : no such field in structure
+ERROR: 0:38: 'gl_ClipDistance' : no such field in structure 'gl_in'
ERROR: 0:38: 'expression' : left of '[' is not of type array, matrix, or vector
ERROR: 0:37: 'assign' : l-value required (can't modify a const)
ERROR: 0:45: 'selecting output stream' : not supported with this profile: es
diff --git a/Test/baseResults/320.tesc.out b/Test/baseResults/320.tesc.out
index 6bb52b3..67848d9 100644
--- a/Test/baseResults/320.tesc.out
+++ b/Test/baseResults/320.tesc.out
@@ -6,12 +6,12 @@
ERROR: 0:24: 'gl_PointSize' : required extension not requested: Possible extensions include:
GL_EXT_tessellation_point_size
GL_OES_tessellation_point_size
-ERROR: 0:25: 'gl_ClipDistance' : no such field in structure
+ERROR: 0:25: 'gl_ClipDistance' : no such field in structure 'gl_in'
ERROR: 0:25: 'expression' : left of '[' is not of type array, matrix, or vector
ERROR: 0:32: 'gl_PointSize' : required extension not requested: Possible extensions include:
GL_EXT_tessellation_point_size
GL_OES_tessellation_point_size
-ERROR: 0:33: 'gl_ClipDistance' : no such field in structure
+ERROR: 0:33: 'gl_ClipDistance' : no such field in structure 'gl_out'
ERROR: 0:33: 'expression' : left of '[' is not of type array, matrix, or vector
ERROR: 0:33: 'assign' : l-value required (can't modify a const)
ERROR: 0:39: '' : tessellation control barrier() cannot be placed within flow control
diff --git a/Test/baseResults/320.tese.out b/Test/baseResults/320.tese.out
index 014eeb0..ba51b9c 100644
--- a/Test/baseResults/320.tese.out
+++ b/Test/baseResults/320.tese.out
@@ -10,7 +10,7 @@
ERROR: 0:33: 'gl_PointSize' : required extension not requested: Possible extensions include:
GL_EXT_tessellation_point_size
GL_OES_tessellation_point_size
-ERROR: 0:34: 'gl_ClipDistance' : no such field in structure
+ERROR: 0:34: 'gl_ClipDistance' : no such field in structure 'gl_in'
ERROR: 0:34: 'expression' : left of '[' is not of type array, matrix, or vector
ERROR: 0:43: 'gl_PointSize' : required extension not requested: Possible extensions include:
GL_EXT_tessellation_point_size
diff --git a/Test/baseResults/410.geom.out b/Test/baseResults/410.geom.out
index 498da5a..3cc7900 100644
--- a/Test/baseResults/410.geom.out
+++ b/Test/baseResults/410.geom.out
@@ -2,7 +2,7 @@
ERROR: 0:8: 'myIn' : cannot redeclare a built-in block with a user name
ERROR: 0:12: 'gl_myIn' : no declaration found for redeclaration
ERROR: 0:20: 'gl_PerVertex' : can only redeclare a built-in block once, and before any use
-ERROR: 0:32: 'gl_Position' : no such field in structure
+ERROR: 0:32: 'gl_Position' : no such field in structure 'gl_in'
ERROR: 0:32: '=' : cannot convert from ' temp block{ in float PointSize gl_PointSize}' to ' temp 4-component vector of float'
ERROR: 0:33: 'gl_Position' : member of nameless block was not redeclared
ERROR: 0:33: 'assign' : l-value required "gl_PerVertex" (can't modify void)
diff --git a/Test/baseResults/420.tesc.out b/Test/baseResults/420.tesc.out
index a1f881c..4410c84 100644
--- a/Test/baseResults/420.tesc.out
+++ b/Test/baseResults/420.tesc.out
@@ -2,7 +2,7 @@
ERROR: 0:7: 'vertices' : inconsistent output number of vertices for array size of gl_out
ERROR: 0:11: 'vertices' : inconsistent output number of vertices for array size of a
ERROR: 0:12: 'vertices' : inconsistent output number of vertices for array size of outb
-ERROR: 0:26: 'gl_PointSize' : no such field in structure
+ERROR: 0:26: 'gl_PointSize' : no such field in structure 'gl_out'
ERROR: 0:26: 'assign' : cannot convert from ' temp float' to ' temp block{ out 4-component vector of float Position gl_Position}'
ERROR: 0:29: 'out' : type must be an array: outf
ERROR: 0:43: 'vertices' : must be greater than 0
diff --git a/Test/baseResults/450.geom.out b/Test/baseResults/450.geom.out
index e75bf93..b51a674 100644
--- a/Test/baseResults/450.geom.out
+++ b/Test/baseResults/450.geom.out
@@ -1,6 +1,6 @@
450.geom
ERROR: 0:15: '[' : array index out of range '3'
-ERROR: 0:15: 'gl_Position' : no such field in structure
+ERROR: 0:15: 'gl_Position' : no such field in structure 'gl_in'
ERROR: 0:19: 'points' : can only apply to a standalone qualifier
ERROR: 3 compilation errors. No code generated.
diff --git a/Test/baseResults/BestMatchFunction.vert.out b/Test/baseResults/BestMatchFunction.vert.out
new file mode 100644
index 0000000..843ffd7
--- /dev/null
+++ b/Test/baseResults/BestMatchFunction.vert.out
@@ -0,0 +1,206 @@
+BestMatchFunction.vert
+WARNING: 0:2: '#extension' : extension is only partially supported: GL_ARB_gpu_shader5
+
+Shader version: 150
+Requested GL_ARB_gpu_shader5
+0:? Sequence
+0:7 Function Definition: f(vf4;vf4; ( global 4-component vector of float)
+0:7 Function Parameters:
+0:7 'a' ( in 4-component vector of float)
+0:7 'b' ( in 4-component vector of float)
+0:7 Sequence
+0:7 Branch: Return with expression
+0:7 component-wise multiply ( temp 4-component vector of float)
+0:7 'a' ( in 4-component vector of float)
+0:7 'b' ( in 4-component vector of float)
+0:8 Function Definition: f(vu4;vu4; ( global 4-component vector of float)
+0:8 Function Parameters:
+0:8 'a' ( in 4-component vector of uint)
+0:8 'b' ( in 4-component vector of uint)
+0:8 Sequence
+0:8 Branch: Return with expression
+0:8 Convert uint to float ( temp 4-component vector of float)
+0:8 subtract ( temp 4-component vector of uint)
+0:8 'a' ( in 4-component vector of uint)
+0:8 'b' ( in 4-component vector of uint)
+0:10 Function Definition: main( ( global void)
+0:10 Function Parameters:
+0:12 Sequence
+0:12 move second child to first child ( temp 4-component vector of float)
+0:12 'result' ( smooth out 4-component vector of float)
+0:12 Function Call: f(vu4;vu4; ( global 4-component vector of float)
+0:12 Convert int to uint ( temp 4-component vector of uint)
+0:12 'u1' ( uniform 4-component vector of int)
+0:12 'u2' ( uniform 4-component vector of uint)
+0:13 switch
+0:13 condition
+0:13 'gl_VertexID' ( gl_VertexId int VertexId)
+0:13 body
+0:13 Sequence
+0:15 case: with expression
+0:15 Constant:
+0:15 0 (const int)
+0:? Sequence
+0:15 move second child to first child ( temp 4-component vector of float)
+0:15 gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:15 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:15 Constant:
+0:15 0 (const uint)
+0:15 Constant:
+0:15 -1.000000
+0:15 1.000000
+0:15 0.000000
+0:15 1.000000
+0:15 Branch: Break
+0:16 case: with expression
+0:16 Constant:
+0:16 1 (const int)
+0:? Sequence
+0:16 move second child to first child ( temp 4-component vector of float)
+0:16 gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:16 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:16 Constant:
+0:16 0 (const uint)
+0:16 Constant:
+0:16 1.000000
+0:16 1.000000
+0:16 0.000000
+0:16 1.000000
+0:16 Branch: Break
+0:17 case: with expression
+0:17 Constant:
+0:17 2 (const int)
+0:? Sequence
+0:17 move second child to first child ( temp 4-component vector of float)
+0:17 gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:17 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:17 Constant:
+0:17 0 (const uint)
+0:17 Constant:
+0:17 -1.000000
+0:17 -1.000000
+0:17 0.000000
+0:17 1.000000
+0:17 Branch: Break
+0:18 case: with expression
+0:18 Constant:
+0:18 3 (const int)
+0:? Sequence
+0:18 move second child to first child ( temp 4-component vector of float)
+0:18 gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:18 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:18 Constant:
+0:18 0 (const uint)
+0:18 Constant:
+0:18 1.000000
+0:18 -1.000000
+0:18 0.000000
+0:18 1.000000
+0:18 Branch: Break
+0:? Linker Objects
+0:? 'u1' ( uniform 4-component vector of int)
+0:? 'u2' ( uniform 4-component vector of uint)
+0:? 'result' ( smooth out 4-component vector of float)
+0:? 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:? 'gl_VertexID' ( gl_VertexId int VertexId)
+0:? 'gl_InstanceID' ( gl_InstanceId int InstanceId)
+
+
+Linked vertex stage:
+
+
+Shader version: 150
+Requested GL_ARB_gpu_shader5
+0:? Sequence
+0:8 Function Definition: f(vu4;vu4; ( global 4-component vector of float)
+0:8 Function Parameters:
+0:8 'a' ( in 4-component vector of uint)
+0:8 'b' ( in 4-component vector of uint)
+0:8 Sequence
+0:8 Branch: Return with expression
+0:8 Convert uint to float ( temp 4-component vector of float)
+0:8 subtract ( temp 4-component vector of uint)
+0:8 'a' ( in 4-component vector of uint)
+0:8 'b' ( in 4-component vector of uint)
+0:10 Function Definition: main( ( global void)
+0:10 Function Parameters:
+0:12 Sequence
+0:12 move second child to first child ( temp 4-component vector of float)
+0:12 'result' ( smooth out 4-component vector of float)
+0:12 Function Call: f(vu4;vu4; ( global 4-component vector of float)
+0:12 Convert int to uint ( temp 4-component vector of uint)
+0:12 'u1' ( uniform 4-component vector of int)
+0:12 'u2' ( uniform 4-component vector of uint)
+0:13 switch
+0:13 condition
+0:13 'gl_VertexID' ( gl_VertexId int VertexId)
+0:13 body
+0:13 Sequence
+0:15 case: with expression
+0:15 Constant:
+0:15 0 (const int)
+0:? Sequence
+0:15 move second child to first child ( temp 4-component vector of float)
+0:15 gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:15 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out 1-element array of float ClipDistance gl_ClipDistance})
+0:15 Constant:
+0:15 0 (const uint)
+0:15 Constant:
+0:15 -1.000000
+0:15 1.000000
+0:15 0.000000
+0:15 1.000000
+0:15 Branch: Break
+0:16 case: with expression
+0:16 Constant:
+0:16 1 (const int)
+0:? Sequence
+0:16 move second child to first child ( temp 4-component vector of float)
+0:16 gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:16 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out 1-element array of float ClipDistance gl_ClipDistance})
+0:16 Constant:
+0:16 0 (const uint)
+0:16 Constant:
+0:16 1.000000
+0:16 1.000000
+0:16 0.000000
+0:16 1.000000
+0:16 Branch: Break
+0:17 case: with expression
+0:17 Constant:
+0:17 2 (const int)
+0:? Sequence
+0:17 move second child to first child ( temp 4-component vector of float)
+0:17 gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:17 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out 1-element array of float ClipDistance gl_ClipDistance})
+0:17 Constant:
+0:17 0 (const uint)
+0:17 Constant:
+0:17 -1.000000
+0:17 -1.000000
+0:17 0.000000
+0:17 1.000000
+0:17 Branch: Break
+0:18 case: with expression
+0:18 Constant:
+0:18 3 (const int)
+0:? Sequence
+0:18 move second child to first child ( temp 4-component vector of float)
+0:18 gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:18 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out 1-element array of float ClipDistance gl_ClipDistance})
+0:18 Constant:
+0:18 0 (const uint)
+0:18 Constant:
+0:18 1.000000
+0:18 -1.000000
+0:18 0.000000
+0:18 1.000000
+0:18 Branch: Break
+0:? Linker Objects
+0:? 'u1' ( uniform 4-component vector of int)
+0:? 'u2' ( uniform 4-component vector of uint)
+0:? 'result' ( smooth out 4-component vector of float)
+0:? 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out 1-element array of float ClipDistance gl_ClipDistance})
+0:? 'gl_VertexID' ( gl_VertexId int VertexId)
+0:? 'gl_InstanceID' ( gl_InstanceId int InstanceId)
+
diff --git a/Test/baseResults/EndStreamPrimitive.geom.out b/Test/baseResults/EndStreamPrimitive.geom.out
new file mode 100644
index 0000000..702c3f9
--- /dev/null
+++ b/Test/baseResults/EndStreamPrimitive.geom.out
@@ -0,0 +1,97 @@
+EndStreamPrimitive.geom
+WARNING: 0:2: '#extension' : extension is only partially supported: GL_ARB_gpu_shader5
+
+Shader version: 150
+Requested GL_ARB_gpu_shader5
+invocations = -1
+max_vertices = 1
+input primitive = points
+output primitive = points
+0:? Sequence
+0:10 Function Definition: main( ( global void)
+0:10 Function Parameters:
+0:12 Sequence
+0:12 move second child to first child ( temp float)
+0:12 'output1' (layout( stream=0) out float)
+0:12 Constant:
+0:12 1.000000
+0:13 move second child to first child ( temp float)
+0:13 'output2' (layout( stream=0) out float)
+0:13 Constant:
+0:13 2.000000
+0:14 EmitStreamVertex ( global void)
+0:14 Constant:
+0:14 0 (const int)
+0:15 EndStreamPrimitive ( global void)
+0:15 Constant:
+0:15 0 (const int)
+0:16 move second child to first child ( temp float)
+0:16 'output3' (layout( stream=1) out float)
+0:16 Constant:
+0:16 3.000000
+0:17 move second child to first child ( temp float)
+0:17 'output4' (layout( stream=1) out float)
+0:17 Constant:
+0:17 4.000000
+0:18 EmitStreamVertex ( global void)
+0:18 Constant:
+0:18 1 (const int)
+0:19 EndStreamPrimitive ( global void)
+0:19 Constant:
+0:19 1 (const int)
+0:? Linker Objects
+0:? 'output1' (layout( stream=0) out float)
+0:? 'output2' (layout( stream=0) out float)
+0:? 'output3' (layout( stream=1) out float)
+0:? 'output4' (layout( stream=1) out float)
+0:? 'stream' ( uniform uint)
+
+
+Linked geometry stage:
+
+
+Shader version: 150
+Requested GL_ARB_gpu_shader5
+invocations = 1
+max_vertices = 1
+input primitive = points
+output primitive = points
+0:? Sequence
+0:10 Function Definition: main( ( global void)
+0:10 Function Parameters:
+0:12 Sequence
+0:12 move second child to first child ( temp float)
+0:12 'output1' (layout( stream=0) out float)
+0:12 Constant:
+0:12 1.000000
+0:13 move second child to first child ( temp float)
+0:13 'output2' (layout( stream=0) out float)
+0:13 Constant:
+0:13 2.000000
+0:14 EmitStreamVertex ( global void)
+0:14 Constant:
+0:14 0 (const int)
+0:15 EndStreamPrimitive ( global void)
+0:15 Constant:
+0:15 0 (const int)
+0:16 move second child to first child ( temp float)
+0:16 'output3' (layout( stream=1) out float)
+0:16 Constant:
+0:16 3.000000
+0:17 move second child to first child ( temp float)
+0:17 'output4' (layout( stream=1) out float)
+0:17 Constant:
+0:17 4.000000
+0:18 EmitStreamVertex ( global void)
+0:18 Constant:
+0:18 1 (const int)
+0:19 EndStreamPrimitive ( global void)
+0:19 Constant:
+0:19 1 (const int)
+0:? Linker Objects
+0:? 'output1' (layout( stream=0) out float)
+0:? 'output2' (layout( stream=0) out float)
+0:? 'output3' (layout( stream=1) out float)
+0:? 'output4' (layout( stream=1) out float)
+0:? 'stream' ( uniform uint)
+
diff --git a/Test/baseResults/GL_ARB_fragment_coord_conventions.vert.out b/Test/baseResults/GL_ARB_fragment_coord_conventions.vert.out
new file mode 100644
index 0000000..3b55ae0
--- /dev/null
+++ b/Test/baseResults/GL_ARB_fragment_coord_conventions.vert.out
@@ -0,0 +1,143 @@
+GL_ARB_fragment_coord_conventions.vert
+Shader version: 140
+Requested GL_ARB_explicit_attrib_location
+Requested GL_ARB_fragment_coord_conventions
+0:? Sequence
+0:22 Function Definition: main( ( global void)
+0:22 Function Parameters:
+0:24 Sequence
+0:24 move second child to first child ( temp 4-component vector of float)
+0:24 'gl_Position' ( gl_Position 4-component vector of float Position)
+0:24 'pos' (layout( location=0) in 4-component vector of float)
+0:25 move second child to first child ( temp 4-component vector of float)
+0:25 'i' ( smooth out 4-component vector of float)
+0:25 Construct vec4 ( temp 4-component vector of float)
+0:25 component-wise multiply ( temp float)
+0:25 component-wise multiply ( temp float)
+0:25 add ( temp float)
+0:25 direct index ( temp float)
+0:25 'pos' (layout( location=0) in 4-component vector of float)
+0:25 Constant:
+0:25 0 (const int)
+0:25 Constant:
+0:25 1.000000
+0:25 Constant:
+0:25 0.500000
+0:25 'gtf_windowWidth' ( uniform float)
+0:25 component-wise multiply ( temp float)
+0:25 component-wise multiply ( temp float)
+0:25 add ( temp float)
+0:25 direct index ( temp float)
+0:25 'pos' (layout( location=0) in 4-component vector of float)
+0:25 Constant:
+0:25 1 (const int)
+0:25 Constant:
+0:25 1.000000
+0:25 Constant:
+0:25 0.500000
+0:25 'gtf_windowHeight' ( uniform float)
+0:25 add ( temp float)
+0:25 component-wise multiply ( temp float)
+0:25 component-wise multiply ( temp float)
+0:25 subtract ( temp float)
+0:25 'f' ( uniform float)
+0:25 'n' ( uniform float)
+0:25 Constant:
+0:25 0.500000
+0:25 direct index ( temp float)
+0:25 'pos' (layout( location=0) in 4-component vector of float)
+0:25 Constant:
+0:25 2 (const int)
+0:25 component-wise multiply ( temp float)
+0:25 add ( temp float)
+0:25 'f' ( uniform float)
+0:25 'n' ( uniform float)
+0:25 Constant:
+0:25 0.500000
+0:25 direct index ( temp float)
+0:25 'pos' (layout( location=0) in 4-component vector of float)
+0:25 Constant:
+0:25 3 (const int)
+0:? Linker Objects
+0:? 'pos' (layout( location=0) in 4-component vector of float)
+0:? 'i' ( smooth out 4-component vector of float)
+0:? 'gtf_windowWidth' ( uniform float)
+0:? 'gtf_windowHeight' ( uniform float)
+0:? 'n' ( uniform float)
+0:? 'f' ( uniform float)
+0:? 'gl_VertexID' ( gl_VertexId int VertexId)
+0:? 'gl_InstanceID' ( gl_InstanceId int InstanceId)
+
+
+Linked vertex stage:
+
+
+Shader version: 140
+Requested GL_ARB_explicit_attrib_location
+Requested GL_ARB_fragment_coord_conventions
+0:? Sequence
+0:22 Function Definition: main( ( global void)
+0:22 Function Parameters:
+0:24 Sequence
+0:24 move second child to first child ( temp 4-component vector of float)
+0:24 'gl_Position' ( gl_Position 4-component vector of float Position)
+0:24 'pos' (layout( location=0) in 4-component vector of float)
+0:25 move second child to first child ( temp 4-component vector of float)
+0:25 'i' ( smooth out 4-component vector of float)
+0:25 Construct vec4 ( temp 4-component vector of float)
+0:25 component-wise multiply ( temp float)
+0:25 component-wise multiply ( temp float)
+0:25 add ( temp float)
+0:25 direct index ( temp float)
+0:25 'pos' (layout( location=0) in 4-component vector of float)
+0:25 Constant:
+0:25 0 (const int)
+0:25 Constant:
+0:25 1.000000
+0:25 Constant:
+0:25 0.500000
+0:25 'gtf_windowWidth' ( uniform float)
+0:25 component-wise multiply ( temp float)
+0:25 component-wise multiply ( temp float)
+0:25 add ( temp float)
+0:25 direct index ( temp float)
+0:25 'pos' (layout( location=0) in 4-component vector of float)
+0:25 Constant:
+0:25 1 (const int)
+0:25 Constant:
+0:25 1.000000
+0:25 Constant:
+0:25 0.500000
+0:25 'gtf_windowHeight' ( uniform float)
+0:25 add ( temp float)
+0:25 component-wise multiply ( temp float)
+0:25 component-wise multiply ( temp float)
+0:25 subtract ( temp float)
+0:25 'f' ( uniform float)
+0:25 'n' ( uniform float)
+0:25 Constant:
+0:25 0.500000
+0:25 direct index ( temp float)
+0:25 'pos' (layout( location=0) in 4-component vector of float)
+0:25 Constant:
+0:25 2 (const int)
+0:25 component-wise multiply ( temp float)
+0:25 add ( temp float)
+0:25 'f' ( uniform float)
+0:25 'n' ( uniform float)
+0:25 Constant:
+0:25 0.500000
+0:25 direct index ( temp float)
+0:25 'pos' (layout( location=0) in 4-component vector of float)
+0:25 Constant:
+0:25 3 (const int)
+0:? Linker Objects
+0:? 'pos' (layout( location=0) in 4-component vector of float)
+0:? 'i' ( smooth out 4-component vector of float)
+0:? 'gtf_windowWidth' ( uniform float)
+0:? 'gtf_windowHeight' ( uniform float)
+0:? 'n' ( uniform float)
+0:? 'f' ( uniform float)
+0:? 'gl_VertexID' ( gl_VertexId int VertexId)
+0:? 'gl_InstanceID' ( gl_InstanceId int InstanceId)
+
diff --git a/Test/baseResults/compoundsuffix.frag.hlsl b/Test/baseResults/compoundsuffix.frag.hlsl
index 5a62488..f8dcfaa 100644
--- a/Test/baseResults/compoundsuffix.frag.hlsl
+++ b/Test/baseResults/compoundsuffix.frag.hlsl
@@ -1,45 +1,45 @@
-compoundsuffix.frag.hlsl
-// Module Version 10000
-// Generated by (magic number): 8000a
-// Id's are bound by 22
-
- Capability Shader
- 1: ExtInstImport "GLSL.std.450"
- MemoryModel Logical GLSL450
- EntryPoint Fragment 4 "main" 20
- ExecutionMode 4 OriginUpperLeft
- Source HLSL 500
- Name 4 "main"
- Name 11 "@main(vf4;"
- Name 10 "fragColor"
- Name 15 "fragColor"
- Name 16 "param"
- Name 20 "fragColor"
- Decorate 20(fragColor) Location 0
- 2: TypeVoid
- 3: TypeFunction 2
- 6: TypeFloat 32
- 7: TypeVector 6(float) 4
- 8: TypePointer Function 7(fvec4)
- 9: TypeFunction 2 8(ptr)
- 13: 6(float) Constant 1065353216
- 14: 7(fvec4) ConstantComposite 13 13 13 13
- 19: TypePointer Output 7(fvec4)
- 20(fragColor): 19(ptr) Variable Output
- 4(main): 2 Function None 3
- 5: Label
- 15(fragColor): 8(ptr) Variable Function
- 16(param): 8(ptr) Variable Function
- 17: 2 FunctionCall 11(@main(vf4;) 16(param)
- 18: 7(fvec4) Load 16(param)
- Store 15(fragColor) 18
- 21: 7(fvec4) Load 15(fragColor)
- Store 20(fragColor) 21
- Return
- FunctionEnd
- 11(@main(vf4;): 2 Function None 9
- 10(fragColor): 8(ptr) FunctionParameter
- 12: Label
- Store 10(fragColor) 14
- Return
- FunctionEnd
+compoundsuffix.frag.hlsl
+// Module Version 10000
+// Generated by (magic number): 8000b
+// Id's are bound by 22
+
+ Capability Shader
+ 1: ExtInstImport "GLSL.std.450"
+ MemoryModel Logical GLSL450
+ EntryPoint Fragment 4 "main" 20
+ ExecutionMode 4 OriginUpperLeft
+ Source HLSL 500
+ Name 4 "main"
+ Name 11 "@main(vf4;"
+ Name 10 "fragColor"
+ Name 15 "fragColor"
+ Name 16 "param"
+ Name 20 "fragColor"
+ Decorate 20(fragColor) Location 0
+ 2: TypeVoid
+ 3: TypeFunction 2
+ 6: TypeFloat 32
+ 7: TypeVector 6(float) 4
+ 8: TypePointer Function 7(fvec4)
+ 9: TypeFunction 2 8(ptr)
+ 13: 6(float) Constant 1065353216
+ 14: 7(fvec4) ConstantComposite 13 13 13 13
+ 19: TypePointer Output 7(fvec4)
+ 20(fragColor): 19(ptr) Variable Output
+ 4(main): 2 Function None 3
+ 5: Label
+ 15(fragColor): 8(ptr) Variable Function
+ 16(param): 8(ptr) Variable Function
+ 17: 2 FunctionCall 11(@main(vf4;) 16(param)
+ 18: 7(fvec4) Load 16(param)
+ Store 15(fragColor) 18
+ 21: 7(fvec4) Load 15(fragColor)
+ Store 20(fragColor) 21
+ Return
+ FunctionEnd
+ 11(@main(vf4;): 2 Function None 9
+ 10(fragColor): 8(ptr) FunctionParameter
+ 12: Label
+ Store 10(fragColor) 14
+ Return
+ FunctionEnd
diff --git a/Test/baseResults/compoundsuffix.vert.glsl b/Test/baseResults/compoundsuffix.vert.glsl
index 58354a4..8535b47 100644
--- a/Test/baseResults/compoundsuffix.vert.glsl
+++ b/Test/baseResults/compoundsuffix.vert.glsl
@@ -1,15 +1,15 @@
-compoundsuffix.vert.glsl
-Shader version: 100
-0:? Sequence
-0:1 Function Definition: main( ( global void)
-0:1 Function Parameters:
-0:3 Sequence
-0:3 move second child to first child ( temp highp 4-component vector of float)
-0:3 'gl_Position' ( gl_Position highp 4-component vector of float Position)
-0:3 Constant:
-0:3 1.000000
-0:3 1.000000
-0:3 1.000000
-0:3 1.000000
-0:? Linker Objects
-
+compoundsuffix.vert.glsl
+Shader version: 100
+0:? Sequence
+0:1 Function Definition: main( ( global void)
+0:1 Function Parameters:
+0:3 Sequence
+0:3 move second child to first child ( temp highp 4-component vector of float)
+0:3 'gl_Position' ( gl_Position highp 4-component vector of float Position)
+0:3 Constant:
+0:3 1.000000
+0:3 1.000000
+0:3 1.000000
+0:3 1.000000
+0:? Linker Objects
+
diff --git a/Test/baseResults/constantUnaryConversion.comp.out b/Test/baseResults/constantUnaryConversion.comp.out
index fcaf6f2..78372f0 100644
--- a/Test/baseResults/constantUnaryConversion.comp.out
+++ b/Test/baseResults/constantUnaryConversion.comp.out
@@ -3,8 +3,8 @@
Requested GL_EXT_shader_explicit_arithmetic_types
local_size = (1, 1, 1)
0:? Sequence
-0:48 Function Definition: main( ( global void)
-0:48 Function Parameters:
+0:69 Function Definition: main( ( global void)
+0:69 Function Parameters:
0:? Linker Objects
0:? 'bool_init' ( const bool)
0:? true (const bool)
@@ -29,6 +29,12 @@
0:? 'float32_t_init' ( const float)
0:? 13.000000
0:? 'float64_t_init' ( const double)
+0:? 4.000000
+0:? 'neg_float16_t_init' ( const float16_t)
+0:? -42.000000
+0:? 'neg_float32_t_init' ( const float)
+0:? -13.000000
+0:? 'neg_float64_t_init' ( const double)
0:? -4.000000
0:? 'bool_to_bool' ( const bool)
0:? true (const bool)
@@ -77,7 +83,7 @@
0:? 'float32_t_to_int8_t' ( const int8_t)
0:? 13 (const int8_t)
0:? 'float64_t_to_int8_t' ( const int8_t)
-0:? -4 (const int8_t)
+0:? 4 (const int8_t)
0:? 'bool_to_int16_t' ( const int16_t)
0:? 1 (const int16_t)
0:? 'int8_t_to_int16_t' ( const int16_t)
@@ -101,7 +107,7 @@
0:? 'float32_t_to_int16_t' ( const int16_t)
0:? 13 (const int16_t)
0:? 'float64_t_to_int16_t' ( const int16_t)
-0:? -4 (const int16_t)
+0:? 4 (const int16_t)
0:? 'bool_to_int32_t' ( const int)
0:? 1 (const int)
0:? 'int8_t_to_int32_t' ( const int)
@@ -125,7 +131,7 @@
0:? 'float32_t_to_int32_t' ( const int)
0:? 13 (const int)
0:? 'float64_t_to_int32_t' ( const int)
-0:? -4 (const int)
+0:? 4 (const int)
0:? 'bool_to_int64_t' ( const int64_t)
0:? 1 (const int64_t)
0:? 'int8_t_to_int64_t' ( const int64_t)
@@ -149,7 +155,7 @@
0:? 'float32_t_to_int64_t' ( const int64_t)
0:? 13 (const int64_t)
0:? 'float64_t_to_int64_t' ( const int64_t)
-0:? -4 (const int64_t)
+0:? 4 (const int64_t)
0:? 'bool_to_uint8_t' ( const uint8_t)
0:? 1 (const uint8_t)
0:? 'int8_t_to_uint8_t' ( const uint8_t)
@@ -173,7 +179,7 @@
0:? 'float32_t_to_uint8_t' ( const uint8_t)
0:? 13 (const uint8_t)
0:? 'float64_t_to_uint8_t' ( const uint8_t)
-0:? 252 (const uint8_t)
+0:? 4 (const uint8_t)
0:? 'bool_to_uint16_t' ( const uint16_t)
0:? 1 (const uint16_t)
0:? 'int8_t_to_uint16_t' ( const uint16_t)
@@ -197,7 +203,7 @@
0:? 'float32_t_to_uint16_t' ( const uint16_t)
0:? 13 (const uint16_t)
0:? 'float64_t_to_uint16_t' ( const uint16_t)
-0:? 65532 (const uint16_t)
+0:? 4 (const uint16_t)
0:? 'bool_to_uint32_t' ( const uint)
0:? 1 (const uint)
0:? 'int8_t_to_uint32_t' ( const uint)
@@ -221,7 +227,7 @@
0:? 'float32_t_to_uint32_t' ( const uint)
0:? 13 (const uint)
0:? 'float64_t_to_uint32_t' ( const uint)
-0:? 4294967292 (const uint)
+0:? 4 (const uint)
0:? 'bool_to_uint64_t' ( const uint64_t)
0:? 1 (const uint64_t)
0:? 'int8_t_to_uint64_t' ( const uint64_t)
@@ -245,7 +251,7 @@
0:? 'float32_t_to_uint64_t' ( const uint64_t)
0:? 13 (const uint64_t)
0:? 'float64_t_to_uint64_t' ( const uint64_t)
-0:? 18446744073709551612 (const uint64_t)
+0:? 4 (const uint64_t)
0:? 'bool_to_float16_t' ( const float16_t)
0:? 1.000000
0:? 'int8_t_to_float16_t' ( const float16_t)
@@ -269,7 +275,7 @@
0:? 'float32_t_to_float16_t' ( const float16_t)
0:? 13.000000
0:? 'float64_t_to_float16_t' ( const float16_t)
-0:? -4.000000
+0:? 4.000000
0:? 'bool_to_float32_t' ( const float)
0:? 1.000000
0:? 'int8_t_to_float32_t' ( const float)
@@ -293,7 +299,7 @@
0:? 'float32_t_to_float32_t' ( const float)
0:? 13.000000
0:? 'float64_t_to_float32_t' ( const float)
-0:? -4.000000
+0:? 4.000000
0:? 'bool_to_float64_t' ( const double)
0:? 1.000000
0:? 'int8_t_to_float64_t' ( const double)
@@ -317,6 +323,54 @@
0:? 'float32_t_to_float64_t' ( const double)
0:? 13.000000
0:? 'float64_t_to_float64_t' ( const double)
+0:? 4.000000
+0:? 'neg_float16_t_to_bool' ( const bool)
+0:? true (const bool)
+0:? 'neg_float32_t_to_bool' ( const bool)
+0:? true (const bool)
+0:? 'neg_float64_t_to_bool' ( const bool)
+0:? true (const bool)
+0:? 'neg_float16_t_to_int8_t' ( const int8_t)
+0:? -42 (const int8_t)
+0:? 'neg_float32_t_to_int8_t' ( const int8_t)
+0:? -13 (const int8_t)
+0:? 'neg_float64_t_to_int8_t' ( const int8_t)
+0:? -4 (const int8_t)
+0:? 'neg_float16_t_to_int16_t' ( const int16_t)
+0:? -42 (const int16_t)
+0:? 'neg_float32_t_to_int16_t' ( const int16_t)
+0:? -13 (const int16_t)
+0:? 'neg_float64_t_to_int16_t' ( const int16_t)
+0:? -4 (const int16_t)
+0:? 'neg_float16_t_to_int32_t' ( const int)
+0:? -42 (const int)
+0:? 'neg_float32_t_to_int32_t' ( const int)
+0:? -13 (const int)
+0:? 'neg_float64_t_to_int32_t' ( const int)
+0:? -4 (const int)
+0:? 'neg_float16_t_to_int64_t' ( const int64_t)
+0:? -42 (const int64_t)
+0:? 'neg_float32_t_to_int64_t' ( const int64_t)
+0:? -13 (const int64_t)
+0:? 'neg_float64_t_to_int64_t' ( const int64_t)
+0:? -4 (const int64_t)
+0:? 'neg_float16_t_to_float16_t' ( const float16_t)
+0:? -42.000000
+0:? 'neg_float32_t_to_float16_t' ( const float16_t)
+0:? -13.000000
+0:? 'neg_float64_t_to_float16_t' ( const float16_t)
+0:? -4.000000
+0:? 'neg_float16_t_to_float32_t' ( const float)
+0:? -42.000000
+0:? 'neg_float32_t_to_float32_t' ( const float)
+0:? -13.000000
+0:? 'neg_float64_t_to_float32_t' ( const float)
+0:? -4.000000
+0:? 'neg_float16_t_to_float64_t' ( const double)
+0:? -42.000000
+0:? 'neg_float32_t_to_float64_t' ( const double)
+0:? -13.000000
+0:? 'neg_float64_t_to_float64_t' ( const double)
0:? -4.000000
@@ -327,8 +381,8 @@
Requested GL_EXT_shader_explicit_arithmetic_types
local_size = (1, 1, 1)
0:? Sequence
-0:48 Function Definition: main( ( global void)
-0:48 Function Parameters:
+0:69 Function Definition: main( ( global void)
+0:69 Function Parameters:
0:? Linker Objects
0:? 'bool_init' ( const bool)
0:? true (const bool)
@@ -353,6 +407,12 @@
0:? 'float32_t_init' ( const float)
0:? 13.000000
0:? 'float64_t_init' ( const double)
+0:? 4.000000
+0:? 'neg_float16_t_init' ( const float16_t)
+0:? -42.000000
+0:? 'neg_float32_t_init' ( const float)
+0:? -13.000000
+0:? 'neg_float64_t_init' ( const double)
0:? -4.000000
0:? 'bool_to_bool' ( const bool)
0:? true (const bool)
@@ -401,7 +461,7 @@
0:? 'float32_t_to_int8_t' ( const int8_t)
0:? 13 (const int8_t)
0:? 'float64_t_to_int8_t' ( const int8_t)
-0:? -4 (const int8_t)
+0:? 4 (const int8_t)
0:? 'bool_to_int16_t' ( const int16_t)
0:? 1 (const int16_t)
0:? 'int8_t_to_int16_t' ( const int16_t)
@@ -425,7 +485,7 @@
0:? 'float32_t_to_int16_t' ( const int16_t)
0:? 13 (const int16_t)
0:? 'float64_t_to_int16_t' ( const int16_t)
-0:? -4 (const int16_t)
+0:? 4 (const int16_t)
0:? 'bool_to_int32_t' ( const int)
0:? 1 (const int)
0:? 'int8_t_to_int32_t' ( const int)
@@ -449,7 +509,7 @@
0:? 'float32_t_to_int32_t' ( const int)
0:? 13 (const int)
0:? 'float64_t_to_int32_t' ( const int)
-0:? -4 (const int)
+0:? 4 (const int)
0:? 'bool_to_int64_t' ( const int64_t)
0:? 1 (const int64_t)
0:? 'int8_t_to_int64_t' ( const int64_t)
@@ -473,7 +533,7 @@
0:? 'float32_t_to_int64_t' ( const int64_t)
0:? 13 (const int64_t)
0:? 'float64_t_to_int64_t' ( const int64_t)
-0:? -4 (const int64_t)
+0:? 4 (const int64_t)
0:? 'bool_to_uint8_t' ( const uint8_t)
0:? 1 (const uint8_t)
0:? 'int8_t_to_uint8_t' ( const uint8_t)
@@ -497,7 +557,7 @@
0:? 'float32_t_to_uint8_t' ( const uint8_t)
0:? 13 (const uint8_t)
0:? 'float64_t_to_uint8_t' ( const uint8_t)
-0:? 252 (const uint8_t)
+0:? 4 (const uint8_t)
0:? 'bool_to_uint16_t' ( const uint16_t)
0:? 1 (const uint16_t)
0:? 'int8_t_to_uint16_t' ( const uint16_t)
@@ -521,7 +581,7 @@
0:? 'float32_t_to_uint16_t' ( const uint16_t)
0:? 13 (const uint16_t)
0:? 'float64_t_to_uint16_t' ( const uint16_t)
-0:? 65532 (const uint16_t)
+0:? 4 (const uint16_t)
0:? 'bool_to_uint32_t' ( const uint)
0:? 1 (const uint)
0:? 'int8_t_to_uint32_t' ( const uint)
@@ -545,7 +605,7 @@
0:? 'float32_t_to_uint32_t' ( const uint)
0:? 13 (const uint)
0:? 'float64_t_to_uint32_t' ( const uint)
-0:? 4294967292 (const uint)
+0:? 4 (const uint)
0:? 'bool_to_uint64_t' ( const uint64_t)
0:? 1 (const uint64_t)
0:? 'int8_t_to_uint64_t' ( const uint64_t)
@@ -569,7 +629,7 @@
0:? 'float32_t_to_uint64_t' ( const uint64_t)
0:? 13 (const uint64_t)
0:? 'float64_t_to_uint64_t' ( const uint64_t)
-0:? 18446744073709551612 (const uint64_t)
+0:? 4 (const uint64_t)
0:? 'bool_to_float16_t' ( const float16_t)
0:? 1.000000
0:? 'int8_t_to_float16_t' ( const float16_t)
@@ -593,7 +653,7 @@
0:? 'float32_t_to_float16_t' ( const float16_t)
0:? 13.000000
0:? 'float64_t_to_float16_t' ( const float16_t)
-0:? -4.000000
+0:? 4.000000
0:? 'bool_to_float32_t' ( const float)
0:? 1.000000
0:? 'int8_t_to_float32_t' ( const float)
@@ -617,7 +677,7 @@
0:? 'float32_t_to_float32_t' ( const float)
0:? 13.000000
0:? 'float64_t_to_float32_t' ( const float)
-0:? -4.000000
+0:? 4.000000
0:? 'bool_to_float64_t' ( const double)
0:? 1.000000
0:? 'int8_t_to_float64_t' ( const double)
@@ -641,5 +701,53 @@
0:? 'float32_t_to_float64_t' ( const double)
0:? 13.000000
0:? 'float64_t_to_float64_t' ( const double)
+0:? 4.000000
+0:? 'neg_float16_t_to_bool' ( const bool)
+0:? true (const bool)
+0:? 'neg_float32_t_to_bool' ( const bool)
+0:? true (const bool)
+0:? 'neg_float64_t_to_bool' ( const bool)
+0:? true (const bool)
+0:? 'neg_float16_t_to_int8_t' ( const int8_t)
+0:? -42 (const int8_t)
+0:? 'neg_float32_t_to_int8_t' ( const int8_t)
+0:? -13 (const int8_t)
+0:? 'neg_float64_t_to_int8_t' ( const int8_t)
+0:? -4 (const int8_t)
+0:? 'neg_float16_t_to_int16_t' ( const int16_t)
+0:? -42 (const int16_t)
+0:? 'neg_float32_t_to_int16_t' ( const int16_t)
+0:? -13 (const int16_t)
+0:? 'neg_float64_t_to_int16_t' ( const int16_t)
+0:? -4 (const int16_t)
+0:? 'neg_float16_t_to_int32_t' ( const int)
+0:? -42 (const int)
+0:? 'neg_float32_t_to_int32_t' ( const int)
+0:? -13 (const int)
+0:? 'neg_float64_t_to_int32_t' ( const int)
+0:? -4 (const int)
+0:? 'neg_float16_t_to_int64_t' ( const int64_t)
+0:? -42 (const int64_t)
+0:? 'neg_float32_t_to_int64_t' ( const int64_t)
+0:? -13 (const int64_t)
+0:? 'neg_float64_t_to_int64_t' ( const int64_t)
+0:? -4 (const int64_t)
+0:? 'neg_float16_t_to_float16_t' ( const float16_t)
+0:? -42.000000
+0:? 'neg_float32_t_to_float16_t' ( const float16_t)
+0:? -13.000000
+0:? 'neg_float64_t_to_float16_t' ( const float16_t)
+0:? -4.000000
+0:? 'neg_float16_t_to_float32_t' ( const float)
+0:? -42.000000
+0:? 'neg_float32_t_to_float32_t' ( const float)
+0:? -13.000000
+0:? 'neg_float64_t_to_float32_t' ( const float)
+0:? -4.000000
+0:? 'neg_float16_t_to_float64_t' ( const double)
+0:? -42.000000
+0:? 'neg_float32_t_to_float64_t' ( const double)
+0:? -13.000000
+0:? 'neg_float64_t_to_float64_t' ( const double)
0:? -4.000000
diff --git a/Test/baseResults/coord_conventions.frag.out b/Test/baseResults/coord_conventions.frag.out
new file mode 100644
index 0000000..656c608
--- /dev/null
+++ b/Test/baseResults/coord_conventions.frag.out
@@ -0,0 +1,255 @@
+coord_conventions.frag
+Shader version: 140
+Requested GL_ARB_explicit_attrib_location
+Requested GL_ARB_fragment_coord_conventions
+gl_FragCoord pixel center is integer
+gl_FragCoord origin is upper left
+0:? Sequence
+0:17 Function Definition: main( ( global void)
+0:17 Function Parameters:
+0:19 Sequence
+0:19 move second child to first child ( temp 4-component vector of float)
+0:19 'myColor' (layout( location=0) out 4-component vector of float)
+0:19 Constant:
+0:19 0.200000
+0:19 0.200000
+0:19 0.200000
+0:19 0.200000
+0:20 Test condition and select ( temp void)
+0:20 Condition
+0:20 Compare Greater Than or Equal ( temp bool)
+0:20 direct index ( temp float)
+0:20 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:20 Constant:
+0:20 1 (const int)
+0:20 Constant:
+0:20 10.000000
+0:20 true case
+0:21 Sequence
+0:21 move second child to first child ( temp float)
+0:21 direct index ( temp float)
+0:21 'myColor' (layout( location=0) out 4-component vector of float)
+0:21 Constant:
+0:21 2 (const int)
+0:21 Constant:
+0:21 0.800000
+0:23 Test condition and select ( temp void)
+0:23 Condition
+0:23 Compare Equal ( temp bool)
+0:23 direct index ( temp float)
+0:23 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:23 Constant:
+0:23 1 (const int)
+0:23 trunc ( global float)
+0:23 direct index ( temp float)
+0:23 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:23 Constant:
+0:23 1 (const int)
+0:23 true case
+0:24 Sequence
+0:24 move second child to first child ( temp float)
+0:24 direct index ( temp float)
+0:24 'myColor' (layout( location=0) out 4-component vector of float)
+0:24 Constant:
+0:24 1 (const int)
+0:24 Constant:
+0:24 0.800000
+0:26 Test condition and select ( temp void)
+0:26 Condition
+0:26 Compare Equal ( temp bool)
+0:26 direct index ( temp float)
+0:26 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:26 Constant:
+0:26 0 (const int)
+0:26 trunc ( global float)
+0:26 direct index ( temp float)
+0:26 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:26 Constant:
+0:26 0 (const int)
+0:26 true case
+0:27 Sequence
+0:27 move second child to first child ( temp float)
+0:27 direct index ( temp float)
+0:27 'myColor' (layout( location=0) out 4-component vector of float)
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 0.800000
+0:30 Sequence
+0:30 move second child to first child ( temp 4-component vector of float)
+0:30 'diff' ( temp 4-component vector of float)
+0:30 subtract ( temp 4-component vector of float)
+0:30 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:30 'i' ( smooth in 4-component vector of float)
+0:31 Test condition and select ( temp void)
+0:31 Condition
+0:31 Compare Greater Than ( temp bool)
+0:31 Absolute value ( global float)
+0:31 direct index ( temp float)
+0:31 'diff' ( temp 4-component vector of float)
+0:31 Constant:
+0:31 2 (const int)
+0:31 Constant:
+0:31 0.001000
+0:31 true case
+0:32 move second child to first child ( temp float)
+0:32 direct index ( temp float)
+0:32 'myColor' (layout( location=0) out 4-component vector of float)
+0:32 Constant:
+0:32 2 (const int)
+0:32 Constant:
+0:32 0.500000
+0:33 Test condition and select ( temp void)
+0:33 Condition
+0:33 Compare Greater Than ( temp bool)
+0:33 Absolute value ( global float)
+0:33 direct index ( temp float)
+0:33 'diff' ( temp 4-component vector of float)
+0:33 Constant:
+0:33 3 (const int)
+0:33 Constant:
+0:33 0.001000
+0:33 true case
+0:34 move second child to first child ( temp float)
+0:34 direct index ( temp float)
+0:34 'myColor' (layout( location=0) out 4-component vector of float)
+0:34 Constant:
+0:34 3 (const int)
+0:34 Constant:
+0:34 0.500000
+0:? Linker Objects
+0:? 'i' ( smooth in 4-component vector of float)
+0:? 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:? 'myColor' (layout( location=0) out 4-component vector of float)
+0:? 'eps' ( const float)
+0:? 0.001000
+
+
+Linked fragment stage:
+
+
+Shader version: 140
+Requested GL_ARB_explicit_attrib_location
+Requested GL_ARB_fragment_coord_conventions
+gl_FragCoord pixel center is integer
+gl_FragCoord origin is upper left
+0:? Sequence
+0:17 Function Definition: main( ( global void)
+0:17 Function Parameters:
+0:19 Sequence
+0:19 move second child to first child ( temp 4-component vector of float)
+0:19 'myColor' (layout( location=0) out 4-component vector of float)
+0:19 Constant:
+0:19 0.200000
+0:19 0.200000
+0:19 0.200000
+0:19 0.200000
+0:20 Test condition and select ( temp void)
+0:20 Condition
+0:20 Compare Greater Than or Equal ( temp bool)
+0:20 direct index ( temp float)
+0:20 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:20 Constant:
+0:20 1 (const int)
+0:20 Constant:
+0:20 10.000000
+0:20 true case
+0:21 Sequence
+0:21 move second child to first child ( temp float)
+0:21 direct index ( temp float)
+0:21 'myColor' (layout( location=0) out 4-component vector of float)
+0:21 Constant:
+0:21 2 (const int)
+0:21 Constant:
+0:21 0.800000
+0:23 Test condition and select ( temp void)
+0:23 Condition
+0:23 Compare Equal ( temp bool)
+0:23 direct index ( temp float)
+0:23 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:23 Constant:
+0:23 1 (const int)
+0:23 trunc ( global float)
+0:23 direct index ( temp float)
+0:23 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:23 Constant:
+0:23 1 (const int)
+0:23 true case
+0:24 Sequence
+0:24 move second child to first child ( temp float)
+0:24 direct index ( temp float)
+0:24 'myColor' (layout( location=0) out 4-component vector of float)
+0:24 Constant:
+0:24 1 (const int)
+0:24 Constant:
+0:24 0.800000
+0:26 Test condition and select ( temp void)
+0:26 Condition
+0:26 Compare Equal ( temp bool)
+0:26 direct index ( temp float)
+0:26 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:26 Constant:
+0:26 0 (const int)
+0:26 trunc ( global float)
+0:26 direct index ( temp float)
+0:26 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:26 Constant:
+0:26 0 (const int)
+0:26 true case
+0:27 Sequence
+0:27 move second child to first child ( temp float)
+0:27 direct index ( temp float)
+0:27 'myColor' (layout( location=0) out 4-component vector of float)
+0:27 Constant:
+0:27 0 (const int)
+0:27 Constant:
+0:27 0.800000
+0:30 Sequence
+0:30 move second child to first child ( temp 4-component vector of float)
+0:30 'diff' ( temp 4-component vector of float)
+0:30 subtract ( temp 4-component vector of float)
+0:30 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:30 'i' ( smooth in 4-component vector of float)
+0:31 Test condition and select ( temp void)
+0:31 Condition
+0:31 Compare Greater Than ( temp bool)
+0:31 Absolute value ( global float)
+0:31 direct index ( temp float)
+0:31 'diff' ( temp 4-component vector of float)
+0:31 Constant:
+0:31 2 (const int)
+0:31 Constant:
+0:31 0.001000
+0:31 true case
+0:32 move second child to first child ( temp float)
+0:32 direct index ( temp float)
+0:32 'myColor' (layout( location=0) out 4-component vector of float)
+0:32 Constant:
+0:32 2 (const int)
+0:32 Constant:
+0:32 0.500000
+0:33 Test condition and select ( temp void)
+0:33 Condition
+0:33 Compare Greater Than ( temp bool)
+0:33 Absolute value ( global float)
+0:33 direct index ( temp float)
+0:33 'diff' ( temp 4-component vector of float)
+0:33 Constant:
+0:33 3 (const int)
+0:33 Constant:
+0:33 0.001000
+0:33 true case
+0:34 move second child to first child ( temp float)
+0:34 direct index ( temp float)
+0:34 'myColor' (layout( location=0) out 4-component vector of float)
+0:34 Constant:
+0:34 3 (const int)
+0:34 Constant:
+0:34 0.500000
+0:? Linker Objects
+0:? 'i' ( smooth in 4-component vector of float)
+0:? 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:? 'myColor' (layout( location=0) out 4-component vector of float)
+0:? 'eps' ( const float)
+0:? 0.001000
+
diff --git a/Test/baseResults/enhanced.0.frag.out b/Test/baseResults/enhanced.0.frag.out
new file mode 100644
index 0000000..1171bfa
--- /dev/null
+++ b/Test/baseResults/enhanced.0.frag.out
@@ -0,0 +1,6 @@
+enhanced.0.frag
+ERROR: enhanced.0.frag:7: ' vec4 constructor' : not enough data provided for construction
+ERROR: 1 compilation errors. No code generated.
+
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/enhanced.1.frag.out b/Test/baseResults/enhanced.1.frag.out
new file mode 100644
index 0000000..42f5b72
--- /dev/null
+++ b/Test/baseResults/enhanced.1.frag.out
@@ -0,0 +1,6 @@
+enhanced.1.frag
+ERROR: enhanced.1.frag:9: 'v2' : no such field in structure 'vVert'
+ERROR: 1 compilation errors. No code generated.
+
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/enhanced.2.frag.out b/Test/baseResults/enhanced.2.frag.out
new file mode 100644
index 0000000..a7e48de
--- /dev/null
+++ b/Test/baseResults/enhanced.2.frag.out
@@ -0,0 +1,6 @@
+enhanced.2.frag
+ERROR: enhanced.2.frag:5: ' vec3 constructor' : too many arguments
+ERROR: 1 compilation errors. No code generated.
+
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/enhanced.3.link.out b/Test/baseResults/enhanced.3.link.out
new file mode 100644
index 0000000..c0e6a20
--- /dev/null
+++ b/Test/baseResults/enhanced.3.link.out
@@ -0,0 +1,8 @@
+enhanced.3.vert
+enhanced.3.frag
+ERROR: Linking vertex and fragment stages: Member names and types must match:
+ Block: VS_OUT
+ vertex stage: " vec2 TexCoords"
+ fragment stage: " vec2 foobar"
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/enhanced.4.link.out b/Test/baseResults/enhanced.4.link.out
new file mode 100644
index 0000000..2c0acf4
--- /dev/null
+++ b/Test/baseResults/enhanced.4.link.out
@@ -0,0 +1,7 @@
+enhanced.4.vert
+enhanced.4.frag
+ERROR: Linking vertex and fragment stages: Layout location qualifier must match:
+ vertex stage: Block: VS_OUT Instance: vs_out: "layout( location=0) out"
+ fragment stage: Block: VS_OUT Instance: fs_in: "layout( location=1) in"
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/enhanced.5.link.out b/Test/baseResults/enhanced.5.link.out
new file mode 100644
index 0000000..929cfce
--- /dev/null
+++ b/Test/baseResults/enhanced.5.link.out
@@ -0,0 +1,8 @@
+enhanced.5.vert
+enhanced.5.frag
+ERROR: Linking vertex and fragment stages: Member names and types must match:
+ Block: VS_OUT
+ vertex stage: " vec2 TexCoords"
+ fragment stage: " vec3 TexCoords"
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/enhanced.6.link.out b/Test/baseResults/enhanced.6.link.out
new file mode 100644
index 0000000..9962628
--- /dev/null
+++ b/Test/baseResults/enhanced.6.link.out
@@ -0,0 +1,7 @@
+enhanced.6.vert
+enhanced.6.frag
+ERROR: Linking vertex and fragment stages: Array sizes must be compatible:
+ vertex stage: " VS_OUT{ vec2 TexCoords} vs_out[2]"
+ fragment stage: " VS_OUT{ vec2 TexCoords} fs_in[1]"
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/enhanced.7.link.out b/Test/baseResults/enhanced.7.link.out
new file mode 100644
index 0000000..a6333be
--- /dev/null
+++ b/Test/baseResults/enhanced.7.link.out
@@ -0,0 +1,7 @@
+enhanced.7.vert
+enhanced.7.frag
+ERROR: Linking vertex and fragment stages: vertex block member has no corresponding member in fragment block:
+ vertex stage: Block: Vertex, Member: ii
+ fragment stage: Block: Vertex, Member: n/a
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/floatBitsToInt.vert.out b/Test/baseResults/floatBitsToInt.vert.out
new file mode 100644
index 0000000..6d5185c
--- /dev/null
+++ b/Test/baseResults/floatBitsToInt.vert.out
@@ -0,0 +1,217 @@
+floatBitsToInt.vert
+WARNING: 0:2: '#extension' : extension is only partially supported: GL_ARB_gpu_shader5
+
+Shader version: 150
+Requested GL_ARB_gpu_shader5
+0:? Sequence
+0:6 Function Definition: main( ( global void)
+0:6 Function Parameters:
+0:8 Sequence
+0:8 move second child to first child ( temp 4-component vector of float)
+0:8 'result' ( smooth out 4-component vector of float)
+0:8 Constant:
+0:8 1.000000
+0:8 1.000000
+0:8 1.000000
+0:8 1.000000
+0:9 Sequence
+0:9 move second child to first child ( temp int)
+0:9 'ret_val' ( temp int)
+0:9 floatBitsToInt ( global int)
+0:9 'value' ( uniform float)
+0:10 Test condition and select ( temp void)
+0:10 Condition
+0:10 Compare Not Equal ( temp bool)
+0:10 'expected_value' ( uniform int)
+0:10 'ret_val' ( temp int)
+0:10 true case
+0:10 Sequence
+0:10 move second child to first child ( temp 4-component vector of float)
+0:10 'result' ( smooth out 4-component vector of float)
+0:10 Constant:
+0:10 0.000000
+0:10 0.000000
+0:10 0.000000
+0:10 0.000000
+0:12 switch
+0:12 condition
+0:12 'gl_VertexID' ( gl_VertexId int VertexId)
+0:12 body
+0:12 Sequence
+0:13 case: with expression
+0:13 Constant:
+0:13 0 (const int)
+0:? Sequence
+0:13 move second child to first child ( temp 4-component vector of float)
+0:13 gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:13 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:13 Constant:
+0:13 0 (const uint)
+0:13 Constant:
+0:13 -1.000000
+0:13 1.000000
+0:13 0.000000
+0:13 1.000000
+0:13 Branch: Break
+0:14 case: with expression
+0:14 Constant:
+0:14 1 (const int)
+0:? Sequence
+0:14 move second child to first child ( temp 4-component vector of float)
+0:14 gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:14 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:14 Constant:
+0:14 0 (const uint)
+0:14 Constant:
+0:14 1.000000
+0:14 1.000000
+0:14 0.000000
+0:14 1.000000
+0:14 Branch: Break
+0:15 case: with expression
+0:15 Constant:
+0:15 2 (const int)
+0:? Sequence
+0:15 move second child to first child ( temp 4-component vector of float)
+0:15 gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:15 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:15 Constant:
+0:15 0 (const uint)
+0:15 Constant:
+0:15 -1.000000
+0:15 -1.000000
+0:15 0.000000
+0:15 1.000000
+0:15 Branch: Break
+0:16 case: with expression
+0:16 Constant:
+0:16 3 (const int)
+0:? Sequence
+0:16 move second child to first child ( temp 4-component vector of float)
+0:16 gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:16 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:16 Constant:
+0:16 0 (const uint)
+0:16 Constant:
+0:16 1.000000
+0:16 -1.000000
+0:16 0.000000
+0:16 1.000000
+0:16 Branch: Break
+0:? Linker Objects
+0:? 'expected_value' ( uniform int)
+0:? 'value' ( uniform float)
+0:? 'result' ( smooth out 4-component vector of float)
+0:? 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out unsized 1-element array of float ClipDistance gl_ClipDistance})
+0:? 'gl_VertexID' ( gl_VertexId int VertexId)
+0:? 'gl_InstanceID' ( gl_InstanceId int InstanceId)
+
+
+Linked vertex stage:
+
+
+Shader version: 150
+Requested GL_ARB_gpu_shader5
+0:? Sequence
+0:6 Function Definition: main( ( global void)
+0:6 Function Parameters:
+0:8 Sequence
+0:8 move second child to first child ( temp 4-component vector of float)
+0:8 'result' ( smooth out 4-component vector of float)
+0:8 Constant:
+0:8 1.000000
+0:8 1.000000
+0:8 1.000000
+0:8 1.000000
+0:9 Sequence
+0:9 move second child to first child ( temp int)
+0:9 'ret_val' ( temp int)
+0:9 floatBitsToInt ( global int)
+0:9 'value' ( uniform float)
+0:10 Test condition and select ( temp void)
+0:10 Condition
+0:10 Compare Not Equal ( temp bool)
+0:10 'expected_value' ( uniform int)
+0:10 'ret_val' ( temp int)
+0:10 true case
+0:10 Sequence
+0:10 move second child to first child ( temp 4-component vector of float)
+0:10 'result' ( smooth out 4-component vector of float)
+0:10 Constant:
+0:10 0.000000
+0:10 0.000000
+0:10 0.000000
+0:10 0.000000
+0:12 switch
+0:12 condition
+0:12 'gl_VertexID' ( gl_VertexId int VertexId)
+0:12 body
+0:12 Sequence
+0:13 case: with expression
+0:13 Constant:
+0:13 0 (const int)
+0:? Sequence
+0:13 move second child to first child ( temp 4-component vector of float)
+0:13 gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:13 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out 1-element array of float ClipDistance gl_ClipDistance})
+0:13 Constant:
+0:13 0 (const uint)
+0:13 Constant:
+0:13 -1.000000
+0:13 1.000000
+0:13 0.000000
+0:13 1.000000
+0:13 Branch: Break
+0:14 case: with expression
+0:14 Constant:
+0:14 1 (const int)
+0:? Sequence
+0:14 move second child to first child ( temp 4-component vector of float)
+0:14 gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:14 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out 1-element array of float ClipDistance gl_ClipDistance})
+0:14 Constant:
+0:14 0 (const uint)
+0:14 Constant:
+0:14 1.000000
+0:14 1.000000
+0:14 0.000000
+0:14 1.000000
+0:14 Branch: Break
+0:15 case: with expression
+0:15 Constant:
+0:15 2 (const int)
+0:? Sequence
+0:15 move second child to first child ( temp 4-component vector of float)
+0:15 gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:15 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out 1-element array of float ClipDistance gl_ClipDistance})
+0:15 Constant:
+0:15 0 (const uint)
+0:15 Constant:
+0:15 -1.000000
+0:15 -1.000000
+0:15 0.000000
+0:15 1.000000
+0:15 Branch: Break
+0:16 case: with expression
+0:16 Constant:
+0:16 3 (const int)
+0:? Sequence
+0:16 move second child to first child ( temp 4-component vector of float)
+0:16 gl_Position: direct index for structure ( gl_Position 4-component vector of float Position)
+0:16 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out 1-element array of float ClipDistance gl_ClipDistance})
+0:16 Constant:
+0:16 0 (const uint)
+0:16 Constant:
+0:16 1.000000
+0:16 -1.000000
+0:16 0.000000
+0:16 1.000000
+0:16 Branch: Break
+0:? Linker Objects
+0:? 'expected_value' ( uniform int)
+0:? 'value' ( uniform float)
+0:? 'result' ( smooth out 4-component vector of float)
+0:? 'anon@0' ( out block{ gl_Position 4-component vector of float Position gl_Position, gl_PointSize float PointSize gl_PointSize, out 1-element array of float ClipDistance gl_ClipDistance})
+0:? 'gl_VertexID' ( gl_VertexId int VertexId)
+0:? 'gl_InstanceID' ( gl_InstanceId int InstanceId)
+
diff --git a/Test/baseResults/gl_FragCoord.frag.out b/Test/baseResults/gl_FragCoord.frag.out
new file mode 100644
index 0000000..da9e8dc
--- /dev/null
+++ b/Test/baseResults/gl_FragCoord.frag.out
@@ -0,0 +1,269 @@
+gl_FragCoord.frag
+Shader version: 150
+Requested GL_ARB_explicit_attrib_location
+gl_FragCoord pixel center is integer
+gl_FragCoord origin is upper left
+0:? Sequence
+0:9 Sequence
+0:9 move second child to first child ( temp float)
+0:9 'myGlobalVar' ( global float)
+0:9 direct index ( temp float)
+0:9 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:9 Constant:
+0:9 0 (const int)
+0:16 Function Definition: main( ( global void)
+0:16 Function Parameters:
+0:17 Sequence
+0:17 move second child to first child ( temp 4-component vector of float)
+0:17 'myColor' (layout( location=0) out 4-component vector of float)
+0:17 Constant:
+0:17 0.200000
+0:17 0.200000
+0:17 0.200000
+0:17 0.200000
+0:18 Test condition and select ( temp void)
+0:18 Condition
+0:18 Compare Greater Than or Equal ( temp bool)
+0:18 direct index ( temp float)
+0:18 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:18 Constant:
+0:18 1 (const int)
+0:18 Constant:
+0:18 10.000000
+0:18 true case
+0:19 Sequence
+0:19 move second child to first child ( temp float)
+0:19 direct index ( temp float)
+0:19 'myColor' (layout( location=0) out 4-component vector of float)
+0:19 Constant:
+0:19 2 (const int)
+0:19 Constant:
+0:19 0.800000
+0:21 Test condition and select ( temp void)
+0:21 Condition
+0:21 Compare Equal ( temp bool)
+0:21 direct index ( temp float)
+0:21 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:21 Constant:
+0:21 1 (const int)
+0:21 trunc ( global float)
+0:21 direct index ( temp float)
+0:21 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:21 Constant:
+0:21 1 (const int)
+0:21 true case
+0:22 Sequence
+0:22 move second child to first child ( temp float)
+0:22 direct index ( temp float)
+0:22 'myColor' (layout( location=0) out 4-component vector of float)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Constant:
+0:22 0.800000
+0:24 Test condition and select ( temp void)
+0:24 Condition
+0:24 Compare Equal ( temp bool)
+0:24 direct index ( temp float)
+0:24 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:24 Constant:
+0:24 0 (const int)
+0:24 trunc ( global float)
+0:24 direct index ( temp float)
+0:24 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:24 Constant:
+0:24 0 (const int)
+0:24 true case
+0:25 Sequence
+0:25 move second child to first child ( temp float)
+0:25 direct index ( temp float)
+0:25 'myColor' (layout( location=0) out 4-component vector of float)
+0:25 Constant:
+0:25 0 (const int)
+0:25 Constant:
+0:25 0.800000
+0:28 Sequence
+0:28 move second child to first child ( temp 4-component vector of float)
+0:28 'diff' ( temp 4-component vector of float)
+0:28 subtract ( temp 4-component vector of float)
+0:28 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:28 'i' ( smooth in 4-component vector of float)
+0:29 Test condition and select ( temp void)
+0:29 Condition
+0:29 Compare Greater Than ( temp bool)
+0:29 Absolute value ( global float)
+0:29 direct index ( temp float)
+0:29 'diff' ( temp 4-component vector of float)
+0:29 Constant:
+0:29 2 (const int)
+0:29 Constant:
+0:29 0.001000
+0:29 true case
+0:29 move second child to first child ( temp float)
+0:29 direct index ( temp float)
+0:29 'myColor' (layout( location=0) out 4-component vector of float)
+0:29 Constant:
+0:29 2 (const int)
+0:29 Constant:
+0:29 0.500000
+0:30 Test condition and select ( temp void)
+0:30 Condition
+0:30 Compare Greater Than ( temp bool)
+0:30 Absolute value ( global float)
+0:30 direct index ( temp float)
+0:30 'diff' ( temp 4-component vector of float)
+0:30 Constant:
+0:30 3 (const int)
+0:30 Constant:
+0:30 0.001000
+0:30 true case
+0:30 move second child to first child ( temp float)
+0:30 direct index ( temp float)
+0:30 'myColor' (layout( location=0) out 4-component vector of float)
+0:30 Constant:
+0:30 3 (const int)
+0:30 Constant:
+0:30 0.500000
+0:? Linker Objects
+0:? 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:? 'myGlobalVar' ( global float)
+0:? 'i' ( smooth in 4-component vector of float)
+0:? 'myColor' (layout( location=0) out 4-component vector of float)
+0:? 'eps' ( const float)
+0:? 0.001000
+
+
+Linked fragment stage:
+
+
+Shader version: 150
+Requested GL_ARB_explicit_attrib_location
+gl_FragCoord pixel center is integer
+gl_FragCoord origin is upper left
+0:? Sequence
+0:9 Sequence
+0:9 move second child to first child ( temp float)
+0:9 'myGlobalVar' ( global float)
+0:9 direct index ( temp float)
+0:9 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:9 Constant:
+0:9 0 (const int)
+0:16 Function Definition: main( ( global void)
+0:16 Function Parameters:
+0:17 Sequence
+0:17 move second child to first child ( temp 4-component vector of float)
+0:17 'myColor' (layout( location=0) out 4-component vector of float)
+0:17 Constant:
+0:17 0.200000
+0:17 0.200000
+0:17 0.200000
+0:17 0.200000
+0:18 Test condition and select ( temp void)
+0:18 Condition
+0:18 Compare Greater Than or Equal ( temp bool)
+0:18 direct index ( temp float)
+0:18 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:18 Constant:
+0:18 1 (const int)
+0:18 Constant:
+0:18 10.000000
+0:18 true case
+0:19 Sequence
+0:19 move second child to first child ( temp float)
+0:19 direct index ( temp float)
+0:19 'myColor' (layout( location=0) out 4-component vector of float)
+0:19 Constant:
+0:19 2 (const int)
+0:19 Constant:
+0:19 0.800000
+0:21 Test condition and select ( temp void)
+0:21 Condition
+0:21 Compare Equal ( temp bool)
+0:21 direct index ( temp float)
+0:21 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:21 Constant:
+0:21 1 (const int)
+0:21 trunc ( global float)
+0:21 direct index ( temp float)
+0:21 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:21 Constant:
+0:21 1 (const int)
+0:21 true case
+0:22 Sequence
+0:22 move second child to first child ( temp float)
+0:22 direct index ( temp float)
+0:22 'myColor' (layout( location=0) out 4-component vector of float)
+0:22 Constant:
+0:22 1 (const int)
+0:22 Constant:
+0:22 0.800000
+0:24 Test condition and select ( temp void)
+0:24 Condition
+0:24 Compare Equal ( temp bool)
+0:24 direct index ( temp float)
+0:24 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:24 Constant:
+0:24 0 (const int)
+0:24 trunc ( global float)
+0:24 direct index ( temp float)
+0:24 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:24 Constant:
+0:24 0 (const int)
+0:24 true case
+0:25 Sequence
+0:25 move second child to first child ( temp float)
+0:25 direct index ( temp float)
+0:25 'myColor' (layout( location=0) out 4-component vector of float)
+0:25 Constant:
+0:25 0 (const int)
+0:25 Constant:
+0:25 0.800000
+0:28 Sequence
+0:28 move second child to first child ( temp 4-component vector of float)
+0:28 'diff' ( temp 4-component vector of float)
+0:28 subtract ( temp 4-component vector of float)
+0:28 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:28 'i' ( smooth in 4-component vector of float)
+0:29 Test condition and select ( temp void)
+0:29 Condition
+0:29 Compare Greater Than ( temp bool)
+0:29 Absolute value ( global float)
+0:29 direct index ( temp float)
+0:29 'diff' ( temp 4-component vector of float)
+0:29 Constant:
+0:29 2 (const int)
+0:29 Constant:
+0:29 0.001000
+0:29 true case
+0:29 move second child to first child ( temp float)
+0:29 direct index ( temp float)
+0:29 'myColor' (layout( location=0) out 4-component vector of float)
+0:29 Constant:
+0:29 2 (const int)
+0:29 Constant:
+0:29 0.500000
+0:30 Test condition and select ( temp void)
+0:30 Condition
+0:30 Compare Greater Than ( temp bool)
+0:30 Absolute value ( global float)
+0:30 direct index ( temp float)
+0:30 'diff' ( temp 4-component vector of float)
+0:30 Constant:
+0:30 3 (const int)
+0:30 Constant:
+0:30 0.001000
+0:30 true case
+0:30 move second child to first child ( temp float)
+0:30 direct index ( temp float)
+0:30 'myColor' (layout( location=0) out 4-component vector of float)
+0:30 Constant:
+0:30 3 (const int)
+0:30 Constant:
+0:30 0.500000
+0:? Linker Objects
+0:? 'gl_FragCoord' ( gl_FragCoord 4-component vector of float FragCoord)
+0:? 'myGlobalVar' ( global float)
+0:? 'i' ( smooth in 4-component vector of float)
+0:? 'myColor' (layout( location=0) out 4-component vector of float)
+0:? 'eps' ( const float)
+0:? 0.001000
+
diff --git a/Test/baseResults/glsl.460.subgroupEXT.mesh.out b/Test/baseResults/glsl.460.subgroupEXT.mesh.out
new file mode 100644
index 0000000..8d45106
--- /dev/null
+++ b/Test/baseResults/glsl.460.subgroupEXT.mesh.out
@@ -0,0 +1,1039 @@
+glsl.460.subgroupEXT.mesh
+ERROR: 0:6: 'gl_SubgroupSize' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:7: 'gl_SubgroupInvocationID' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:8: 'subgroupBarrier' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:9: 'subgroupMemoryBarrier' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:10: 'subgroupMemoryBarrierBuffer' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:11: 'subgroupMemoryBarrierImage' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:12: 'subgroupElect' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:13: 'gl_NumSubgroups' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:14: 'gl_SubgroupID' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:15: 'subgroupMemoryBarrierShared' : required extension not requested: GL_KHR_shader_subgroup_basic
+ERROR: 0:17: 'subgroupAll' : required extension not requested: GL_KHR_shader_subgroup_vote
+ERROR: 0:18: 'subgroupAny' : required extension not requested: GL_KHR_shader_subgroup_vote
+ERROR: 0:19: 'subgroupAllEqual' : required extension not requested: GL_KHR_shader_subgroup_vote
+ERROR: 0:21: 'gl_SubgroupEqMask' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:22: 'gl_SubgroupGeMask' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:23: 'gl_SubgroupGtMask' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:24: 'gl_SubgroupLeMask' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:25: 'gl_SubgroupLtMask' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:26: 'subgroupBroadcast' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:27: 'subgroupBroadcastFirst' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:28: 'subgroupBallot' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:29: 'subgroupInverseBallot' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:30: 'subgroupBallotBitExtract' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:31: 'subgroupBallotBitCount' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:32: 'subgroupBallotInclusiveBitCount' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:33: 'subgroupBallotExclusiveBitCount' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:34: 'subgroupBallotFindLSB' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:35: 'subgroupBallotFindMSB' : required extension not requested: GL_KHR_shader_subgroup_ballot
+ERROR: 0:37: 'subgroupShuffle' : required extension not requested: GL_KHR_shader_subgroup_shuffle
+ERROR: 0:38: 'subgroupShuffleXor' : required extension not requested: GL_KHR_shader_subgroup_shuffle
+ERROR: 0:39: 'subgroupShuffleUp' : required extension not requested: GL_KHR_shader_subgroup_shuffle_relative
+ERROR: 0:40: 'subgroupShuffleDown' : required extension not requested: GL_KHR_shader_subgroup_shuffle_relative
+ERROR: 0:42: 'subgroupAdd' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:43: 'subgroupMul' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:44: 'subgroupMin' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:45: 'subgroupMax' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:46: 'subgroupAnd' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:47: 'subgroupOr' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:48: 'subgroupXor' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:49: 'subgroupInclusiveAdd' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:50: 'subgroupInclusiveMul' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:51: 'subgroupInclusiveMin' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:52: 'subgroupInclusiveMax' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:53: 'subgroupInclusiveAnd' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:54: 'subgroupInclusiveOr' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:55: 'subgroupInclusiveXor' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:56: 'subgroupExclusiveAdd' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:57: 'subgroupExclusiveMul' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:58: 'subgroupExclusiveMin' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:59: 'subgroupExclusiveMax' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:60: 'subgroupExclusiveAnd' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:61: 'subgroupExclusiveOr' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:62: 'subgroupExclusiveXor' : required extension not requested: GL_KHR_shader_subgroup_arithmetic
+ERROR: 0:64: 'subgroupClusteredAdd' : required extension not requested: GL_KHR_shader_subgroup_clustered
+ERROR: 0:65: 'subgroupClusteredMul' : required extension not requested: GL_KHR_shader_subgroup_clustered
+ERROR: 0:66: 'subgroupClusteredMin' : required extension not requested: GL_KHR_shader_subgroup_clustered
+ERROR: 0:67: 'subgroupClusteredMax' : required extension not requested: GL_KHR_shader_subgroup_clustered
+ERROR: 0:68: 'subgroupClusteredAnd' : required extension not requested: GL_KHR_shader_subgroup_clustered
+ERROR: 0:69: 'subgroupClusteredOr' : required extension not requested: GL_KHR_shader_subgroup_clustered
+ERROR: 0:70: 'subgroupClusteredXor' : required extension not requested: GL_KHR_shader_subgroup_clustered
+ERROR: 0:72: 'subgroupQuadBroadcast' : required extension not requested: GL_KHR_shader_subgroup_quad
+ERROR: 0:73: 'subgroupQuadSwapHorizontal' : required extension not requested: GL_KHR_shader_subgroup_quad
+ERROR: 0:74: 'subgroupQuadSwapVertical' : required extension not requested: GL_KHR_shader_subgroup_quad
+ERROR: 0:75: 'subgroupQuadSwapDiagonal' : required extension not requested: GL_KHR_shader_subgroup_quad
+ERROR: 64 compilation errors. No code generated.
+
+
+Shader version: 460
+Requested GL_EXT_mesh_shader
+Requested GL_KHR_shader_subgroup_arithmetic
+Requested GL_KHR_shader_subgroup_ballot
+Requested GL_KHR_shader_subgroup_basic
+Requested GL_KHR_shader_subgroup_clustered
+Requested GL_KHR_shader_subgroup_quad
+Requested GL_KHR_shader_subgroup_shuffle
+Requested GL_KHR_shader_subgroup_shuffle_relative
+Requested GL_KHR_shader_subgroup_vote
+max_vertices = 81
+max_primitives = 32
+output primitive = triangles
+local_size = (32, 1, 1)
+ERROR: node is still EOpNull!
+0:3 Function Definition: undeclared_errors(vf4; ( global 4-component vector of float)
+0:3 Function Parameters:
+0:3 'f4' ( in 4-component vector of float)
+0:? Sequence
+0:6 'gl_SubgroupSize' ( in uint SubgroupSize)
+0:7 'gl_SubgroupInvocationID' ( in uint SubgroupInvocationID)
+0:8 subgroupBarrier ( global void)
+0:9 subgroupMemoryBarrier ( global void)
+0:10 subgroupMemoryBarrierBuffer ( global void)
+0:11 subgroupMemoryBarrierImage ( global void)
+0:12 subgroupElect ( global bool)
+0:13 'gl_NumSubgroups' ( in uint NumSubgroups)
+0:14 'gl_SubgroupID' ( in uint SubgroupID)
+0:15 subgroupMemoryBarrierShared ( global void)
+0:17 subgroupAll ( global bool)
+0:17 Constant:
+0:17 true (const bool)
+0:18 subgroupAny ( global bool)
+0:18 Constant:
+0:18 false (const bool)
+0:19 subgroupAllEqual ( global bool)
+0:19 'f4' ( in 4-component vector of float)
+0:21 'gl_SubgroupEqMask' ( in 4-component vector of uint SubgroupEqMask)
+0:22 'gl_SubgroupGeMask' ( in 4-component vector of uint SubgroupGeMask)
+0:23 'gl_SubgroupGtMask' ( in 4-component vector of uint SubgroupGtMask)
+0:24 'gl_SubgroupLeMask' ( in 4-component vector of uint SubgroupLeMask)
+0:25 'gl_SubgroupLtMask' ( in 4-component vector of uint SubgroupLtMask)
+0:26 subgroupBroadcast ( global 4-component vector of float)
+0:26 'f4' ( in 4-component vector of float)
+0:26 Constant:
+0:26 0 (const uint)
+0:27 subgroupBroadcastFirst ( global 4-component vector of float)
+0:27 'f4' ( in 4-component vector of float)
+0:28 Sequence
+0:28 move second child to first child ( temp 4-component vector of uint)
+0:28 'ballot' ( temp 4-component vector of uint)
+0:28 subgroupBallot ( global 4-component vector of uint)
+0:28 Constant:
+0:28 false (const bool)
+0:29 subgroupInverseBallot ( global bool)
+0:29 Constant:
+0:29 1 (const uint)
+0:29 1 (const uint)
+0:29 1 (const uint)
+0:29 1 (const uint)
+0:30 subgroupBallotBitExtract ( global bool)
+0:30 'ballot' ( temp 4-component vector of uint)
+0:30 Constant:
+0:30 0 (const uint)
+0:31 subgroupBallotBitCount ( global uint)
+0:31 'ballot' ( temp 4-component vector of uint)
+0:32 subgroupBallotInclusiveBitCount ( global uint)
+0:32 'ballot' ( temp 4-component vector of uint)
+0:33 subgroupBallotExclusiveBitCount ( global uint)
+0:33 'ballot' ( temp 4-component vector of uint)
+0:34 subgroupBallotFindLSB ( global uint)
+0:34 'ballot' ( temp 4-component vector of uint)
+0:35 subgroupBallotFindMSB ( global uint)
+0:35 'ballot' ( temp 4-component vector of uint)
+0:37 subgroupShuffle ( global 4-component vector of float)
+0:37 'f4' ( in 4-component vector of float)
+0:37 Constant:
+0:37 0 (const uint)
+0:38 subgroupShuffleXor ( global 4-component vector of float)
+0:38 'f4' ( in 4-component vector of float)
+0:38 Constant:
+0:38 1 (const uint)
+0:39 subgroupShuffleUp ( global 4-component vector of float)
+0:39 'f4' ( in 4-component vector of float)
+0:39 Constant:
+0:39 1 (const uint)
+0:40 subgroupShuffleDown ( global 4-component vector of float)
+0:40 'f4' ( in 4-component vector of float)
+0:40 Constant:
+0:40 1 (const uint)
+0:42 move second child to first child ( temp 4-component vector of float)
+0:42 'result' ( temp 4-component vector of float)
+0:42 subgroupAdd ( global 4-component vector of float)
+0:42 'f4' ( in 4-component vector of float)
+0:43 subgroupMul ( global 4-component vector of float)
+0:43 'f4' ( in 4-component vector of float)
+0:44 subgroupMin ( global 4-component vector of float)
+0:44 'f4' ( in 4-component vector of float)
+0:45 subgroupMax ( global 4-component vector of float)
+0:45 'f4' ( in 4-component vector of float)
+0:46 subgroupAnd ( global 4-component vector of uint)
+0:46 'ballot' ( temp 4-component vector of uint)
+0:47 subgroupOr ( global 4-component vector of uint)
+0:47 'ballot' ( temp 4-component vector of uint)
+0:48 subgroupXor ( global 4-component vector of uint)
+0:48 'ballot' ( temp 4-component vector of uint)
+0:49 subgroupInclusiveAdd ( global 4-component vector of float)
+0:49 'f4' ( in 4-component vector of float)
+0:50 subgroupInclusiveMul ( global 4-component vector of float)
+0:50 'f4' ( in 4-component vector of float)
+0:51 subgroupInclusiveMin ( global 4-component vector of float)
+0:51 'f4' ( in 4-component vector of float)
+0:52 subgroupInclusiveMax ( global 4-component vector of float)
+0:52 'f4' ( in 4-component vector of float)
+0:53 subgroupInclusiveAnd ( global 4-component vector of uint)
+0:53 'ballot' ( temp 4-component vector of uint)
+0:54 subgroupInclusiveOr ( global 4-component vector of uint)
+0:54 'ballot' ( temp 4-component vector of uint)
+0:55 subgroupInclusiveXor ( global 4-component vector of uint)
+0:55 'ballot' ( temp 4-component vector of uint)
+0:56 subgroupExclusiveAdd ( global 4-component vector of float)
+0:56 'f4' ( in 4-component vector of float)
+0:57 subgroupExclusiveMul ( global 4-component vector of float)
+0:57 'f4' ( in 4-component vector of float)
+0:58 subgroupExclusiveMin ( global 4-component vector of float)
+0:58 'f4' ( in 4-component vector of float)
+0:59 subgroupExclusiveMax ( global 4-component vector of float)
+0:59 'f4' ( in 4-component vector of float)
+0:60 subgroupExclusiveAnd ( global 4-component vector of uint)
+0:60 'ballot' ( temp 4-component vector of uint)
+0:61 subgroupExclusiveOr ( global 4-component vector of uint)
+0:61 'ballot' ( temp 4-component vector of uint)
+0:62 subgroupExclusiveXor ( global 4-component vector of uint)
+0:62 'ballot' ( temp 4-component vector of uint)
+0:64 subgroupClusteredAdd ( global 4-component vector of float)
+0:64 'f4' ( in 4-component vector of float)
+0:64 Constant:
+0:64 2 (const uint)
+0:65 subgroupClusteredMul ( global 4-component vector of float)
+0:65 'f4' ( in 4-component vector of float)
+0:65 Constant:
+0:65 2 (const uint)
+0:66 subgroupClusteredMin ( global 4-component vector of float)
+0:66 'f4' ( in 4-component vector of float)
+0:66 Constant:
+0:66 2 (const uint)
+0:67 subgroupClusteredMax ( global 4-component vector of float)
+0:67 'f4' ( in 4-component vector of float)
+0:67 Constant:
+0:67 2 (const uint)
+0:68 subgroupClusteredAnd ( global 4-component vector of uint)
+0:68 'ballot' ( temp 4-component vector of uint)
+0:68 Constant:
+0:68 2 (const uint)
+0:69 subgroupClusteredOr ( global 4-component vector of uint)
+0:69 'ballot' ( temp 4-component vector of uint)
+0:69 Constant:
+0:69 2 (const uint)
+0:70 subgroupClusteredXor ( global 4-component vector of uint)
+0:70 'ballot' ( temp 4-component vector of uint)
+0:70 Constant:
+0:70 2 (const uint)
+0:72 subgroupQuadBroadcast ( global 4-component vector of float)
+0:72 'f4' ( in 4-component vector of float)
+0:72 Constant:
+0:72 0 (const uint)
+0:73 subgroupQuadSwapHorizontal ( global 4-component vector of float)
+0:73 'f4' ( in 4-component vector of float)
+0:74 subgroupQuadSwapVertical ( global 4-component vector of float)
+0:74 'f4' ( in 4-component vector of float)
+0:75 subgroupQuadSwapDiagonal ( global 4-component vector of float)
+0:75 'f4' ( in 4-component vector of float)
+0:77 Branch: Return with expression
+0:77 'result' ( temp 4-component vector of float)
+0:97 Function Definition: main( ( global void)
+0:97 Function Parameters:
+0:99 Sequence
+0:99 Sequence
+0:99 move second child to first child ( temp uint)
+0:99 'iid' ( temp uint)
