Merge remote-tracking branch 'aosp/upstream-master'
Pulls in the following:
27d98e2 Merge pull request #181 from antiagainst/readme
29ca6f9 Use footnotes for links in README.md.
4897864 Grammar update: OpPhi now uses PairIdRefIdRef as the last operand.
11636fb Update the core grammar.
469f0e8 Make paths to grammar output files
8ba7c92 Remove revision from SPV_ENV_*.
670c0ac Allow to only build certain grammar tables.
051e067 Remove the outdated patch file.
7649c73 Fix MSVC error C2797.
80e416c Use JSON grammar files to generate extended instruction sets.
9ca2d6d Rname grammar.json to spirv.core.grammar.json and add version info.
3fb2676 Fix validation of array length.
6fa3f8a Remove dependency on SPIR-V headers in libspirv.h.
d03c0a1 Enable linking against libSPIRV-Tools from linux shared libraries
c9b2285 Fix spelling mistakes
4f293b7 Use the JSON grammar file to generate various info tables.
a1de2b3 Handle CRLF in assembly text.
3d27da4 Add a target environment to spvContextCreate().
6836e17 OpExecutionMode only takes a single ExecutionMode
4529146 Capability fix: ImageReadWrite & ImageMipmap require ImageBasic.
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 11f5379..bd80545 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -29,6 +29,8 @@
enable_testing()
set(SPIRV_TOOLS "SPIRV-Tools")
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
if("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux")
add_definitions(-DSPIRV_LINUX)
elseif("${CMAKE_SYSTEM_NAME}" STREQUAL "Windows")
@@ -135,6 +137,18 @@
${spirv-tools_SOURCE_DIR}
COMMENT "Update build-version.inc in the Spirv-tools build directory (if necessary).")
+add_custom_target(spirv-tools-build-tables
+ ${PYTHON_EXECUTABLE}
+ ${CMAKE_CURRENT_SOURCE_DIR}/utils/generate_grammar_tables.py
+ --spirv-core-grammar=${spirv-tools_SOURCE_DIR}/source/spirv.core.grammar.json
+ --extinst-glsl-grammar=${spirv-tools_SOURCE_DIR}/source/extinst.glsl.std.450.grammar.json
+ --extinst-opencl-grammar=${spirv-tools_SOURCE_DIR}/source/extinst.opencl.std.grammar.json
+ --core-insts-output=${spirv-tools_BINARY_DIR}/core.insts.inc
+ --glsl-insts-output=${spirv-tools_BINARY_DIR}/glsl.std.450.insts.inc
+ --opencl-insts-output=${spirv-tools_BINARY_DIR}/opencl.std.insts.inc
+ --operand-kinds-output=${spirv-tools_BINARY_DIR}/operand.kinds.inc
+ COMMENT "Generate info tables for SPIR-V instructions and operands.")
+
# Defaults to OFF if the user didn't set it.
option(SPIRV_SKIP_EXECUTABLES
"Skip building the executable and tests along with the library"
@@ -149,9 +163,3 @@
install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/spirv-tools/libspirv.h
DESTINATION include/spirv-tools/)
-# The installation is broken without these header files from the SPIR-V Registry.
-# The libspirv.h header includes them.
-install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/spirv/spirv.h
- ${CMAKE_CURRENT_SOURCE_DIR}/include/spirv/GLSL.std.450.h
- ${CMAKE_CURRENT_SOURCE_DIR}/include/spirv/OpenCL.std.h
- DESTINATION include/spirv/)
diff --git a/README.md b/README.md
index 18f5368..f4edf57 100644
--- a/README.md
+++ b/README.md
@@ -15,8 +15,8 @@
The interfaces are still under development, and are expected to change.
SPIR-V is defined by the Khronos Group Inc.
-See the [SPIR-V Registry](https://www.khronos.org/registry/spir-v/) for the
-SPIR-V specification, headers, and XML registry.
+See the [SPIR-V Registry][spirv-registry] for the SPIR-V specification,
+headers, and XML registry.
## Supported features
@@ -38,12 +38,12 @@
## Source code
The SPIR-V Tools are maintained by members of the The Khronos Group Inc.,
-at [https://github.com/KhronosGroup/SPIRV-Tools](https://github.com/KhronosGroup/SPIRV-Tools).
+at https://github.com/KhronosGroup/SPIRV-Tools.
Contributions via merge request are welcome. Changes should:
* Be provided under the [Khronos license](#license).
* Include tests to cover updated functionality.
-* C++ code should follow the [Google C++ Style Guide](https://google.github.io/styleguide/cppguide.html).
+* C++ code should follow the [Google C++ Style Guide][cpp-style-guide].
* Code should be formatted with `clang-format`. Settings are defined by
the included [.clang-format](.clang-format) file.
@@ -52,22 +52,20 @@
### Source code organization
* `external/googletest`: Intended location for the
- [googletest](https://github.com/google/googletest) sources, not provided
-* `include/` : API clients should add this directory to the include search
- path
+ [googletest][googletest] sources, not provided
+* `include/`: API clients should add this directory to the include search path
* `include/spirv-tools/libspirv.h`: C API public interface
* `include/spirv/` : Contains header files from the SPIR-V Registry, required
by the public API.
* `source/`: API implementation
-* `test/`: Tests, using the [googletest](https://github.com/google/googletest)
- framework.
+* `test/`: Tests, using the [googletest][googletest] framework
* `tools/`: Command line executables
### Tests
The project contains a number of tests, used to drive development
and ensure correctness. The tests are written using the
-[googletest](https://github.com/google/googletest) framework. The `googletest`
+[googletest][googletest] framework. The `googletest`
source is not provided with this project. There are two ways to enable
tests:
* If SPIR-V Tools is configured as part of an enclosing project, then the
@@ -77,16 +75,14 @@
configuring and building the project.
*Note*: You must use a version of googletest that includes
-[a fix](https://github.com/google/googletest/pull/612) for
-[googletest issue 610](https://github.com/google/googletest/issues/610).
+[a fix][googletest-pull-612] for [googletest issue 610][googletest-issue-610].
The fix is included on the googletest master branch any time after 2015-11-10.
In particular, googletest must be newer than version 1.7.0.
## Build
-The project uses [CMake](https://cmake.org/) to generate platform-specific
-build configurations. To generate these build files, issue the following
-commands:
+The project uses [CMake][cmake] to generate platform-specific build
+configurations. To generate these build files, issue the following commands:
```
mkdir <spirv-dir>/build
@@ -104,10 +100,9 @@
* `SPIRV_COLOR_TERMINAL={ON|OFF}`, default `ON` - Enables color console output.
* `SPIRV_SKIP_EXECUTABLES={ON|OFF}`, default `OFF`- Build only the library, not
the command line tools. This will also prevent the tests from being built.
-* `SPIRV_USE_SANITIZER=<sanitizer>`, default is no sanitizing - On UNIX platforms
- with an appropriate version of `clang` this option enables the use of the
- sanitizers documented
- [here](http://clang.llvm.org/docs/UsersManual.html#controlling-code-generation).
+* `SPIRV_USE_SANITIZER=<sanitizer>`, default is no sanitizing - On UNIX
+ platforms with an appropriate version of `clang` this option enables the use
+ of the sanitizers documented [here][clang-sanitizers].
This should only be used with a debug build.
* `SPIRV_WARN_EVERYTHING={ON|OFF}`, default `OFF` - On UNIX platforms enable
more strict warnings. The code might not compile with this option enabled.
@@ -123,10 +118,10 @@
The library provides a C API, but the internals use C++11.
-In order to use the library from an application, the include path should point to
-`<spirv-dir>/include`, which will enable the application to include the header
-`<spirv-dir>/include/libspirv/libspirv.h` then linking against the static
-library in `<spirv-build-dir>/libSPIRV-Tools.a` or
+In order to use the library from an application, the include path should point
+to `<spirv-dir>/include`, which will enable the application to include the
+header `<spirv-dir>/include/libspirv/libspirv.h` then linking against the
+static library in `<spirv-build-dir>/libSPIRV-Tools.a` or
`<spirv-build-dir>/SPIRV-Tools.lib`.
* `SPIRV-Tools` CMake target: Creates the static library:
@@ -250,3 +245,11 @@
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
```
+
+[spirv-registry]: https://www.khronos.org/registry/spir-v/
+[googletest]: https://github.com/google/googletest
+[googletest-pull-612]: https://github.com/google/googletest/pull/612
+[googletest-issue-610]: https://github.com/google/googletest/issues/610
+[CMake]: https://cmake.org/
+[cpp-style-guide]: https://google.github.io/styleguide/cppguide.html
+[clang-sanitizers]: http://clang.llvm.org/docs/UsersManual.html#controlling-code-generation
diff --git a/include/spirv-tools/libspirv.h b/include/spirv-tools/libspirv.h
index ac44ae8..3a2f2d6 100644
--- a/include/spirv-tools/libspirv.h
+++ b/include/spirv-tools/libspirv.h
@@ -27,10 +27,6 @@
#ifndef SPIRV_TOOLS_LIBSPIRV_H_
#define SPIRV_TOOLS_LIBSPIRV_H_
-#include "spirv/GLSL.std.450.h"
-#include "spirv/OpenCL.std.h"
-#include "spirv/spirv.h"
-
#ifdef __cplusplus
extern "C" {
#else
@@ -40,18 +36,8 @@
#include <stddef.h>
#include <stdint.h>
-// Versions
-// This library is based on SPIR-V 1.0 Rev2
-// TODO(dneto): Use the values from the SPIR-V header, when it's updated for
-// SPIR-V 1.0 public release.
-#define SPV_SPIRV_VERSION_MAJOR (SPV_VERSION >> 16)
-#define SPV_SPIRV_VERSION_MINOR (SPV_VERSION & 0xffff)
-#define SPV_SPIRV_VERSION_REVISION (SPV_REVISION)
-
// Helpers
-#define spvIsInBitfield(value, bitfield) ((value) == ((value)&bitfield))
-
#define SPV_BIT(shift) (1 << (shift))
#define SPV_FORCE_16_BIT_ENUM(name) _##name = 0x7fff
@@ -205,8 +191,6 @@
SPV_OPERAND_TYPE_OPTIONAL_TYPED_LITERAL_INTEGER,
// An optional literal string.
SPV_OPERAND_TYPE_OPTIONAL_LITERAL_STRING,
- // An optional execution mode.
- SPV_OPERAND_TYPE_OPTIONAL_EXECUTION_MODE,
// An optional access qualifier
SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER,
// An optional context-independent value, or CIV. CIVs are tokens that we can
@@ -225,9 +209,7 @@
// where the literal number must always be an integer of some sort.
SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER_ID,
// A sequence of zero or more pairs of (Id, Literal integer)
- SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_INTEGER,
- // A sequence of zero or more execution modes
- LAST_VARIABLE(SPV_OPERAND_TYPE_VARIABLE_EXECUTION_MODE),
+ LAST_VARIABLE(SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_INTEGER),
// This is a sentinel value, and does not represent an operand type.
// It should come last.
@@ -291,7 +273,7 @@
const uint32_t* words;
// The number of words in this instruction.
uint16_t num_words;
- SpvOp opcode;
+ uint16_t opcode;
// The extended instruction type, if opcode is OpExtInst. Otherwise
// this is the "none" value.
spv_ext_inst_type_t ext_inst_type;
@@ -347,8 +329,19 @@
// Platform API
-// Creates a context object.
-spv_context spvContextCreate();
+// Certain target environments impose additional restrictions on SPIR-V, so it's
+// often necessary to specify which one applies. SPV_ENV_UNIVERSAL means
+// environment-agnostic SPIR-V.
+typedef enum {
+ SPV_ENV_UNIVERSAL_1_0, // SPIR-V 1.0 latest revision, no other restrictions.
+ SPV_ENV_VULKAN_1_0, // Vulkan 1.0 latest revision.
+} spv_target_env;
+
+// Returns a string describing the given SPIR-V target environment.
+const char* spvTargetEnvDescription(spv_target_env env);
+
+// Creates a context object. Returns null if env is invalid.
+spv_context spvContextCreate(spv_target_env env);
// Destroys the given context object.
void spvContextDestroy(spv_context context);
@@ -377,10 +370,11 @@
// pointer.
void spvBinaryDestroy(spv_binary binary);
-// Validates a SPIR-V binary for correctness.
+// Validates a SPIR-V binary for correctness. Any errors will be written into
+// *diagnostic.
spv_result_t spvValidate(const spv_const_context context,
const spv_const_binary binary,
- spv_diagnostic* pDiagnostic);
+ spv_diagnostic* diagnostic);
// Creates a diagnostic object. The position parameter specifies the location in
// the text/binary stream. The message parameter, copied into the diagnostic
diff --git a/source/CMakeLists.txt b/source/CMakeLists.txt
index ca8ee89..e3b14a7 100644
--- a/source/CMakeLists.txt
+++ b/source/CMakeLists.txt
@@ -29,6 +29,7 @@
${spirv-tools_SOURCE_DIR}/include/spirv/spirv.h
${spirv-tools_SOURCE_DIR}/include/spirv/GLSL.std.450.h
${spirv-tools_SOURCE_DIR}/include/spirv/OpenCL.std.h
+
${CMAKE_CURRENT_SOURCE_DIR}/util/bitutils.h
${CMAKE_CURRENT_SOURCE_DIR}/util/hex_float.h
${CMAKE_CURRENT_SOURCE_DIR}/assembly_grammar.h
@@ -46,16 +47,18 @@
${CMAKE_CURRENT_SOURCE_DIR}/text.h
${CMAKE_CURRENT_SOURCE_DIR}/text_handler.h
${CMAKE_CURRENT_SOURCE_DIR}/validate.h
+
${CMAKE_CURRENT_SOURCE_DIR}/assembly_grammar.cpp
${CMAKE_CURRENT_SOURCE_DIR}/binary.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/disassemble.cpp
${CMAKE_CURRENT_SOURCE_DIR}/diagnostic.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/disassemble.cpp
${CMAKE_CURRENT_SOURCE_DIR}/ext_inst.cpp
${CMAKE_CURRENT_SOURCE_DIR}/instruction.cpp
${CMAKE_CURRENT_SOURCE_DIR}/opcode.cpp
${CMAKE_CURRENT_SOURCE_DIR}/operand.cpp
${CMAKE_CURRENT_SOURCE_DIR}/print.cpp
${CMAKE_CURRENT_SOURCE_DIR}/spirv_endian.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/spirv_target_env.cpp
${CMAKE_CURRENT_SOURCE_DIR}/table.cpp
${CMAKE_CURRENT_SOURCE_DIR}/text.cpp
${CMAKE_CURRENT_SOURCE_DIR}/text_handler.cpp
@@ -69,7 +72,11 @@
add_library(${SPIRV_TOOLS} ${SPIRV_SOURCES})
spvtools_default_compile_options(${SPIRV_TOOLS})
-target_include_directories(${SPIRV_TOOLS} PUBLIC ${spirv-tools_SOURCE_DIR}/include)
+target_include_directories(${SPIRV_TOOLS}
+ PUBLIC ${spirv-tools_SOURCE_DIR}/include
+ PRIVATE ${spirv-tools_BINARY_DIR}
+ )
+add_dependencies(${SPIRV_TOOLS} spirv-tools-build-tables)
install(TARGETS ${SPIRV_TOOLS}
RUNTIME DESTINATION bin
diff --git a/source/assembly_grammar.h b/source/assembly_grammar.h
index 3364f71..56ff226 100644
--- a/source/assembly_grammar.h
+++ b/source/assembly_grammar.h
@@ -29,6 +29,7 @@
#include "operand.h"
#include "spirv-tools/libspirv.h"
+#include "spirv/spirv.h"
#include "table.h"
namespace libspirv {
@@ -38,13 +39,17 @@
class AssemblyGrammar {
public:
explicit AssemblyGrammar(const spv_const_context context)
- : operandTable_(context->operand_table),
+ : target_env_(context->target_env),
+ operandTable_(context->operand_table),
opcodeTable_(context->opcode_table),
extInstTable_(context->ext_inst_table) {}
// Returns true if the internal tables have been initialized with valid data.
bool isValid() const;
+ // Returns the SPIR-V target environment.
+ spv_target_env target_env() const { return target_env_; }
+
// Fills in the desc parameter with the information about the opcode
// of the given name. Returns SPV_SUCCESS if the opcode was found, and
// SPV_ERROR_INVALID_LOOKUP if the opcode does not exist.
@@ -115,6 +120,7 @@
spv_operand_pattern_t* pattern) const;
private:
+ const spv_target_env target_env_;
const spv_operand_table operandTable_;
const spv_opcode_table opcodeTable_;
const spv_ext_inst_table extInstTable_;
diff --git a/source/binary.cpp b/source/binary.cpp
index 5c6aa8f..b3cdc33 100644
--- a/source/binary.cpp
+++ b/source/binary.cpp
@@ -300,8 +300,8 @@
<< inst_word_count;
}
spv_opcode_desc opcode_desc;
- if (grammar_.lookupOpcode(inst.opcode, &opcode_desc))
- return diagnostic() << "Invalid opcode: " << int(inst.opcode);
+ if (grammar_.lookupOpcode(static_cast<SpvOp>(inst.opcode), &opcode_desc))
+ return diagnostic() << "Invalid opcode: " << inst.opcode;
// Advance past the opcode word. But remember the of the start
// of the instruction.
@@ -397,6 +397,7 @@
std::vector<uint32_t>* words,
std::vector<spv_parsed_operand_t>* operands,
spv_operand_pattern_t* expected_operands) {
+ const SpvOp opcode = static_cast<SpvOp>(inst->opcode);
// We'll fill in this result as we go along.
spv_parsed_operand_t parsed_operand;
parsed_operand.offset = uint16_t(_.word_index - inst_offset);
@@ -414,7 +415,7 @@
parsed_operand.number_bit_width = 0;
if (_.word_index >= _.num_words)
- return exhaustedInputDiagnostic(inst_offset, inst->opcode, type);
+ return exhaustedInputDiagnostic(inst_offset, opcode, type);
const uint32_t word = peek();
@@ -442,9 +443,8 @@
// A regular value maps to its type. Some instructions (e.g. OpLabel)
// have no type Id, and will map to 0. The result Id for a
// type-generating instruction (e.g. OpTypeInt) maps to itself.
- _.id_to_type_id[inst->result_id] = spvOpcodeGeneratesType(inst->opcode)
- ? inst->result_id
- : inst->type_id;
+ _.id_to_type_id[inst->result_id] =
+ spvOpcodeGeneratesType(opcode) ? inst->result_id : inst->type_id;
break;
case SPV_OPERAND_TYPE_ID:
@@ -452,7 +452,7 @@
if (!word) return diagnostic(SPV_ERROR_INVALID_ID) << "Id is 0";
parsed_operand.type = SPV_OPERAND_TYPE_ID;
- if (inst->opcode == SpvOpExtInst && parsed_operand.offset == 3) {
+ if (opcode == SpvOpExtInst && parsed_operand.offset == 3) {
// The current word is the extended instruction set Id.
// Set the extended instruction set type for the current instruction.
auto ext_inst_type_iter = _.import_id_to_ext_inst_type.find(word);
@@ -473,7 +473,7 @@
break;
case SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER: {
- assert(SpvOpExtInst == inst->opcode);
+ assert(SpvOpExtInst == opcode);
assert(inst->ext_inst_type != SPV_EXT_INST_TYPE_NONE);
spv_ext_inst_desc ext_inst;
if (grammar_.lookupExtInst(inst->ext_inst_type, word, &ext_inst))
@@ -482,7 +482,7 @@
} break;
case SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER: {
- assert(SpvOpSpecConstantOp == inst->opcode);
+ assert(SpvOpSpecConstantOp == opcode);
if (grammar_.lookupSpecConstantOpcode(SpvOp(word))) {
return diagnostic() << "Invalid " << spvOperandTypeStr(type) << ": "
<< word;
@@ -514,7 +514,7 @@
case SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER:
case SPV_OPERAND_TYPE_OPTIONAL_TYPED_LITERAL_INTEGER:
parsed_operand.type = SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER;
- if (inst->opcode == SpvOpSwitch) {
+ if (opcode == SpvOpSwitch) {
// The literal operands have the same type as the value
// referenced by the selector Id.
const uint32_t selector_id = peekAt(inst_offset + 1);
@@ -540,8 +540,7 @@
<< " is not a scalar integer";
}
} else {
- assert(inst->opcode == SpvOpConstant ||
- inst->opcode == SpvOpSpecConstant);
+ assert(opcode == SpvOpConstant || opcode == SpvOpSpecConstant);
// The literal number type is determined by the type Id for the
// constant.
assert(inst->type_id);
@@ -565,7 +564,7 @@
// If there was no terminating null byte, then that's an end-of-input
// error.
if (string_num_content_bytes == remaining_input_bytes)
- return exhaustedInputDiagnostic(inst_offset, inst->opcode, type);
+ return exhaustedInputDiagnostic(inst_offset, opcode, type);
// Account for null in the word length, so add 1 for null, then add 3 to
// make sure we round up. The following is equivalent to:
// (string_num_content_bytes + 1 + 3) / 4
@@ -582,7 +581,7 @@
parsed_operand.num_words = uint16_t(string_num_words);
parsed_operand.type = SPV_OPERAND_TYPE_LITERAL_STRING;
- if (SpvOpExtInstImport == inst->opcode) {
+ if (SpvOpExtInstImport == opcode) {
// Record the extended instruction type for the ID for this import.
// There is only one string literal argument to OpExtInstImport,
// so it's sufficient to guard this just on the opcode.
@@ -599,9 +598,6 @@
}
} break;
- case SPV_OPERAND_TYPE_OPTIONAL_EXECUTION_MODE:
- parsed_operand.type = SPV_OPERAND_TYPE_EXECUTION_MODE;
- // Fall through
case SPV_OPERAND_TYPE_CAPABILITY:
case SPV_OPERAND_TYPE_SOURCE_LANGUAGE:
case SPV_OPERAND_TYPE_EXECUTION_MODEL:
@@ -699,7 +695,7 @@
// handled earlier.) For example, this error can occur for a multi-word
// argument to OpConstant, or a multi-word case literal operand for OpSwitch.
if (_.num_words < index_after_operand)
- return exhaustedInputDiagnostic(inst_offset, inst->opcode, type);
+ return exhaustedInputDiagnostic(inst_offset, opcode, type);
if (_.requires_endian_conversion) {
// Copy instruction words. Translate to native endianness as needed.
@@ -745,13 +741,14 @@
void Parser::recordNumberType(size_t inst_offset,
const spv_parsed_instruction_t* inst) {
- if (spvOpcodeGeneratesType(inst->opcode)) {
+ const SpvOp opcode = static_cast<SpvOp>(inst->opcode);
+ if (spvOpcodeGeneratesType(opcode)) {
NumberType info = {SPV_NUMBER_NONE, 0};
- if (SpvOpTypeInt == inst->opcode) {
+ if (SpvOpTypeInt == opcode) {
const bool is_signed = peekAt(inst_offset + 3) != 0;
info.type = is_signed ? SPV_NUMBER_SIGNED_INT : SPV_NUMBER_UNSIGNED_INT;
info.bit_width = peekAt(inst_offset + 2);
- } else if (SpvOpTypeFloat == inst->opcode) {
+ } else if (SpvOpTypeFloat == opcode) {
info.type = SPV_NUMBER_FLOATING;
info.bit_width = peekAt(inst_offset + 2);
}
diff --git a/source/disassemble.cpp b/source/disassemble.cpp
index 9fae7e5..53e07cb 100644
--- a/source/disassemble.cpp
+++ b/source/disassemble.cpp
@@ -182,7 +182,7 @@
stream_ << std::string(indent_, ' ');
}
- stream_ << "Op" << spvOpcodeString(inst.opcode);
+ stream_ << "Op" << spvOpcodeString(static_cast<SpvOp>(inst.opcode));
for (uint16_t i = 0; i < inst.num_operands; i++) {
const spv_operand_type_t type = inst.operands[i].type;
diff --git a/source/ext_inst.cpp b/source/ext_inst.cpp
index 7ae384e..f612fa9 100644
--- a/source/ext_inst.cpp
+++ b/source/ext_inst.cpp
@@ -28,135 +28,16 @@
#include <string.h>
+#include "spirv/GLSL.std.450.h"
+#include "spirv/OpenCL.std.h"
#include "spirv_definition.h"
-/// Generate a spv_ext_inst_desc_t literal for a GLSL std450 extended
-/// instruction with one/two/three <id> parameter(s).
-#define GLSL450Inst1(name) \
- #name, GLSLstd450::GLSLstd450##name, 0, { SPV_OPERAND_TYPE_ID }
-#define GLSL450Inst1Cap(name, cap) \
- #name, GLSLstd450::GLSLstd450##name, \
- SPV_CAPABILITY_AS_MASK(SpvCapability##cap), { \
- SPV_OPERAND_TYPE_ID \
- }
-#define GLSL450Inst2(name) \
- #name, GLSLstd450::GLSLstd450##name, 0, { \
- SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID \
- }
-#define GLSL450Inst2Cap(name, cap) \
- #name, GLSLstd450::GLSLstd450##name, \
- SPV_CAPABILITY_AS_MASK(SpvCapability##cap), { \
- SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID \
- }
-#define GLSL450Inst3(name) \
- #name, GLSLstd450::GLSLstd450##name, 0, { \
- SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID, SPV_OPERAND_TYPE_ID \
- }
-
static const spv_ext_inst_desc_t glslStd450Entries[] = {
- {GLSL450Inst1(Round)},
- {GLSL450Inst1(RoundEven)},
- {GLSL450Inst1(Trunc)},
- {GLSL450Inst1(FAbs)},
- {GLSL450Inst1(SAbs)},
- {GLSL450Inst1(FSign)},
- {GLSL450Inst1(SSign)},
- {GLSL450Inst1(Floor)},
- {GLSL450Inst1(Ceil)},
- {GLSL450Inst1(Fract)},
- {GLSL450Inst1(Radians)},
- {GLSL450Inst1(Degrees)},
- {GLSL450Inst1(Sin)},
- {GLSL450Inst1(Cos)},
- {GLSL450Inst1(Tan)},
- {GLSL450Inst1(Asin)},
- {GLSL450Inst1(Acos)},
- {GLSL450Inst1(Atan)},
- {GLSL450Inst1(Sinh)},
- {GLSL450Inst1(Cosh)},
- {GLSL450Inst1(Tanh)},
- {GLSL450Inst1(Asinh)},
- {GLSL450Inst1(Acosh)},
- {GLSL450Inst1(Atanh)},
- {GLSL450Inst2(Atan2)},
- {GLSL450Inst2(Pow)},
- {GLSL450Inst1(Exp)},
- {GLSL450Inst1(Log)},
- {GLSL450Inst1(Exp2)},
- {GLSL450Inst1(Log2)},
- {GLSL450Inst1(Sqrt)},
- {GLSL450Inst1(InverseSqrt)},
- {GLSL450Inst1(Determinant)},
- {GLSL450Inst1(MatrixInverse)},
- {GLSL450Inst2(Modf)},
- {GLSL450Inst1(ModfStruct)},
- {GLSL450Inst2(FMin)},
- {GLSL450Inst2(UMin)},
- {GLSL450Inst2(SMin)},
- {GLSL450Inst2(FMax)},
- {GLSL450Inst2(UMax)},
- {GLSL450Inst2(SMax)},
- {GLSL450Inst3(FClamp)},
- {GLSL450Inst3(UClamp)},
- {GLSL450Inst3(SClamp)},
- {GLSL450Inst3(FMix)},
- {GLSL450Inst3(IMix)},
- {GLSL450Inst2(Step)},
- {GLSL450Inst3(SmoothStep)},
- {GLSL450Inst3(Fma)},
- {GLSL450Inst2(Frexp)},
- {GLSL450Inst1(FrexpStruct)},
- {GLSL450Inst2(Ldexp)},
- {GLSL450Inst1(PackSnorm4x8)},
- {GLSL450Inst1(PackUnorm4x8)},
- {GLSL450Inst1(PackSnorm2x16)},
- {GLSL450Inst1(PackUnorm2x16)},
- {GLSL450Inst1(PackHalf2x16)},
- {GLSL450Inst1Cap(PackDouble2x32, Float64)},
- {GLSL450Inst1(UnpackSnorm2x16)},
- {GLSL450Inst1(UnpackUnorm2x16)},
- {GLSL450Inst1(UnpackHalf2x16)},
- {GLSL450Inst1(UnpackSnorm4x8)},
- {GLSL450Inst1(UnpackUnorm4x8)},
- {GLSL450Inst1(UnpackDouble2x32)},
- {GLSL450Inst1(Length)},
- {GLSL450Inst2(Distance)},
- {GLSL450Inst2(Cross)},
- {GLSL450Inst1(Normalize)},
- {GLSL450Inst3(FaceForward)},
- {GLSL450Inst2(Reflect)},
- {GLSL450Inst3(Refract)},
- {GLSL450Inst1(FindILsb)},
- {GLSL450Inst1(FindSMsb)},
- {GLSL450Inst1(FindUMsb)},
- {GLSL450Inst1Cap(InterpolateAtCentroid, InterpolationFunction)},
- {GLSL450Inst2Cap(InterpolateAtSample, InterpolationFunction)},
- {GLSL450Inst2Cap(InterpolateAtOffset, InterpolationFunction)},
- {GLSL450Inst2(NMin)},
- {GLSL450Inst2(NMax)},
- {GLSL450Inst2(NClamp)},
+#include "glsl.std.450.insts.inc"
};
static const spv_ext_inst_desc_t openclEntries[] = {
-#define ExtInst(Name, Opcode, OperandList) \
- { #Name, Opcode, 0, OperandList } \
- ,
-#define EmptyList \
- {}
-#define List(...) \
- { __VA_ARGS__ }
-#define OperandId SPV_OPERAND_TYPE_ID
-#define OperandLiteralNumber SPV_OPERAND_TYPE_LITERAL_INTEGER
-#define OperandFPRoundingMode SPV_OPERAND_TYPE_FP_ROUNDING_MODE
-#define OperandVariableIds SPV_OPERAND_TYPE_VARIABLE_ID
-#include "opencl_std_ext_inst.inc"
-#undef ExtList
-#undef EmptyList
-#undef List
-#undef OperandId
-#undef OperandLiteralNumber
-#undef OperandFPRoundingMode
-#undef OperandVariableIds
+#include "opencl.std.insts.inc"
};
spv_result_t spvExtInstTableGet(spv_ext_inst_table* pExtInstTable) {
diff --git a/source/extinst.glsl.std.450.grammar.json b/source/extinst.glsl.std.450.grammar.json
new file mode 100644
index 0000000..b39142f
--- /dev/null
+++ b/source/extinst.glsl.std.450.grammar.json
@@ -0,0 +1,640 @@
+{
+ "copyright" : [
+ "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."
+ ],
+ "version" : 100,
+ "revision" : 2,
+ "instructions" : [
+ {
+ "opname" : "Round",
+ "opcode" : 1,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "RoundEven",
+ "opcode" : 2,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Trunc",
+ "opcode" : 3,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "FAbs",
+ "opcode" : 4,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "SAbs",
+ "opcode" : 5,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "FSign",
+ "opcode" : 6,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "SSign",
+ "opcode" : 7,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Floor",
+ "opcode" : 8,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Ceil",
+ "opcode" : 9,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Fract",
+ "opcode" : 10,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Radians",
+ "opcode" : 11,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Degrees",
+ "opcode" : 12,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Sin",
+ "opcode" : 13,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Cos",
+ "opcode" : 14,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Tan",
+ "opcode" : 15,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Asin",
+ "opcode" : 16,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Acos",
+ "opcode" : 17,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Atan",
+ "opcode" : 18,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Sinh",
+ "opcode" : 19,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Cosh",
+ "opcode" : 20,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Tanh",
+ "opcode" : 21,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Asinh",
+ "opcode" : 22,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Acosh",
+ "opcode" : 23,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Atanh",
+ "opcode" : 24,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Atan2",
+ "opcode" : 25,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Pow",
+ "opcode" : 26,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Exp",
+ "opcode" : 27,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Log",
+ "opcode" : 28,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Exp2",
+ "opcode" : 29,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Log2",
+ "opcode" : 30,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Sqrt",
+ "opcode" : 31,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "InverseSqrt",
+ "opcode" : 32,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Determinant",
+ "opcode" : 33,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "MatrixInverse",
+ "opcode" : 34,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Modf",
+ "opcode" : 35,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "ModfStruct",
+ "opcode" : 36,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "FMin",
+ "opcode" : 37,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "UMin",
+ "opcode" : 38,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "SMin",
+ "opcode" : 39,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "FMax",
+ "opcode" : 40,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "UMax",
+ "opcode" : 41,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "SMax",
+ "opcode" : 42,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "FClamp",
+ "opcode" : 43,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "UClamp",
+ "opcode" : 44,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "SClamp",
+ "opcode" : 45,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "FMix",
+ "opcode" : 46,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "IMix",
+ "opcode" : 47,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Step",
+ "opcode" : 48,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "SmoothStep",
+ "opcode" : 49,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Fma",
+ "opcode" : 50,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Frexp",
+ "opcode" : 51,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "FrexpStruct",
+ "opcode" : 52,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Ldexp",
+ "opcode" : 53,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "PackSnorm4x8",
+ "opcode" : 54,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "PackUnorm4x8",
+ "opcode" : 55,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "PackSnorm2x16",
+ "opcode" : 56,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "PackUnorm2x16",
+ "opcode" : 57,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "PackHalf2x16",
+ "opcode" : 58,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "PackDouble2x32",
+ "opcode" : 59,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ],
+ "capabilities" : [ "Float64" ]
+ },
+ {
+ "opname" : "UnpackSnorm2x16",
+ "opcode" : 60,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "UnpackUnorm2x16",
+ "opcode" : 61,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "UnpackHalf2x16",
+ "opcode" : 62,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "UnpackSnorm4x8",
+ "opcode" : 63,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "UnpackUnorm4x8",
+ "opcode" : 64,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "UnpackDouble2x32",
+ "opcode" : 65,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Length",
+ "opcode" : 66,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Distance",
+ "opcode" : 67,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Cross",
+ "opcode" : 68,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Normalize",
+ "opcode" : 69,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "FaceForward",
+ "opcode" : 70,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Reflect",
+ "opcode" : 71,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "Refract",
+ "opcode" : 72,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "FindILsb",
+ "opcode" : 73,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "FindSMsb",
+ "opcode" : 74,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "FindUMsb",
+ "opcode" : 75,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "InterpolateAtCentroid",
+ "opcode" : 76,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ],
+ "capabilities" : [ "InterpolationFunction" ]
+ },
+ {
+ "opname" : "InterpolateAtSample",
+ "opcode" : 77,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ],
+ "capabilities" : [ "InterpolationFunction" ]
+ },
+ {
+ "opname" : "InterpolateAtOffset",
+ "opcode" : 78,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ],
+ "capabilities" : [ "InterpolationFunction" ]
+ },
+ {
+ "opname" : "NMin",
+ "opcode" : 79,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "NMax",
+ "opcode" : 80,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "NClamp",
+ "opcode" : 81,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ }
+ ]
+}
diff --git a/source/extinst.opencl.std.grammar.json b/source/extinst.opencl.std.grammar.json
new file mode 100644
index 0000000..1145a47
--- /dev/null
+++ b/source/extinst.opencl.std.grammar.json
@@ -0,0 +1,1277 @@
+{
+ "copyright" : [
+ "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."
+ ],
+ "instructions" : [
+ {
+ "opname" : "acos",
+ "opcode" : 0,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "acosh",
+ "opcode" : 1,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "acospi",
+ "opcode" : 2,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "asin",
+ "opcode" : 3,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "asinh",
+ "opcode" : 4,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "asinpi",
+ "opcode" : 5,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "atan",
+ "opcode" : 6,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "atan2",
+ "opcode" : 7,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "atanh",
+ "opcode" : 8,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "atanpi",
+ "opcode" : 9,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "atan2pi",
+ "opcode" : 10,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "cbrt",
+ "opcode" : 11,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "ceil",
+ "opcode" : 12,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "copysign",
+ "opcode" : 13,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "cos",
+ "opcode" : 14,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "cosh",
+ "opcode" : 15,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "cospi",
+ "opcode" : 16,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "erfc",
+ "opcode" : 17,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "erf",
+ "opcode" : 18,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "exp",
+ "opcode" : 19,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "exp2",
+ "opcode" : 20,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "exp10",
+ "opcode" : 21,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "expm1",
+ "opcode" : 22,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "fabs",
+ "opcode" : 23,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "fdim",
+ "opcode" : 24,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "floor",
+ "opcode" : 25,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "fma",
+ "opcode" : 26,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "fmax",
+ "opcode" : 27,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "fmin",
+ "opcode" : 28,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "fmod",
+ "opcode" : 29,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "fract",
+ "opcode" : 30,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "frexp",
+ "opcode" : 31,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "hypot",
+ "opcode" : 32,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "ilogb",
+ "opcode" : 33,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "ldexp",
+ "opcode" : 34,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "lgamma",
+ "opcode" : 35,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "lgamma_r",
+ "opcode" : 36,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "log",
+ "opcode" : 37,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "log2",
+ "opcode" : 38,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "log10",
+ "opcode" : 39,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "log1p",
+ "opcode" : 40,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "logb",
+ "opcode" : 41,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "mad",
+ "opcode" : 42,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "maxmag",
+ "opcode" : 43,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "minmag",
+ "opcode" : 44,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "modf",
+ "opcode" : 45,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "nan",
+ "opcode" : 46,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "nextafter",
+ "opcode" : 47,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "pow",
+ "opcode" : 48,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "pown",
+ "opcode" : 49,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "powr",
+ "opcode" : 50,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "remainder",
+ "opcode" : 51,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "remquo",
+ "opcode" : 52,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "rint",
+ "opcode" : 53,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "rootn",
+ "opcode" : 54,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "round",
+ "opcode" : 55,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "rsqrt",
+ "opcode" : 56,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "sin",
+ "opcode" : 57,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "sincos",
+ "opcode" : 58,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "sinh",
+ "opcode" : 59,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "sinpi",
+ "opcode" : 60,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "sqrt",
+ "opcode" : 61,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "tan",
+ "opcode" : 62,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "tanh",
+ "opcode" : 63,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "tanpi",
+ "opcode" : 64,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "tgamma",
+ "opcode" : 65,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "trunc",
+ "opcode" : 66,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "half_cos",
+ "opcode" : 67,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "half_divide",
+ "opcode" : 68,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "half_exp",
+ "opcode" : 69,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "half_exp2",
+ "opcode" : 70,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "half_exp10",
+ "opcode" : 71,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "half_log",
+ "opcode" : 72,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "half_log2",
+ "opcode" : 73,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "half_log10",
+ "opcode" : 74,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "half_powr",
+ "opcode" : 75,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "half_recip",
+ "opcode" : 76,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "half_rsqrt",
+ "opcode" : 77,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "half_sin",
+ "opcode" : 78,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "half_sqrt",
+ "opcode" : 79,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "half_tan",
+ "opcode" : 80,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "native_cos",
+ "opcode" : 81,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "native_divide",
+ "opcode" : 82,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "native_exp",
+ "opcode" : 83,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "native_exp2",
+ "opcode" : 84,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "native_exp10",
+ "opcode" : 85,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "native_log",
+ "opcode" : 86,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "native_log2",
+ "opcode" : 87,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "native_log10",
+ "opcode" : 88,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "native_powr",
+ "opcode" : 89,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "native_recip",
+ "opcode" : 90,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "native_rsqrt",
+ "opcode" : 91,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "native_sin",
+ "opcode" : 92,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "native_sqrt",
+ "opcode" : 93,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "native_tan",
+ "opcode" : 94,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "fclamp",
+ "opcode" : 95,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "degrees",
+ "opcode" : 96,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "fmax_common",
+ "opcode" : 97,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "fmin_common",
+ "opcode" : 98,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "mix",
+ "opcode" : 99,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "radians",
+ "opcode" : 100,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "step",
+ "opcode" : 101,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "smoothstep",
+ "opcode" : 102,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "sign",
+ "opcode" : 103,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "cross",
+ "opcode" : 104,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "distance",
+ "opcode" : 105,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "length",
+ "opcode" : 106,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "normalize",
+ "opcode" : 107,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "fast_distance",
+ "opcode" : 108,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "fast_length",
+ "opcode" : 109,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "fast_normalize",
+ "opcode" : 110,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "s_abs",
+ "opcode" : 141,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "s_abs_diff",
+ "opcode" : 142,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "s_add_sat",
+ "opcode" : 143,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "u_add_sat",
+ "opcode" : 144,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "s_hadd",
+ "opcode" : 145,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "u_hadd",
+ "opcode" : 146,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "s_rhadd",
+ "opcode" : 147,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "u_rhadd",
+ "opcode" : 148,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "s_clamp",
+ "opcode" : 149,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "u_clamp",
+ "opcode" : 150,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "clz",
+ "opcode" : 151,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "ctz",
+ "opcode" : 152,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "s_mad_hi",
+ "opcode" : 153,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "u_mad_sat",
+ "opcode" : 154,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "s_mad_sat",
+ "opcode" : 155,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "s_max",
+ "opcode" : 156,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "u_max",
+ "opcode" : 157,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "s_min",
+ "opcode" : 158,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "u_min",
+ "opcode" : 159,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "s_mul_hi",
+ "opcode" : 160,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "rotate",
+ "opcode" : 161,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "s_sub_sat",
+ "opcode" : 162,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "u_sub_sat",
+ "opcode" : 163,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "u_upsample",
+ "opcode" : 164,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "s_upsample",
+ "opcode" : 165,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "popcount",
+ "opcode" : 166,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "s_mad24",
+ "opcode" : 167,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "u_mad24",
+ "opcode" : 168,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "s_mul24",
+ "opcode" : 169,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "u_mul24",
+ "opcode" : 170,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "vloadn",
+ "opcode" : 171,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "LiteralInteger" }
+ ]
+ },
+ {
+ "opname" : "vstoren",
+ "opcode" : 172,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "vload_half",
+ "opcode" : 173,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "vload_halfn",
+ "opcode" : 174,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "LiteralInteger" }
+ ]
+ },
+ {
+ "opname" : "vstore_half",
+ "opcode" : 175,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "vstore_half_r",
+ "opcode" : 176,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "FPRoundingMode" }
+ ]
+ },
+ {
+ "opname" : "vstore_halfn",
+ "opcode" : 177,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "vstore_halfn_r",
+ "opcode" : 178,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "FPRoundingMode" }
+ ]
+ },
+ {
+ "opname" : "vloada_halfn",
+ "opcode" : 179,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "LiteralInteger" }
+ ]
+ },
+ {
+ "opname" : "vstorea_halfn",
+ "opcode" : 180,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "vstorea_halfn_r",
+ "opcode" : 181,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "FPRoundingMode" }
+ ]
+ },
+ {
+ "opname" : "shuffle",
+ "opcode" : 182,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "shuffle2",
+ "opcode" : 183,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "printf",
+ "opcode" : 184,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef", "quantifier" : "*" }
+ ]
+ },
+ {
+ "opname" : "prefetch",
+ "opcode" : 185,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "bitselect",
+ "opcode" : 186,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "select",
+ "opcode" : 187,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "u_abs",
+ "opcode" : 201,
+ "operands" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "u_abs_diff",
+ "opcode" : 202,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "u_mul_hi",
+ "opcode" : 203,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "opname" : "u_mad_hi",
+ "opcode" : 204,
+ "operands" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ }
+ ]
+}
diff --git a/source/opcode.cpp b/source/opcode.cpp
index 1a37a6a..518da26 100644
--- a/source/opcode.cpp
+++ b/source/opcode.cpp
@@ -35,7 +35,6 @@
#include "spirv-tools/libspirv.h"
#include "spirv_constant.h"
#include "spirv_endian.h"
-#include "spirv_operands.h"
namespace {
@@ -49,246 +48,11 @@
// TODO(dneto): Some of the macros are quite unreadable. We could make
// good use of constexpr functions, but some compilers don't support that yet.
const spv_opcode_desc_t opcodeTableEntries[] = {
-#define EmptyList \
- {}
-#define List(...) \
- { __VA_ARGS__ }
-#define Capability(X) SPV_CAPABILITY_AS_MASK(SpvCapability##X)
-#define Capability2(X, Y) Capability(X) | Capability(Y)
-#define SpvCapabilityNone \
- 0 // Needed so Capability(None) still expands to valid syntax.
-#define Instruction(Name, HasResult, HasType, NumLogicalOperands, \
- NumCapabilities, CapabilityRequired, IsVariable, \
- LogicalArgsList) \
- {#Name, SpvOp##Name, (NumCapabilities) ? (CapabilityRequired) : 0, \
- 0, {}, /* Filled in later. Operand list, including \
- result id and type id, if needed */ \
- HasResult, HasType, LogicalArgsList},
-#include "opcode.inc"
-#undef EmptyList
-#undef List
-#undef Capability
-#undef Capability2
-#undef CapabilityNone
-#undef Instruction
+#include "core.insts.inc"
};
-// Opcode API
-
-// Converts the given operand class enum (from the SPIR-V document generation
-// logic) to the operand type required by the parser. The SPV_OPERAND_TYPE_NONE
-// value indicates there is no current operand and no further operands.
-// This only applies to logical operands.
-spv_operand_type_t convertOperandClassToType(SpvOp opcode,
- OperandClass operandClass) {
- // The spec document generator uses OptionalOperandLiteral for several kinds
- // of repeating values. Our parser needs more specific information about
- // what is being repeated.
- if (operandClass == OperandOptionalLiteral) {
- switch (opcode) {
- case SpvOpExecutionMode:
- return SPV_OPERAND_TYPE_VARIABLE_EXECUTION_MODE;
- default:
- break;
- }
- } else if (operandClass == OperandVariableLiterals) {
- switch (opcode) {
- case SpvOpConstant:
- case SpvOpSpecConstant:
- // The number type is determined by the type Id operand.
- return SPV_OPERAND_TYPE_TYPED_LITERAL_NUMBER;
- case SpvOpDecorate:
- case SpvOpMemberDecorate:
- // The operand types at the end of the instruction are
- // determined instead by the decoration kind.
- return SPV_OPERAND_TYPE_NONE;
- default:
- break;
- }
- }
-
- switch (operandClass) {
- case OperandNone:
- return SPV_OPERAND_TYPE_NONE;
- case OperandId:
- return SPV_OPERAND_TYPE_ID;
- case OperandOptionalId:
- return SPV_OPERAND_TYPE_OPTIONAL_ID;
- case OperandVariableIds:
- if (opcode == SpvOpSpecConstantOp) {
- // These are the operands to the specialization constant opcode.
- // The assembler and binary parser set up the extra Id and literal
- // arguments when processing the opcode operand. So don't add
- // an operand type for them here.
- return SPV_OPERAND_TYPE_NONE;
- }
- return SPV_OPERAND_TYPE_VARIABLE_ID;
- // The spec only uses OptionalLiteral for an optional literal number.
- case OperandOptionalLiteral:
- return SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER;
- case OperandOptionalLiteralString:
- return SPV_OPERAND_TYPE_OPTIONAL_LITERAL_STRING;
- // This is only used for sequences of literal numbers.
- case OperandVariableLiterals:
- return SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER;
- case OperandLiteralNumber:
- if (opcode == SpvOpExtInst) {
- // We use a special operand type for the extension instruction number.
- // For now, we assume there is only one LiteraNumber argument to
- // OpExtInst, and it is the extension instruction argument.
- // See the ExtInst entry in opcode.inc
- // TODO(dneto): Use a function to confirm the assumption, and to verify
- // that the index into the operandClass is 1, as expected.
- return SPV_OPERAND_TYPE_EXTENSION_INSTRUCTION_NUMBER;
- } else if (opcode == SpvOpSpecConstantOp) {
- // Use a special operand type for the opcode operand, so we can
- // use mnemonic names instead of the numbers. For example, the
- // assembler should accept "IAdd" instead of the numeric value of
- // SpvOpIAdd.
- return SPV_OPERAND_TYPE_SPEC_CONSTANT_OP_NUMBER;
- }
- return SPV_OPERAND_TYPE_LITERAL_INTEGER;
- case OperandLiteralString:
- return SPV_OPERAND_TYPE_LITERAL_STRING;
- case OperandSource:
- return SPV_OPERAND_TYPE_SOURCE_LANGUAGE;
- case OperandExecutionModel:
- return SPV_OPERAND_TYPE_EXECUTION_MODEL;
- case OperandAddressing:
- return SPV_OPERAND_TYPE_ADDRESSING_MODEL;
- case OperandMemory:
- return SPV_OPERAND_TYPE_MEMORY_MODEL;
- case OperandExecutionMode:
- return SPV_OPERAND_TYPE_EXECUTION_MODE;
- case OperandStorage:
- return SPV_OPERAND_TYPE_STORAGE_CLASS;
- case OperandDimensionality:
- return SPV_OPERAND_TYPE_DIMENSIONALITY;
- case OperandSamplerAddressingMode:
- return SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE;
- case OperandSamplerFilterMode:
- return SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE;
- case OperandSamplerImageFormat:
- return SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT;
- case OperandImageChannelOrder:
- // This is only used to describe the value generated by OpImageQueryOrder.
- // It is not used as an operand.
- break;
- case OperandImageChannelDataType:
- // This is only used to describe the value generated by
- // OpImageQueryFormat. It is not used as an operand.
- break;
- case OperandImageOperands:
- return SPV_OPERAND_TYPE_IMAGE;
- case OperandOptionalImageOperands:
- return SPV_OPERAND_TYPE_OPTIONAL_IMAGE;
- case OperandFPFastMath:
- return SPV_OPERAND_TYPE_FP_FAST_MATH_MODE;
- case OperandFPRoundingMode:
- return SPV_OPERAND_TYPE_FP_ROUNDING_MODE;
- case OperandLinkageType:
- return SPV_OPERAND_TYPE_LINKAGE_TYPE;
- case OperandAccessQualifier:
- return SPV_OPERAND_TYPE_ACCESS_QUALIFIER;
- case OperandOptionalAccessQualifier:
- return SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER;
- case OperandFuncParamAttr:
- return SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE;
- case OperandDecoration:
- return SPV_OPERAND_TYPE_DECORATION;
- case OperandBuiltIn:
- return SPV_OPERAND_TYPE_BUILT_IN;
- case OperandSelect:
- return SPV_OPERAND_TYPE_SELECTION_CONTROL;
- case OperandLoop:
- return SPV_OPERAND_TYPE_LOOP_CONTROL;
- case OperandFunction:
- return SPV_OPERAND_TYPE_FUNCTION_CONTROL;
- case OperandMemorySemantics:
- return SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID;
- case OperandMemoryAccess:
- // This case does not occur in the table for SPIR-V 0.99 Rev 32.
- // We expect that it will become SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS,
- // and we can remove the special casing above for memory operation
- // instructions.
- break;
- case OperandOptionalMemoryAccess:
- // Expect an optional mask. When the Aligned bit is set in the mask,
- // we will later add the expectation of a literal number operand.
- return SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS;
- case OperandScope:
- return SPV_OPERAND_TYPE_SCOPE_ID;
- case OperandGroupOperation:
- return SPV_OPERAND_TYPE_GROUP_OPERATION;
- case OperandKernelEnqueueFlags:
- return SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS;
- case OperandKernelProfilingInfo:
- return SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO;
- case OperandCapability:
- return SPV_OPERAND_TYPE_CAPABILITY;
-
- // Used by GroupMemberDecorate
- case OperandVariableIdLiteral:
- return SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_INTEGER;
-
- // Used by Switch
- case OperandVariableLiteralId:
- return SPV_OPERAND_TYPE_VARIABLE_LITERAL_INTEGER_ID;
-
- // These exceptional cases shouldn't occur.
- case OperandCount:
- default:
- break;
- }
- assert(0 && "Unexpected operand class");
- return SPV_OPERAND_TYPE_NONE;
-}
-
} // anonymous namespace
-// Finish populating the opcodeTableEntries array.
-void spvOpcodeTableInitialize(spv_opcode_desc_t* entries,
- uint32_t num_entries) {
- // Compute the operandTypes field for each entry.
- for (uint32_t i = 0; i < num_entries; ++i) {
- spv_opcode_desc_t& opcode = entries[i];
- opcode.numTypes = 0;
- // Type ID always comes first, if present.
- if (opcode.hasType)
- opcode.operandTypes[opcode.numTypes++] = SPV_OPERAND_TYPE_TYPE_ID;
- // Result ID always comes next, if present
- if (opcode.hasResult)
- opcode.operandTypes[opcode.numTypes++] = SPV_OPERAND_TYPE_RESULT_ID;
- const uint16_t maxNumOperands = static_cast<uint16_t>(
- sizeof(opcode.operandTypes) / sizeof(opcode.operandTypes[0]));
- const uint16_t maxNumClasses = static_cast<uint16_t>(
- sizeof(opcode.operandClass) / sizeof(opcode.operandClass[0]));
- for (uint16_t classIndex = 0;
- opcode.numTypes < maxNumOperands && classIndex < maxNumClasses;
- classIndex++) {
- const OperandClass operandClass = opcode.operandClass[classIndex];
- const auto operandType =
- convertOperandClassToType(opcode.opcode, operandClass);
- opcode.operandTypes[opcode.numTypes++] = operandType;
- // The OperandNone value is not explicitly represented in the .inc file.
- // However, it is the zero value, and is created via implicit value
- // initialization. It converts to SPV_OPERAND_TYPE_NONE.
- // The SPV_OPERAND_TYPE_NONE operand type indicates no current or futher
- // operands.
- if (operandType == SPV_OPERAND_TYPE_NONE) {
- opcode.numTypes--;
- break;
- }
- }
-
- // We should have written the terminating SPV_OPERAND_TYPE_NONE entry, but
- // also without overflowing.
- assert((opcode.numTypes < maxNumOperands) &&
- "Operand class list is too long. Expand "
- "spv_opcode_desc_t.operandClass");
- }
-}
-
const char* spvGeneratorStr(uint32_t generator) {
switch (generator) {
case SPV_GENERATOR_KHRONOS:
@@ -318,31 +82,29 @@
return ((uint32_t)opcode) | (((uint32_t)wordCount) << 16);
}
-void spvOpcodeSplit(const uint32_t word, uint16_t* pWordCount, SpvOp* pOpcode) {
+void spvOpcodeSplit(const uint32_t word, uint16_t* pWordCount,
+ uint16_t* pOpcode) {
if (pWordCount) {
*pWordCount = (uint16_t)((0xffff0000 & word) >> 16);
}
if (pOpcode) {
- *pOpcode = (SpvOp)(0x0000ffff & word);
+ *pOpcode = 0x0000ffff & word;
}
}
+// Evaluates to the number of elements of array A.
+// If we could use constexpr, then we could make this a template function.
+// If the source arrays were std::array, then we could have used
+// std::array::size.
+#define ARRAY_SIZE(A) (static_cast<uint32_t>(sizeof(A) / sizeof(A[0])))
+
spv_result_t spvOpcodeTableGet(spv_opcode_table* pInstTable) {
if (!pInstTable) return SPV_ERROR_INVALID_POINTER;
- const uint32_t size = sizeof(opcodeTableEntries);
- spv_opcode_desc_t* copied_entries =
- static_cast<spv_opcode_desc_t*>(::malloc(size));
- if (!copied_entries) return SPV_ERROR_OUT_OF_MEMORY;
- ::memcpy(copied_entries, opcodeTableEntries, size);
+ static const spv_opcode_table_t table = {ARRAY_SIZE(opcodeTableEntries),
+ opcodeTableEntries};
- const uint32_t count = static_cast<uint32_t>(sizeof(opcodeTableEntries) /
- sizeof(spv_opcode_desc_t));
- spv_opcode_table_t* table = new spv_opcode_table_t{count, copied_entries};
-
- spvOpcodeTableInitialize(copied_entries, count);
-
- *pInstTable = table;
+ *pInstTable = &table;
return SPV_SUCCESS;
}
@@ -401,26 +163,22 @@
pInst->words[wordIndex] = spvFixWord(words[wordIndex], endian);
if (!wordIndex) {
uint16_t thisWordCount;
- SpvOp thisOpcode;
+ uint16_t thisOpcode;
spvOpcodeSplit(pInst->words[wordIndex], &thisWordCount, &thisOpcode);
- assert(opcode == thisOpcode && wordCount == thisWordCount &&
- "Endianness failed!");
+ assert(opcode == static_cast<SpvOp>(thisOpcode) &&
+ wordCount == thisWordCount && "Endianness failed!");
}
}
}
const char* spvOpcodeString(const SpvOp opcode) {
-// Use the syntax table so it's sure to be complete.
-#define Instruction(Name, ...) \
- case SpvOp##Name: \
- return #Name;
- switch (opcode) {
-#include "opcode.inc"
- default:
- assert(0 && "Unreachable!");
+ for (uint32_t i = 0;
+ i < sizeof(opcodeTableEntries) / sizeof(spv_opcode_desc_t); ++i) {
+ if (opcodeTableEntries[i].opcode == opcode)
+ return opcodeTableEntries[i].name;
}
+ assert(0 && "Unreachable!");
return "unknown";
-#undef Instruction
}
int32_t spvOpcodeIsScalarType(const SpvOp opcode) {
@@ -441,13 +199,12 @@
case SpvOpConstant:
case SpvOpConstantComposite:
case SpvOpConstantSampler:
- // case SpvOpConstantNull:
case SpvOpConstantNull:
case SpvOpSpecConstantTrue:
case SpvOpSpecConstantFalse:
case SpvOpSpecConstant:
case SpvOpSpecConstantComposite:
- // case SpvOpSpecConstantOp:
+ case SpvOpSpecConstantOp:
return true;
default:
return false;
diff --git a/source/opcode.h b/source/opcode.h
index 786c1f4..737af8c 100644
--- a/source/opcode.h
+++ b/source/opcode.h
@@ -29,6 +29,7 @@
#include "instruction.h"
#include "spirv-tools/libspirv.h"
+#include "spirv/spirv.h"
#include "table.h"
// Returns the name of a registered SPIR-V generator as a null-terminated
@@ -43,7 +44,8 @@
uint32_t spvOpcodeMake(uint16_t word_count, SpvOp opcode);
// Splits word into into two constituent parts: word_count and opcode.
-void spvOpcodeSplit(const uint32_t word, uint16_t* word_count, SpvOp* opcode);
+void spvOpcodeSplit(const uint32_t word, uint16_t* word_count,
+ uint16_t* opcode);
// Finds the named opcode in the given opcode table. On success, returns
// SPV_SUCCESS and writes a handle of the table entry into *entry.
diff --git a/source/opcode.inc b/source/opcode.inc
deleted file mode 100644
index 6199e18..0000000
--- a/source/opcode.inc
+++ /dev/null
@@ -1,310 +0,0 @@
-// Instruction fields are:
-// name - skips the "Op" prefix
-// {0|1} - whether the instruction generates a result Id
-// {0|1} - whether the instruction encodes the type of the result Id
-// numLogicalOperands - does not include result id or type id
-// numCapabilities - we only handle 0 or 1 required capabilities
-// Capability(<capability-name>) - capability required to use this instruction. Might be None.
-// There can be Capability2(a,b) for dependence on two capabilities.
-// {0|1} - whether the instruction is variable number of logical operands
-// EmptyList or List(...) - list of classes of logical operands
-// Example use:
-// #define EmptyList {}
-// #define List(...) {__VA_ARGS__}
-// #define Capability(C) Capability##C
-// #define CapabilityNone -1
-// #define Instruction(Name,HasResult,HasType,NumLogicalOperands,CapabiltyRequired,IsVariable,LogicalArgsList)
-Instruction(Nop, 0, 0, 0, 0, Capability(None), 0, EmptyList)
-Instruction(Undef, 1, 1, 0, 0, Capability(None), 0, EmptyList)
-Instruction(SourceContinued, 0, 0, 1, 0, Capability(None), 1, List(OperandLiteralString))
-Instruction(Source, 0, 0, 4, 0, Capability(None), 1, List(OperandSource, OperandLiteralNumber, OperandOptionalId, OperandOptionalLiteralString))
-Instruction(SourceExtension, 0, 0, 1, 0, Capability(None), 1, List(OperandLiteralString))
-Instruction(Name, 0, 0, 2, 0, Capability(None), 1, List(OperandId, OperandLiteralString))
-Instruction(MemberName, 0, 0, 3, 0, Capability(None), 1, List(OperandId, OperandLiteralNumber, OperandLiteralString))
-Instruction(String, 1, 0, 1, 0, Capability(None), 1, List(OperandLiteralString))
-Instruction(Line, 0, 0, 3, 0, Capability(None), 0, List(OperandId, OperandLiteralNumber, OperandLiteralNumber))
-Instruction(Extension, 0, 0, 1, 0, Capability(None), 1, List(OperandLiteralString))
-Instruction(ExtInstImport, 1, 0, 1, 0, Capability(None), 1, List(OperandLiteralString))
-Instruction(ExtInst, 1, 1, 3, 0, Capability(None), 1, List(OperandId, OperandLiteralNumber, OperandVariableIds))
-Instruction(MemoryModel, 0, 0, 2, 0, Capability(None), 0, List(OperandAddressing, OperandMemory))
-Instruction(EntryPoint, 0, 0, 4, 0, Capability(None), 1, List(OperandExecutionModel, OperandId, OperandLiteralString, OperandVariableIds))
-Instruction(ExecutionMode, 0, 0, 3, 0, Capability(None), 1, List(OperandId, OperandExecutionMode, OperandOptionalLiteral))
-Instruction(Capability, 0, 0, 1, 0, Capability(None), 0, List(OperandCapability))
-Instruction(TypeVoid, 1, 0, 0, 0, Capability(None), 0, EmptyList)
-Instruction(TypeBool, 1, 0, 0, 0, Capability(None), 0, EmptyList)
-Instruction(TypeInt, 1, 0, 2, 0, Capability(None), 0, List(OperandLiteralNumber, OperandLiteralNumber))
-Instruction(TypeFloat, 1, 0, 1, 0, Capability(None), 0, List(OperandLiteralNumber))
-Instruction(TypeVector, 1, 0, 2, 0, Capability(None), 0, List(OperandId, OperandLiteralNumber))
-Instruction(TypeMatrix, 1, 0, 2, 1, Capability(Matrix), 0, List(OperandId, OperandLiteralNumber))
-Instruction(TypeImage, 1, 0, 8, 0, Capability(None), 1, List(OperandId, OperandDimensionality, OperandLiteralNumber, OperandLiteralNumber, OperandLiteralNumber, OperandLiteralNumber, OperandSamplerImageFormat, OperandOptionalAccessQualifier))
-Instruction(TypeSampler, 1, 0, 0, 0, Capability(None), 0, EmptyList)
-Instruction(TypeSampledImage, 1, 0, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(TypeArray, 1, 0, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(TypeRuntimeArray, 1, 0, 1, 1, Capability(Shader), 0, List(OperandId))
-Instruction(TypeStruct, 1, 0, 1, 0, Capability(None), 1, List(OperandVariableIds))
-Instruction(TypeOpaque, 1, 0, 1, 1, Capability(Kernel), 1, List(OperandLiteralString))
-Instruction(TypePointer, 1, 0, 2, 0, Capability(None), 0, List(OperandStorage, OperandId))
-Instruction(TypeFunction, 1, 0, 2, 0, Capability(None), 1, List(OperandId, OperandVariableIds))
-Instruction(TypeEvent, 1, 0, 0, 1, Capability(Kernel), 0, EmptyList)
-Instruction(TypeDeviceEvent, 1, 0, 0, 1, Capability(DeviceEnqueue), 0, EmptyList)
-Instruction(TypeReserveId, 1, 0, 0, 1, Capability(Pipes), 0, EmptyList)
-Instruction(TypeQueue, 1, 0, 0, 1, Capability(DeviceEnqueue), 0, EmptyList)
-Instruction(TypePipe, 1, 0, 1, 1, Capability(Pipes), 0, List(OperandAccessQualifier))
-Instruction(TypeForwardPointer, 0, 0, 2, 1, Capability(Addresses), 0, List(OperandId, OperandStorage))
-Instruction(ConstantTrue, 1, 1, 0, 0, Capability(None), 0, EmptyList)
-Instruction(ConstantFalse, 1, 1, 0, 0, Capability(None), 0, EmptyList)
-Instruction(Constant, 1, 1, 1, 0, Capability(None), 1, List(OperandVariableLiterals))
-Instruction(ConstantComposite, 1, 1, 1, 0, Capability(None), 1, List(OperandVariableIds))
-Instruction(ConstantSampler, 1, 1, 3, 1, Capability(LiteralSampler), 0, List(OperandSamplerAddressingMode, OperandLiteralNumber, OperandSamplerFilterMode))
-Instruction(ConstantNull, 1, 1, 0, 0, Capability(None), 0, EmptyList)
-Instruction(SpecConstantTrue, 1, 1, 0, 0, Capability(None), 0, EmptyList)
-Instruction(SpecConstantFalse, 1, 1, 0, 0, Capability(None), 0, EmptyList)
-Instruction(SpecConstant, 1, 1, 1, 0, Capability(None), 1, List(OperandVariableLiterals))
-Instruction(SpecConstantComposite, 1, 1, 1, 0, Capability(None), 1, List(OperandVariableIds))
-Instruction(SpecConstantOp, 1, 1, 2, 0, Capability(None), 1, List(OperandLiteralNumber, OperandVariableIds))
-Instruction(Function, 1, 1, 2, 0, Capability(None), 0, List(OperandFunction, OperandId))
-Instruction(FunctionParameter, 1, 1, 0, 0, Capability(None), 0, EmptyList)
-Instruction(FunctionEnd, 0, 0, 0, 0, Capability(None), 0, EmptyList)
-Instruction(FunctionCall, 1, 1, 2, 0, Capability(None), 1, List(OperandId, OperandVariableIds))
-Instruction(Variable, 1, 1, 2, 0, Capability(None), 1, List(OperandStorage, OperandOptionalId))
-Instruction(ImageTexelPointer, 1, 1, 3, 0, Capability(None), 0, List(OperandId, OperandId, OperandId))
-Instruction(Load, 1, 1, 2, 0, Capability(None), 1, List(OperandId, OperandOptionalMemoryAccess))
-Instruction(Store, 0, 0, 3, 0, Capability(None), 1, List(OperandId, OperandId, OperandOptionalMemoryAccess))
-Instruction(CopyMemory, 0, 0, 3, 0, Capability(None), 1, List(OperandId, OperandId, OperandOptionalMemoryAccess))
-Instruction(CopyMemorySized, 0, 0, 4, 1, Capability(Addresses), 1, List(OperandId, OperandId, OperandId, OperandOptionalMemoryAccess))
-Instruction(AccessChain, 1, 1, 2, 0, Capability(None), 1, List(OperandId, OperandVariableIds))
-Instruction(InBoundsAccessChain, 1, 1, 2, 0, Capability(None), 1, List(OperandId, OperandVariableIds))
-Instruction(PtrAccessChain, 1, 1, 3, 1, Capability(Addresses), 1, List(OperandId, OperandId, OperandVariableIds))
-Instruction(ArrayLength, 1, 1, 2, 1, Capability(Shader), 0, List(OperandId, OperandLiteralNumber))
-Instruction(GenericPtrMemSemantics, 1, 1, 1, 1, Capability(Kernel), 0, List(OperandId))
-Instruction(InBoundsPtrAccessChain, 1, 1, 3, 1, Capability(Addresses), 1, List(OperandId, OperandId, OperandVariableIds))
-Instruction(Decorate, 0, 0, 3, 0, Capability(None), 1, List(OperandId, OperandDecoration, OperandVariableLiterals))
-Instruction(MemberDecorate, 0, 0, 4, 0, Capability(None), 1, List(OperandId, OperandLiteralNumber, OperandDecoration, OperandVariableLiterals))
-Instruction(DecorationGroup, 1, 0, 0, 0, Capability(None), 0, EmptyList)
-Instruction(GroupDecorate, 0, 0, 2, 0, Capability(None), 1, List(OperandId, OperandVariableIds))
-Instruction(GroupMemberDecorate, 0, 0, 2, 0, Capability(None), 1, List(OperandId, OperandVariableIdLiteral))
-Instruction(VectorExtractDynamic, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(VectorInsertDynamic, 1, 1, 3, 0, Capability(None), 0, List(OperandId, OperandId, OperandId))
-Instruction(VectorShuffle, 1, 1, 3, 0, Capability(None), 1, List(OperandId, OperandId, OperandVariableLiterals))
-Instruction(CompositeConstruct, 1, 1, 1, 0, Capability(None), 1, List(OperandVariableIds))
-Instruction(CompositeExtract, 1, 1, 2, 0, Capability(None), 1, List(OperandId, OperandVariableLiterals))
-Instruction(CompositeInsert, 1, 1, 3, 0, Capability(None), 1, List(OperandId, OperandId, OperandVariableLiterals))
-Instruction(CopyObject, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(Transpose, 1, 1, 1, 1, Capability(Matrix), 0, List(OperandId))
-Instruction(SampledImage, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(ImageSampleImplicitLod, 1, 1, 4, 1, Capability(Shader), 1, List(OperandId, OperandId, OperandOptionalImageOperands))
-Instruction(ImageSampleExplicitLod, 1, 1, 5, 0, Capability(None), 1, List(OperandId, OperandId, OperandImageOperands))
-Instruction(ImageSampleDrefImplicitLod, 1, 1, 5, 1, Capability(Shader), 1, List(OperandId, OperandId, OperandId, OperandOptionalImageOperands))
-Instruction(ImageSampleDrefExplicitLod, 1, 1, 6, 1, Capability(Shader), 1, List(OperandId, OperandId, OperandId, OperandImageOperands))
-Instruction(ImageSampleProjImplicitLod, 1, 1, 4, 1, Capability(Shader), 1, List(OperandId, OperandId, OperandOptionalImageOperands))
-Instruction(ImageSampleProjExplicitLod, 1, 1, 5, 1, Capability(Shader), 1, List(OperandId, OperandId, OperandImageOperands))
-Instruction(ImageSampleProjDrefImplicitLod, 1, 1, 5, 1, Capability(Shader), 1, List(OperandId, OperandId, OperandId, OperandOptionalImageOperands))
-Instruction(ImageSampleProjDrefExplicitLod, 1, 1, 6, 1, Capability(Shader), 1, List(OperandId, OperandId, OperandId, OperandImageOperands))
-Instruction(ImageFetch, 1, 1, 4, 0, Capability(None), 1, List(OperandId, OperandId, OperandOptionalImageOperands))
-Instruction(ImageGather, 1, 1, 5, 1, Capability(Shader), 1, List(OperandId, OperandId, OperandId, OperandOptionalImageOperands))
-Instruction(ImageDrefGather, 1, 1, 5, 1, Capability(Shader), 1, List(OperandId, OperandId, OperandId, OperandOptionalImageOperands))
-Instruction(ImageRead, 1, 1, 4, 0, Capability(None), 1, List(OperandId, OperandId, OperandOptionalImageOperands))
-Instruction(ImageWrite, 0, 0, 5, 0, Capability(None), 1, List(OperandId, OperandId, OperandId, OperandOptionalImageOperands))
-Instruction(Image, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(ImageQueryFormat, 1, 1, 1, 1, Capability(Kernel), 0, List(OperandId))
-Instruction(ImageQueryOrder, 1, 1, 1, 1, Capability(Kernel), 0, List(OperandId))
-Instruction(ImageQuerySizeLod, 1, 1, 2, 2, Capability2(Kernel,ImageQuery), 0, List(OperandId, OperandId))
-Instruction(ImageQuerySize, 1, 1, 1, 2, Capability2(Kernel,ImageQuery), 0, List(OperandId))
-Instruction(ImageQueryLod, 1, 1, 2, 1, Capability(ImageQuery), 0, List(OperandId, OperandId))
-Instruction(ImageQueryLevels, 1, 1, 1, 2, Capability2(Kernel,ImageQuery), 0, List(OperandId))
-Instruction(ImageQuerySamples, 1, 1, 1, 2, Capability2(Kernel,ImageQuery), 0, List(OperandId))
-Instruction(ConvertFToU, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(ConvertFToS, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(ConvertSToF, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(ConvertUToF, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(UConvert, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(SConvert, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(FConvert, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(QuantizeToF16, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(ConvertPtrToU, 1, 1, 1, 1, Capability(Addresses), 0, List(OperandId))
-Instruction(SatConvertSToU, 1, 1, 1, 1, Capability(Kernel), 0, List(OperandId))
-Instruction(SatConvertUToS, 1, 1, 1, 1, Capability(Kernel), 0, List(OperandId))
-Instruction(ConvertUToPtr, 1, 1, 1, 1, Capability(Addresses), 0, List(OperandId))
-Instruction(PtrCastToGeneric, 1, 1, 1, 1, Capability(Kernel), 0, List(OperandId))
-Instruction(GenericCastToPtr, 1, 1, 1, 1, Capability(Kernel), 0, List(OperandId))
-Instruction(GenericCastToPtrExplicit, 1, 1, 2, 1, Capability(Kernel), 0, List(OperandId, OperandStorage))
-Instruction(Bitcast, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(SNegate, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(FNegate, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(IAdd, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FAdd, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(ISub, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FSub, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(IMul, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FMul, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(UDiv, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(SDiv, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FDiv, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(UMod, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(SRem, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(SMod, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FRem, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FMod, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(VectorTimesScalar, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(MatrixTimesScalar, 1, 1, 2, 1, Capability(Matrix), 0, List(OperandId, OperandId))
-Instruction(VectorTimesMatrix, 1, 1, 2, 1, Capability(Matrix), 0, List(OperandId, OperandId))
-Instruction(MatrixTimesVector, 1, 1, 2, 1, Capability(Matrix), 0, List(OperandId, OperandId))
-Instruction(MatrixTimesMatrix, 1, 1, 2, 1, Capability(Matrix), 0, List(OperandId, OperandId))
-Instruction(OuterProduct, 1, 1, 2, 1, Capability(Matrix), 0, List(OperandId, OperandId))
-Instruction(Dot, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(IAddCarry, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(ISubBorrow, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(UMulExtended, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(SMulExtended, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(Any, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(All, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(IsNan, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(IsInf, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(IsFinite, 1, 1, 1, 1, Capability(Kernel), 0, List(OperandId))
-Instruction(IsNormal, 1, 1, 1, 1, Capability(Kernel), 0, List(OperandId))
-Instruction(SignBitSet, 1, 1, 1, 1, Capability(Kernel), 0, List(OperandId))
-Instruction(LessOrGreater, 1, 1, 2, 1, Capability(Kernel), 0, List(OperandId, OperandId))
-Instruction(Ordered, 1, 1, 2, 1, Capability(Kernel), 0, List(OperandId, OperandId))
-Instruction(Unordered, 1, 1, 2, 1, Capability(Kernel), 0, List(OperandId, OperandId))
-Instruction(LogicalEqual, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(LogicalNotEqual, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(LogicalOr, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(LogicalAnd, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(LogicalNot, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(Select, 1, 1, 3, 0, Capability(None), 0, List(OperandId, OperandId, OperandId))
-Instruction(IEqual, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(INotEqual, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(UGreaterThan, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(SGreaterThan, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(UGreaterThanEqual, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(SGreaterThanEqual, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(ULessThan, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(SLessThan, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(ULessThanEqual, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(SLessThanEqual, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FOrdEqual, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FUnordEqual, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FOrdNotEqual, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FUnordNotEqual, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FOrdLessThan, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FUnordLessThan, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FOrdGreaterThan, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FUnordGreaterThan, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FOrdLessThanEqual, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FUnordLessThanEqual, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FOrdGreaterThanEqual, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(FUnordGreaterThanEqual, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(ShiftRightLogical, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(ShiftRightArithmetic, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(ShiftLeftLogical, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(BitwiseOr, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(BitwiseXor, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(BitwiseAnd, 1, 1, 2, 0, Capability(None), 0, List(OperandId, OperandId))
-Instruction(Not, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(BitFieldInsert, 1, 1, 4, 1, Capability(Shader), 0, List(OperandId, OperandId, OperandId, OperandId))
-Instruction(BitFieldSExtract, 1, 1, 3, 1, Capability(Shader), 0, List(OperandId, OperandId, OperandId))
-Instruction(BitFieldUExtract, 1, 1, 3, 1, Capability(Shader), 0, List(OperandId, OperandId, OperandId))
-Instruction(BitReverse, 1, 1, 1, 1, Capability(Shader), 0, List(OperandId))
-Instruction(BitCount, 1, 1, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(DPdx, 1, 1, 1, 1, Capability(Shader), 0, List(OperandId))
-Instruction(DPdy, 1, 1, 1, 1, Capability(Shader), 0, List(OperandId))
-Instruction(Fwidth, 1, 1, 1, 1, Capability(Shader), 0, List(OperandId))
-Instruction(DPdxFine, 1, 1, 1, 1, Capability(DerivativeControl), 0, List(OperandId))
-Instruction(DPdyFine, 1, 1, 1, 1, Capability(DerivativeControl), 0, List(OperandId))
-Instruction(FwidthFine, 1, 1, 1, 1, Capability(DerivativeControl), 0, List(OperandId))
-Instruction(DPdxCoarse, 1, 1, 1, 1, Capability(DerivativeControl), 0, List(OperandId))
-Instruction(DPdyCoarse, 1, 1, 1, 1, Capability(DerivativeControl), 0, List(OperandId))
-Instruction(FwidthCoarse, 1, 1, 1, 1, Capability(DerivativeControl), 0, List(OperandId))
-Instruction(EmitVertex, 0, 0, 0, 1, Capability(Geometry), 0, EmptyList)
-Instruction(EndPrimitive, 0, 0, 0, 1, Capability(Geometry), 0, EmptyList)
-Instruction(EmitStreamVertex, 0, 0, 1, 1, Capability(GeometryStreams), 0, List(OperandId))
-Instruction(EndStreamPrimitive, 0, 0, 1, 1, Capability(GeometryStreams), 0, List(OperandId))
-Instruction(ControlBarrier, 0, 0, 3, 0, Capability(None), 0, List(OperandScope, OperandScope, OperandMemorySemantics))
-Instruction(MemoryBarrier, 0, 0, 2, 0, Capability(None), 0, List(OperandScope, OperandMemorySemantics))
-Instruction(AtomicLoad, 1, 1, 3, 0, Capability(None), 0, List(OperandId, OperandScope, OperandMemorySemantics))
-Instruction(AtomicStore, 0, 0, 4, 0, Capability(None), 0, List(OperandId, OperandScope, OperandMemorySemantics, OperandId))
-Instruction(AtomicExchange, 1, 1, 4, 0, Capability(None), 0, List(OperandId, OperandScope, OperandMemorySemantics, OperandId))
-Instruction(AtomicCompareExchange, 1, 1, 6, 0, Capability(None), 0, List(OperandId, OperandScope, OperandMemorySemantics, OperandMemorySemantics, OperandId, OperandId))
-Instruction(AtomicCompareExchangeWeak, 1, 1, 6, 1, Capability(Kernel), 0, List(OperandId, OperandScope, OperandMemorySemantics, OperandMemorySemantics, OperandId, OperandId))
-Instruction(AtomicIIncrement, 1, 1, 3, 0, Capability(None), 0, List(OperandId, OperandScope, OperandMemorySemantics))
-Instruction(AtomicIDecrement, 1, 1, 3, 0, Capability(None), 0, List(OperandId, OperandScope, OperandMemorySemantics))
-Instruction(AtomicIAdd, 1, 1, 4, 0, Capability(None), 0, List(OperandId, OperandScope, OperandMemorySemantics, OperandId))
-Instruction(AtomicISub, 1, 1, 4, 0, Capability(None), 0, List(OperandId, OperandScope, OperandMemorySemantics, OperandId))
-Instruction(AtomicSMin, 1, 1, 4, 0, Capability(None), 0, List(OperandId, OperandScope, OperandMemorySemantics, OperandId))
-Instruction(AtomicUMin, 1, 1, 4, 0, Capability(None), 0, List(OperandId, OperandScope, OperandMemorySemantics, OperandId))
-Instruction(AtomicSMax, 1, 1, 4, 0, Capability(None), 0, List(OperandId, OperandScope, OperandMemorySemantics, OperandId))
-Instruction(AtomicUMax, 1, 1, 4, 0, Capability(None), 0, List(OperandId, OperandScope, OperandMemorySemantics, OperandId))
-Instruction(AtomicAnd, 1, 1, 4, 0, Capability(None), 0, List(OperandId, OperandScope, OperandMemorySemantics, OperandId))
-Instruction(AtomicOr, 1, 1, 4, 0, Capability(None), 0, List(OperandId, OperandScope, OperandMemorySemantics, OperandId))
-Instruction(AtomicXor, 1, 1, 4, 0, Capability(None), 0, List(OperandId, OperandScope, OperandMemorySemantics, OperandId))
-Instruction(Phi, 1, 1, 1, 0, Capability(None), 1, List(OperandVariableIds))
-Instruction(LoopMerge, 0, 0, 3, 0, Capability(None), 0, List(OperandId, OperandId, OperandLoop))
-Instruction(SelectionMerge, 0, 0, 2, 0, Capability(None), 0, List(OperandId, OperandSelect))
-Instruction(Label, 1, 0, 0, 0, Capability(None), 0, EmptyList)
-Instruction(Branch, 0, 0, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(BranchConditional, 0, 0, 4, 0, Capability(None), 1, List(OperandId, OperandId, OperandId, OperandVariableLiterals))
-Instruction(Switch, 0, 0, 3, 0, Capability(None), 1, List(OperandId, OperandId, OperandVariableLiteralId))
-Instruction(Kill, 0, 0, 0, 1, Capability(Shader), 0, EmptyList)
-Instruction(Return, 0, 0, 0, 0, Capability(None), 0, EmptyList)
-Instruction(ReturnValue, 0, 0, 1, 0, Capability(None), 0, List(OperandId))
-Instruction(Unreachable, 0, 0, 0, 0, Capability(None), 0, EmptyList)
-Instruction(LifetimeStart, 0, 0, 2, 1, Capability(Kernel), 0, List(OperandId, OperandLiteralNumber))
-Instruction(LifetimeStop, 0, 0, 2, 1, Capability(Kernel), 0, List(OperandId, OperandLiteralNumber))
-Instruction(GroupAsyncCopy, 1, 1, 6, 1, Capability(Kernel), 0, List(OperandScope, OperandId, OperandId, OperandId, OperandId, OperandId))
-Instruction(GroupWaitEvents, 0, 0, 3, 1, Capability(Kernel), 0, List(OperandScope, OperandId, OperandId))
-Instruction(GroupAll, 1, 1, 2, 1, Capability(Groups), 0, List(OperandScope, OperandId))
-Instruction(GroupAny, 1, 1, 2, 1, Capability(Groups), 0, List(OperandScope, OperandId))
-Instruction(GroupBroadcast, 1, 1, 3, 1, Capability(Groups), 0, List(OperandScope, OperandId, OperandId))
-Instruction(GroupIAdd, 1, 1, 3, 1, Capability(Groups), 0, List(OperandScope, OperandGroupOperation, OperandId))
-Instruction(GroupFAdd, 1, 1, 3, 1, Capability(Groups), 0, List(OperandScope, OperandGroupOperation, OperandId))
-Instruction(GroupFMin, 1, 1, 3, 1, Capability(Groups), 0, List(OperandScope, OperandGroupOperation, OperandId))
-Instruction(GroupUMin, 1, 1, 3, 1, Capability(Groups), 0, List(OperandScope, OperandGroupOperation, OperandId))
-Instruction(GroupSMin, 1, 1, 3, 1, Capability(Groups), 0, List(OperandScope, OperandGroupOperation, OperandId))
-Instruction(GroupFMax, 1, 1, 3, 1, Capability(Groups), 0, List(OperandScope, OperandGroupOperation, OperandId))
-Instruction(GroupUMax, 1, 1, 3, 1, Capability(Groups), 0, List(OperandScope, OperandGroupOperation, OperandId))
-Instruction(GroupSMax, 1, 1, 3, 1, Capability(Groups), 0, List(OperandScope, OperandGroupOperation, OperandId))
-Instruction(ReadPipe, 1, 1, 4, 1, Capability(Pipes), 0, List(OperandId, OperandId, OperandId, OperandId))
-Instruction(WritePipe, 1, 1, 4, 1, Capability(Pipes), 0, List(OperandId, OperandId, OperandId, OperandId))
-Instruction(ReservedReadPipe, 1, 1, 6, 1, Capability(Pipes), 0, List(OperandId, OperandId, OperandId, OperandId, OperandId, OperandId))
-Instruction(ReservedWritePipe, 1, 1, 6, 1, Capability(Pipes), 0, List(OperandId, OperandId, OperandId, OperandId, OperandId, OperandId))
-Instruction(ReserveReadPipePackets, 1, 1, 4, 1, Capability(Pipes), 0, List(OperandId, OperandId, OperandId, OperandId))
-Instruction(ReserveWritePipePackets, 1, 1, 4, 1, Capability(Pipes), 0, List(OperandId, OperandId, OperandId, OperandId))
-Instruction(CommitReadPipe, 0, 0, 4, 1, Capability(Pipes), 0, List(OperandId, OperandId, OperandId, OperandId))
-Instruction(CommitWritePipe, 0, 0, 4, 1, Capability(Pipes), 0, List(OperandId, OperandId, OperandId, OperandId))
-Instruction(IsValidReserveId, 1, 1, 1, 1, Capability(Pipes), 0, List(OperandId))
-Instruction(GetNumPipePackets, 1, 1, 3, 1, Capability(Pipes), 0, List(OperandId, OperandId, OperandId))
-Instruction(GetMaxPipePackets, 1, 1, 3, 1, Capability(Pipes), 0, List(OperandId, OperandId, OperandId))
-Instruction(GroupReserveReadPipePackets, 1, 1, 5, 1, Capability(Pipes), 0, List(OperandScope, OperandId, OperandId, OperandId, OperandId))
-Instruction(GroupReserveWritePipePackets, 1, 1, 5, 1, Capability(Pipes), 0, List(OperandScope, OperandId, OperandId, OperandId, OperandId))
-Instruction(GroupCommitReadPipe, 0, 0, 5, 1, Capability(Pipes), 0, List(OperandScope, OperandId, OperandId, OperandId, OperandId))
-Instruction(GroupCommitWritePipe, 0, 0, 5, 1, Capability(Pipes), 0, List(OperandScope, OperandId, OperandId, OperandId, OperandId))
-Instruction(EnqueueMarker, 1, 1, 4, 1, Capability(DeviceEnqueue), 0, List(OperandId, OperandId, OperandId, OperandId))
-Instruction(EnqueueKernel, 1, 1, 11, 1, Capability(DeviceEnqueue), 1, List(OperandId, OperandId, OperandId, OperandId, OperandId, OperandId, OperandId, OperandId, OperandId, OperandId, OperandVariableIds))
-Instruction(GetKernelNDrangeSubGroupCount, 1, 1, 5, 1, Capability(DeviceEnqueue), 0, List(OperandId, OperandId, OperandId, OperandId, OperandId))
-Instruction(GetKernelNDrangeMaxSubGroupSize, 1, 1, 5, 1, Capability(DeviceEnqueue), 0, List(OperandId, OperandId, OperandId, OperandId, OperandId))
-Instruction(GetKernelWorkGroupSize, 1, 1, 4, 1, Capability(DeviceEnqueue), 0, List(OperandId, OperandId, OperandId, OperandId))
-Instruction(GetKernelPreferredWorkGroupSizeMultiple, 1, 1, 4, 1, Capability(DeviceEnqueue), 0, List(OperandId, OperandId, OperandId, OperandId))
-Instruction(RetainEvent, 0, 0, 1, 1, Capability(DeviceEnqueue), 0, List(OperandId))
-Instruction(ReleaseEvent, 0, 0, 1, 1, Capability(DeviceEnqueue), 0, List(OperandId))
-Instruction(CreateUserEvent, 1, 1, 0, 1, Capability(DeviceEnqueue), 0, EmptyList)
-Instruction(IsValidEvent, 1, 1, 1, 1, Capability(DeviceEnqueue), 0, List(OperandId))
-Instruction(SetUserEventStatus, 0, 0, 2, 1, Capability(DeviceEnqueue), 0, List(OperandId, OperandId))
-Instruction(CaptureEventProfilingInfo, 0, 0, 3, 1, Capability(DeviceEnqueue), 0, List(OperandId, OperandId, OperandId))
-Instruction(GetDefaultQueue, 1, 1, 0, 1, Capability(DeviceEnqueue), 0, EmptyList)
-Instruction(BuildNDRange, 1, 1, 3, 1, Capability(DeviceEnqueue), 0, List(OperandId, OperandId, OperandId))
-Instruction(ImageSparseSampleImplicitLod, 1, 1, 4, 1, Capability(SparseResidency), 1, List(OperandId, OperandId, OperandOptionalImageOperands))
-Instruction(ImageSparseSampleExplicitLod, 1, 1, 5, 1, Capability(SparseResidency), 1, List(OperandId, OperandId, OperandImageOperands))
-Instruction(ImageSparseSampleDrefImplicitLod, 1, 1, 5, 1, Capability(SparseResidency), 1, List(OperandId, OperandId, OperandId, OperandOptionalImageOperands))
-Instruction(ImageSparseSampleDrefExplicitLod, 1, 1, 6, 1, Capability(SparseResidency), 1, List(OperandId, OperandId, OperandId, OperandImageOperands))
-Instruction(ImageSparseSampleProjImplicitLod, 1, 1, 4, 1, Capability(SparseResidency), 1, List(OperandId, OperandId, OperandOptionalImageOperands))
-Instruction(ImageSparseSampleProjExplicitLod, 1, 1, 5, 1, Capability(SparseResidency), 1, List(OperandId, OperandId, OperandImageOperands))
-Instruction(ImageSparseSampleProjDrefImplicitLod, 1, 1, 5, 1, Capability(SparseResidency), 1, List(OperandId, OperandId, OperandId, OperandOptionalImageOperands))
-Instruction(ImageSparseSampleProjDrefExplicitLod, 1, 1, 6, 1, Capability(SparseResidency), 1, List(OperandId, OperandId, OperandId, OperandImageOperands))
-Instruction(ImageSparseFetch, 1, 1, 4, 1, Capability(SparseResidency), 1, List(OperandId, OperandId, OperandOptionalImageOperands))
-Instruction(ImageSparseGather, 1, 1, 5, 1, Capability(SparseResidency), 1, List(OperandId, OperandId, OperandId, OperandOptionalImageOperands))
-Instruction(ImageSparseDrefGather, 1, 1, 5, 1, Capability(SparseResidency), 1, List(OperandId, OperandId, OperandId, OperandOptionalImageOperands))
-Instruction(ImageSparseTexelsResident, 1, 1, 1, 1, Capability(SparseResidency), 0, List(OperandId))
-Instruction(NoLine, 0, 0, 0, 0, Capability(None), 0, EmptyList)
-Instruction(AtomicFlagTestAndSet, 1, 1, 3, 1, Capability(Kernel), 0, List(OperandId, OperandScope, OperandMemorySemantics))
-Instruction(AtomicFlagClear, 0, 0, 3, 1, Capability(Kernel), 0, List(OperandId, OperandScope, OperandMemorySemantics))
-Instruction(ImageSparseRead, 1, 1, 4, 1, Capability(SparseResidency), 1, List(OperandId, OperandId, OperandOptionalImageOperands))
diff --git a/source/opencl_std_ext_inst.inc b/source/opencl_std_ext_inst.inc
deleted file mode 100644
index c9ad7a4..0000000
--- a/source/opencl_std_ext_inst.inc
+++ /dev/null
@@ -1,169 +0,0 @@
-
-// OpenCL extended instructions table, one instruction per line.
-// All instructions have a result type and a result ID.
-// Fields in this file are:
-// - name
-// - extended instruction index
-// - EmptyList, or List of operand classes.
-ExtInst(acos, 0, List(OperandId))
-ExtInst(acosh, 1, List(OperandId))
-ExtInst(acospi, 2, List(OperandId))
-ExtInst(asin, 3, List(OperandId))
-ExtInst(asinh, 4, List(OperandId))
-ExtInst(asinpi, 5, List(OperandId))
-ExtInst(atan, 6, List(OperandId))
-ExtInst(atan2, 7, List(OperandId, OperandId))
-ExtInst(atanh, 8, List(OperandId))
-ExtInst(atanpi, 9, List(OperandId))
-ExtInst(atan2pi, 10, List(OperandId, OperandId))
-ExtInst(cbrt, 11, List(OperandId))
-ExtInst(ceil, 12, List(OperandId))
-ExtInst(copysign, 13, List(OperandId, OperandId))
-ExtInst(cos, 14, List(OperandId))
-ExtInst(cosh, 15, List(OperandId))
-ExtInst(cospi, 16, List(OperandId))
-ExtInst(erfc, 17, List(OperandId))
-ExtInst(erf, 18, List(OperandId))
-ExtInst(exp, 19, List(OperandId))
-ExtInst(exp2, 20, List(OperandId))
-ExtInst(exp10, 21, List(OperandId))
-ExtInst(expm1, 22, List(OperandId))
-ExtInst(fabs, 23, List(OperandId))
-ExtInst(fdim, 24, List(OperandId, OperandId))
-ExtInst(floor, 25, List(OperandId))
-ExtInst(fma, 26, List(OperandId, OperandId, OperandId))
-ExtInst(fmax, 27, List(OperandId, OperandId))
-ExtInst(fmin, 28, List(OperandId, OperandId))
-ExtInst(fmod, 29, List(OperandId, OperandId))
-ExtInst(fract, 30, List(OperandId, OperandId))
-ExtInst(frexp, 31, List(OperandId, OperandId))
-ExtInst(hypot, 32, List(OperandId, OperandId))
-ExtInst(ilogb, 33, List(OperandId))
-ExtInst(ldexp, 34, List(OperandId, OperandId))
-ExtInst(lgamma, 35, List(OperandId))
-ExtInst(lgamma_r, 36, List(OperandId, OperandId))
-ExtInst(log, 37, List(OperandId))
-ExtInst(log2, 38, List(OperandId))
-ExtInst(log10, 39, List(OperandId))
-ExtInst(log1p, 40, List(OperandId))
-ExtInst(logb, 41, List(OperandId))
-ExtInst(mad, 42, List(OperandId, OperandId, OperandId))
-ExtInst(maxmag, 43, List(OperandId, OperandId))
-ExtInst(minmag, 44, List(OperandId, OperandId))
-ExtInst(modf, 45, List(OperandId, OperandId))
-ExtInst(nan, 46, List(OperandId))
-ExtInst(nextafter, 47, List(OperandId, OperandId))
-ExtInst(pow, 48, List(OperandId, OperandId, OperandId))
-ExtInst(pown, 49, List(OperandId))
-ExtInst(powr, 50, List(OperandId, OperandId))
-ExtInst(remainder, 51, List(OperandId, OperandId))
-ExtInst(remquo, 52, List(OperandId, OperandId, OperandId))
-ExtInst(rint, 53, List(OperandId))
-ExtInst(rootn, 54, List(OperandId, OperandId))
-ExtInst(round, 55, List(OperandId))
-ExtInst(rsqrt, 56, List(OperandId))
-ExtInst(sin, 57, List(OperandId))
-ExtInst(sincos, 58, List(OperandId, OperandId))
-ExtInst(sinh, 59, List(OperandId))
-ExtInst(sinpi, 60, List(OperandId))
-ExtInst(sqrt, 61, List(OperandId))
-ExtInst(tan, 62, List(OperandId))
-ExtInst(tanh, 63, List(OperandId))
-ExtInst(tanpi, 64, List(OperandId))
-ExtInst(tgamma, 65, List(OperandId))
-ExtInst(trunc, 66, List(OperandId))
-ExtInst(half_cos, 67, List(OperandId))
-ExtInst(half_divide, 68, List(OperandId, OperandId))
-ExtInst(half_exp, 69, List(OperandId))
-ExtInst(half_exp2, 70, List(OperandId))
-ExtInst(half_exp10, 71, List(OperandId))
-ExtInst(half_log, 72, List(OperandId))
-ExtInst(half_log2, 73, List(OperandId))
-ExtInst(half_log10, 74, List(OperandId))
-ExtInst(half_powr, 75, List(OperandId, OperandId))
-ExtInst(half_recip, 76, List(OperandId))
-ExtInst(half_rsqrt, 77, List(OperandId))
-ExtInst(half_sin, 78, List(OperandId))
-ExtInst(half_sqrt, 79, List(OperandId))
-ExtInst(half_tan, 80, List(OperandId))
-ExtInst(native_cos, 81, List(OperandId))
-ExtInst(native_divide, 82, List(OperandId, OperandId))
-ExtInst(native_exp, 83, List(OperandId))
-ExtInst(native_exp2, 84, List(OperandId))
-ExtInst(native_exp10, 85, List(OperandId))
-ExtInst(native_log, 86, List(OperandId))
-ExtInst(native_log2, 87, List(OperandId))
-ExtInst(native_log10, 88, List(OperandId))
-ExtInst(native_powr, 89, List(OperandId, OperandId))
-ExtInst(native_recip, 90, List(OperandId))
-ExtInst(native_rsqrt, 91, List(OperandId))
-ExtInst(native_sin, 92, List(OperandId))
-ExtInst(native_sqrt, 93, List(OperandId))
-ExtInst(native_tan, 94, List(OperandId))
-ExtInst(fclamp, 95, List(OperandId, OperandId, OperandId))
-ExtInst(degrees, 96, List(OperandId))
-ExtInst(fmax_common, 97, List(OperandId, OperandId))
-ExtInst(fmin_common, 98, List(OperandId, OperandId))
-ExtInst(mix, 99, List(OperandId, OperandId, OperandId))
-ExtInst(radians, 100, List(OperandId))
-ExtInst(step, 101, List(OperandId, OperandId))
-ExtInst(smoothstep, 102, List(OperandId, OperandId, OperandId))
-ExtInst(sign, 103, List(OperandId))
-ExtInst(cross, 104, List(OperandId, OperandId))
-ExtInst(distance, 105, List(OperandId, OperandId))
-ExtInst(length, 106, List(OperandId))
-ExtInst(normalize, 107, List(OperandId))
-ExtInst(fast_distance, 108, List(OperandId, OperandId))
-ExtInst(fast_length, 109, List(OperandId))
-ExtInst(fast_normalize, 110, List(OperandId))
-ExtInst(s_abs, 141, List(OperandId))
-ExtInst(s_abs_diff, 142, List(OperandId, OperandId))
-ExtInst(s_add_sat, 143, List(OperandId, OperandId))
-ExtInst(u_add_sat, 144, List(OperandId, OperandId))
-ExtInst(s_hadd, 145, List(OperandId, OperandId))
-ExtInst(u_hadd, 146, List(OperandId, OperandId))
-ExtInst(s_rhadd, 147, List(OperandId, OperandId))
-ExtInst(u_rhadd, 148, List(OperandId, OperandId))
-ExtInst(s_clamp, 149, List(OperandId, OperandId, OperandId))
-ExtInst(u_clamp, 150, List(OperandId, OperandId, OperandId))
-ExtInst(clz, 151, List(OperandId))
-ExtInst(ctz, 152, List(OperandId))
-ExtInst(s_mad_hi, 153, List(OperandId, OperandId, OperandId))
-ExtInst(u_mad_sat, 154, List(OperandId, OperandId, OperandId))
-ExtInst(s_mad_sat, 155, List(OperandId, OperandId, OperandId))
-ExtInst(s_max, 156, List(OperandId, OperandId))
-ExtInst(u_max, 157, List(OperandId, OperandId))
-ExtInst(s_min, 158, List(OperandId, OperandId))
-ExtInst(u_min, 159, List(OperandId, OperandId))
-ExtInst(s_mul_hi, 160, List(OperandId, OperandId))
-ExtInst(rotate, 161, List(OperandId, OperandId))
-ExtInst(s_sub_sat, 162, List(OperandId, OperandId))
-ExtInst(u_sub_sat, 163, List(OperandId, OperandId))
-ExtInst(u_upsample, 164, List(OperandId, OperandId))
-ExtInst(s_upsample, 165, List(OperandId, OperandId))
-ExtInst(popcount, 166, List(OperandId))
-ExtInst(s_mad24, 167, List(OperandId, OperandId, OperandId))
-ExtInst(u_mad24, 168, List(OperandId, OperandId, OperandId))
-ExtInst(s_mul24, 169, List(OperandId, OperandId))
-ExtInst(u_mul24, 170, List(OperandId, OperandId))
-ExtInst(vloadn, 171, List(OperandId, OperandId, OperandLiteralNumber))
-ExtInst(vstoren, 172, List(OperandId, OperandId, OperandId))
-ExtInst(vload_half, 173, List(OperandId, OperandId))
-ExtInst(vload_halfn, 174, List(OperandId, OperandId, OperandLiteralNumber))
-ExtInst(vstore_half, 175, List(OperandId, OperandId, OperandId))
-ExtInst(vstore_half_r, 176, List(OperandId, OperandId, OperandId, OperandFPRoundingMode))
-ExtInst(vstore_halfn, 177, List(OperandId, OperandId, OperandId))
-ExtInst(vstore_halfn_r, 178, List(OperandId, OperandId, OperandId, OperandFPRoundingMode))
-ExtInst(vloada_halfn, 179, List(OperandId, OperandId, OperandLiteralNumber))
-ExtInst(vstorea_halfn, 180, List(OperandId, OperandId, OperandId))
-ExtInst(vstorea_halfn_r, 181, List(OperandId, OperandId, OperandId, OperandFPRoundingMode))
-ExtInst(shuffle, 182, List(OperandId, OperandId))
-ExtInst(shuffle2, 183, List(OperandId, OperandId, OperandId))
-ExtInst(printf, 184, List(OperandId, OperandVariableIds))
-ExtInst(prefetch, 185, List(OperandId, OperandId))
-ExtInst(bitselect, 186, List(OperandId, OperandId, OperandId))
-ExtInst(select, 187, List(OperandId, OperandId, OperandId))
-ExtInst(u_abs, 201, List(OperandId))
-ExtInst(u_abs_diff, 202, List(OperandId, OperandId))
-ExtInst(u_mul_hi, 203, List(OperandId, OperandId))
-ExtInst(u_mad_hi, 204, List(OperandId, OperandId, OperandId))
diff --git a/source/operand.cpp b/source/operand.cpp
index 7a2c075..5de3f43 100644
--- a/source/operand.cpp
+++ b/source/operand.cpp
@@ -29,1066 +29,21 @@
#include <assert.h>
#include <string.h>
-static const spv_operand_desc_t sourceLanguageEntries[] = {
- {"Unknown", SpvSourceLanguageUnknown, 0, {SPV_OPERAND_TYPE_NONE}},
- {"ESSL", SpvSourceLanguageESSL, 0, {SPV_OPERAND_TYPE_NONE}},
- {"GLSL", SpvSourceLanguageGLSL, 0, {SPV_OPERAND_TYPE_NONE}},
- {"OpenCL_C", SpvSourceLanguageOpenCL_C, 0, {SPV_OPERAND_TYPE_NONE}},
- {"OpenCL_CPP", SpvSourceLanguageOpenCL_CPP, 0, {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t executionModelEntries[] = {
- {"Vertex",
- SpvExecutionModelVertex,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"TessellationControl",
- SpvExecutionModelTessellationControl,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityTessellation),
- {SPV_OPERAND_TYPE_NONE}},
- {"TessellationEvaluation",
- SpvExecutionModelTessellationEvaluation,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityTessellation),
- {SPV_OPERAND_TYPE_NONE}},
- {"Geometry",
- SpvExecutionModelGeometry,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityGeometry),
- {SPV_OPERAND_TYPE_NONE}},
- {"Fragment",
- SpvExecutionModelFragment,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"GLCompute",
- SpvExecutionModelGLCompute,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"Kernel",
- SpvExecutionModelKernel,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t addressingModelEntries[] = {
- {"Logical", SpvAddressingModelLogical, 0, {SPV_OPERAND_TYPE_NONE}},
- {"Physical32",
- SpvAddressingModelPhysical32,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityAddresses),
- {SPV_OPERAND_TYPE_NONE}},
- {"Physical64",
- SpvAddressingModelPhysical64,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityAddresses),
- {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t memoryModelEntries[] = {
- {"Simple",
- SpvMemoryModelSimple,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"GLSL450",
- SpvMemoryModelGLSL450,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"OpenCL",
- SpvMemoryModelOpenCL,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
-};
-
-// Execution mode requiring the given capability and having no operands.
-#define ExecMode0(mode, cap) \
- #mode, SpvExecutionMode##mode, SPV_CAPABILITY_AS_MASK(SpvCapability##cap), { \
- SPV_OPERAND_TYPE_NONE \
- }
-// Execution mode requiring the given capability and having one literal number
-// operand.
-#define ExecMode1(mode, cap) \
- #mode, SpvExecutionMode##mode, SPV_CAPABILITY_AS_MASK(SpvCapability##cap), { \
- SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE \
- }
-static const spv_operand_desc_t executionModeEntries[] = {
- {ExecMode1(Invocations, Geometry)},
- {ExecMode0(SpacingEqual, Tessellation)},
- {ExecMode0(SpacingFractionalEven, Tessellation)},
- {ExecMode0(SpacingFractionalOdd, Tessellation)},
- {ExecMode0(VertexOrderCw, Tessellation)},
- {ExecMode0(VertexOrderCcw, Tessellation)},
- {ExecMode0(PixelCenterInteger, Shader)},
- {ExecMode0(OriginUpperLeft, Shader)},
- {ExecMode0(OriginLowerLeft, Shader)},
- {ExecMode0(EarlyFragmentTests, Shader)},
- {ExecMode0(PointMode, Tessellation)},
- {ExecMode0(Xfb, TransformFeedback)},
- {ExecMode0(DepthReplacing, Shader)},
- {ExecMode0(DepthGreater, Shader)},
- {ExecMode0(DepthLess, Shader)},
- {ExecMode0(DepthUnchanged, Shader)},
- {"LocalSize",
- SpvExecutionModeLocalSize,
- 0,
- {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER,
- SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
- {"LocalSizeHint",
- SpvExecutionModeLocalSizeHint,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_LITERAL_INTEGER,
- SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
- {ExecMode0(InputPoints, Geometry)},
- {ExecMode0(InputLines, Geometry)},
- {ExecMode0(InputLinesAdjacency, Geometry)},
- {"Triangles",
- SpvExecutionModeTriangles,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityGeometry) |
- SPV_CAPABILITY_AS_MASK(SpvCapabilityTessellation),
- {SPV_OPERAND_TYPE_NONE}},
- {ExecMode0(InputTrianglesAdjacency, Geometry)},
- {ExecMode0(Quads, Tessellation)},
- {ExecMode0(Isolines, Tessellation)},
- {"OutputVertices",
- SpvExecutionModeOutputVertices,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityGeometry) |
- SPV_CAPABILITY_AS_MASK(SpvCapabilityTessellation),
- {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
- {ExecMode0(OutputPoints, Geometry)},
- {ExecMode0(OutputLineStrip, Geometry)},
- {ExecMode0(OutputTriangleStrip, Geometry)},
- {ExecMode1(VecTypeHint, Kernel)},
- {ExecMode0(ContractionOff, Kernel)},
-};
-#undef ExecMode0
-#undef ExecMode1
-
-static const spv_operand_desc_t storageClassEntries[] = {
- // TODO(dneto): There are more storage classes in Rev32 and later.
- {"UniformConstant",
- SpvStorageClassUniformConstant,
- 0,
- {SPV_OPERAND_TYPE_NONE}},
- {"Input",
- SpvStorageClassInput,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"Uniform",
- SpvStorageClassUniform,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"Output",
- SpvStorageClassOutput,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"Workgroup", SpvStorageClassWorkgroup, 0, {SPV_OPERAND_TYPE_NONE}},
- {"CrossWorkgroup",
- SpvStorageClassCrossWorkgroup,
- 0,
- {SPV_OPERAND_TYPE_NONE}},
- {"Private",
- SpvStorageClassPrivate,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"Function", SpvStorageClassFunction, 0, {SPV_OPERAND_TYPE_NONE}},
- {"Generic",
- SpvStorageClassGeneric,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityGenericPointer),
- {SPV_OPERAND_TYPE_NONE}},
- {"PushConstant",
- SpvStorageClassPushConstant,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"AtomicCounter",
- SpvStorageClassAtomicCounter,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityAtomicStorage),
- {SPV_OPERAND_TYPE_NONE}},
- {"Image", SpvStorageClassImage, 0, {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t dimensionalityEntries[] = {
- {"1D",
- SpvDim1D,
- SPV_CAPABILITY_AS_MASK(SpvCapabilitySampled1D),
- {SPV_OPERAND_TYPE_NONE}},
- {"2D", SpvDim2D, 0, {SPV_OPERAND_TYPE_NONE}},
- {"3D", SpvDim3D, 0, {SPV_OPERAND_TYPE_NONE}},
- {"Cube",
- SpvDimCube,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"Rect",
- SpvDimRect,
- SPV_CAPABILITY_AS_MASK(SpvCapabilitySampledRect),
- {SPV_OPERAND_TYPE_NONE}},
- {"Buffer",
- SpvDimBuffer,
- SPV_CAPABILITY_AS_MASK(SpvCapabilitySampledBuffer),
- {SPV_OPERAND_TYPE_NONE}},
- {"SubpassData",
- SpvDimSubpassData,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityInputAttachment),
- {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t samplerAddressingModeEntries[] = {
- {"None",
- SpvSamplerAddressingModeNone,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"ClampToEdge",
- SpvSamplerAddressingModeClampToEdge,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"Clamp",
- SpvSamplerAddressingModeClamp,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"Repeat",
- SpvSamplerAddressingModeRepeat,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"RepeatMirrored",
- SpvSamplerAddressingModeRepeatMirrored,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t samplerFilterModeEntries[] = {
- {"Nearest",
- SpvSamplerFilterModeNearest,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"Linear",
- SpvSamplerFilterModeLinear,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t samplerImageFormatEntries[] = {
-#define CASE0(NAME) \
- { \
- #NAME, SpvImageFormat##NAME, 0, { SPV_OPERAND_TYPE_NONE } \
- }
-#define CASE(NAME, CAP) \
- { \
- #NAME, SpvImageFormat##NAME, SPV_CAPABILITY_AS_MASK(SpvCapability##CAP), { \
- SPV_OPERAND_TYPE_NONE \
- } \
- }
- // clang-format off
- CASE0(Unknown),
- CASE(Rgba32f, Shader),
- CASE(Rgba16f, Shader),
- CASE(R32f, Shader),
- CASE(Rgba8, Shader),
- CASE(Rgba8Snorm, Shader),
- CASE(Rg32f, StorageImageExtendedFormats),
- CASE(Rg16f, StorageImageExtendedFormats),
- CASE(R11fG11fB10f, StorageImageExtendedFormats),
- CASE(R16f, StorageImageExtendedFormats),
- CASE(Rgba16, StorageImageExtendedFormats),
- CASE(Rgb10A2, StorageImageExtendedFormats),
- CASE(Rg16, StorageImageExtendedFormats),
- CASE(Rg8, StorageImageExtendedFormats),
- CASE(R16, StorageImageExtendedFormats),
- CASE(R8, StorageImageExtendedFormats),
- CASE(Rgba16Snorm, StorageImageExtendedFormats),
- CASE(Rg16Snorm, StorageImageExtendedFormats),
- CASE(Rg8Snorm, StorageImageExtendedFormats),
- CASE(R16Snorm, StorageImageExtendedFormats),
- CASE(R8Snorm, StorageImageExtendedFormats),
- CASE(Rgba32i, Shader),
- CASE(Rgba16i, Shader),
- CASE(Rgba8i, Shader),
- CASE(R32i, Shader),
- CASE(Rg32i, StorageImageExtendedFormats),
- CASE(Rg16i, StorageImageExtendedFormats),
- CASE(Rg8i, StorageImageExtendedFormats),
- CASE(R16i, StorageImageExtendedFormats),
- CASE(R8i, StorageImageExtendedFormats),
- CASE(Rgba32ui, Shader),
- CASE(Rgba16ui, Shader),
- CASE(Rgba8ui, Shader),
- CASE(R32ui, Shader),
- CASE(Rgb10a2ui, StorageImageExtendedFormats),
- CASE(Rg32ui, StorageImageExtendedFormats),
- CASE(Rg16ui, StorageImageExtendedFormats),
- CASE(Rg8ui, StorageImageExtendedFormats),
- CASE(R16ui, StorageImageExtendedFormats),
- CASE(R8ui, StorageImageExtendedFormats),
-// clang-format on
-#undef CASE
-};
-
-// All image channel orders depend on the Kernel capability.
-#define CASE(NAME) \
- { \
- #NAME, SpvImageChannelOrder##NAME, \
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel), { \
- SPV_OPERAND_TYPE_NONE \
- } \
- }
-static const spv_operand_desc_t imageChannelOrderEntries[] = {
- CASE(R), CASE(A), CASE(RG), CASE(RA), CASE(RGB),
- CASE(RGBA), CASE(BGRA), CASE(ARGB), CASE(Intensity), CASE(Luminance),
- CASE(Rx), CASE(RGx), CASE(RGBx), CASE(Depth), CASE(DepthStencil),
- CASE(sRGB), CASE(sRGBx), CASE(sRGBA), CASE(sBGRA),
-};
-#undef CASE
-
-// All image channel data types depend on the Kernel capability.
-#define CASE(NAME) \
- { \
- #NAME, SpvImageChannelDataType##NAME, \
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel), { \
- SPV_OPERAND_TYPE_NONE \
- } \
- }
-static const spv_operand_desc_t imageChannelDataTypeEntries[] = {
- CASE(SnormInt8), CASE(SnormInt16), CASE(UnormInt8),
- CASE(UnormInt16), CASE(UnormShort565), CASE(UnormShort555),
- CASE(UnormInt101010), CASE(SignedInt8), CASE(SignedInt16),
- CASE(SignedInt32), CASE(UnsignedInt8), CASE(UnsignedInt16),
- CASE(UnsignedInt32), CASE(HalfFloat), CASE(Float),
- CASE(UnormInt24), CASE(UnormInt101010_2),
-};
-#undef CASE
-
-// Image operand definitions. Each enum value is a mask. When that mask
-// bit is set, the instruction should have further ID operands.
-// Some mask values depend on a capability.
-static const spv_operand_desc_t imageOperandEntries[] = {
-// Rev32 and later adds many more enums.
-#define CASE(NAME) #NAME, SpvImageOperands##NAME##Mask, 0
-#define CASE_CAP(NAME, CAP) #NAME, SpvImageOperands##NAME##Mask, CAP
-#define ID SPV_OPERAND_TYPE_ID
-#define NONE SPV_OPERAND_TYPE_NONE
- {"None", SpvImageOperandsMaskNone, 0, {NONE}},
- {CASE_CAP(Bias, SPV_CAPABILITY_AS_MASK(SpvCapabilityShader)), {ID, NONE}},
- {CASE(Lod), {ID, NONE}},
- {CASE(Grad), {ID, ID, NONE}},
- {CASE(ConstOffset), {ID, NONE}},
- {CASE_CAP(Offset, SPV_CAPABILITY_AS_MASK(SpvCapabilityImageGatherExtended)),
- {ID, NONE}},
- {CASE(ConstOffsets), {ID, NONE}},
- {CASE(Sample), {ID, NONE}},
- {CASE_CAP(MinLod, SPV_CAPABILITY_AS_MASK(SpvCapabilityMinLod)), {ID, NONE}},
-#undef CASE
-#undef CASE_CAP
-#undef ID
-#undef NONE
-};
-
-static const spv_operand_desc_t fpFastMathModeEntries[] = {
- {"None", SpvFPFastMathModeMaskNone, 0, {SPV_OPERAND_TYPE_NONE}},
- {"NotNaN",
- SpvFPFastMathModeNotNaNMask,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"NotInf",
- SpvFPFastMathModeNotInfMask,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"NSZ",
- SpvFPFastMathModeNSZMask,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"AllowRecip",
- SpvFPFastMathModeAllowRecipMask,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"Fast",
- SpvFPFastMathModeFastMask,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t fpRoundingModeEntries[] = {
- {"RTE",
- SpvFPRoundingModeRTE,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"RTZ",
- SpvFPRoundingModeRTZ,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"RTP",
- SpvFPRoundingModeRTP,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"RTN",
- SpvFPRoundingModeRTN,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t linkageTypeEntries[] = {
- {"Export",
- SpvLinkageTypeExport,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityLinkage),
- {SPV_OPERAND_TYPE_NONE}},
- {"Import",
- SpvLinkageTypeImport,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityLinkage),
- {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t accessQualifierEntries[] = {
- {"ReadOnly",
- SpvAccessQualifierReadOnly,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"WriteOnly",
- SpvAccessQualifierWriteOnly,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"ReadWrite",
- SpvAccessQualifierReadWrite,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t functionParameterAttributeEntries[] = {
- {"Zext",
- SpvFunctionParameterAttributeZext,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"Sext",
- SpvFunctionParameterAttributeSext,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"ByVal",
- SpvFunctionParameterAttributeByVal,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"Sret",
- SpvFunctionParameterAttributeSret,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"NoAlias",
- SpvFunctionParameterAttributeNoAlias,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"NoCapture",
- SpvFunctionParameterAttributeNoCapture,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"NoWrite",
- SpvFunctionParameterAttributeNoWrite,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"NoReadWrite",
- SpvFunctionParameterAttributeNoReadWrite,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t decorationEntries[] = {
- {"RelaxedPrecision",
- SpvDecorationRelaxedPrecision,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {
- "SpecId",
- SpvDecorationSpecId,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_LITERAL_INTEGER},
- },
- {"Block",
- SpvDecorationBlock,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"BufferBlock",
- SpvDecorationBufferBlock,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"RowMajor",
- SpvDecorationRowMajor,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityMatrix),
- {SPV_OPERAND_TYPE_NONE}},
- {"ColMajor",
- SpvDecorationColMajor,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityMatrix),
- {SPV_OPERAND_TYPE_NONE}},
- {"ArrayStride",
- SpvDecorationArrayStride,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
- {"MatrixStride",
- SpvDecorationMatrixStride,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityMatrix),
- {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
- {"GLSLShared",
- SpvDecorationGLSLShared,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"GLSLPacked",
- SpvDecorationGLSLPacked,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"CPacked",
- SpvDecorationCPacked,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"BuiltIn",
- SpvDecorationBuiltIn,
- 0,
- {SPV_OPERAND_TYPE_BUILT_IN, SPV_OPERAND_TYPE_NONE}},
- {"NoPerspective",
- SpvDecorationNoPerspective,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"Flat",
- SpvDecorationFlat,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"Patch",
- SpvDecorationPatch,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityTessellation),
- {SPV_OPERAND_TYPE_NONE}},
- {"Centroid",
- SpvDecorationCentroid,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"Sample",
- SpvDecorationSample,
- SPV_CAPABILITY_AS_MASK(SpvCapabilitySampleRateShading),
- {SPV_OPERAND_TYPE_NONE}},
- {"Invariant",
- SpvDecorationInvariant,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"Restrict", SpvDecorationRestrict, 0, {SPV_OPERAND_TYPE_NONE}},
- {"Aliased", SpvDecorationAliased, 0, {SPV_OPERAND_TYPE_NONE}},
- {"Volatile", SpvDecorationVolatile, 0, {SPV_OPERAND_TYPE_NONE}},
- {"Constant",
- SpvDecorationConstant,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"Coherent", SpvDecorationCoherent, 0, {SPV_OPERAND_TYPE_NONE}},
- {"NonWritable", SpvDecorationNonWritable, 0, {SPV_OPERAND_TYPE_NONE}},
- {"NonReadable", SpvDecorationNonReadable, 0, {SPV_OPERAND_TYPE_NONE}},
- {"Uniform",
- SpvDecorationUniform,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"SaturatedConversion",
- SpvDecorationSaturatedConversion,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"Stream",
- SpvDecorationStream,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityGeometryStreams),
- {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
- {"Location",
- SpvDecorationLocation,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
- {"Component",
- SpvDecorationComponent,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
- {"Index",
- SpvDecorationIndex,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
- {"Binding",
- SpvDecorationBinding,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
- {"DescriptorSet",
- SpvDecorationDescriptorSet,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
- {"Offset",
- SpvDecorationOffset,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
- {"XfbBuffer",
- SpvDecorationXfbBuffer,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityTransformFeedback),
- {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
- {"XfbStride",
- SpvDecorationXfbStride,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityTransformFeedback),
- {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
- {"FuncParamAttr",
- SpvDecorationFuncParamAttr,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE, SPV_OPERAND_TYPE_NONE}},
- {"FPRoundingMode",
- SpvDecorationFPRoundingMode,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_FP_ROUNDING_MODE, SPV_OPERAND_TYPE_NONE}},
- {"FPFastMathMode",
- SpvDecorationFPFastMathMode,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_FP_FAST_MATH_MODE, SPV_OPERAND_TYPE_NONE}},
- {"LinkageAttributes",
- SpvDecorationLinkageAttributes,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityLinkage),
- {SPV_OPERAND_TYPE_LITERAL_STRING, SPV_OPERAND_TYPE_LINKAGE_TYPE,
- SPV_OPERAND_TYPE_NONE}},
- {"NoContraction",
- SpvDecorationNoContraction,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"InputAttachmentIndex",
- SpvDecorationInputAttachmentIndex,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityInputAttachment),
- {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
- {"Alignment",
- SpvDecorationAlignment,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t builtInEntries[] = {
- {"Position",
- SpvBuiltInPosition,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"PointSize",
- SpvBuiltInPointSize,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"ClipDistance",
- SpvBuiltInClipDistance,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityClipDistance),
- {SPV_OPERAND_TYPE_NONE}},
- {"CullDistance",
- SpvBuiltInCullDistance,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityCullDistance),
- {SPV_OPERAND_TYPE_NONE}},
- {"VertexId",
- SpvBuiltInVertexId,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"InstanceId",
- SpvBuiltInInstanceId,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"PrimitiveId",
- SpvBuiltInPrimitiveId,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityGeometry) |
- SPV_CAPABILITY_AS_MASK(SpvCapabilityTessellation),
- {SPV_OPERAND_TYPE_NONE}},
- {"InvocationId",
- SpvBuiltInInvocationId,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityGeometry) |
- SPV_CAPABILITY_AS_MASK(SpvCapabilityTessellation),
- {SPV_OPERAND_TYPE_NONE}},
- {"Layer",
- SpvBuiltInLayer,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityGeometry),
- {SPV_OPERAND_TYPE_NONE}},
- {"ViewportIndex",
- SpvBuiltInViewportIndex,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityMultiViewport),
- {SPV_OPERAND_TYPE_NONE}},
- {"TessLevelOuter",
- SpvBuiltInTessLevelOuter,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityTessellation),
- {SPV_OPERAND_TYPE_NONE}},
- {"TessLevelInner",
- SpvBuiltInTessLevelInner,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityTessellation),
- {SPV_OPERAND_TYPE_NONE}},
- {"TessCoord",
- SpvBuiltInTessCoord,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityTessellation),
- {SPV_OPERAND_TYPE_NONE}},
- {"PatchVertices",
- SpvBuiltInPatchVertices,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityTessellation),
- {SPV_OPERAND_TYPE_NONE}},
- {"FragCoord",
- SpvBuiltInFragCoord,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"PointCoord",
- SpvBuiltInPointCoord,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"FrontFacing",
- SpvBuiltInFrontFacing,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"SampleId",
- SpvBuiltInSampleId,
- SPV_CAPABILITY_AS_MASK(SpvCapabilitySampleRateShading),
- {SPV_OPERAND_TYPE_NONE}},
- {"SamplePosition",
- SpvBuiltInSamplePosition,
- SPV_CAPABILITY_AS_MASK(SpvCapabilitySampleRateShading),
- {SPV_OPERAND_TYPE_NONE}},
- {"SampleMask",
- SpvBuiltInSampleMask,
- SPV_CAPABILITY_AS_MASK(SpvCapabilitySampleRateShading),
- {SPV_OPERAND_TYPE_NONE}},
- {"FragDepth",
- SpvBuiltInFragDepth,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"HelperInvocation",
- SpvBuiltInHelperInvocation,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"NumWorkgroups", SpvBuiltInNumWorkgroups, 0, {SPV_OPERAND_TYPE_NONE}},
- {"WorkgroupSize", SpvBuiltInWorkgroupSize, 0, {SPV_OPERAND_TYPE_NONE}},
- {"WorkgroupId", SpvBuiltInWorkgroupId, 0, {SPV_OPERAND_TYPE_NONE}},
- {"LocalInvocationId",
- SpvBuiltInLocalInvocationId,
- 0,
- {SPV_OPERAND_TYPE_NONE}},
- {"GlobalInvocationId",
- SpvBuiltInGlobalInvocationId,
- 0,
- {SPV_OPERAND_TYPE_NONE}},
- {"LocalInvocationIndex",
- SpvBuiltInLocalInvocationIndex,
- 0,
- {SPV_OPERAND_TYPE_NONE}},
- {"WorkDim",
- SpvBuiltInWorkDim,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"GlobalSize",
- SpvBuiltInGlobalSize,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"EnqueuedWorkgroupSize",
- SpvBuiltInEnqueuedWorkgroupSize,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"GlobalOffset",
- SpvBuiltInGlobalOffset,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"GlobalLinearId",
- SpvBuiltInGlobalLinearId,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"SubgroupSize",
- SpvBuiltInSubgroupSize,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"SubgroupMaxSize",
- SpvBuiltInSubgroupMaxSize,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"NumSubgroups",
- SpvBuiltInNumSubgroups,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"NumEnqueuedSubgroups",
- SpvBuiltInNumEnqueuedSubgroups,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"SubgroupId",
- SpvBuiltInSubgroupId,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"SubgroupLocalInvocationId",
- SpvBuiltInSubgroupLocalInvocationId,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"VertexIndex",
- SpvBuiltInVertexIndex,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"InstanceIndex",
- SpvBuiltInInstanceIndex,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t selectionControlEntries[] = {
- {"None", SpvSelectionControlMaskNone, 0, {SPV_OPERAND_TYPE_NONE}},
- {"Flatten", SpvSelectionControlFlattenMask, 0, {SPV_OPERAND_TYPE_NONE}},
- {"DontFlatten",
- SpvSelectionControlDontFlattenMask,
- 0,
- {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t loopControlEntries[] = {
- {"None", SpvLoopControlMaskNone, 0, {SPV_OPERAND_TYPE_NONE}},
- {"Unroll", SpvLoopControlUnrollMask, 0, {SPV_OPERAND_TYPE_NONE}},
- {"DontUnroll", SpvLoopControlDontUnrollMask, 0, {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t functionControlEntries[] = {
- {"None", SpvFunctionControlMaskNone, 0, {SPV_OPERAND_TYPE_NONE}},
- {"Inline", SpvFunctionControlInlineMask, 0, {SPV_OPERAND_TYPE_NONE}},
- {"DontInline",
- SpvFunctionControlDontInlineMask,
- 0,
- {SPV_OPERAND_TYPE_NONE}},
- {"Pure", SpvFunctionControlPureMask, 0, {SPV_OPERAND_TYPE_NONE}},
- {"Const", SpvFunctionControlConstMask, 0, {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t memorySemanticsEntries[] = {
- // "Relaxed" should be a synonym for "None".
- // Put the Relaxed entry first so that the disassembler
- // will prefer to emit "Relaxed".
- {"Relaxed", SpvMemorySemanticsMaskNone, 0, {SPV_OPERAND_TYPE_NONE}},
- {"None", SpvMemorySemanticsMaskNone, 0, {SPV_OPERAND_TYPE_NONE}},
- {"SequentiallyConsistent",
- SpvMemorySemanticsSequentiallyConsistentMask,
- 0,
- {SPV_OPERAND_TYPE_NONE}},
- {"Acquire", SpvMemorySemanticsAcquireMask, 0, {SPV_OPERAND_TYPE_NONE}},
- {"Release", SpvMemorySemanticsReleaseMask, 0, {SPV_OPERAND_TYPE_NONE}},
- {"AcquireRelease",
- SpvMemorySemanticsAcquireReleaseMask,
- 0,
- {SPV_OPERAND_TYPE_NONE}},
- {"UniformMemory",
- SpvMemorySemanticsUniformMemoryMask,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityShader),
- {SPV_OPERAND_TYPE_NONE}},
- {"SubgroupMemory",
- SpvMemorySemanticsSubgroupMemoryMask,
- 0,
- {SPV_OPERAND_TYPE_NONE}},
- {"WorkgroupMemory",
- SpvMemorySemanticsWorkgroupMemoryMask,
- 0,
- {SPV_OPERAND_TYPE_NONE}},
- {"CrossWorkgroupMemory",
- SpvMemorySemanticsCrossWorkgroupMemoryMask,
- 0,
- {SPV_OPERAND_TYPE_NONE}},
- {"AtomicCounterMemory",
- SpvMemorySemanticsAtomicCounterMemoryMask,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityAtomicStorage),
- {SPV_OPERAND_TYPE_NONE}},
- {
- "ImageMemory",
- SpvMemorySemanticsImageMemoryMask,
- 0,
- {SPV_OPERAND_TYPE_NONE},
- },
-};
-
-static const spv_operand_desc_t memoryAccessEntries[] = {
- {"None", SpvMemoryAccessMaskNone, 0, {SPV_OPERAND_TYPE_NONE}},
- {"Volatile", SpvMemoryAccessVolatileMask, 0, {SPV_OPERAND_TYPE_NONE}},
- {
- "Aligned",
- SpvMemoryAccessAlignedMask,
- 0,
- {SPV_OPERAND_TYPE_LITERAL_INTEGER, SPV_OPERAND_TYPE_NONE},
- },
- {"Nontemporal", SpvMemoryAccessNontemporalMask, 0, {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t scopeEntries[] = {
- {"CrossDevice", SpvScopeCrossDevice, 0, {SPV_OPERAND_TYPE_NONE}},
- {"Device", SpvScopeDevice, 0, {SPV_OPERAND_TYPE_NONE}},
- {"Workgroup", SpvScopeWorkgroup, 0, {SPV_OPERAND_TYPE_NONE}},
- {"Subgroup", SpvScopeSubgroup, 0, {SPV_OPERAND_TYPE_NONE}},
- {
- "Invocation", SpvScopeInvocation, 0, {SPV_OPERAND_TYPE_NONE},
- },
-};
-
-static const spv_operand_desc_t groupOperationEntries[] = {
- {"Reduce",
- SpvGroupOperationReduce,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"InclusiveScan",
- SpvGroupOperationInclusiveScan,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"ExclusiveScan",
- SpvGroupOperationExclusiveScan,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t kernelKernelEnqueueFlagssEntries[] = {
- {"NoWait",
- SpvKernelEnqueueFlagsNoWait,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"WaitKernel",
- SpvKernelEnqueueFlagsWaitKernel,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
- {"WaitWorkGroup",
- SpvKernelEnqueueFlagsWaitWorkGroup,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
-};
-
-static const spv_operand_desc_t kernelProfilingInfoEntries[] = {
- {"None", SpvKernelProfilingInfoMaskNone, 0, {SPV_OPERAND_TYPE_NONE}},
- {"CmdExecTime",
- SpvKernelProfilingInfoCmdExecTimeMask,
- SPV_CAPABILITY_AS_MASK(SpvCapabilityKernel),
- {SPV_OPERAND_TYPE_NONE}},
-};
-
-// A macro for defining a capability that doesn't depend on another capability.
-#define CASE(NAME) \
- { \
- #NAME, SpvCapability##NAME, 0, { SPV_OPERAND_TYPE_NONE } \
- }
-
-// A macro for defining a capability that depends on another.
-#define CASE_CAP(NAME, CAP) \
- { \
- #NAME, SpvCapability##NAME, SPV_CAPABILITY_AS_MASK(SpvCapability##CAP), { \
- SPV_OPERAND_TYPE_NONE \
- } \
- }
-
-// clang-format off
-static const spv_operand_desc_t capabilityInfoEntries[] = {
- CASE(Matrix),
- CASE_CAP(Shader, Matrix),
- CASE_CAP(Geometry, Shader),
- CASE_CAP(Tessellation, Shader),
- CASE(Addresses),
- CASE(Linkage),
- CASE(Kernel),
- CASE_CAP(Vector16, Kernel),
- CASE_CAP(Float16Buffer, Kernel),
- CASE(Float16),
- CASE(Float64),
- CASE(Int64),
- CASE_CAP(Int64Atomics, Int64),
- CASE_CAP(ImageBasic, Kernel),
- CASE_CAP(ImageReadWrite, Kernel),
- CASE_CAP(ImageMipmap, Kernel),
- // Value 16 intentionally missing.
- CASE_CAP(Pipes, Kernel),
- CASE(Groups),
- CASE_CAP(DeviceEnqueue, Kernel),
- CASE_CAP(LiteralSampler, Kernel),
- CASE_CAP(AtomicStorage, Shader),
- CASE(Int16),
- CASE_CAP(TessellationPointSize, Tessellation),
- CASE_CAP(GeometryPointSize, Geometry),
- CASE_CAP(ImageGatherExtended, Shader),
- // Value 26 intentionally missing.
- CASE_CAP(StorageImageMultisample, Shader),
- CASE_CAP(UniformBufferArrayDynamicIndexing, Shader),
- CASE_CAP(SampledImageArrayDynamicIndexing, Shader),
- CASE_CAP(StorageBufferArrayDynamicIndexing, Shader),
- CASE_CAP(StorageImageArrayDynamicIndexing, Shader),
- CASE_CAP(ClipDistance, Shader),
- CASE_CAP(CullDistance, Shader),
- CASE_CAP(ImageCubeArray, SampledCubeArray),
- CASE_CAP(SampleRateShading, Shader),
- CASE_CAP(ImageRect, SampledRect),
- CASE_CAP(SampledRect, Shader),
- CASE_CAP(GenericPointer, Addresses),
- CASE_CAP(Int8, Kernel),
- CASE_CAP(InputAttachment, Shader),
- CASE_CAP(SparseResidency, Shader),
- CASE_CAP(MinLod, Shader),
- CASE_CAP(Sampled1D, Shader),
- CASE_CAP(Image1D, Sampled1D),
- CASE_CAP(SampledCubeArray, Shader),
- CASE_CAP(SampledBuffer, Shader),
- CASE_CAP(ImageBuffer, SampledBuffer),
- CASE_CAP(ImageMSArray, Shader),
- CASE_CAP(StorageImageExtendedFormats, Shader),
- CASE_CAP(ImageQuery, Shader),
- CASE_CAP(DerivativeControl, Shader),
- CASE_CAP(InterpolationFunction, Shader),
- CASE_CAP(TransformFeedback, Shader),
- CASE_CAP(GeometryStreams, Geometry),
- CASE_CAP(StorageImageReadWithoutFormat, Shader),
- CASE_CAP(StorageImageWriteWithoutFormat, Shader),
- CASE_CAP(MultiViewport, Geometry),
-};
-// clang-format on
-#undef CASE
-#undef CASE_CAP
-
// Evaluates to the number of elements of array A.
// If we could use constexpr, then we could make this a template function.
// If the source arrays were std::array, then we could have used
// std::array::size.
#define ARRAY_SIZE(A) (static_cast<uint32_t>(sizeof(A) / sizeof(A[0])))
-static const spv_operand_desc_group_t opcodeEntryTypes[] = {
- // TODO(dneto): Reformat this table.
- {SPV_OPERAND_TYPE_SOURCE_LANGUAGE, ARRAY_SIZE(sourceLanguageEntries),
- sourceLanguageEntries},
- {SPV_OPERAND_TYPE_EXECUTION_MODEL, ARRAY_SIZE(executionModelEntries),
- executionModelEntries},
- {SPV_OPERAND_TYPE_ADDRESSING_MODEL, ARRAY_SIZE(addressingModelEntries),
- addressingModelEntries},
- {SPV_OPERAND_TYPE_MEMORY_MODEL, ARRAY_SIZE(memoryModelEntries),
- memoryModelEntries},
- {SPV_OPERAND_TYPE_EXECUTION_MODE, ARRAY_SIZE(executionModeEntries),
- executionModeEntries},
- {SPV_OPERAND_TYPE_STORAGE_CLASS, ARRAY_SIZE(storageClassEntries),
- storageClassEntries},
- {SPV_OPERAND_TYPE_DIMENSIONALITY, ARRAY_SIZE(dimensionalityEntries),
- dimensionalityEntries},
- {SPV_OPERAND_TYPE_SAMPLER_ADDRESSING_MODE,
- ARRAY_SIZE(samplerAddressingModeEntries), samplerAddressingModeEntries},
- {SPV_OPERAND_TYPE_SAMPLER_FILTER_MODE, ARRAY_SIZE(samplerFilterModeEntries),
- samplerFilterModeEntries},
- {SPV_OPERAND_TYPE_SAMPLER_IMAGE_FORMAT,
- ARRAY_SIZE(samplerImageFormatEntries), samplerImageFormatEntries},
- {SPV_OPERAND_TYPE_IMAGE_CHANNEL_ORDER, ARRAY_SIZE(imageChannelOrderEntries),
- imageChannelOrderEntries},
- {SPV_OPERAND_TYPE_IMAGE_CHANNEL_DATA_TYPE,
- ARRAY_SIZE(imageChannelDataTypeEntries), imageChannelDataTypeEntries},
- {SPV_OPERAND_TYPE_IMAGE, ARRAY_SIZE(imageOperandEntries),
- imageOperandEntries},
- {SPV_OPERAND_TYPE_OPTIONAL_IMAGE, // Same as *_IMAGE
- ARRAY_SIZE(imageOperandEntries), imageOperandEntries},
- {SPV_OPERAND_TYPE_FP_FAST_MATH_MODE, ARRAY_SIZE(fpFastMathModeEntries),
- fpFastMathModeEntries},
- {SPV_OPERAND_TYPE_FP_ROUNDING_MODE, ARRAY_SIZE(fpRoundingModeEntries),
- fpRoundingModeEntries},
- {SPV_OPERAND_TYPE_LINKAGE_TYPE, ARRAY_SIZE(linkageTypeEntries),
- linkageTypeEntries},
- {SPV_OPERAND_TYPE_ACCESS_QUALIFIER, ARRAY_SIZE(accessQualifierEntries),
- accessQualifierEntries},
- {SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER, // Same as *_ACCESS_QUALIFIER
- ARRAY_SIZE(accessQualifierEntries), accessQualifierEntries},
- {SPV_OPERAND_TYPE_FUNCTION_PARAMETER_ATTRIBUTE,
- ARRAY_SIZE(functionParameterAttributeEntries),
- functionParameterAttributeEntries},
- {SPV_OPERAND_TYPE_DECORATION, ARRAY_SIZE(decorationEntries),
- decorationEntries},
- {SPV_OPERAND_TYPE_BUILT_IN, ARRAY_SIZE(builtInEntries), builtInEntries},
- {SPV_OPERAND_TYPE_SELECTION_CONTROL, ARRAY_SIZE(selectionControlEntries),
- selectionControlEntries},
- {SPV_OPERAND_TYPE_LOOP_CONTROL, ARRAY_SIZE(loopControlEntries),
- loopControlEntries},
- {SPV_OPERAND_TYPE_FUNCTION_CONTROL, ARRAY_SIZE(functionControlEntries),
- functionControlEntries},
- {SPV_OPERAND_TYPE_MEMORY_SEMANTICS_ID, ARRAY_SIZE(memorySemanticsEntries),
- memorySemanticsEntries},
- {SPV_OPERAND_TYPE_MEMORY_ACCESS, ARRAY_SIZE(memoryAccessEntries),
- memoryAccessEntries},
- {SPV_OPERAND_TYPE_OPTIONAL_MEMORY_ACCESS, // Same as *_MEMORY_ACCESS
- ARRAY_SIZE(memoryAccessEntries), memoryAccessEntries},
- {SPV_OPERAND_TYPE_SCOPE_ID, ARRAY_SIZE(scopeEntries), scopeEntries},
- {SPV_OPERAND_TYPE_GROUP_OPERATION, ARRAY_SIZE(groupOperationEntries),
- groupOperationEntries},
- {SPV_OPERAND_TYPE_KERNEL_ENQ_FLAGS,
- ARRAY_SIZE(kernelKernelEnqueueFlagssEntries),
- kernelKernelEnqueueFlagssEntries},
- {SPV_OPERAND_TYPE_KERNEL_PROFILING_INFO,
- ARRAY_SIZE(kernelProfilingInfoEntries), kernelProfilingInfoEntries},
- {SPV_OPERAND_TYPE_CAPABILITY, ARRAY_SIZE(capabilityInfoEntries),
- capabilityInfoEntries},
-};
+// Pull in operand info tables automatically generated from JSON grammar.
+#include "operand.kinds.inc"
spv_result_t spvOperandTableGet(spv_operand_table* pOperandTable) {
if (!pOperandTable) return SPV_ERROR_INVALID_POINTER;
- static const spv_operand_table_t table = {ARRAY_SIZE(opcodeEntryTypes),
- opcodeEntryTypes};
+ static const spv_operand_table_t table = {
+ ARRAY_SIZE(pygen_variable_OperandInfoTable),
+ pygen_variable_OperandInfoTable};
*pOperandTable = &table;
@@ -1178,7 +133,6 @@
case SPV_OPERAND_TYPE_MEMORY_MODEL:
return "memory model";
case SPV_OPERAND_TYPE_EXECUTION_MODE:
- case SPV_OPERAND_TYPE_OPTIONAL_EXECUTION_MODE:
return "execution mode";
case SPV_OPERAND_TYPE_STORAGE_CLASS:
return "storage class";
@@ -1312,10 +266,6 @@
{SPV_OPERAND_TYPE_OPTIONAL_ID,
SPV_OPERAND_TYPE_LITERAL_INTEGER, type});
return true;
- case SPV_OPERAND_TYPE_VARIABLE_EXECUTION_MODE:
- pattern->insert(pattern->begin(),
- {SPV_OPERAND_TYPE_OPTIONAL_EXECUTION_MODE, type});
- return true;
default:
break;
}
diff --git a/source/spirv.core.grammar.json b/source/spirv.core.grammar.json
new file mode 100644
index 0000000..972be4f
--- /dev/null
+++ b/source/spirv.core.grammar.json
@@ -0,0 +1,5104 @@
+{
+ "copyright" : [
+ "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."
+ ],
+ "magic_number" : "0x07230203",
+ "major_version" : 1,
+ "minor_version" : 0,
+ "revision" : 4,
+ "instructions" : [
+ {
+ "opname" : "OpNop",
+ "opcode" : 0
+ },
+ {
+ "opname" : "OpUndef",
+ "opcode" : 1,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" }
+ ]
+ },
+ {
+ "opname" : "OpSourceContinued",
+ "opcode" : 2,
+ "operands" : [
+ { "kind" : "LiteralString", "name" : "'Continued Source'" }
+ ]
+ },
+ {
+ "opname" : "OpSource",
+ "opcode" : 3,
+ "operands" : [
+ { "kind" : "SourceLanguage" },
+ { "kind" : "LiteralInteger", "name" : "'Version'" },
+ { "kind" : "IdRef", "quantifier" : "?", "name" : "'File'" },
+ { "kind" : "LiteralString", "quantifier" : "?", "name" : "'Source'" }
+ ]
+ },
+ {
+ "opname" : "OpSourceExtension",
+ "opcode" : 4,
+ "operands" : [
+ { "kind" : "LiteralString", "name" : "'Extension'" }
+ ]
+ },
+ {
+ "opname" : "OpName",
+ "opcode" : 5,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Target'" },
+ { "kind" : "LiteralString", "name" : "'Name'" }
+ ]
+ },
+ {
+ "opname" : "OpMemberName",
+ "opcode" : 6,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Type'" },
+ { "kind" : "LiteralInteger", "name" : "'Member'" },
+ { "kind" : "LiteralString", "name" : "'Name'" }
+ ]
+ },
+ {
+ "opname" : "OpString",
+ "opcode" : 7,
+ "operands" : [
+ { "kind" : "IdResult" },
+ { "kind" : "LiteralString", "name" : "'String'" }
+ ]
+ },
+ {
+ "opname" : "OpLine",
+ "opcode" : 8,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'File'" },
+ { "kind" : "LiteralInteger", "name" : "'Line'" },
+ { "kind" : "LiteralInteger", "name" : "'Column'" }
+ ]
+ },
+ {
+ "opname" : "OpExtension",
+ "opcode" : 10,
+ "operands" : [
+ { "kind" : "LiteralString", "name" : "'Name'" }
+ ]
+ },
+ {
+ "opname" : "OpExtInstImport",
+ "opcode" : 11,
+ "operands" : [
+ { "kind" : "IdResult" },
+ { "kind" : "LiteralString", "name" : "'Name'" }
+ ]
+ },
+ {
+ "opname" : "OpExtInst",
+ "opcode" : 12,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Set'" },
+ { "kind" : "LiteralExtInstInteger", "name" : "'Instruction'" },
+ { "kind" : "IdRef", "quantifier" : "*", "name" : "'Operand 1', +\n'Operand 2', +\n..." }
+ ]
+ },
+ {
+ "opname" : "OpMemoryModel",
+ "opcode" : 14,
+ "operands" : [
+ { "kind" : "AddressingModel" },
+ { "kind" : "MemoryModel" }
+ ]
+ },
+ {
+ "opname" : "OpEntryPoint",
+ "opcode" : 15,
+ "operands" : [
+ { "kind" : "ExecutionModel" },
+ { "kind" : "IdRef", "name" : "'Entry Point'" },
+ { "kind" : "LiteralString", "name" : "'Name'" },
+ { "kind" : "IdRef", "quantifier" : "*", "name" : "'Interface'" }
+ ]
+ },
+ {
+ "opname" : "OpExecutionMode",
+ "opcode" : 16,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Entry Point'" },
+ { "kind" : "ExecutionMode", "name" : "'Mode'" }
+ ]
+ },
+ {
+ "opname" : "OpCapability",
+ "opcode" : 17,
+ "operands" : [
+ { "kind" : "Capability", "name" : "'Capability'" }
+ ]
+ },
+ {
+ "opname" : "OpTypeVoid",
+ "opcode" : 19,
+ "operands" : [
+ { "kind" : "IdResult" }
+ ]
+ },
+ {
+ "opname" : "OpTypeBool",
+ "opcode" : 20,
+ "operands" : [
+ { "kind" : "IdResult" }
+ ]
+ },
+ {
+ "opname" : "OpTypeInt",
+ "opcode" : 21,
+ "operands" : [
+ { "kind" : "IdResult" },
+ { "kind" : "LiteralInteger", "name" : "'Width'" },
+ { "kind" : "LiteralInteger", "name" : "'Signedness'" }
+ ]
+ },
+ {
+ "opname" : "OpTypeFloat",
+ "opcode" : 22,
+ "operands" : [
+ { "kind" : "IdResult" },
+ { "kind" : "LiteralInteger", "name" : "'Width'" }
+ ]
+ },
+ {
+ "opname" : "OpTypeVector",
+ "opcode" : 23,
+ "operands" : [
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Component Type'" },
+ { "kind" : "LiteralInteger", "name" : "'Component Count'" }
+ ]
+ },
+ {
+ "opname" : "OpTypeMatrix",
+ "opcode" : 24,
+ "operands" : [
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Column Type'" },
+ { "kind" : "LiteralInteger", "name" : "'Column Count'" }
+ ],
+ "capabilities" : [ "Matrix" ]
+ },
+ {
+ "opname" : "OpTypeImage",
+ "opcode" : 25,
+ "operands" : [
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Type'" },
+ { "kind" : "Dim" },
+ { "kind" : "LiteralInteger", "name" : "'Depth'" },
+ { "kind" : "LiteralInteger", "name" : "'Arrayed'" },
+ { "kind" : "LiteralInteger", "name" : "'MS'" },
+ { "kind" : "LiteralInteger", "name" : "'Sampled'" },
+ { "kind" : "ImageFormat" },
+ { "kind" : "AccessQualifier", "quantifier" : "?" }
+ ]
+ },
+ {
+ "opname" : "OpTypeSampler",
+ "opcode" : 26,
+ "operands" : [
+ { "kind" : "IdResult" }
+ ]
+ },
+ {
+ "opname" : "OpTypeSampledImage",
+ "opcode" : 27,
+ "operands" : [
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Image Type'" }
+ ]
+ },
+ {
+ "opname" : "OpTypeArray",
+ "opcode" : 28,
+ "operands" : [
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Element Type'" },
+ { "kind" : "IdRef", "name" : "'Length'" }
+ ]
+ },
+ {
+ "opname" : "OpTypeRuntimeArray",
+ "opcode" : 29,
+ "operands" : [
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Element Type'" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpTypeStruct",
+ "opcode" : 30,
+ "operands" : [
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "quantifier" : "*", "name" : "'Member 0 type', +\n'member 1 type', +\n..." }
+ ]
+ },
+ {
+ "opname" : "OpTypeOpaque",
+ "opcode" : 31,
+ "operands" : [
+ { "kind" : "IdResult" },
+ { "kind" : "LiteralString", "name" : "The name of the opaque type." }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpTypePointer",
+ "opcode" : 32,
+ "operands" : [
+ { "kind" : "IdResult" },
+ { "kind" : "StorageClass" },
+ { "kind" : "IdRef", "name" : "'Type'" }
+ ]
+ },
+ {
+ "opname" : "OpTypeFunction",
+ "opcode" : 33,
+ "operands" : [
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Return Type'" },
+ { "kind" : "IdRef", "quantifier" : "*", "name" : "'Parameter 0 Type', +\n'Parameter 1 Type', +\n..." }
+ ]
+ },
+ {
+ "opname" : "OpTypeEvent",
+ "opcode" : 34,
+ "operands" : [
+ { "kind" : "IdResult" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpTypeDeviceEvent",
+ "opcode" : 35,
+ "operands" : [
+ { "kind" : "IdResult" }
+ ],
+ "capabilities" : [ "DeviceEnqueue" ]
+ },
+ {
+ "opname" : "OpTypeReserveId",
+ "opcode" : 36,
+ "operands" : [
+ { "kind" : "IdResult" }
+ ],
+ "capabilities" : [ "Pipes" ]
+ },
+ {
+ "opname" : "OpTypeQueue",
+ "opcode" : 37,
+ "operands" : [
+ { "kind" : "IdResult" }
+ ],
+ "capabilities" : [ "DeviceEnqueue" ]
+ },
+ {
+ "opname" : "OpTypePipe",
+ "opcode" : 38,
+ "operands" : [
+ { "kind" : "IdResult" },
+ { "kind" : "AccessQualifier", "name" : "'Qualifier'" }
+ ],
+ "capabilities" : [ "Pipes" ]
+ },
+ {
+ "opname" : "OpTypeForwardPointer",
+ "opcode" : 39,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Pointer Type'" },
+ { "kind" : "StorageClass" }
+ ],
+ "capabilities" : [ "Addresses" ]
+ },
+ {
+ "opname" : "OpConstantTrue",
+ "opcode" : 41,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" }
+ ]
+ },
+ {
+ "opname" : "OpConstantFalse",
+ "opcode" : 42,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" }
+ ]
+ },
+ {
+ "opname" : "OpConstant",
+ "opcode" : 43,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "LiteralContextDependentNumber", "name" : "'Value'" }
+ ]
+ },
+ {
+ "opname" : "OpConstantComposite",
+ "opcode" : 44,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "quantifier" : "*", "name" : "'Constituents'" }
+ ]
+ },
+ {
+ "opname" : "OpConstantSampler",
+ "opcode" : 45,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "SamplerAddressingMode" },
+ { "kind" : "LiteralInteger", "name" : "'Param'" },
+ { "kind" : "SamplerFilterMode" }
+ ],
+ "capabilities" : [ "LiteralSampler" ]
+ },
+ {
+ "opname" : "OpConstantNull",
+ "opcode" : 46,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" }
+ ]
+ },
+ {
+ "opname" : "OpSpecConstantTrue",
+ "opcode" : 48,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" }
+ ]
+ },
+ {
+ "opname" : "OpSpecConstantFalse",
+ "opcode" : 49,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" }
+ ]
+ },
+ {
+ "opname" : "OpSpecConstant",
+ "opcode" : 50,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "LiteralContextDependentNumber", "name" : "'Value'" }
+ ]
+ },
+ {
+ "opname" : "OpSpecConstantComposite",
+ "opcode" : 51,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "quantifier" : "*", "name" : "'Constituents'" }
+ ]
+ },
+ {
+ "opname" : "OpSpecConstantOp",
+ "opcode" : 52,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "LiteralSpecConstantOpInteger", "name" : "'Opcode'" }
+ ]
+ },
+ {
+ "opname" : "OpFunction",
+ "opcode" : 54,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "FunctionControl" },
+ { "kind" : "IdRef", "name" : "'Function Type'" }
+ ]
+ },
+ {
+ "opname" : "OpFunctionParameter",
+ "opcode" : 55,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" }
+ ]
+ },
+ {
+ "opname" : "OpFunctionEnd",
+ "opcode" : 56
+ },
+ {
+ "opname" : "OpFunctionCall",
+ "opcode" : 57,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Function'" },
+ { "kind" : "IdRef", "quantifier" : "*", "name" : "'Argument 0', +\n'Argument 1', +\n..." }
+ ]
+ },
+ {
+ "opname" : "OpVariable",
+ "opcode" : 59,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "StorageClass" },
+ { "kind" : "IdRef", "quantifier" : "?", "name" : "'Initializer'" }
+ ]
+ },
+ {
+ "opname" : "OpImageTexelPointer",
+ "opcode" : 60,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "IdRef", "name" : "'Sample'" }
+ ]
+ },
+ {
+ "opname" : "OpLoad",
+ "opcode" : 61,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "MemoryAccess", "quantifier" : "?" }
+ ]
+ },
+ {
+ "opname" : "OpStore",
+ "opcode" : 62,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdRef", "name" : "'Object'" },
+ { "kind" : "MemoryAccess", "quantifier" : "?" }
+ ]
+ },
+ {
+ "opname" : "OpCopyMemory",
+ "opcode" : 63,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Target'" },
+ { "kind" : "IdRef", "name" : "'Source'" },
+ { "kind" : "MemoryAccess", "quantifier" : "?" }
+ ]
+ },
+ {
+ "opname" : "OpCopyMemorySized",
+ "opcode" : 64,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Target'" },
+ { "kind" : "IdRef", "name" : "'Source'" },
+ { "kind" : "IdRef", "name" : "'Size'" },
+ { "kind" : "MemoryAccess", "quantifier" : "?" }
+ ],
+ "capabilities" : [ "Addresses" ]
+ },
+ {
+ "opname" : "OpAccessChain",
+ "opcode" : 65,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Base'" },
+ { "kind" : "IdRef", "quantifier" : "*", "name" : "'Indexes'" }
+ ]
+ },
+ {
+ "opname" : "OpInBoundsAccessChain",
+ "opcode" : 66,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Base'" },
+ { "kind" : "IdRef", "quantifier" : "*", "name" : "'Indexes'" }
+ ]
+ },
+ {
+ "opname" : "OpPtrAccessChain",
+ "opcode" : 67,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Base'" },
+ { "kind" : "IdRef", "name" : "'Element'" },
+ { "kind" : "IdRef", "quantifier" : "*", "name" : "'Indexes'" }
+ ],
+ "capabilities" : [ "Addresses" ]
+ },
+ {
+ "opname" : "OpArrayLength",
+ "opcode" : 68,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Structure'" },
+ { "kind" : "LiteralInteger", "name" : "'Array member'" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpGenericPtrMemSemantics",
+ "opcode" : 69,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpInBoundsPtrAccessChain",
+ "opcode" : 70,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Base'" },
+ { "kind" : "IdRef", "name" : "'Element'" },
+ { "kind" : "IdRef", "quantifier" : "*", "name" : "'Indexes'" }
+ ],
+ "capabilities" : [ "Addresses" ]
+ },
+ {
+ "opname" : "OpDecorate",
+ "opcode" : 71,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Target'" },
+ { "kind" : "Decoration" }
+ ]
+ },
+ {
+ "opname" : "OpMemberDecorate",
+ "opcode" : 72,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Structure Type'" },
+ { "kind" : "LiteralInteger", "name" : "'Member'" },
+ { "kind" : "Decoration" }
+ ]
+ },
+ {
+ "opname" : "OpDecorationGroup",
+ "opcode" : 73,
+ "operands" : [
+ { "kind" : "IdResult" }
+ ]
+ },
+ {
+ "opname" : "OpGroupDecorate",
+ "opcode" : 74,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Decoration Group'" },
+ { "kind" : "IdRef", "quantifier" : "*", "name" : "'Targets'" }
+ ]
+ },
+ {
+ "opname" : "OpGroupMemberDecorate",
+ "opcode" : 75,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Decoration Group'" },
+ { "kind" : "PairIdRefLiteralInteger", "quantifier" : "*", "name" : "'Targets'" }
+ ]
+ },
+ {
+ "opname" : "OpVectorExtractDynamic",
+ "opcode" : 77,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Vector'" },
+ { "kind" : "IdRef", "name" : "'Index'" }
+ ]
+ },
+ {
+ "opname" : "OpVectorInsertDynamic",
+ "opcode" : 78,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Vector'" },
+ { "kind" : "IdRef", "name" : "'Component'" },
+ { "kind" : "IdRef", "name" : "'Index'" }
+ ]
+ },
+ {
+ "opname" : "OpVectorShuffle",
+ "opcode" : 79,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Vector 1'" },
+ { "kind" : "IdRef", "name" : "'Vector 2'" },
+ { "kind" : "LiteralInteger", "quantifier" : "*", "name" : "'Components'" }
+ ]
+ },
+ {
+ "opname" : "OpCompositeConstruct",
+ "opcode" : 80,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "quantifier" : "*", "name" : "'Constituents'" }
+ ]
+ },
+ {
+ "opname" : "OpCompositeExtract",
+ "opcode" : 81,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Composite'" },
+ { "kind" : "LiteralInteger", "quantifier" : "*", "name" : "'Indexes'" }
+ ]
+ },
+ {
+ "opname" : "OpCompositeInsert",
+ "opcode" : 82,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Object'" },
+ { "kind" : "IdRef", "name" : "'Composite'" },
+ { "kind" : "LiteralInteger", "quantifier" : "*", "name" : "'Indexes'" }
+ ]
+ },
+ {
+ "opname" : "OpCopyObject",
+ "opcode" : 83,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand'" }
+ ]
+ },
+ {
+ "opname" : "OpTranspose",
+ "opcode" : 84,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Matrix'" }
+ ],
+ "capabilities" : [ "Matrix" ]
+ },
+ {
+ "opname" : "OpSampledImage",
+ "opcode" : 86,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Image'" },
+ { "kind" : "IdRef", "name" : "'Sampler'" }
+ ]
+ },
+ {
+ "opname" : "OpImageSampleImplicitLod",
+ "opcode" : 87,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "ImageOperands", "quantifier" : "?" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpImageSampleExplicitLod",
+ "opcode" : 88,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "ImageOperands" }
+ ]
+ },
+ {
+ "opname" : "OpImageSampleDrefImplicitLod",
+ "opcode" : 89,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "IdRef", "name" : "'D~ref~'" },
+ { "kind" : "ImageOperands", "quantifier" : "?" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpImageSampleDrefExplicitLod",
+ "opcode" : 90,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "IdRef", "name" : "'D~ref~'" },
+ { "kind" : "ImageOperands" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpImageSampleProjImplicitLod",
+ "opcode" : 91,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "ImageOperands", "quantifier" : "?" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpImageSampleProjExplicitLod",
+ "opcode" : 92,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "ImageOperands" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpImageSampleProjDrefImplicitLod",
+ "opcode" : 93,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "IdRef", "name" : "'D~ref~'" },
+ { "kind" : "ImageOperands", "quantifier" : "?" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpImageSampleProjDrefExplicitLod",
+ "opcode" : 94,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "IdRef", "name" : "'D~ref~'" },
+ { "kind" : "ImageOperands" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpImageFetch",
+ "opcode" : 95,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "ImageOperands", "quantifier" : "?" }
+ ]
+ },
+ {
+ "opname" : "OpImageGather",
+ "opcode" : 96,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "IdRef", "name" : "'Component'" },
+ { "kind" : "ImageOperands", "quantifier" : "?" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpImageDrefGather",
+ "opcode" : 97,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "IdRef", "name" : "'D~ref~'" },
+ { "kind" : "ImageOperands", "quantifier" : "?" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpImageRead",
+ "opcode" : 98,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "ImageOperands", "quantifier" : "?" }
+ ]
+ },
+ {
+ "opname" : "OpImageWrite",
+ "opcode" : 99,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "IdRef", "name" : "'Texel'" },
+ { "kind" : "ImageOperands", "quantifier" : "?" }
+ ]
+ },
+ {
+ "opname" : "OpImage",
+ "opcode" : 100,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" }
+ ]
+ },
+ {
+ "opname" : "OpImageQueryFormat",
+ "opcode" : 101,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Image'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpImageQueryOrder",
+ "opcode" : 102,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Image'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpImageQuerySizeLod",
+ "opcode" : 103,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Image'" },
+ { "kind" : "IdRef", "name" : "'Level of Detail'" }
+ ],
+ "capabilities" : [ "Kernel", "ImageQuery" ]
+ },
+ {
+ "opname" : "OpImageQuerySize",
+ "opcode" : 104,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Image'" }
+ ],
+ "capabilities" : [ "Kernel", "ImageQuery" ]
+ },
+ {
+ "opname" : "OpImageQueryLod",
+ "opcode" : 105,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" }
+ ],
+ "capabilities" : [ "ImageQuery" ]
+ },
+ {
+ "opname" : "OpImageQueryLevels",
+ "opcode" : 106,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Image'" }
+ ],
+ "capabilities" : [ "Kernel", "ImageQuery" ]
+ },
+ {
+ "opname" : "OpImageQuerySamples",
+ "opcode" : 107,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Image'" }
+ ],
+ "capabilities" : [ "Kernel", "ImageQuery" ]
+ },
+ {
+ "opname" : "OpConvertFToU",
+ "opcode" : 109,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Float Value'" }
+ ]
+ },
+ {
+ "opname" : "OpConvertFToS",
+ "opcode" : 110,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Float Value'" }
+ ]
+ },
+ {
+ "opname" : "OpConvertSToF",
+ "opcode" : 111,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Signed Value'" }
+ ]
+ },
+ {
+ "opname" : "OpConvertUToF",
+ "opcode" : 112,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Unsigned Value'" }
+ ]
+ },
+ {
+ "opname" : "OpUConvert",
+ "opcode" : 113,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Unsigned Value'" }
+ ]
+ },
+ {
+ "opname" : "OpSConvert",
+ "opcode" : 114,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Signed Value'" }
+ ]
+ },
+ {
+ "opname" : "OpFConvert",
+ "opcode" : 115,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Float Value'" }
+ ]
+ },
+ {
+ "opname" : "OpQuantizeToF16",
+ "opcode" : 116,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Value'" }
+ ]
+ },
+ {
+ "opname" : "OpConvertPtrToU",
+ "opcode" : 117,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" }
+ ],
+ "capabilities" : [ "Addresses" ]
+ },
+ {
+ "opname" : "OpSatConvertSToU",
+ "opcode" : 118,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Signed Value'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpSatConvertUToS",
+ "opcode" : 119,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Unsigned Value'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpConvertUToPtr",
+ "opcode" : 120,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Integer Value'" }
+ ],
+ "capabilities" : [ "Addresses" ]
+ },
+ {
+ "opname" : "OpPtrCastToGeneric",
+ "opcode" : 121,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpGenericCastToPtr",
+ "opcode" : 122,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpGenericCastToPtrExplicit",
+ "opcode" : 123,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "StorageClass", "name" : "'Storage'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpBitcast",
+ "opcode" : 124,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand'" }
+ ]
+ },
+ {
+ "opname" : "OpSNegate",
+ "opcode" : 126,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand'" }
+ ]
+ },
+ {
+ "opname" : "OpFNegate",
+ "opcode" : 127,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand'" }
+ ]
+ },
+ {
+ "opname" : "OpIAdd",
+ "opcode" : 128,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFAdd",
+ "opcode" : 129,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpISub",
+ "opcode" : 130,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFSub",
+ "opcode" : 131,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpIMul",
+ "opcode" : 132,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFMul",
+ "opcode" : 133,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpUDiv",
+ "opcode" : 134,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpSDiv",
+ "opcode" : 135,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFDiv",
+ "opcode" : 136,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpUMod",
+ "opcode" : 137,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpSRem",
+ "opcode" : 138,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpSMod",
+ "opcode" : 139,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFRem",
+ "opcode" : 140,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFMod",
+ "opcode" : 141,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpVectorTimesScalar",
+ "opcode" : 142,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Vector'" },
+ { "kind" : "IdRef", "name" : "'Scalar'" }
+ ]
+ },
+ {
+ "opname" : "OpMatrixTimesScalar",
+ "opcode" : 143,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Matrix'" },
+ { "kind" : "IdRef", "name" : "'Scalar'" }
+ ],
+ "capabilities" : [ "Matrix" ]
+ },
+ {
+ "opname" : "OpVectorTimesMatrix",
+ "opcode" : 144,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Vector'" },
+ { "kind" : "IdRef", "name" : "'Matrix'" }
+ ],
+ "capabilities" : [ "Matrix" ]
+ },
+ {
+ "opname" : "OpMatrixTimesVector",
+ "opcode" : 145,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Matrix'" },
+ { "kind" : "IdRef", "name" : "'Vector'" }
+ ],
+ "capabilities" : [ "Matrix" ]
+ },
+ {
+ "opname" : "OpMatrixTimesMatrix",
+ "opcode" : 146,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'LeftMatrix'" },
+ { "kind" : "IdRef", "name" : "'RightMatrix'" }
+ ],
+ "capabilities" : [ "Matrix" ]
+ },
+ {
+ "opname" : "OpOuterProduct",
+ "opcode" : 147,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Vector 1'" },
+ { "kind" : "IdRef", "name" : "'Vector 2'" }
+ ],
+ "capabilities" : [ "Matrix" ]
+ },
+ {
+ "opname" : "OpDot",
+ "opcode" : 148,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Vector 1'" },
+ { "kind" : "IdRef", "name" : "'Vector 2'" }
+ ]
+ },
+ {
+ "opname" : "OpIAddCarry",
+ "opcode" : 149,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpISubBorrow",
+ "opcode" : 150,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpUMulExtended",
+ "opcode" : 151,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpSMulExtended",
+ "opcode" : 152,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpAny",
+ "opcode" : 154,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Vector'" }
+ ]
+ },
+ {
+ "opname" : "OpAll",
+ "opcode" : 155,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Vector'" }
+ ]
+ },
+ {
+ "opname" : "OpIsNan",
+ "opcode" : 156,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'x'" }
+ ]
+ },
+ {
+ "opname" : "OpIsInf",
+ "opcode" : 157,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'x'" }
+ ]
+ },
+ {
+ "opname" : "OpIsFinite",
+ "opcode" : 158,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'x'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpIsNormal",
+ "opcode" : 159,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'x'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpSignBitSet",
+ "opcode" : 160,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'x'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpLessOrGreater",
+ "opcode" : 161,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'x'" },
+ { "kind" : "IdRef", "name" : "'y'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpOrdered",
+ "opcode" : 162,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'x'" },
+ { "kind" : "IdRef", "name" : "'y'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpUnordered",
+ "opcode" : 163,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'x'" },
+ { "kind" : "IdRef", "name" : "'y'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpLogicalEqual",
+ "opcode" : 164,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpLogicalNotEqual",
+ "opcode" : 165,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpLogicalOr",
+ "opcode" : 166,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpLogicalAnd",
+ "opcode" : 167,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpLogicalNot",
+ "opcode" : 168,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand'" }
+ ]
+ },
+ {
+ "opname" : "OpSelect",
+ "opcode" : 169,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Condition'" },
+ { "kind" : "IdRef", "name" : "'Object 1'" },
+ { "kind" : "IdRef", "name" : "'Object 2'" }
+ ]
+ },
+ {
+ "opname" : "OpIEqual",
+ "opcode" : 170,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpINotEqual",
+ "opcode" : 171,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpUGreaterThan",
+ "opcode" : 172,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpSGreaterThan",
+ "opcode" : 173,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpUGreaterThanEqual",
+ "opcode" : 174,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpSGreaterThanEqual",
+ "opcode" : 175,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpULessThan",
+ "opcode" : 176,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpSLessThan",
+ "opcode" : 177,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpULessThanEqual",
+ "opcode" : 178,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpSLessThanEqual",
+ "opcode" : 179,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFOrdEqual",
+ "opcode" : 180,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFUnordEqual",
+ "opcode" : 181,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFOrdNotEqual",
+ "opcode" : 182,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFUnordNotEqual",
+ "opcode" : 183,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFOrdLessThan",
+ "opcode" : 184,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFUnordLessThan",
+ "opcode" : 185,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFOrdGreaterThan",
+ "opcode" : 186,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFUnordGreaterThan",
+ "opcode" : 187,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFOrdLessThanEqual",
+ "opcode" : 188,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFUnordLessThanEqual",
+ "opcode" : 189,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFOrdGreaterThanEqual",
+ "opcode" : 190,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpFUnordGreaterThanEqual",
+ "opcode" : 191,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpShiftRightLogical",
+ "opcode" : 194,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Base'" },
+ { "kind" : "IdRef", "name" : "'Shift'" }
+ ]
+ },
+ {
+ "opname" : "OpShiftRightArithmetic",
+ "opcode" : 195,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Base'" },
+ { "kind" : "IdRef", "name" : "'Shift'" }
+ ]
+ },
+ {
+ "opname" : "OpShiftLeftLogical",
+ "opcode" : 196,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Base'" },
+ { "kind" : "IdRef", "name" : "'Shift'" }
+ ]
+ },
+ {
+ "opname" : "OpBitwiseOr",
+ "opcode" : 197,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpBitwiseXor",
+ "opcode" : 198,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpBitwiseAnd",
+ "opcode" : 199,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand 1'" },
+ { "kind" : "IdRef", "name" : "'Operand 2'" }
+ ]
+ },
+ {
+ "opname" : "OpNot",
+ "opcode" : 200,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Operand'" }
+ ]
+ },
+ {
+ "opname" : "OpBitFieldInsert",
+ "opcode" : 201,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Base'" },
+ { "kind" : "IdRef", "name" : "'Insert'" },
+ { "kind" : "IdRef", "name" : "'Offset'" },
+ { "kind" : "IdRef", "name" : "'Count'" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpBitFieldSExtract",
+ "opcode" : 202,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Base'" },
+ { "kind" : "IdRef", "name" : "'Offset'" },
+ { "kind" : "IdRef", "name" : "'Count'" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpBitFieldUExtract",
+ "opcode" : 203,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Base'" },
+ { "kind" : "IdRef", "name" : "'Offset'" },
+ { "kind" : "IdRef", "name" : "'Count'" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpBitReverse",
+ "opcode" : 204,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Base'" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpBitCount",
+ "opcode" : 205,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Base'" }
+ ]
+ },
+ {
+ "opname" : "OpDPdx",
+ "opcode" : 207,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'P'" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpDPdy",
+ "opcode" : 208,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'P'" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpFwidth",
+ "opcode" : 209,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'P'" }
+ ],
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpDPdxFine",
+ "opcode" : 210,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'P'" }
+ ],
+ "capabilities" : [ "DerivativeControl" ]
+ },
+ {
+ "opname" : "OpDPdyFine",
+ "opcode" : 211,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'P'" }
+ ],
+ "capabilities" : [ "DerivativeControl" ]
+ },
+ {
+ "opname" : "OpFwidthFine",
+ "opcode" : 212,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'P'" }
+ ],
+ "capabilities" : [ "DerivativeControl" ]
+ },
+ {
+ "opname" : "OpDPdxCoarse",
+ "opcode" : 213,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'P'" }
+ ],
+ "capabilities" : [ "DerivativeControl" ]
+ },
+ {
+ "opname" : "OpDPdyCoarse",
+ "opcode" : 214,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'P'" }
+ ],
+ "capabilities" : [ "DerivativeControl" ]
+ },
+ {
+ "opname" : "OpFwidthCoarse",
+ "opcode" : 215,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'P'" }
+ ],
+ "capabilities" : [ "DerivativeControl" ]
+ },
+ {
+ "opname" : "OpEmitVertex",
+ "opcode" : 218,
+ "capabilities" : [ "Geometry" ]
+ },
+ {
+ "opname" : "OpEndPrimitive",
+ "opcode" : 219,
+ "capabilities" : [ "Geometry" ]
+ },
+ {
+ "opname" : "OpEmitStreamVertex",
+ "opcode" : 220,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Stream'" }
+ ],
+ "capabilities" : [ "GeometryStreams" ]
+ },
+ {
+ "opname" : "OpEndStreamPrimitive",
+ "opcode" : 221,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Stream'" }
+ ],
+ "capabilities" : [ "GeometryStreams" ]
+ },
+ {
+ "opname" : "OpControlBarrier",
+ "opcode" : 224,
+ "operands" : [
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "IdScope", "name" : "'Memory'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }
+ ]
+ },
+ {
+ "opname" : "OpMemoryBarrier",
+ "opcode" : 225,
+ "operands" : [
+ { "kind" : "IdScope", "name" : "'Memory'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }
+ ]
+ },
+ {
+ "opname" : "OpAtomicLoad",
+ "opcode" : 227,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }
+ ]
+ },
+ {
+ "opname" : "OpAtomicStore",
+ "opcode" : 228,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" },
+ { "kind" : "IdRef", "name" : "'Value'" }
+ ]
+ },
+ {
+ "opname" : "OpAtomicExchange",
+ "opcode" : 229,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" },
+ { "kind" : "IdRef", "name" : "'Value'" }
+ ]
+ },
+ {
+ "opname" : "OpAtomicCompareExchange",
+ "opcode" : 230,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Equal'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Unequal'" },
+ { "kind" : "IdRef", "name" : "'Value'" },
+ { "kind" : "IdRef", "name" : "'Comparator'" }
+ ]
+ },
+ {
+ "opname" : "OpAtomicCompareExchangeWeak",
+ "opcode" : 231,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Equal'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Unequal'" },
+ { "kind" : "IdRef", "name" : "'Value'" },
+ { "kind" : "IdRef", "name" : "'Comparator'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpAtomicIIncrement",
+ "opcode" : 232,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }
+ ]
+ },
+ {
+ "opname" : "OpAtomicIDecrement",
+ "opcode" : 233,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }
+ ]
+ },
+ {
+ "opname" : "OpAtomicIAdd",
+ "opcode" : 234,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" },
+ { "kind" : "IdRef", "name" : "'Value'" }
+ ]
+ },
+ {
+ "opname" : "OpAtomicISub",
+ "opcode" : 235,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" },
+ { "kind" : "IdRef", "name" : "'Value'" }
+ ]
+ },
+ {
+ "opname" : "OpAtomicSMin",
+ "opcode" : 236,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" },
+ { "kind" : "IdRef", "name" : "'Value'" }
+ ]
+ },
+ {
+ "opname" : "OpAtomicUMin",
+ "opcode" : 237,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" },
+ { "kind" : "IdRef", "name" : "'Value'" }
+ ]
+ },
+ {
+ "opname" : "OpAtomicSMax",
+ "opcode" : 238,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" },
+ { "kind" : "IdRef", "name" : "'Value'" }
+ ]
+ },
+ {
+ "opname" : "OpAtomicUMax",
+ "opcode" : 239,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" },
+ { "kind" : "IdRef", "name" : "'Value'" }
+ ]
+ },
+ {
+ "opname" : "OpAtomicAnd",
+ "opcode" : 240,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" },
+ { "kind" : "IdRef", "name" : "'Value'" }
+ ]
+ },
+ {
+ "opname" : "OpAtomicOr",
+ "opcode" : 241,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" },
+ { "kind" : "IdRef", "name" : "'Value'" }
+ ]
+ },
+ {
+ "opname" : "OpAtomicXor",
+ "opcode" : 242,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" },
+ { "kind" : "IdRef", "name" : "'Value'" }
+ ]
+ },
+ {
+ "opname" : "OpPhi",
+ "opcode" : 245,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "PairIdRefIdRef", "quantifier" : "*", "name" : "'Variable, Parent, ...'" }
+ ]
+ },
+ {
+ "opname" : "OpLoopMerge",
+ "opcode" : 246,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Merge Block'" },
+ { "kind" : "IdRef", "name" : "'Continue Target'" },
+ { "kind" : "LoopControl" }
+ ]
+ },
+ {
+ "opname" : "OpSelectionMerge",
+ "opcode" : 247,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Merge Block'" },
+ { "kind" : "SelectionControl" }
+ ]
+ },
+ {
+ "opname" : "OpLabel",
+ "opcode" : 248,
+ "operands" : [
+ { "kind" : "IdResult" }
+ ]
+ },
+ {
+ "opname" : "OpBranch",
+ "opcode" : 249,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Target Label'" }
+ ]
+ },
+ {
+ "opname" : "OpBranchConditional",
+ "opcode" : 250,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Condition'" },
+ { "kind" : "IdRef", "name" : "'True Label'" },
+ { "kind" : "IdRef", "name" : "'False Label'" },
+ { "kind" : "LiteralInteger", "quantifier" : "*", "name" : "'Branch weights'" }
+ ]
+ },
+ {
+ "opname" : "OpSwitch",
+ "opcode" : 251,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Selector'" },
+ { "kind" : "IdRef", "name" : "'Default'" },
+ { "kind" : "PairLiteralIntegerIdRef", "quantifier" : "*", "name" : "'Target'" }
+ ]
+ },
+ {
+ "opname" : "OpKill",
+ "opcode" : 252,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "opname" : "OpReturn",
+ "opcode" : 253
+ },
+ {
+ "opname" : "OpReturnValue",
+ "opcode" : 254,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Value'" }
+ ]
+ },
+ {
+ "opname" : "OpUnreachable",
+ "opcode" : 255
+ },
+ {
+ "opname" : "OpLifetimeStart",
+ "opcode" : 256,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "LiteralInteger", "name" : "'Size'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpLifetimeStop",
+ "opcode" : 257,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "LiteralInteger", "name" : "'Size'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpGroupAsyncCopy",
+ "opcode" : 259,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "IdRef", "name" : "'Destination'" },
+ { "kind" : "IdRef", "name" : "'Source'" },
+ { "kind" : "IdRef", "name" : "'Num Elements'" },
+ { "kind" : "IdRef", "name" : "'Stride'" },
+ { "kind" : "IdRef", "name" : "'Event'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpGroupWaitEvents",
+ "opcode" : 260,
+ "operands" : [
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "IdRef", "name" : "'Num Events'" },
+ { "kind" : "IdRef", "name" : "'Events List'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpGroupAll",
+ "opcode" : 261,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "IdRef", "name" : "'Predicate'" }
+ ],
+ "capabilities" : [ "Groups" ]
+ },
+ {
+ "opname" : "OpGroupAny",
+ "opcode" : 262,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "IdRef", "name" : "'Predicate'" }
+ ],
+ "capabilities" : [ "Groups" ]
+ },
+ {
+ "opname" : "OpGroupBroadcast",
+ "opcode" : 263,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "IdRef", "name" : "'Value'" },
+ { "kind" : "IdRef", "name" : "'LocalId'" }
+ ],
+ "capabilities" : [ "Groups" ]
+ },
+ {
+ "opname" : "OpGroupIAdd",
+ "opcode" : 264,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "GroupOperation", "name" : "'Operation'" },
+ { "kind" : "IdRef", "name" : "'X'" }
+ ],
+ "capabilities" : [ "Groups" ]
+ },
+ {
+ "opname" : "OpGroupFAdd",
+ "opcode" : 265,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "GroupOperation", "name" : "'Operation'" },
+ { "kind" : "IdRef", "name" : "'X'" }
+ ],
+ "capabilities" : [ "Groups" ]
+ },
+ {
+ "opname" : "OpGroupFMin",
+ "opcode" : 266,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "GroupOperation", "name" : "'Operation'" },
+ { "kind" : "IdRef", "name" : "X" }
+ ],
+ "capabilities" : [ "Groups" ]
+ },
+ {
+ "opname" : "OpGroupUMin",
+ "opcode" : 267,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "GroupOperation", "name" : "'Operation'" },
+ { "kind" : "IdRef", "name" : "'X'" }
+ ],
+ "capabilities" : [ "Groups" ]
+ },
+ {
+ "opname" : "OpGroupSMin",
+ "opcode" : 268,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "GroupOperation", "name" : "'Operation'" },
+ { "kind" : "IdRef", "name" : "X" }
+ ],
+ "capabilities" : [ "Groups" ]
+ },
+ {
+ "opname" : "OpGroupFMax",
+ "opcode" : 269,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "GroupOperation", "name" : "'Operation'" },
+ { "kind" : "IdRef", "name" : "X" }
+ ],
+ "capabilities" : [ "Groups" ]
+ },
+ {
+ "opname" : "OpGroupUMax",
+ "opcode" : 270,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "GroupOperation", "name" : "'Operation'" },
+ { "kind" : "IdRef", "name" : "X" }
+ ],
+ "capabilities" : [ "Groups" ]
+ },
+ {
+ "opname" : "OpGroupSMax",
+ "opcode" : 271,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "GroupOperation", "name" : "'Operation'" },
+ { "kind" : "IdRef", "name" : "X" }
+ ],
+ "capabilities" : [ "Groups" ]
+ },
+ {
+ "opname" : "OpReadPipe",
+ "opcode" : 274,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pipe'" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdRef", "name" : "'Packet Size'" },
+ { "kind" : "IdRef", "name" : "'Packet Alignment'" }
+ ],
+ "capabilities" : [ "Pipes" ]
+ },
+ {
+ "opname" : "OpWritePipe",
+ "opcode" : 275,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pipe'" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdRef", "name" : "'Packet Size'" },
+ { "kind" : "IdRef", "name" : "'Packet Alignment'" }
+ ],
+ "capabilities" : [ "Pipes" ]
+ },
+ {
+ "opname" : "OpReservedReadPipe",
+ "opcode" : 276,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pipe'" },
+ { "kind" : "IdRef", "name" : "'Reserve Id'" },
+ { "kind" : "IdRef", "name" : "'Index'" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdRef", "name" : "'Packet Size'" },
+ { "kind" : "IdRef", "name" : "'Packet Alignment'" }
+ ],
+ "capabilities" : [ "Pipes" ]
+ },
+ {
+ "opname" : "OpReservedWritePipe",
+ "opcode" : 277,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pipe'" },
+ { "kind" : "IdRef", "name" : "'Reserve Id'" },
+ { "kind" : "IdRef", "name" : "'Index'" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdRef", "name" : "'Packet Size'" },
+ { "kind" : "IdRef", "name" : "'Packet Alignment'" }
+ ],
+ "capabilities" : [ "Pipes" ]
+ },
+ {
+ "opname" : "OpReserveReadPipePackets",
+ "opcode" : 278,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pipe'" },
+ { "kind" : "IdRef", "name" : "'Num Packets'" },
+ { "kind" : "IdRef", "name" : "'Packet Size'" },
+ { "kind" : "IdRef", "name" : "'Packet Alignment'" }
+ ],
+ "capabilities" : [ "Pipes" ]
+ },
+ {
+ "opname" : "OpReserveWritePipePackets",
+ "opcode" : 279,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pipe'" },
+ { "kind" : "IdRef", "name" : "'Num Packets'" },
+ { "kind" : "IdRef", "name" : "'Packet Size'" },
+ { "kind" : "IdRef", "name" : "'Packet Alignment'" }
+ ],
+ "capabilities" : [ "Pipes" ]
+ },
+ {
+ "opname" : "OpCommitReadPipe",
+ "opcode" : 280,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Pipe'" },
+ { "kind" : "IdRef", "name" : "'Reserve Id'" },
+ { "kind" : "IdRef", "name" : "'Packet Size'" },
+ { "kind" : "IdRef", "name" : "'Packet Alignment'" }
+ ],
+ "capabilities" : [ "Pipes" ]
+ },
+ {
+ "opname" : "OpCommitWritePipe",
+ "opcode" : 281,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Pipe'" },
+ { "kind" : "IdRef", "name" : "'Reserve Id'" },
+ { "kind" : "IdRef", "name" : "'Packet Size'" },
+ { "kind" : "IdRef", "name" : "'Packet Alignment'" }
+ ],
+ "capabilities" : [ "Pipes" ]
+ },
+ {
+ "opname" : "OpIsValidReserveId",
+ "opcode" : 282,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Reserve Id'" }
+ ],
+ "capabilities" : [ "Pipes" ]
+ },
+ {
+ "opname" : "OpGetNumPipePackets",
+ "opcode" : 283,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pipe'" },
+ { "kind" : "IdRef", "name" : "'Packet Size'" },
+ { "kind" : "IdRef", "name" : "'Packet Alignment'" }
+ ],
+ "capabilities" : [ "Pipes" ]
+ },
+ {
+ "opname" : "OpGetMaxPipePackets",
+ "opcode" : 284,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pipe'" },
+ { "kind" : "IdRef", "name" : "'Packet Size'" },
+ { "kind" : "IdRef", "name" : "'Packet Alignment'" }
+ ],
+ "capabilities" : [ "Pipes" ]
+ },
+ {
+ "opname" : "OpGroupReserveReadPipePackets",
+ "opcode" : 285,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "IdRef", "name" : "'Pipe'" },
+ { "kind" : "IdRef", "name" : "'Num Packets'" },
+ { "kind" : "IdRef", "name" : "'Packet Size'" },
+ { "kind" : "IdRef", "name" : "'Packet Alignment'" }
+ ],
+ "capabilities" : [ "Pipes" ]
+ },
+ {
+ "opname" : "OpGroupReserveWritePipePackets",
+ "opcode" : 286,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "IdRef", "name" : "'Pipe'" },
+ { "kind" : "IdRef", "name" : "'Num Packets'" },
+ { "kind" : "IdRef", "name" : "'Packet Size'" },
+ { "kind" : "IdRef", "name" : "'Packet Alignment'" }
+ ],
+ "capabilities" : [ "Pipes" ]
+ },
+ {
+ "opname" : "OpGroupCommitReadPipe",
+ "opcode" : 287,
+ "operands" : [
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "IdRef", "name" : "'Pipe'" },
+ { "kind" : "IdRef", "name" : "'Reserve Id'" },
+ { "kind" : "IdRef", "name" : "'Packet Size'" },
+ { "kind" : "IdRef", "name" : "'Packet Alignment'" }
+ ],
+ "capabilities" : [ "Pipes" ]
+ },
+ {
+ "opname" : "OpGroupCommitWritePipe",
+ "opcode" : 288,
+ "operands" : [
+ { "kind" : "IdScope", "name" : "'Execution'" },
+ { "kind" : "IdRef", "name" : "'Pipe'" },
+ { "kind" : "IdRef", "name" : "'Reserve Id'" },
+ { "kind" : "IdRef", "name" : "'Packet Size'" },
+ { "kind" : "IdRef", "name" : "'Packet Alignment'" }
+ ],
+ "capabilities" : [ "Pipes" ]
+ },
+ {
+ "opname" : "OpEnqueueMarker",
+ "opcode" : 291,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Queue'" },
+ { "kind" : "IdRef", "name" : "'Num Events'" },
+ { "kind" : "IdRef", "name" : "'Wait Events'" },
+ { "kind" : "IdRef", "name" : "'Ret Event'" }
+ ],
+ "capabilities" : [ "DeviceEnqueue" ]
+ },
+ {
+ "opname" : "OpEnqueueKernel",
+ "opcode" : 292,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Queue'" },
+ { "kind" : "IdRef", "name" : "'Flags'" },
+ { "kind" : "IdRef", "name" : "'ND Range'" },
+ { "kind" : "IdRef", "name" : "'Num Events'" },
+ { "kind" : "IdRef", "name" : "'Wait Events'" },
+ { "kind" : "IdRef", "name" : "'Ret Event'" },
+ { "kind" : "IdRef", "name" : "'Invoke'" },
+ { "kind" : "IdRef", "name" : "'Param'" },
+ { "kind" : "IdRef", "name" : "'Param Size'" },
+ { "kind" : "IdRef", "name" : "'Param Align'" },
+ { "kind" : "IdRef", "quantifier" : "*", "name" : "'Local Size'" }
+ ],
+ "capabilities" : [ "DeviceEnqueue" ]
+ },
+ {
+ "opname" : "OpGetKernelNDrangeSubGroupCount",
+ "opcode" : 293,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'ND Range'" },
+ { "kind" : "IdRef", "name" : "'Invoke'" },
+ { "kind" : "IdRef", "name" : "'Param'" },
+ { "kind" : "IdRef", "name" : "'Param Size'" },
+ { "kind" : "IdRef", "name" : "'Param Align'" }
+ ],
+ "capabilities" : [ "DeviceEnqueue" ]
+ },
+ {
+ "opname" : "OpGetKernelNDrangeMaxSubGroupSize",
+ "opcode" : 294,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'ND Range'" },
+ { "kind" : "IdRef", "name" : "'Invoke'" },
+ { "kind" : "IdRef", "name" : "'Param'" },
+ { "kind" : "IdRef", "name" : "'Param Size'" },
+ { "kind" : "IdRef", "name" : "'Param Align'" }
+ ],
+ "capabilities" : [ "DeviceEnqueue" ]
+ },
+ {
+ "opname" : "OpGetKernelWorkGroupSize",
+ "opcode" : 295,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Invoke'" },
+ { "kind" : "IdRef", "name" : "'Param'" },
+ { "kind" : "IdRef", "name" : "'Param Size'" },
+ { "kind" : "IdRef", "name" : "'Param Align'" }
+ ],
+ "capabilities" : [ "DeviceEnqueue" ]
+ },
+ {
+ "opname" : "OpGetKernelPreferredWorkGroupSizeMultiple",
+ "opcode" : 296,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Invoke'" },
+ { "kind" : "IdRef", "name" : "'Param'" },
+ { "kind" : "IdRef", "name" : "'Param Size'" },
+ { "kind" : "IdRef", "name" : "'Param Align'" }
+ ],
+ "capabilities" : [ "DeviceEnqueue" ]
+ },
+ {
+ "opname" : "OpRetainEvent",
+ "opcode" : 297,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Event'" }
+ ],
+ "capabilities" : [ "DeviceEnqueue" ]
+ },
+ {
+ "opname" : "OpReleaseEvent",
+ "opcode" : 298,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Event'" }
+ ],
+ "capabilities" : [ "DeviceEnqueue" ]
+ },
+ {
+ "opname" : "OpCreateUserEvent",
+ "opcode" : 299,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" }
+ ],
+ "capabilities" : [ "DeviceEnqueue" ]
+ },
+ {
+ "opname" : "OpIsValidEvent",
+ "opcode" : 300,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Event'" }
+ ],
+ "capabilities" : [ "DeviceEnqueue" ]
+ },
+ {
+ "opname" : "OpSetUserEventStatus",
+ "opcode" : 301,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Event'" },
+ { "kind" : "IdRef", "name" : "'Status'" }
+ ],
+ "capabilities" : [ "DeviceEnqueue" ]
+ },
+ {
+ "opname" : "OpCaptureEventProfilingInfo",
+ "opcode" : 302,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Event'" },
+ { "kind" : "IdRef", "name" : "'Profiling Info'" },
+ { "kind" : "IdRef", "name" : "'Value'" }
+ ],
+ "capabilities" : [ "DeviceEnqueue" ]
+ },
+ {
+ "opname" : "OpGetDefaultQueue",
+ "opcode" : 303,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" }
+ ],
+ "capabilities" : [ "DeviceEnqueue" ]
+ },
+ {
+ "opname" : "OpBuildNDRange",
+ "opcode" : 304,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'GlobalWorkSize'" },
+ { "kind" : "IdRef", "name" : "'LocalWorkSize'" },
+ { "kind" : "IdRef", "name" : "'GlobalWorkOffset'" }
+ ],
+ "capabilities" : [ "DeviceEnqueue" ]
+ },
+ {
+ "opname" : "OpImageSparseSampleImplicitLod",
+ "opcode" : 305,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "ImageOperands", "quantifier" : "?" }
+ ],
+ "capabilities" : [ "SparseResidency" ]
+ },
+ {
+ "opname" : "OpImageSparseSampleExplicitLod",
+ "opcode" : 306,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "ImageOperands" }
+ ],
+ "capabilities" : [ "SparseResidency" ]
+ },
+ {
+ "opname" : "OpImageSparseSampleDrefImplicitLod",
+ "opcode" : 307,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "IdRef", "name" : "'D~ref~'" },
+ { "kind" : "ImageOperands", "quantifier" : "?" }
+ ],
+ "capabilities" : [ "SparseResidency" ]
+ },
+ {
+ "opname" : "OpImageSparseSampleDrefExplicitLod",
+ "opcode" : 308,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "IdRef", "name" : "'D~ref~'" },
+ { "kind" : "ImageOperands" }
+ ],
+ "capabilities" : [ "SparseResidency" ]
+ },
+ {
+ "opname" : "OpImageSparseSampleProjImplicitLod",
+ "opcode" : 309,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "ImageOperands", "quantifier" : "?" }
+ ],
+ "capabilities" : [ "SparseResidency" ]
+ },
+ {
+ "opname" : "OpImageSparseSampleProjExplicitLod",
+ "opcode" : 310,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "ImageOperands" }
+ ],
+ "capabilities" : [ "SparseResidency" ]
+ },
+ {
+ "opname" : "OpImageSparseSampleProjDrefImplicitLod",
+ "opcode" : 311,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "IdRef", "name" : "'D~ref~'" },
+ { "kind" : "ImageOperands", "quantifier" : "?" }
+ ],
+ "capabilities" : [ "SparseResidency" ]
+ },
+ {
+ "opname" : "OpImageSparseSampleProjDrefExplicitLod",
+ "opcode" : 312,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "IdRef", "name" : "'D~ref~'" },
+ { "kind" : "ImageOperands" }
+ ],
+ "capabilities" : [ "SparseResidency" ]
+ },
+ {
+ "opname" : "OpImageSparseFetch",
+ "opcode" : 313,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "ImageOperands", "quantifier" : "?" }
+ ],
+ "capabilities" : [ "SparseResidency" ]
+ },
+ {
+ "opname" : "OpImageSparseGather",
+ "opcode" : 314,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "IdRef", "name" : "'Component'" },
+ { "kind" : "ImageOperands", "quantifier" : "?" }
+ ],
+ "capabilities" : [ "SparseResidency" ]
+ },
+ {
+ "opname" : "OpImageSparseDrefGather",
+ "opcode" : 315,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Sampled Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "IdRef", "name" : "'D~ref~'" },
+ { "kind" : "ImageOperands", "quantifier" : "?" }
+ ],
+ "capabilities" : [ "SparseResidency" ]
+ },
+ {
+ "opname" : "OpImageSparseTexelsResident",
+ "opcode" : 316,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Resident Code'" }
+ ],
+ "capabilities" : [ "SparseResidency" ]
+ },
+ {
+ "opname" : "OpNoLine",
+ "opcode" : 317
+ },
+ {
+ "opname" : "OpAtomicFlagTestAndSet",
+ "opcode" : 318,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpAtomicFlagClear",
+ "opcode" : 319,
+ "operands" : [
+ { "kind" : "IdRef", "name" : "'Pointer'" },
+ { "kind" : "IdScope", "name" : "'Scope'" },
+ { "kind" : "IdMemorySemantics", "name" : "'Semantics'" }
+ ],
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "opname" : "OpImageSparseRead",
+ "opcode" : 320,
+ "operands" : [
+ { "kind" : "IdResultType" },
+ { "kind" : "IdResult" },
+ { "kind" : "IdRef", "name" : "'Image'" },
+ { "kind" : "IdRef", "name" : "'Coordinate'" },
+ { "kind" : "ImageOperands", "quantifier" : "?" }
+ ],
+ "capabilities" : [ "SparseResidency" ]
+ }
+ ],
+ "operand_kinds" : [
+ {
+ "category" : "BitEnum",
+ "kind" : "ImageOperands",
+ "enumerants" : [
+ {
+ "enumerant" : "None",
+ "value" : "0x0000"
+ },
+ {
+ "enumerant" : "Bias",
+ "value" : "0x0001",
+ "capabilities" : [ "Shader" ],
+ "parameters" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "enumerant" : "Lod",
+ "value" : "0x0002",
+ "parameters" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "enumerant" : "Grad",
+ "value" : "0x0004",
+ "parameters" : [
+ { "kind" : "IdRef" },
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "enumerant" : "ConstOffset",
+ "value" : "0x0008",
+ "parameters" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "enumerant" : "Offset",
+ "value" : "0x0010",
+ "capabilities" : [ "ImageGatherExtended" ],
+ "parameters" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "enumerant" : "ConstOffsets",
+ "value" : "0x0020",
+ "parameters" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "enumerant" : "Sample",
+ "value" : "0x0040",
+ "parameters" : [
+ { "kind" : "IdRef" }
+ ]
+ },
+ {
+ "enumerant" : "MinLod",
+ "value" : "0x0080",
+ "capabilities" : [ "MinLod" ],
+ "parameters" : [
+ { "kind" : "IdRef" }
+ ]
+ }
+ ]
+ },
+ {
+ "category" : "BitEnum",
+ "kind" : "FPFastMathMode",
+ "enumerants" : [
+ {
+ "enumerant" : "None",
+ "value" : "0x0000"
+ },
+ {
+ "enumerant" : "NotNaN",
+ "value" : "0x0001",
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "NotInf",
+ "value" : "0x0002",
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "NSZ",
+ "value" : "0x0004",
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "AllowRecip",
+ "value" : "0x0008",
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "Fast",
+ "value" : "0x0010",
+ "capabilities" : [ "Kernel" ]
+ }
+ ]
+ },
+ {
+ "category" : "BitEnum",
+ "kind" : "SelectionControl",
+ "enumerants" : [
+ {
+ "enumerant" : "None",
+ "value" : "0x0000"
+ },
+ {
+ "enumerant" : "Flatten",
+ "value" : "0x0001"
+ },
+ {
+ "enumerant" : "DontFlatten",
+ "value" : "0x0002"
+ }
+ ]
+ },
+ {
+ "category" : "BitEnum",
+ "kind" : "LoopControl",
+ "enumerants" : [
+ {
+ "enumerant" : "None",
+ "value" : "0x0000"
+ },
+ {
+ "enumerant" : "Unroll",
+ "value" : "0x0001"
+ },
+ {
+ "enumerant" : "DontUnroll",
+ "value" : "0x0002"
+ }
+ ]
+ },
+ {
+ "category" : "BitEnum",
+ "kind" : "FunctionControl",
+ "enumerants" : [
+ {
+ "enumerant" : "None",
+ "value" : "0x0000"
+ },
+ {
+ "enumerant" : "Inline",
+ "value" : "0x0001"
+ },
+ {
+ "enumerant" : "DontInline",
+ "value" : "0x0002"
+ },
+ {
+ "enumerant" : "Pure",
+ "value" : "0x0004"
+ },
+ {
+ "enumerant" : "Const",
+ "value" : "0x0008"
+ }
+ ]
+ },
+ {
+ "category" : "BitEnum",
+ "kind" : "MemorySemantics",
+ "enumerants" : [
+ {
+ "enumerant" : "Relaxed",
+ "value" : "0x0000"
+ },
+ {
+ "enumerant" : "None",
+ "value" : "0x0000"
+ },
+ {
+ "enumerant" : "SequentiallyConsistent",
+ "value" : "0x0010"
+ },
+ {
+ "enumerant" : "Acquire",
+ "value" : "0x0002"
+ },
+ {
+ "enumerant" : "Release",
+ "value" : "0x0004"
+ },
+ {
+ "enumerant" : "AcquireRelease",
+ "value" : "0x0008"
+ },
+ {
+ "enumerant" : "UniformMemory",
+ "value" : "0x0040",
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "SubgroupMemory",
+ "value" : "0x0080"
+ },
+ {
+ "enumerant" : "WorkgroupMemory",
+ "value" : "0x0100"
+ },
+ {
+ "enumerant" : "CrossWorkgroupMemory",
+ "value" : "0x0200"
+ },
+ {
+ "enumerant" : "AtomicCounterMemory",
+ "value" : "0x0400",
+ "capabilities" : [ "AtomicStorage" ]
+ },
+ {
+ "enumerant" : "ImageMemory",
+ "value" : "0x0800"
+ }
+ ]
+ },
+ {
+ "category" : "BitEnum",
+ "kind" : "MemoryAccess",
+ "enumerants" : [
+ {
+ "enumerant" : "None",
+ "value" : "0x0000"
+ },
+ {
+ "enumerant" : "Volatile",
+ "value" : "0x0001"
+ },
+ {
+ "enumerant" : "Aligned",
+ "value" : "0x0002",
+ "parameters" : [
+ { "kind" : "LiteralInteger" }
+ ]
+ },
+ {
+ "enumerant" : "Nontemporal",
+ "value" : "0x0004"
+ }
+ ]
+ },
+ {
+ "category" : "BitEnum",
+ "kind" : "KernelProfilingInfo",
+ "enumerants" : [
+ {
+ "enumerant" : "None",
+ "value" : "0x0000"
+ },
+ {
+ "enumerant" : "CmdExecTime",
+ "value" : "0x0001",
+ "capabilities" : [ "Kernel" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "SourceLanguage",
+ "enumerants" : [
+ {
+ "enumerant" : "Unknown",
+ "value" : 0
+ },
+ {
+ "enumerant" : "ESSL",
+ "value" : 1
+ },
+ {
+ "enumerant" : "GLSL",
+ "value" : 2
+ },
+ {
+ "enumerant" : "OpenCL_C",
+ "value" : 3
+ },
+ {
+ "enumerant" : "OpenCL_CPP",
+ "value" : 4
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "ExecutionModel",
+ "enumerants" : [
+ {
+ "enumerant" : "Vertex",
+ "value" : 0,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "TessellationControl",
+ "value" : 1,
+ "capabilities" : [ "Tessellation" ]
+ },
+ {
+ "enumerant" : "TessellationEvaluation",
+ "value" : 2,
+ "capabilities" : [ "Tessellation" ]
+ },
+ {
+ "enumerant" : "Geometry",
+ "value" : 3,
+ "capabilities" : [ "Geometry" ]
+ },
+ {
+ "enumerant" : "Fragment",
+ "value" : 4,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "GLCompute",
+ "value" : 5,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Kernel",
+ "value" : 6,
+ "capabilities" : [ "Kernel" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "AddressingModel",
+ "enumerants" : [
+ {
+ "enumerant" : "Logical",
+ "value" : 0
+ },
+ {
+ "enumerant" : "Physical32",
+ "value" : 1,
+ "capabilities" : [ "Addresses" ]
+ },
+ {
+ "enumerant" : "Physical64",
+ "value" : 2,
+ "capabilities" : [ "Addresses" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "MemoryModel",
+ "enumerants" : [
+ {
+ "enumerant" : "Simple",
+ "value" : 0,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "GLSL450",
+ "value" : 1,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "OpenCL",
+ "value" : 2,
+ "capabilities" : [ "Kernel" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "ExecutionMode",
+ "enumerants" : [
+ {
+ "enumerant" : "Invocations",
+ "value" : 0,
+ "capabilities" : [ "Geometry" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'Number of <<Invocation,invocations>>'" }
+ ]
+ },
+ {
+ "enumerant" : "SpacingEqual",
+ "value" : 1,
+ "capabilities" : [ "Tessellation" ]
+ },
+ {
+ "enumerant" : "SpacingFractionalEven",
+ "value" : 2,
+ "capabilities" : [ "Tessellation" ]
+ },
+ {
+ "enumerant" : "SpacingFractionalOdd",
+ "value" : 3,
+ "capabilities" : [ "Tessellation" ]
+ },
+ {
+ "enumerant" : "VertexOrderCw",
+ "value" : 4,
+ "capabilities" : [ "Tessellation" ]
+ },
+ {
+ "enumerant" : "VertexOrderCcw",
+ "value" : 5,
+ "capabilities" : [ "Tessellation" ]
+ },
+ {
+ "enumerant" : "PixelCenterInteger",
+ "value" : 6,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "OriginUpperLeft",
+ "value" : 7,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "OriginLowerLeft",
+ "value" : 8,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "EarlyFragmentTests",
+ "value" : 9,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "PointMode",
+ "value" : 10,
+ "capabilities" : [ "Tessellation" ]
+ },
+ {
+ "enumerant" : "Xfb",
+ "value" : 11,
+ "capabilities" : [ "TransformFeedback" ]
+ },
+ {
+ "enumerant" : "DepthReplacing",
+ "value" : 12,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "DepthGreater",
+ "value" : 14,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "DepthLess",
+ "value" : 15,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "DepthUnchanged",
+ "value" : 16,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "LocalSize",
+ "value" : 17,
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'x size'" },
+ { "kind" : "LiteralInteger", "name" : "'y size'" },
+ { "kind" : "LiteralInteger", "name" : "'z size'" }
+ ]
+ },
+ {
+ "enumerant" : "LocalSizeHint",
+ "value" : 18,
+ "capabilities" : [ "Kernel" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'x size'" },
+ { "kind" : "LiteralInteger", "name" : "'y size'" },
+ { "kind" : "LiteralInteger", "name" : "'z size'" }
+ ]
+ },
+ {
+ "enumerant" : "InputPoints",
+ "value" : 19,
+ "capabilities" : [ "Geometry" ]
+ },
+ {
+ "enumerant" : "InputLines",
+ "value" : 20,
+ "capabilities" : [ "Geometry" ]
+ },
+ {
+ "enumerant" : "InputLinesAdjacency",
+ "value" : 21,
+ "capabilities" : [ "Geometry" ]
+ },
+ {
+ "enumerant" : "Triangles",
+ "value" : 22,
+ "capabilities" : [ "Geometry", "Tessellation" ]
+ },
+ {
+ "enumerant" : "InputTrianglesAdjacency",
+ "value" : 23,
+ "capabilities" : [ "Geometry" ]
+ },
+ {
+ "enumerant" : "Quads",
+ "value" : 24,
+ "capabilities" : [ "Tessellation" ]
+ },
+ {
+ "enumerant" : "Isolines",
+ "value" : 25,
+ "capabilities" : [ "Tessellation" ]
+ },
+ {
+ "enumerant" : "OutputVertices",
+ "value" : 26,
+ "capabilities" : [ "Geometry", "Tessellation" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'Vertex count'" }
+ ]
+ },
+ {
+ "enumerant" : "OutputPoints",
+ "value" : 27,
+ "capabilities" : [ "Geometry" ]
+ },
+ {
+ "enumerant" : "OutputLineStrip",
+ "value" : 28,
+ "capabilities" : [ "Geometry" ]
+ },
+ {
+ "enumerant" : "OutputTriangleStrip",
+ "value" : 29,
+ "capabilities" : [ "Geometry" ]
+ },
+ {
+ "enumerant" : "VecTypeHint",
+ "value" : 30,
+ "capabilities" : [ "Kernel" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'Vector type'" }
+ ]
+ },
+ {
+ "enumerant" : "ContractionOff",
+ "value" : 31,
+ "capabilities" : [ "Kernel" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "StorageClass",
+ "enumerants" : [
+ {
+ "enumerant" : "UniformConstant",
+ "value" : 0
+ },
+ {
+ "enumerant" : "Input",
+ "value" : 1,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Uniform",
+ "value" : 2,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Output",
+ "value" : 3,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Workgroup",
+ "value" : 4
+ },
+ {
+ "enumerant" : "CrossWorkgroup",
+ "value" : 5
+ },
+ {
+ "enumerant" : "Private",
+ "value" : 6,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Function",
+ "value" : 7
+ },
+ {
+ "enumerant" : "Generic",
+ "value" : 8,
+ "capabilities" : [ "GenericPointer" ]
+ },
+ {
+ "enumerant" : "PushConstant",
+ "value" : 9,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "AtomicCounter",
+ "value" : 10,
+ "capabilities" : [ "AtomicStorage" ]
+ },
+ {
+ "enumerant" : "Image",
+ "value" : 11
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "Dim",
+ "enumerants" : [
+ {
+ "enumerant" : "1D",
+ "value" : 0,
+ "capabilities" : [ "Sampled1D" ]
+ },
+ {
+ "enumerant" : "2D",
+ "value" : 1
+ },
+ {
+ "enumerant" : "3D",
+ "value" : 2
+ },
+ {
+ "enumerant" : "Cube",
+ "value" : 3,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Rect",
+ "value" : 4,
+ "capabilities" : [ "SampledRect" ]
+ },
+ {
+ "enumerant" : "Buffer",
+ "value" : 5,
+ "capabilities" : [ "SampledBuffer" ]
+ },
+ {
+ "enumerant" : "SubpassData",
+ "value" : 6,
+ "capabilities" : [ "InputAttachment" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "SamplerAddressingMode",
+ "enumerants" : [
+ {
+ "enumerant" : "None",
+ "value" : 0,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "ClampToEdge",
+ "value" : 1,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "Clamp",
+ "value" : 2,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "Repeat",
+ "value" : 3,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "RepeatMirrored",
+ "value" : 4,
+ "capabilities" : [ "Kernel" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "SamplerFilterMode",
+ "enumerants" : [
+ {
+ "enumerant" : "Nearest",
+ "value" : 0,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "Linear",
+ "value" : 1,
+ "capabilities" : [ "Kernel" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "ImageFormat",
+ "enumerants" : [
+ {
+ "enumerant" : "Unknown",
+ "value" : 0
+ },
+ {
+ "enumerant" : "Rgba32f",
+ "value" : 1,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Rgba16f",
+ "value" : 2,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "R32f",
+ "value" : 3,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Rgba8",
+ "value" : 4,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Rgba8Snorm",
+ "value" : 5,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Rg32f",
+ "value" : 6,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "Rg16f",
+ "value" : 7,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "R11fG11fB10f",
+ "value" : 8,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "R16f",
+ "value" : 9,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "Rgba16",
+ "value" : 10,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "Rgb10A2",
+ "value" : 11,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "Rg16",
+ "value" : 12,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "Rg8",
+ "value" : 13,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "R16",
+ "value" : 14,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "R8",
+ "value" : 15,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "Rgba16Snorm",
+ "value" : 16,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "Rg16Snorm",
+ "value" : 17,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "Rg8Snorm",
+ "value" : 18,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "R16Snorm",
+ "value" : 19,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "R8Snorm",
+ "value" : 20,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "Rgba32i",
+ "value" : 21,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Rgba16i",
+ "value" : 22,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Rgba8i",
+ "value" : 23,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "R32i",
+ "value" : 24,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Rg32i",
+ "value" : 25,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "Rg16i",
+ "value" : 26,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "Rg8i",
+ "value" : 27,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "R16i",
+ "value" : 28,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "R8i",
+ "value" : 29,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "Rgba32ui",
+ "value" : 30,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Rgba16ui",
+ "value" : 31,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Rgba8ui",
+ "value" : 32,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "R32ui",
+ "value" : 33,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Rgb10a2ui",
+ "value" : 34,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "Rg32ui",
+ "value" : 35,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "Rg16ui",
+ "value" : 36,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "Rg8ui",
+ "value" : 37,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "R16ui",
+ "value" : 38,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ },
+ {
+ "enumerant" : "R8ui",
+ "value" : 39,
+ "capabilities" : [ "StorageImageExtendedFormats" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "ImageChannelOrder",
+ "enumerants" : [
+ {
+ "enumerant" : "R",
+ "value" : 0,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "A",
+ "value" : 1,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "RG",
+ "value" : 2,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "RA",
+ "value" : 3,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "RGB",
+ "value" : 4,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "RGBA",
+ "value" : 5,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "BGRA",
+ "value" : 6,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "ARGB",
+ "value" : 7,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "Intensity",
+ "value" : 8,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "Luminance",
+ "value" : 9,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "Rx",
+ "value" : 10,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "RGx",
+ "value" : 11,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "RGBx",
+ "value" : 12,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "Depth",
+ "value" : 13,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "DepthStencil",
+ "value" : 14,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "sRGB",
+ "value" : 15,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "sRGBx",
+ "value" : 16,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "sRGBA",
+ "value" : 17,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "sBGRA",
+ "value" : 18,
+ "capabilities" : [ "Kernel" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "ImageChannelDataType",
+ "enumerants" : [
+ {
+ "enumerant" : "SnormInt8",
+ "value" : 0,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "SnormInt16",
+ "value" : 1,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "UnormInt8",
+ "value" : 2,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "UnormInt16",
+ "value" : 3,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "UnormShort565",
+ "value" : 4,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "UnormShort555",
+ "value" : 5,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "UnormInt101010",
+ "value" : 6,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "SignedInt8",
+ "value" : 7,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "SignedInt16",
+ "value" : 8,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "SignedInt32",
+ "value" : 9,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "UnsignedInt8",
+ "value" : 10,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "UnsignedInt16",
+ "value" : 11,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "UnsignedInt32",
+ "value" : 12,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "HalfFloat",
+ "value" : 13,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "Float",
+ "value" : 14,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "UnormInt24",
+ "value" : 15,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "UnormInt101010_2",
+ "value" : 16,
+ "capabilities" : [ "Kernel" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "FPRoundingMode",
+ "enumerants" : [
+ {
+ "enumerant" : "RTE",
+ "value" : 0,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "RTZ",
+ "value" : 1,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "RTP",
+ "value" : 2,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "RTN",
+ "value" : 3,
+ "capabilities" : [ "Kernel" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "LinkageType",
+ "enumerants" : [
+ {
+ "enumerant" : "Export",
+ "value" : 0,
+ "capabilities" : [ "Linkage" ]
+ },
+ {
+ "enumerant" : "Import",
+ "value" : 1,
+ "capabilities" : [ "Linkage" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "AccessQualifier",
+ "enumerants" : [
+ {
+ "enumerant" : "ReadOnly",
+ "value" : 0,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "WriteOnly",
+ "value" : 1,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "ReadWrite",
+ "value" : 2,
+ "capabilities" : [ "Kernel" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "FunctionParameterAttribute",
+ "enumerants" : [
+ {
+ "enumerant" : "Zext",
+ "value" : 0,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "Sext",
+ "value" : 1,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "ByVal",
+ "value" : 2,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "Sret",
+ "value" : 3,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "NoAlias",
+ "value" : 4,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "NoCapture",
+ "value" : 5,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "NoWrite",
+ "value" : 6,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "NoReadWrite",
+ "value" : 7,
+ "capabilities" : [ "Kernel" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "Decoration",
+ "enumerants" : [
+ {
+ "enumerant" : "RelaxedPrecision",
+ "value" : 0,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "SpecId",
+ "value" : 1,
+ "capabilities" : [ "Shader" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'Specialization Constant ID'" }
+ ]
+ },
+ {
+ "enumerant" : "Block",
+ "value" : 2,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "BufferBlock",
+ "value" : 3,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "RowMajor",
+ "value" : 4,
+ "capabilities" : [ "Matrix" ]
+ },
+ {
+ "enumerant" : "ColMajor",
+ "value" : 5,
+ "capabilities" : [ "Matrix" ]
+ },
+ {
+ "enumerant" : "ArrayStride",
+ "value" : 6,
+ "capabilities" : [ "Shader" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'Array Stride'" }
+ ]
+ },
+ {
+ "enumerant" : "MatrixStride",
+ "value" : 7,
+ "capabilities" : [ "Matrix" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'Matrix Stride'" }
+ ]
+ },
+ {
+ "enumerant" : "GLSLShared",
+ "value" : 8,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "GLSLPacked",
+ "value" : 9,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "CPacked",
+ "value" : 10,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "BuiltIn",
+ "value" : 11,
+ "parameters" : [
+ { "kind" : "BuiltIn" }
+ ]
+ },
+ {
+ "enumerant" : "NoPerspective",
+ "value" : 13,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Flat",
+ "value" : 14,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Patch",
+ "value" : 15,
+ "capabilities" : [ "Tessellation" ]
+ },
+ {
+ "enumerant" : "Centroid",
+ "value" : 16,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Sample",
+ "value" : 17,
+ "capabilities" : [ "SampleRateShading" ]
+ },
+ {
+ "enumerant" : "Invariant",
+ "value" : 18,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Restrict",
+ "value" : 19
+ },
+ {
+ "enumerant" : "Aliased",
+ "value" : 20
+ },
+ {
+ "enumerant" : "Volatile",
+ "value" : 21
+ },
+ {
+ "enumerant" : "Constant",
+ "value" : 22,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "Coherent",
+ "value" : 23
+ },
+ {
+ "enumerant" : "NonWritable",
+ "value" : 24
+ },
+ {
+ "enumerant" : "NonReadable",
+ "value" : 25
+ },
+ {
+ "enumerant" : "Uniform",
+ "value" : 26,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "SaturatedConversion",
+ "value" : 28,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "Stream",
+ "value" : 29,
+ "capabilities" : [ "GeometryStreams" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'Stream Number'" }
+ ]
+ },
+ {
+ "enumerant" : "Location",
+ "value" : 30,
+ "capabilities" : [ "Shader" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'Location'" }
+ ]
+ },
+ {
+ "enumerant" : "Component",
+ "value" : 31,
+ "capabilities" : [ "Shader" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'Component'" }
+ ]
+ },
+ {
+ "enumerant" : "Index",
+ "value" : 32,
+ "capabilities" : [ "Shader" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'Index'" }
+ ]
+ },
+ {
+ "enumerant" : "Binding",
+ "value" : 33,
+ "capabilities" : [ "Shader" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'Binding Point'" }
+ ]
+ },
+ {
+ "enumerant" : "DescriptorSet",
+ "value" : 34,
+ "capabilities" : [ "Shader" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'Descriptor Set'" }
+ ]
+ },
+ {
+ "enumerant" : "Offset",
+ "value" : 35,
+ "capabilities" : [ "Shader" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'Byte Offset'" }
+ ]
+ },
+ {
+ "enumerant" : "XfbBuffer",
+ "value" : 36,
+ "capabilities" : [ "TransformFeedback" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'XFB Buffer Number'" }
+ ]
+ },
+ {
+ "enumerant" : "XfbStride",
+ "value" : 37,
+ "capabilities" : [ "TransformFeedback" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'XFB Stride'" }
+ ]
+ },
+ {
+ "enumerant" : "FuncParamAttr",
+ "value" : 38,
+ "capabilities" : [ "Kernel" ],
+ "parameters" : [
+ { "kind" : "FunctionParameterAttribute", "name" : "'Function Parameter Attribute'" }
+ ]
+ },
+ {
+ "enumerant" : "FPRoundingMode",
+ "value" : 39,
+ "capabilities" : [ "Kernel" ],
+ "parameters" : [
+ { "kind" : "FPRoundingMode", "name" : "'Floating-Point Rounding Mode'" }
+ ]
+ },
+ {
+ "enumerant" : "FPFastMathMode",
+ "value" : 40,
+ "capabilities" : [ "Kernel" ],
+ "parameters" : [
+ { "kind" : "FPFastMathMode", "name" : "'Fast-Math Mode'" }
+ ]
+ },
+ {
+ "enumerant" : "LinkageAttributes",
+ "value" : 41,
+ "capabilities" : [ "Linkage" ],
+ "parameters" : [
+ { "kind" : "LiteralString", "name" : "'Name'" },
+ { "kind" : "LinkageType", "name" : "'Linkage Type'" }
+ ]
+ },
+ {
+ "enumerant" : "NoContraction",
+ "value" : 42,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "InputAttachmentIndex",
+ "value" : 43,
+ "capabilities" : [ "InputAttachment" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'Attachment Index'" }
+ ]
+ },
+ {
+ "enumerant" : "Alignment",
+ "value" : 44,
+ "capabilities" : [ "Kernel" ],
+ "parameters" : [
+ { "kind" : "LiteralInteger", "name" : "'Alignment'" }
+ ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "BuiltIn",
+ "enumerants" : [
+ {
+ "enumerant" : "Position",
+ "value" : 0,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "PointSize",
+ "value" : 1,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "ClipDistance",
+ "value" : 3,
+ "capabilities" : [ "ClipDistance" ]
+ },
+ {
+ "enumerant" : "CullDistance",
+ "value" : 4,
+ "capabilities" : [ "CullDistance" ]
+ },
+ {
+ "enumerant" : "VertexId",
+ "value" : 5,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "InstanceId",
+ "value" : 6,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "PrimitiveId",
+ "value" : 7,
+ "capabilities" : [ "Geometry", "Tessellation" ]
+ },
+ {
+ "enumerant" : "InvocationId",
+ "value" : 8,
+ "capabilities" : [ "Geometry", "Tessellation" ]
+ },
+ {
+ "enumerant" : "Layer",
+ "value" : 9,
+ "capabilities" : [ "Geometry" ]
+ },
+ {
+ "enumerant" : "ViewportIndex",
+ "value" : 10,
+ "capabilities" : [ "MultiViewport" ]
+ },
+ {
+ "enumerant" : "TessLevelOuter",
+ "value" : 11,
+ "capabilities" : [ "Tessellation" ]
+ },
+ {
+ "enumerant" : "TessLevelInner",
+ "value" : 12,
+ "capabilities" : [ "Tessellation" ]
+ },
+ {
+ "enumerant" : "TessCoord",
+ "value" : 13,
+ "capabilities" : [ "Tessellation" ]
+ },
+ {
+ "enumerant" : "PatchVertices",
+ "value" : 14,
+ "capabilities" : [ "Tessellation" ]
+ },
+ {
+ "enumerant" : "FragCoord",
+ "value" : 15,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "PointCoord",
+ "value" : 16,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "FrontFacing",
+ "value" : 17,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "SampleId",
+ "value" : 18,
+ "capabilities" : [ "SampleRateShading" ]
+ },
+ {
+ "enumerant" : "SamplePosition",
+ "value" : 19,
+ "capabilities" : [ "SampleRateShading" ]
+ },
+ {
+ "enumerant" : "SampleMask",
+ "value" : 20,
+ "capabilities" : [ "SampleRateShading" ]
+ },
+ {
+ "enumerant" : "FragDepth",
+ "value" : 22,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "HelperInvocation",
+ "value" : 23,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "NumWorkgroups",
+ "value" : 24
+ },
+ {
+ "enumerant" : "WorkgroupSize",
+ "value" : 25
+ },
+ {
+ "enumerant" : "WorkgroupId",
+ "value" : 26
+ },
+ {
+ "enumerant" : "LocalInvocationId",
+ "value" : 27
+ },
+ {
+ "enumerant" : "GlobalInvocationId",
+ "value" : 28
+ },
+ {
+ "enumerant" : "LocalInvocationIndex",
+ "value" : 29
+ },
+ {
+ "enumerant" : "WorkDim",
+ "value" : 30,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "GlobalSize",
+ "value" : 31,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "EnqueuedWorkgroupSize",
+ "value" : 32,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "GlobalOffset",
+ "value" : 33,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "GlobalLinearId",
+ "value" : 34,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "SubgroupSize",
+ "value" : 36,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "SubgroupMaxSize",
+ "value" : 37,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "NumSubgroups",
+ "value" : 38,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "NumEnqueuedSubgroups",
+ "value" : 39,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "SubgroupId",
+ "value" : 40,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "SubgroupLocalInvocationId",
+ "value" : 41,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "VertexIndex",
+ "value" : 42,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "InstanceIndex",
+ "value" : 43,
+ "capabilities" : [ "Shader" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "Scope",
+ "enumerants" : [
+ {
+ "enumerant" : "CrossDevice",
+ "value" : 0
+ },
+ {
+ "enumerant" : "Device",
+ "value" : 1
+ },
+ {
+ "enumerant" : "Workgroup",
+ "value" : 2
+ },
+ {
+ "enumerant" : "Subgroup",
+ "value" : 3
+ },
+ {
+ "enumerant" : "Invocation",
+ "value" : 4
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "GroupOperation",
+ "enumerants" : [
+ {
+ "enumerant" : "Reduce",
+ "value" : 0,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "InclusiveScan",
+ "value" : 1,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "ExclusiveScan",
+ "value" : 2,
+ "capabilities" : [ "Kernel" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "KernelEnqueueFlags",
+ "enumerants" : [
+ {
+ "enumerant" : "NoWait",
+ "value" : 0,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "WaitKernel",
+ "value" : 1,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "WaitWorkGroup",
+ "value" : 2,
+ "capabilities" : [ "Kernel" ]
+ }
+ ]
+ },
+ {
+ "category" : "ValueEnum",
+ "kind" : "Capability",
+ "enumerants" : [
+ {
+ "enumerant" : "Matrix",
+ "value" : 0
+ },
+ {
+ "enumerant" : "Shader",
+ "value" : 1,
+ "capabilities" : [ "Matrix" ]
+ },
+ {
+ "enumerant" : "Geometry",
+ "value" : 2,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Tessellation",
+ "value" : 3,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Addresses",
+ "value" : 4
+ },
+ {
+ "enumerant" : "Linkage",
+ "value" : 5
+ },
+ {
+ "enumerant" : "Kernel",
+ "value" : 6
+ },
+ {
+ "enumerant" : "Vector16",
+ "value" : 7,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "Float16Buffer",
+ "value" : 8,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "Float16",
+ "value" : 9
+ },
+ {
+ "enumerant" : "Float64",
+ "value" : 10
+ },
+ {
+ "enumerant" : "Int64",
+ "value" : 11
+ },
+ {
+ "enumerant" : "Int64Atomics",
+ "value" : 12,
+ "capabilities" : [ "Int64" ]
+ },
+ {
+ "enumerant" : "ImageBasic",
+ "value" : 13,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "ImageReadWrite",
+ "value" : 14,
+ "capabilities" : [ "ImageBasic" ]
+ },
+ {
+ "enumerant" : "ImageMipmap",
+ "value" : 15,
+ "capabilities" : [ "ImageBasic" ]
+ },
+ {
+ "enumerant" : "Pipes",
+ "value" : 17,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "Groups",
+ "value" : 18
+ },
+ {
+ "enumerant" : "DeviceEnqueue",
+ "value" : 19,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "LiteralSampler",
+ "value" : 20,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "AtomicStorage",
+ "value" : 21,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Int16",
+ "value" : 22
+ },
+ {
+ "enumerant" : "TessellationPointSize",
+ "value" : 23,
+ "capabilities" : [ "Tessellation" ]
+ },
+ {
+ "enumerant" : "GeometryPointSize",
+ "value" : 24,
+ "capabilities" : [ "Geometry" ]
+ },
+ {
+ "enumerant" : "ImageGatherExtended",
+ "value" : 25,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "StorageImageMultisample",
+ "value" : 27,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "UniformBufferArrayDynamicIndexing",
+ "value" : 28,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "SampledImageArrayDynamicIndexing",
+ "value" : 29,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "StorageBufferArrayDynamicIndexing",
+ "value" : 30,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "StorageImageArrayDynamicIndexing",
+ "value" : 31,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "ClipDistance",
+ "value" : 32,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "CullDistance",
+ "value" : 33,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "ImageCubeArray",
+ "value" : 34,
+ "capabilities" : [ "SampledCubeArray" ]
+ },
+ {
+ "enumerant" : "SampleRateShading",
+ "value" : 35,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "ImageRect",
+ "value" : 36,
+ "capabilities" : [ "SampledRect" ]
+ },
+ {
+ "enumerant" : "SampledRect",
+ "value" : 37,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "GenericPointer",
+ "value" : 38,
+ "capabilities" : [ "Addresses" ]
+ },
+ {
+ "enumerant" : "Int8",
+ "value" : 39,
+ "capabilities" : [ "Kernel" ]
+ },
+ {
+ "enumerant" : "InputAttachment",
+ "value" : 40,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "SparseResidency",
+ "value" : 41,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "MinLod",
+ "value" : 42,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Sampled1D",
+ "value" : 43,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "Image1D",
+ "value" : 44,
+ "capabilities" : [ "Sampled1D" ]
+ },
+ {
+ "enumerant" : "SampledCubeArray",
+ "value" : 45,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "SampledBuffer",
+ "value" : 46,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "ImageBuffer",
+ "value" : 47,
+ "capabilities" : [ "SampledBuffer" ]
+ },
+ {
+ "enumerant" : "ImageMSArray",
+ "value" : 48,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "StorageImageExtendedFormats",
+ "value" : 49,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "ImageQuery",
+ "value" : 50,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "DerivativeControl",
+ "value" : 51,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "InterpolationFunction",
+ "value" : 52,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "TransformFeedback",
+ "value" : 53,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "GeometryStreams",
+ "value" : 54,
+ "capabilities" : [ "Geometry" ]
+ },
+ {
+ "enumerant" : "StorageImageReadWithoutFormat",
+ "value" : 55,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "StorageImageWriteWithoutFormat",
+ "value" : 56,
+ "capabilities" : [ "Shader" ]
+ },
+ {
+ "enumerant" : "MultiViewport",
+ "value" : 57,
+ "capabilities" : [ "Geometry" ]
+ }
+ ]
+ },
+ {
+ "category" : "Id",
+ "kind" : "IdResultType",
+ "doc" : "Reference to an <id> representing the result's type of the enclosing instruction"
+ },
+ {
+ "category" : "Id",
+ "kind" : "IdResult",
+ "doc" : "Definition of an <id> representing the result of the enclosing instruction"
+ },
+ {
+ "category" : "Id",
+ "kind" : "IdMemorySemantics",
+ "doc" : "Reference to an <id> representing a 32-bit integer that is a mask from the MemorySemantics operand kind"
+ },
+ {
+ "category" : "Id",
+ "kind" : "IdScope",
+ "doc" : "Reference to an <id> representing a 32-bit integer that is a mask from the Scope operand kind"
+ },
+ {
+ "category" : "Id",
+ "kind" : "IdRef",
+ "doc" : "Reference to an <id>"
+ },
+ {
+ "category" : "Literal",
+ "kind" : "LiteralInteger",
+ "doc" : "An integer consuming one or more words"
+ },
+ {
+ "category" : "Literal",
+ "kind" : "LiteralString",
+ "doc" : "A null-terminated stream of characters consuming an integral number of words"
+ },
+ {
+ "category" : "Literal",
+ "kind" : "LiteralContextDependentNumber",
+ "doc" : "A literal number whose size and format are determined by a previous operand in the enclosing instruction"
+ },
+ {
+ "category" : "Literal",
+ "kind" : "LiteralExtInstInteger",
+ "doc" : "A 32-bit unsigned integer indicating which instruction to use and determining the layout of following operands (for OpExtInst)"
+ },
+ {
+ "category" : "Literal",
+ "kind" : "LiteralSpecConstantOpInteger",
+ "doc" : "An opcode indicating the operation to be performed and determining the layout of following operands (for OpSpecConstantOp)"
+ },
+ {
+ "category" : "Composite",
+ "kind" : "PairLiteralIntegerIdRef",
+ "bases" : [ "LiteralInteger", "IdRef" ]
+ },
+ {
+ "category" : "Composite",
+ "kind" : "PairIdRefLiteralInteger",
+ "bases" : [ "IdRef", "LiteralInteger" ]
+ },
+ {
+ "category" : "Composite",
+ "kind" : "PairIdRefIdRef",
+ "bases" : [ "IdRef", "IdRef" ]
+ }
+ ]
+}
diff --git a/source/spirv_constant.h b/source/spirv_constant.h
index 3ade7cc..a53ce0d 100644
--- a/source/spirv_constant.h
+++ b/source/spirv_constant.h
@@ -28,6 +28,7 @@
#define LIBSPIRV_SPIRV_CONSTANT_H_
#include "spirv-tools/libspirv.h"
+#include "spirv/spirv.h"
// Version number macros.
@@ -40,6 +41,9 @@
// Returns the minor version extracted from a version header word.
#define SPV_SPIRV_VERSION_MINOR_PART(WORD) ((uint32_t(WORD) >> 8) & 0xff)
+// Returns the version number for the given SPIR-V target environment.
+uint32_t spvVersionForTargetEnv(spv_target_env env);
+
// Header indices
#define SPV_INDEX_MAGIC_NUMBER 0u
diff --git a/source/spirv_definition.h b/source/spirv_definition.h
index 65d2d54..088ae96 100644
--- a/source/spirv_definition.h
+++ b/source/spirv_definition.h
@@ -31,6 +31,8 @@
#include "spirv-tools/libspirv.h"
+#define spvIsInBitfield(value, bitfield) ((value) == ((value)&bitfield))
+
// A bit mask representing a set of capabilities.
// Currently there are 57 distinct capabilities, so 64 bits
// should be enough.
diff --git a/source/spirv_operands.h b/source/spirv_operands.h
deleted file mode 100644
index ed8c7e5..0000000
--- a/source/spirv_operands.h
+++ /dev/null
@@ -1,97 +0,0 @@
-//
-// Copyright (C) 2014-2016 LunarG, Inc.
-//
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-//
-// Redistributions of source code must retain the above copyright
-// notice, this list of conditions and the following disclaimer.
-//
-// Redistributions in binary form must reproduce the above
-// copyright notice, this list of conditions and the following
-// disclaimer in the documentation and/or other materials provided
-// with the distribution.
-//
-// Neither the name of 3Dlabs Inc. Ltd. nor the names of its
-// contributors may be used to endorse or promote products derived
-// from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-// POSSIBILITY OF SUCH DAMAGE.
-
-//
-// Author: John Kessenich, LunarG
-//
-
-// The contents of this file were extracted from the SPIR-V spec-generating
-// code.
-
-#ifndef LIBSPIRV_SPIRV_OPERANDS_H_
-#define LIBSPIRV_SPIRV_OPERANDS_H_
-
-// Classify the kinds of logical operands of an instruction.
-enum OperandClass {
- OperandNone,
- OperandId,
- OperandOptionalId,
- OperandVariableIds,
- OperandOptionalLiteral,
- OperandOptionalLiteralString,
- OperandVariableLiterals,
- OperandVariableIdLiteral,
- OperandVariableLiteralId, // zero or more pairs of (Literal, Id)
- OperandLiteralNumber,
- OperandLiteralString,
- OperandSource,
- OperandExecutionModel,
- OperandAddressing,
- OperandMemory,
- OperandExecutionMode,
- OperandStorage,
- OperandDimensionality,
- OperandSamplerAddressingMode,
- OperandSamplerFilterMode,
- OperandSamplerImageFormat,
- OperandImageChannelOrder,
- OperandImageChannelDataType,
- OperandImageOperands,
- OperandOptionalImageOperands,
- OperandFPFastMath,
- OperandFPRoundingMode,
- OperandLinkageType,
- OperandAccessQualifier,
- OperandOptionalAccessQualifier,
- OperandFuncParamAttr,
- OperandDecoration,
- OperandBuiltIn,
- OperandSelect,
- OperandLoop,
- OperandFunction,
- OperandMemorySemantics,
- OperandMemoryAccess,
- OperandOptionalMemoryAccess,
- OperandScope,
- OperandGroupOperation,
- OperandKernelEnqueueFlags,
- OperandKernelProfilingInfo,
- OperandCapability,
-
- OperandOpcode,
-
- OperandCount
-};
-
-#endif // LIBSPIRV_SPIRV_OPERANDS_H_
diff --git a/test/Version.cpp b/source/spirv_target_env.cpp
similarity index 63%
rename from test/Version.cpp
rename to source/spirv_target_env.cpp
index 23ac42c..e9e1a1d 100644
--- a/test/Version.cpp
+++ b/source/spirv_target_env.cpp
@@ -1,4 +1,4 @@
-// Copyright 2016 Google Inc. All Rights Reserved.
+// Copyright (c) 2015-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
@@ -24,16 +24,32 @@
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
-#include "gmock/gmock.h"
+#include <assert.h>
-#include "UnitSPIRV.h"
+#include "spirv-tools/libspirv.h"
+#include "spirv_constant.h"
-namespace {
-
-TEST(LibspirvMacros, Version) {
- EXPECT_EQ(1, SPV_SPIRV_VERSION_MAJOR);
- EXPECT_EQ(0, SPV_SPIRV_VERSION_MINOR);
- EXPECT_EQ(3, SPV_SPIRV_VERSION_REVISION);
+const char* spvTargetEnvDescription(spv_target_env env) {
+ switch (env) {
+ case SPV_ENV_UNIVERSAL_1_0:
+ return "SPIR-V 1.0";
+ case SPV_ENV_VULKAN_1_0:
+ return "SPIR-V 1.0 (under Vulkan 1.0 semantics)";
+ default:
+ break;
+ }
+ assert(0 && "Unhandled SPIR-V target environment");
+ return "";
}
-} // anonymous namespace
+uint32_t spvVersionForTargetEnv(spv_target_env env) {
+ switch (env) {
+ case SPV_ENV_UNIVERSAL_1_0:
+ case SPV_ENV_VULKAN_1_0:
+ return SPV_SPIRV_VERSION_WORD(1, 0);
+ default:
+ break;
+ }
+ assert(0 && "Unhandled SPIR-V target environment");
+ return SPV_SPIRV_VERSION_WORD(0, 0);
+}
diff --git a/source/syntax_tables.patch b/source/syntax_tables.patch
deleted file mode 100644
index e2ab8f9..0000000
--- a/source/syntax_tables.patch
+++ /dev/null
@@ -1,500 +0,0 @@
-diff --git a/tools/spirv/CMakeLists.txt b/tools/spirv/CMakeLists.txt
-index af51f86..5775510 100644
---- a/tools/spirv/CMakeLists.txt
-+++ b/tools/spirv/CMakeLists.txt
-@@ -12,6 +12,7 @@ include_directories(../..)
-
- set(SOURCES
- main.cpp
-+ assembler_table.cpp
- disassemble.cpp
- header.cpp
- doc.cpp
-diff --git a/tools/spirv/OclDoc.cpp b/tools/spirv/OclDoc.cpp
-index 1f25221..ff2c7c6 100644
---- a/tools/spirv/OclDoc.cpp
-+++ b/tools/spirv/OclDoc.cpp
-@@ -28,11 +28,14 @@
- #include "headers/spirv.hpp"
- #include "headers/OpenCL.std.h"
-
--#include "doc.h"
- #include "OclDoc.h"
-
-+#include "assembler_table.h"
-+#include "doc.h"
-+
- #include <stdio.h>
- #include <string.h>
-+#include <cassert>
- #include <algorithm>
- #include <map>
-
-@@ -2187,4 +2190,31 @@ void PrintOclCommonDoc()
- PrintOclDoc(SPIROpenCLCommonVersion);
- }
-
-+void PrintOclInstructionsTable(std::ostream& out) {
-+ ParameterizeBuiltins(SPIROpenCLCommonVersion);
-+
-+ out << R"(
-+// OpenCL extended instructions table, one instruction per line.
-+// All instructions have a result type and a result ID.
-+// Fields in this file are:
-+// - name
-+// - extended instruction index
-+// - EmptyList, or List of operand classes.
-+)";
-+ for (int i = 0; i < OclExtInstCeiling; ++i) {
-+ const BuiltInFunctionParameters& inst = BuiltInDesc[i];
-+ // Skip gaps in the enum space, if any.
-+ if (0 == strcmp("unknown", inst.opName)) continue;
-+ assert(inst.hasType());
-+ assert(inst.hasResult());
-+ out << "ExtInst(" << inst.opName << ", " << i << ", ";
-+ std::vector<OperandClassInfo> classes_info;
-+ for (const auto& operand_class : inst.operands.classes()) {
-+ classes_info.push_back({operand_class, false /* not optional */});
-+ }
-+ PrintOperandClasses(classes_info, out);
-+ out << ")" << std::endl;
-+ }
-+}
-+
- }; // end namespace spv
-diff --git a/tools/spirv/OclDoc.h b/tools/spirv/OclDoc.h
-index 8568880..7cf8a31 100644
---- a/tools/spirv/OclDoc.h
-+++ b/tools/spirv/OclDoc.h
-@@ -35,6 +35,8 @@
- #include <map>
- #include "headers/spirv.hpp"
-
-+#include "doc.h"
-+
- namespace spv {
-
- void OclGetDebugNames(const char** names);
-@@ -189,6 +191,8 @@ public:
- int getImageType(int op) { return Type[op]; }
- AccessQualifier getAccessQualifier(int op) { return accessQualifier[op]; }
-
-+ const std::vector<OperandClass>& classes() const { return opClass; }
-+
- protected:
- std::vector<OperandClass> opClass;
- std::vector<const char*> desc;
-@@ -307,4 +311,7 @@ protected:
- // Print out the OpenCL common (all spec revisions) documentation.
- void PrintOclCommonDoc();
-
-+// Prints the OpenCL instructions table, for consumption by SPIR-V Tools.
-+void PrintOclInstructionsTable(std::ostream& out);
-+
- }; // end namespace spv
-diff --git a/tools/spirv/assembler_table.cpp b/tools/spirv/assembler_table.cpp
-new file mode 100644
-index 0000000..8dd8fa1
---- /dev/null
-+++ b/tools/spirv/assembler_table.cpp
-@@ -0,0 +1,229 @@
-+// Copyright (c) 2015-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.
-+
-+#include "assembler_table.h"
-+
-+#include <cassert>
-+#include <cstring>
-+#include <sstream>
-+
-+#include "doc.h"
-+
-+namespace spv {
-+
-+namespace {
-+
-+// Returns true if the given instruction can vary in width.
-+bool IsVariableLength(const InstructionParameters& inst) {
-+ const OperandParameters& operands = inst.operands;
-+ for (int i = 0; i < operands.getNum() ; i++) {
-+ switch (operands.getClass(i)) {
-+ case spv::OperandVariableIds:
-+ case spv::OperandOptionalLiteral:
-+ case spv::OperandOptionalLiteralString:
-+ case spv::OperandVariableLiterals:
-+ case spv::OperandVariableIdLiteral:
-+ case spv::OperandVariableLiteralId:
-+ case spv::OperandLiteralString:
-+ return true;
-+ default:
-+ break;
-+ }
-+ if (operands.isOptional(i)) return true;
-+ }
-+ return false;
-+}
-+
-+// Returns a string for the given operand class, or nullptr if it's invalid.
-+const char* GetOperandClassString(OperandClass operandClass) {
-+ switch (operandClass) {
-+#define CASE(X) case X: return #X;
-+ CASE(OperandNone)
-+ CASE(OperandId)
-+ CASE(OperandVariableIds)
-+ CASE(OperandOptionalLiteral)
-+ CASE(OperandOptionalLiteralString)
-+ CASE(OperandVariableLiterals)
-+ CASE(OperandVariableIdLiteral)
-+ CASE(OperandVariableLiteralId)
-+ CASE(OperandLiteralNumber)
-+ CASE(OperandLiteralString)
-+ CASE(OperandSource)
-+ CASE(OperandExecutionModel)
-+ CASE(OperandAddressing)
-+ CASE(OperandMemory)
-+ CASE(OperandExecutionMode)
-+ CASE(OperandStorage)
-+ CASE(OperandDimensionality)
-+ CASE(OperandSamplerAddressingMode)
-+ CASE(OperandSamplerFilterMode)
-+ CASE(OperandSamplerImageFormat)
-+ CASE(OperandImageChannelOrder)
-+ CASE(OperandImageChannelDataType)
-+ CASE(OperandImageOperands)
-+ CASE(OperandFPFastMath)
-+ CASE(OperandFPRoundingMode)
-+ CASE(OperandLinkageType)
-+ CASE(OperandAccessQualifier)
-+ CASE(OperandFuncParamAttr)
-+ CASE(OperandDecoration)
-+ CASE(OperandBuiltIn)
-+ CASE(OperandSelect)
-+ CASE(OperandLoop)
-+ CASE(OperandFunction)
-+ CASE(OperandMemorySemantics)
-+ CASE(OperandMemoryAccess)
-+ CASE(OperandScope)
-+ CASE(OperandGroupOperation)
-+ CASE(OperandKernelEnqueueFlags)
-+ CASE(OperandKernelProfilingInfo)
-+ CASE(OperandCapability)
-+ CASE(OperandOpcode)
-+#undef CASE
-+
-+ case OperandCount:
-+ default:
-+ break;
-+ }
-+ return nullptr;
-+}
-+} // anonymous namespace
-+
-+// Prints a listing of the operand kinds for the given instruction.
-+// If the list is empty, then emit just "EmptyList",
-+// otherwise the output looks like a call to the "List" macro.
-+void PrintOperandClasses(const std::vector<OperandClassInfo>& classes, std::ostream& out) {
-+ std::stringstream contents;
-+ int numPrinted = 0;
-+ for (auto class_info : classes) {
-+ if (const char* name = GetOperandClassString(class_info.value)) {
-+ if (numPrinted) contents << ", ";
-+ switch (class_info.value) {
-+ case OperandId:
-+ case OperandImageOperands:
-+ case OperandLiteralString:
-+ case OperandMemoryAccess:
-+ case OperandAccessQualifier:
-+ if (class_info.is_optional) {
-+ contents << "OperandOptional" << (name + strlen("Operand"));
-+ } else {
-+ contents << name;
-+ }
-+ break;
-+ default:
-+ contents << name;
-+ break;
-+ }
-+ numPrinted++;
-+ if (class_info.value == OperandImageOperands) {
-+ // There are Id and/or VariableIds after this. Skip them
-+ // because the bits in an OperandImageOperands determine
-+ // exactly the number of Ids required to follow.
-+ break;
-+ }
-+ }
-+ }
-+
-+ if (numPrinted)
-+ out << "List(" << contents.str() << ")";
-+ else
-+ out << "EmptyList";
-+}
-+} // namespace spv
-+
-+namespace spv {
-+
-+// Prints a listing of the operand kinds for the given instruction.
-+// If the list is empty, then emit just "EmptyList",
-+// otherwise the output looks like a call to the "List" macro.
-+void PrintOperandClassesForInstruction(const InstructionParameters& inst,
-+ std::ostream& out) {
-+ std::vector<OperandClassInfo> result;
-+
-+ const OperandParameters& operands = inst.operands;
-+ for (int i = 0; i < operands.getNum(); i++) {
-+ result.push_back({operands.getClass(i), operands.isOptional(i)});
-+ }
-+ PrintOperandClasses(result, out);
-+}
-+
-+// Prints the table entry for the given instruction with the given opcode.
-+void PrintInstructionDesc(int opcode, const InstructionParameters& inst, std::ostream& out) {
-+ const char* name = OpcodeString(opcode);
-+ // There can be gaps in the listing.
-+ // All valid operations have a name beginning with "Op".
-+ if (strlen(name) > 2 && name[0] == 'O' && name[1] == 'p') {
-+ out << "Instruction("
-+ << name + 2 << ", "; // Skip the "Op" part.
-+ out << (inst.hasResult() ? 1 : 0) << ", ";
-+ out << (inst.hasType() ? 1 : 0) << ", ";
-+ out << inst.operands.getNum() << ", ";
-+
-+ // Emit the capability, if any.
-+ // The SPIR-V tools doesn't handle the concept of depending on more than
-+ // one capability. So call it out separately. Currently the biggest case
-+ // is 2. This is a big hack.
-+ out << inst.capabilities.size() << ", ";
-+ assert(inst.capabilities.size() < 3);
-+ if (inst.capabilities.size() == 1) {
-+ out << "Capability(" << CapabilityString(inst.capabilities[0]) << "), ";
-+ } else if (inst.capabilities.size() == 2) {
-+ out << "Capability2(" << CapabilityString(inst.capabilities[0]) << ","
-+ << CapabilityString(inst.capabilities[1]) << "), ";
-+ } else {
-+ out << "Capability(None), ";
-+ }
-+
-+ out << (IsVariableLength(inst) ? 1 : 0) << ", ";
-+ PrintOperandClassesForInstruction(inst, out);
-+ out << ")" << std::endl;
-+ }
-+}
-+
-+void PrintAssemblerTable(std::ostream& out) {
-+ out << "// Instruction fields are:\n"
-+ << "// name - skips the \"Op\" prefix\n"
-+ << "// {0|1} - whether the instruction generates a result Id\n"
-+ << "// {0|1} - whether the instruction encodes the type of the result Id\n"
-+ << "// numLogicalOperands - does not include result id or type id\n"
-+ << "// numCapabilities - we only handle 0 or 1 required capabilities\n"
-+ << "// Capability(<capability-name>) - capability required to use this instruction. Might be None.\n"
-+ << "// There can be Capability2(a,b) for dependence on two capabilities.\n"
-+ << "// {0|1} - whether the instruction is variable number of logical operands\n"
-+ << "// EmptyList or List(...) - list of classes of logical operands\n"
-+ << "// Example use:\n"
-+ << "// #define EmptyList {}\n"
-+ << "// #define List(...) {__VA_ARGS__}\n"
-+ << "// #define Capability(C) Capability##C\n"
-+ << "// #define CapabilityNone -1\n"
-+ << "// #define Instruction(Name,HasResult,HasType,NumLogicalOperands,CapabiltyRequired,IsVariable,LogicalArgsList)\n";
-+
-+ for (int i = 0; i < spv::OpcodeCeiling ; i++ ) {
-+ PrintInstructionDesc(i, InstructionDesc[i], out);
-+ }
-+}
-+
-+}
-diff --git a/tools/spirv/assembler_table.h b/tools/spirv/assembler_table.h
-new file mode 100644
-index 0000000..16ea384
---- /dev/null
-+++ b/tools/spirv/assembler_table.h
-@@ -0,0 +1,55 @@
-+// Copyright (c) 2015-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.
-+
-+#pragma once
-+#ifndef ASSEMBLER_TABLE_H
-+#define ASSEMBLER_TABLE_H
-+
-+#include <iostream>
-+#include <vector>
-+
-+#include "doc.h"
-+
-+namespace spv {
-+
-+ // Relevant facts about an operand class value.
-+ struct OperandClassInfo {
-+ OperandClass value;
-+ bool is_optional;
-+ };
-+
-+ // Prints the tables used to define the structure of instructions.
-+ // Assumes that parameterization has already occurred
-+ void PrintAssemblerTable(std::ostream& out);
-+
-+ // Prints a listing of the operand kinds.
-+ // If the list is empty, then emit just "EmptyList",
-+ // otherwise the output looks like a call to the "List" macro.
-+ void PrintOperandClasses(const std::vector<OperandClassInfo>& classes, std::ostream& out);
-+
-+}; // end namespace spv
-+
-+#endif // ASSEMBLER_TABLE_H
-diff --git a/tools/spirv/doc.h b/tools/spirv/doc.h
-index 4c11d3b..6e1718a 100644
---- a/tools/spirv/doc.h
-+++ b/tools/spirv/doc.h
-@@ -32,6 +32,9 @@
- //ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- //POSSIBILITY OF SUCH DAMAGE.
-
-+#ifndef DOC_H_
-+#define DOC_H_
-+
- //
- // Author: John Kessenich, LunarG
- //
-@@ -81,6 +84,7 @@ const char* KernelEnqueueFlagsString(int);
- const char* KernelProfilingInfoString(int);
- const char* CapabilityString(int);
- const char* OpcodeString(int);
-+const char* OperandClassString(int);
-
- // For grouping opcodes into subsections
- enum OpcodeClass {
-@@ -157,6 +161,10 @@ enum OperandClass {
-
- OperandOpcode,
-
-+ // The operand class enum is not part of the spec, so
-+ // it should come after OperandOpcode.
-+ OperandOperandClass,
-+
- OperandCount
- };
-
-@@ -259,3 +267,5 @@ const char* AccessQualifierString(int attr);
- void PrintOperands(const OperandParameters& operands, int reservedOperands);
-
- }; // end namespace spv
-+
-+#endif // DOC_H_
-diff --git a/tools/spirv/main.cpp b/tools/spirv/main.cpp
-index d7312f9..e1413bb 100644
---- a/tools/spirv/main.cpp
-+++ b/tools/spirv/main.cpp
-@@ -46,6 +46,7 @@ namespace spv {
- #include "headers/OpenCL.std.h"
-
- // This tool's includes
-+#include "assembler_table.h"
- #include "disassemble.h"
- #include "header.h"
- #include "doc.h"
-@@ -65,6 +66,8 @@ enum TOptions {
- EOptionDisassemble = 0x004,
- EOptionPrintHeader = 0x008,
- EOptionPrintOclBuiltinsAsciidoc = 0x010,
-+ EOptionPrintAssemblerTable = 0x020,
-+ EOptionPrintOclInstructionsTable = 0x040,
- };
-
- std::string Filename;
-@@ -86,9 +89,11 @@ void Usage()
- " -H print header in all supported languages to files in current directory\n"
- " -p print documentation\n"
- " -s [version] prints the SPIR-V extended instructions documentation\n"
-- " 'CL12': OpenCL 1.2 extended instructions documentation\n"
-- " 'CL20': OpenCL 2.0 extended instructions documentation\n"
-- " 'CL21': OpenCL 2.1 extended instructions documentation\n"
-+ " 'OpenCL': OpenCL 1.2, 2.0, 2.1 extended instructions documentation\n"
-+ " 'GLSL': GLSL extended instructions documentation\n"
-+ " -a print table for the assembler\n"
-+ " -C print OpenCL instructions for the assembler\n"
-+ " This is incompatibile with -s OpenCL\n"
- );
- }
-
-@@ -155,6 +160,12 @@ bool ProcessArguments(int argc, char* argv[])
- }
- return true;
- }
-+ case 'a':
-+ Options |= EOptionPrintAssemblerTable;
-+ break;
-+ case 'C':
-+ Options |= EOptionPrintOclInstructionsTable;
-+ break;
- default:
- return false;
- }
-@@ -162,6 +173,9 @@ bool ProcessArguments(int argc, char* argv[])
- Filename = std::string(argv[0]);
- }
- }
-+ if ((Options & EOptionPrintOclBuiltinsAsciidoc) &&
-+ (Options & EOptionPrintOclInstructionsTable))
-+ return false;
-
- return true;
- }
-@@ -220,5 +234,11 @@ int main(int argc, char* argv[])
- if (Options & EOptionPrintHeader)
- spv::PrintHeader(Language, std::cout);
-
-+ if (Options & EOptionPrintAssemblerTable)
-+ spv::PrintAssemblerTable(std::cout);
-+
-+ if (Options & EOptionPrintOclInstructionsTable)
-+ spv::PrintOclInstructionsTable(std::cout);
-+
- return 0;
- }
diff --git a/source/table.cpp b/source/table.cpp
index 1a32f2d..3fa5c58 100644
--- a/source/table.cpp
+++ b/source/table.cpp
@@ -28,7 +28,15 @@
#include <cstdlib>
-spv_context spvContextCreate() {
+spv_context spvContextCreate(spv_target_env env) {
+ switch (env) {
+ case SPV_ENV_UNIVERSAL_1_0:
+ case SPV_ENV_VULKAN_1_0:
+ break;
+ default:
+ return nullptr;
+ }
+
spv_opcode_table opcode_table;
spv_operand_table operand_table;
spv_ext_inst_table ext_inst_table;
@@ -37,11 +45,7 @@
spvOperandTableGet(&operand_table);
spvExtInstTableGet(&ext_inst_table);
- return new spv_context_t{opcode_table, operand_table, ext_inst_table};
+ return new spv_context_t{env, opcode_table, operand_table, ext_inst_table};
}
-void spvContextDestroy(spv_context context) {
- ::free(context->opcode_table->entries);
- delete context->opcode_table;
- delete context;
-}
+void spvContextDestroy(spv_context context) { delete context; }
diff --git a/source/table.h b/source/table.h
index 9e427dd..93270df 100644
--- a/source/table.h
+++ b/source/table.h
@@ -28,8 +28,8 @@
#define LIBSPIRV_TABLE_H_
#include "spirv-tools/libspirv.h"
+#include "spirv/spirv.h"
#include "spirv_definition.h"
-#include "spirv_operands.h"
typedef struct spv_opcode_desc_t {
const char* name;
@@ -43,9 +43,6 @@
spv_operand_type_t operandTypes[16]; // TODO: Smaller/larger?
const bool hasResult; // Does the instruction have a result ID operand?
const bool hasType; // Does the instruction have a type ID operand?
- // The operand class for each logical argument. This does *not* include
- // the result Id or type ID. The list is terminated by SPV_OPERAND_TYPE_NONE.
- const OperandClass operandClass[16];
} spv_opcode_desc_t;
typedef struct spv_operand_desc_t {
@@ -78,7 +75,7 @@
typedef struct spv_opcode_table_t {
const uint32_t count;
- spv_opcode_desc_t* entries;
+ const spv_opcode_desc_t* entries;
} spv_opcode_table_t;
typedef struct spv_operand_table_t {
@@ -100,6 +97,7 @@
typedef const spv_ext_inst_table_t* spv_ext_inst_table;
struct spv_context_t {
+ const spv_target_env target_env;
const spv_opcode_table opcode_table;
const spv_operand_table operand_table;
const spv_ext_inst_table ext_inst_table;
diff --git a/source/text.cpp b/source/text.cpp
index ee90689..7d1d756 100644
--- a/source/text.cpp
+++ b/source/text.cpp
@@ -653,22 +653,18 @@
enum { kAssemblerVersion = 0 };
-/// @brief Populate a binary stream's words with this generator's header.
-///
-/// @param[in,out] words the array of words
-/// @param[in] bound the upper ID bound
-///
-/// @return result code
-spv_result_t SetHeader(uint32_t* words, const uint32_t bound) {
- if (!words) return SPV_ERROR_INVALID_BINARY;
+// Populates a binary stream's |header|. The target environment is specified via
+// |env| and Id bound is via |bound|.
+spv_result_t SetHeader(spv_target_env env, const uint32_t bound,
+ uint32_t* header) {
+ if (!header) return SPV_ERROR_INVALID_BINARY;
- words[SPV_INDEX_MAGIC_NUMBER] = SpvMagicNumber;
- words[SPV_INDEX_VERSION_NUMBER] =
- SPV_SPIRV_VERSION_WORD(SPV_SPIRV_VERSION_MAJOR, SPV_SPIRV_VERSION_MINOR);
- words[SPV_INDEX_GENERATOR_NUMBER] =
+ header[SPV_INDEX_MAGIC_NUMBER] = SpvMagicNumber;
+ header[SPV_INDEX_VERSION_NUMBER] = spvVersionForTargetEnv(env);
+ header[SPV_INDEX_GENERATOR_NUMBER] =
SPV_GENERATOR_WORD(SPV_GENERATOR_KHRONOS_ASSEMBLER, kAssemblerVersion);
- words[SPV_INDEX_BOUND] = bound;
- words[SPV_INDEX_SCHEMA] = 0; // NOTE: Reserved
+ header[SPV_INDEX_BOUND] = bound;
+ header[SPV_INDEX_SCHEMA] = 0; // NOTE: Reserved
return SPV_SUCCESS;
}
@@ -721,7 +717,8 @@
currentIndex += inst.words.size();
}
- if (auto error = SetHeader(data, context.getBound())) return error;
+ if (auto error = SetHeader(grammar.target_env(), context.getBound(), data))
+ return error;
spv_binary binary = new spv_binary_t();
if (!binary) {
diff --git a/source/text_handler.cpp b/source/text_handler.cpp
index cc4a42b..3803465 100644
--- a/source/text_handler.cpp
+++ b/source/text_handler.cpp
@@ -90,6 +90,7 @@
return advance(text, position);
case ' ':
case '\t':
+ case '\r':
position->column++;
position->index++;
return advance(text, position);
@@ -137,6 +138,7 @@
case ';':
case '\t':
case '\n':
+ case '\r':
if (escaping || quoting) break;
// Fall through.
case '\0': { // NOTE: End of word found!
diff --git a/source/validate.cpp b/source/validate.cpp
index e706541..ab4de21 100644
--- a/source/validate.cpp
+++ b/source/validate.cpp
@@ -128,7 +128,7 @@
void ProcessIds(ValidationState_t& _, const spv_parsed_instruction_t& inst) {
if (inst.result_id) {
_.usedefs().AddDef(
- {inst.result_id, inst.type_id, inst.opcode,
+ {inst.result_id, inst.type_id, static_cast<SpvOp>(inst.opcode),
std::vector<uint32_t>(inst.words, inst.words + inst.num_words)});
}
for (auto op = inst.operands; op != inst.operands + inst.num_operands; ++op) {
@@ -140,7 +140,7 @@
const spv_parsed_instruction_t* inst) {
ValidationState_t& _ = *(reinterpret_cast<ValidationState_t*>(user_data));
_.incrementInstructionCount();
- if (inst->opcode == SpvOpEntryPoint)
+ if (static_cast<SpvOp>(inst->opcode) == SpvOpEntryPoint)
_.entry_points().push_back(inst->words[2]);
DebugInstructionPass(_, inst);
@@ -203,11 +203,12 @@
uint64_t index = SPV_INDEX_INSTRUCTION;
while (index < binary->wordCount) {
uint16_t wordCount;
- SpvOp opcode;
+ uint16_t opcode;
spvOpcodeSplit(spvFixWord(binary->code[index], endian), &wordCount,
&opcode);
spv_instruction_t inst;
- spvInstructionCopy(&binary->code[index], opcode, wordCount, endian, &inst);
+ spvInstructionCopy(&binary->code[index], static_cast<SpvOp>(opcode),
+ wordCount, endian, &inst);
instructions.push_back(inst);
index += wordCount;
}
diff --git a/source/validate.h b/source/validate.h
index 5438924..77bf9c2 100644
--- a/source/validate.h
+++ b/source/validate.h
@@ -133,7 +133,7 @@
// Returns the number of blocks in the current function being parsed
size_t get_block_count() const;
- // Retuns true if called after a function instruction but before the
+ // Returns true if called after a function instruction but before the
// function end instruction
bool in_function_body() const;
@@ -147,7 +147,7 @@
// Parent module
ValidationState_t& module_;
- // Funciton IDs in a module
+ // Function IDs in a module
std::vector<uint32_t> id_;
// OpTypeFunction IDs of each of the id_ functions
@@ -216,7 +216,7 @@
// Returns the function states
Functions& get_functions();
- // Retuns true if the called after a function instruction but before the
+ // Returns true if the called after a function instruction but before the
// function end instruction
bool in_function_body() const;
diff --git a/source/validate_cfg.cpp b/source/validate_cfg.cpp
index 50dc2b6..0f8e980 100644
--- a/source/validate_cfg.cpp
+++ b/source/validate_cfg.cpp
@@ -33,25 +33,24 @@
spv_result_t CfgPass(ValidationState_t& _,
const spv_parsed_instruction_t* inst) {
if (_.getLayoutSection() == kLayoutFunctionDefinitions) {
- SpvOp opcode = inst->opcode;
+ SpvOp opcode = static_cast<SpvOp>(inst->opcode);
switch (opcode) {
- case SpvOpLabel:
- spvCheckReturn(_.get_functions().RegisterBlock(inst->result_id));
- break;
- case SpvOpBranch:
- case SpvOpBranchConditional:
- case SpvOpSwitch:
- case SpvOpKill:
- case SpvOpReturn:
- case SpvOpReturnValue:
- case SpvOpUnreachable:
- spvCheckReturn(_.get_functions().RegisterBlockEnd());
- break;
- default:
- break;
+ case SpvOpLabel:
+ spvCheckReturn(_.get_functions().RegisterBlock(inst->result_id));
+ break;
+ case SpvOpBranch:
+ case SpvOpBranchConditional:
+ case SpvOpSwitch:
+ case SpvOpKill:
+ case SpvOpReturn:
+ case SpvOpReturnValue:
+ case SpvOpUnreachable:
+ spvCheckReturn(_.get_functions().RegisterBlockEnd());
+ break;
+ default:
+ break;
}
}
return SPV_SUCCESS;
}
-
}
diff --git a/source/validate_id.cpp b/source/validate_id.cpp
index 513f257..879af59 100644
--- a/source/validate_id.cpp
+++ b/source/validate_id.cpp
@@ -264,6 +264,26 @@
return true;
}
+// True if the integer constant is > 0. constWords are words of the
+// constant-defining instruction (either OpConstant or
+// OpSpecConstant). typeWords are the words of the constant's-type-defining
+// OpTypeInt.
+bool aboveZero(const std::vector<uint32_t>& constWords,
+ const std::vector<uint32_t>& typeWords) {
+ const uint32_t width = typeWords[2];
+ const bool is_signed = typeWords[3];
+ const uint32_t loWord = constWords[3];
+ if (width > 32) {
+ // The spec currently doesn't allow integers wider than 64 bits.
+ const uint32_t hiWord = constWords[4]; // Must exist, per spec.
+ if (is_signed && (hiWord >> 31)) return false;
+ return loWord | hiWord;
+ } else {
+ if (is_signed && (loWord >> 31)) return false;
+ return loWord > 0;
+ }
+}
+
template <>
bool idUsage::isValid<SpvOpTypeArray>(const spv_instruction_t* inst,
const spv_opcode_desc) {
@@ -278,8 +298,7 @@
}
auto lengthIndex = 3;
auto length = usedefs_.FindDef(inst->words[lengthIndex]);
- if (!length.first || (SpvOpConstant != length.second.opcode &&
- SpvOpSpecConstant != length.second.opcode)) {
+ if (!length.first || !spvOpcodeIsConstant(length.second.opcode)) {
DIAG(lengthIndex) << "OpTypeArray Length <id> '" << inst->words[lengthIndex]
<< "' is not a scalar constant type.";
return false;
@@ -294,27 +313,23 @@
<< "' is not a constant integer type.";
return false;
}
- if (4 == constInst.size()) {
- spvCheck(1 > constInst[3], DIAG(lengthIndex)
- << "OpTypeArray Length <id> '"
- << inst->words[lengthIndex]
- << "' value must be at least 1.";
- return false);
- } else if (5 == constInst.size()) {
- uint64_t value = constInst[3] | ((uint64_t)constInst[4]) << 32;
- bool signedness = constResultType.second.words[3] != 0;
- if (signedness) {
- spvCheck(1 > (int64_t)value, DIAG(lengthIndex)
- << "OpTypeArray Length <id> '"
- << inst->words[lengthIndex]
- << "' value must be at least 1.";
- return false);
- } else {
- spvCheck(1 > value, DIAG(lengthIndex) << "OpTypeArray Length <id> '"
- << inst->words[lengthIndex]
- << "' value must be at least 1.";
- return false);
+
+ switch (length.second.opcode) {
+ case SpvOpSpecConstant:
+ case SpvOpConstant:
+ if (aboveZero(length.second.words, constResultType.second.words)) break;
+ // Else fall through!
+ case SpvOpConstantNull: {
+ DIAG(lengthIndex) << "OpTypeArray Length <id> '"
+ << inst->words[lengthIndex]
+ << "' default value must be at least 1.";
+ return false;
}
+ case SpvOpSpecConstantOp:
+ // Assume it's OK, rather than try to evaluate the operation.
+ break;
+ default:
+ assert(0 && "bug in spvOpcodeIsConstant() or result type isn't int");
}
return true;
}
@@ -618,10 +633,10 @@
// nullability transitively.
bool IsTypeNullable(const std::vector<uint32_t>& instruction,
const UseDefTracker& usedefs) {
- SpvOp opcode;
+ uint16_t opcode;
uint16_t word_count;
spvOpcodeSplit(instruction[0], &word_count, &opcode);
- switch (opcode) {
+ switch (static_cast<SpvOp>(opcode)) {
case SpvOpTypeBool:
case SpvOpTypeInt:
case SpvOpTypeFloat:
diff --git a/source/validate_instruction.cpp b/source/validate_instruction.cpp
index 87e1998..8ecb715 100644
--- a/source/validate_instruction.cpp
+++ b/source/validate_instruction.cpp
@@ -83,10 +83,11 @@
spv_result_t CapCheck(ValidationState_t& _,
const spv_parsed_instruction_t* inst) {
spv_opcode_desc opcode_desc;
- if (SPV_SUCCESS == _.grammar().lookupOpcode(inst->opcode, &opcode_desc) &&
+ const SpvOp opcode = static_cast<SpvOp>(inst->opcode);
+ if (SPV_SUCCESS == _.grammar().lookupOpcode(opcode, &opcode_desc) &&
!_.HasAnyOf(opcode_desc->capabilities))
return _.diag(SPV_ERROR_INVALID_CAPABILITY)
- << "Opcode " << spvOpcodeString(inst->opcode)
+ << "Opcode " << spvOpcodeString(opcode)
<< " requires one of these capabilities: "
<< ToString(opcode_desc->capabilities, _.grammar());
for (int i = 0; i < inst->num_operands; ++i) {
@@ -99,7 +100,7 @@
const auto caps =
RequiredCapabilities(_.grammar(), operand.type, mask_bit);
if (!_.HasAnyOf(caps)) {
- return CapabilityError(_, i + 1, inst->opcode,
+ return CapabilityError(_, i + 1, opcode,
ToString(caps, _.grammar()));
}
}
@@ -108,8 +109,7 @@
// Check the operand word as a whole.
const auto caps = RequiredCapabilities(_.grammar(), operand.type, word);
if (!_.HasAnyOf(caps)) {
- return CapabilityError(_, i + 1, inst->opcode,
- ToString(caps, _.grammar()));
+ return CapabilityError(_, i + 1, opcode, ToString(caps, _.grammar()));
}
}
}
@@ -118,10 +118,11 @@
spv_result_t InstructionPass(ValidationState_t& _,
const spv_parsed_instruction_t* inst) {
- if (inst->opcode == SpvOpCapability)
+ const SpvOp opcode = static_cast<SpvOp>(inst->opcode);
+ if (opcode == SpvOpCapability)
_.registerCapability(
static_cast<SpvCapability>(inst->words[inst->operands[0].offset]));
- if (inst->opcode == SpvOpVariable) {
+ if (opcode == SpvOpVariable) {
const auto storage_class =
static_cast<SpvStorageClass>(inst->words[inst->operands[2].offset]);
if (storage_class == SpvStorageClassGeneric)
diff --git a/source/validate_layout.cpp b/source/validate_layout.cpp
index 24d2a43..2bb6db2 100644
--- a/source/validate_layout.cpp
+++ b/source/validate_layout.cpp
@@ -103,7 +103,7 @@
}
if (_.get_functions().get_block_count() != 0) {
return _.diag(SPV_ERROR_INVALID_LAYOUT)
- << "Function parameters must only appear immediatly after the "
+ << "Function parameters must only appear immediately after the "
"function definition";
}
spvCheckReturn(_.get_functions().RegisterFunctionParameter(
@@ -182,7 +182,7 @@
// Performs logical layout validation. See Section 2.4
spv_result_t ModuleLayoutPass(ValidationState_t& _,
const spv_parsed_instruction_t* inst) {
- SpvOp opcode = inst->opcode;
+ const SpvOp opcode = static_cast<SpvOp>(inst->opcode);
switch (_.getLayoutSection()) {
case kLayoutCapabilities:
diff --git a/source/validate_ssa.cpp b/source/validate_ssa.cpp
index 88c10f8..38250bf 100644
--- a/source/validate_ssa.cpp
+++ b/source/validate_ssa.cpp
@@ -32,7 +32,7 @@
using libspirv::ValidationState_t;
namespace {
-// This funciton takes the opcode of an instruction and returns
+// This function takes the opcode of an instruction and returns
// a function object that will return true if the index
// of the operand can be forwarad declared. This function will
// used in the SSA validation stage of the pipeline
@@ -95,11 +95,11 @@
//
// TODO(umar): Use dominators to correctly validate SSA. For example, the result
// id from a 'then' block cannot dominate its usage in the 'else' block. This
-// is not yet performed by this funciton.
+// is not yet performed by this function.
spv_result_t SsaPass(ValidationState_t& _,
const spv_parsed_instruction_t* inst) {
auto can_have_forward_declared_ids =
- getCanBeForwardDeclaredFunction(inst->opcode);
+ getCanBeForwardDeclaredFunction(static_cast<SpvOp>(inst->opcode));
for (unsigned i = 0; i < inst->num_operands; i++) {
const spv_parsed_operand_t& operand = inst->operands[i];
diff --git a/test/BinaryParse.cpp b/test/BinaryParse.cpp
index d6df8e7..9cd5bc9 100644
--- a/test/BinaryParse.cpp
+++ b/test/BinaryParse.cpp
@@ -28,10 +28,10 @@
#include <string>
#include <vector>
-#include "gmock/gmock.h"
-
#include "TestFixture.h"
#include "UnitSPIRV.h"
+#include "gmock/gmock.h"
+#include "spirv/OpenCL.std.h"
// Returns true if two spv_parsed_operand_t values are equal.
// To use this operator, this definition must appear in the same namespace
@@ -60,7 +60,7 @@
struct ParsedInstruction {
explicit ParsedInstruction(const spv_parsed_instruction_t& inst)
: words(inst.words, inst.words + inst.num_words),
- opcode(inst.opcode),
+ opcode(static_cast<SpvOp>(inst.opcode)),
ext_inst_type(inst.ext_inst_type),
type_id(inst.type_id),
result_id(inst.result_id),
@@ -463,7 +463,7 @@
"Module has incomplete header: only 3 words instead of 5"},
{kHeaderForBound1, 4,
"Module has incomplete header: only 4 words instead of 5"},
- }),);
+ }), );
// A binary parser diagnostic test case where a vector of words is
// provided. We'll use this to express cases that can't be created
@@ -696,7 +696,7 @@
MakeInstruction(SpvOpConstant, {1, 2, 42}),
}),
"Type Id 1 is not a scalar numeric type"},
- }),);
+ }), );
// A binary parser diagnostic case generated from an assembly text input.
struct AssemblyDiagnosticCase {
@@ -766,6 +766,6 @@
"Invalid image operand: 511 has invalid mask component 256"},
{"OpSelectionMerge %1 !7",
"Invalid selection control operand: 7 has invalid mask component 4"},
- }),);
+ }), );
} // anonymous namespace
diff --git a/test/BinaryToText.cpp b/test/BinaryToText.cpp
index cb4f6ad..bfb8887 100644
--- a/test/BinaryToText.cpp
+++ b/test/BinaryToText.cpp
@@ -30,8 +30,8 @@
#include "gmock/gmock.h"
-#include "source/spirv_constant.h"
#include "TestFixture.h"
+#include "source/spirv_constant.h"
using ::testing::Eq;
using ::testing::HasSubstr;
@@ -41,7 +41,7 @@
namespace {
class BinaryToText : public ::testing::Test {
public:
- BinaryToText() : context(spvContextCreate()) {}
+ BinaryToText() : context(spvContextCreate(SPV_ENV_UNIVERSAL_1_0)) {}
~BinaryToText() { spvContextDestroy(context); }
virtual void SetUp() {
@@ -203,7 +203,7 @@
"%2 = OpTypeVector %1 4",
spvtest::MakeInstruction(SpvOpConstant, {2, 3, 999}),
"Type Id 2 is not a scalar numeric type"},
- }),);
+ }), );
INSTANTIATE_TEST_CASE_P(
InvalidIdsCheckedDuringLiteralCaseParsing, BinaryToTextFail,
@@ -219,7 +219,7 @@
{"%1 = OpTypeFloat 32\n%2 = OpConstant %1 1.5",
spvtest::MakeInstruction(SpvOpSwitch, {2, 3, 4, 5}),
"Invalid OpSwitch: selector id 2 is not a scalar integer"},
- }),);
+ }), );
TEST_F(TextToBinaryTest, OneInstruction) {
const std::string input = "OpSource OpenCL_C 12\n";
@@ -275,7 +275,7 @@
"OpDecorate %1 FPFastMathMode NotNaN|NotInf\n",
"OpDecorate %1 FPFastMathMode NSZ|AllowRecip\n",
"OpDecorate %1 FPFastMathMode NotNaN|NotInf|NSZ|AllowRecip|Fast\n",
- }),);
+ }), );
INSTANTIATE_TEST_CASE_P(LoopControlMasks, RoundTripInstructionsTest,
::testing::ValuesIn(std::vector<std::string>{
@@ -283,7 +283,7 @@
"OpLoopMerge %1 %2 Unroll\n",
"OpLoopMerge %1 %2 DontUnroll\n",
"OpLoopMerge %1 %2 Unroll|DontUnroll\n",
- }),);
+ }), );
INSTANTIATE_TEST_CASE_P(SelectionControlMasks, RoundTripInstructionsTest,
::testing::ValuesIn(std::vector<std::string>{
@@ -291,7 +291,7 @@
"OpSelectionMerge %1 Flatten\n",
"OpSelectionMerge %1 DontFlatten\n",
"OpSelectionMerge %1 Flatten|DontFlatten\n",
- }),);
+ }), );
// clang-format off
INSTANTIATE_TEST_CASE_P(
@@ -421,8 +421,6 @@
Eq(SPV_SUCCESS));
EXPECT_EQ(nullptr, diagnostic);
- EXPECT_EQ(1, SPV_SPIRV_VERSION_MAJOR);
- EXPECT_EQ(0, SPV_SPIRV_VERSION_MINOR);
EXPECT_THAT(decoded_text->str, HasSubstr("Version: 1.0\n"))
<< EncodeAndDecodeSuccessfully("");
spvTextDestroy(decoded_text);
@@ -474,6 +472,6 @@
"Khronos Glslang Reference Front End; 1"},
{9, 18, "Unknown(9); 18"},
{65535, 32767, "Unknown(65535); 32767"},
- }),);
+ }), );
} // anonymous namespace
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 481f6ca..078febd 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -88,7 +88,6 @@
${CMAKE_CURRENT_SOURCE_DIR}/Validate.SSA.cpp
${CMAKE_CURRENT_SOURCE_DIR}/ValidateID.cpp
${CMAKE_CURRENT_SOURCE_DIR}/ValidationState.cpp
- ${CMAKE_CURRENT_SOURCE_DIR}/Version.cpp
${CMAKE_CURRENT_SOURCE_DIR}/main.cpp)
add_executable(UnitSPIRV ${TEST_SOURCES})
diff --git a/test/Comment.cpp b/test/Comment.cpp
index e94c56a..7b9b94f 100644
--- a/test/Comment.cpp
+++ b/test/Comment.cpp
@@ -38,7 +38,7 @@
TEST_F(TextToBinaryTest, Whitespace) {
std::string input = R"(
-; I'm a proud comment at the begining of the file
+; I'm a proud comment at the beginning of the file
; I hide: OpCapability Shader
OpMemoryModel Logical Simple ; comment after instruction
;;;;;;;; many ;'s
diff --git a/test/ExtInst.OpenCL.std.cpp b/test/ExtInst.OpenCL.std.cpp
index 051b3ed..1140678 100644
--- a/test/ExtInst.OpenCL.std.cpp
+++ b/test/ExtInst.OpenCL.std.cpp
@@ -28,6 +28,7 @@
#include <gmock/gmock.h>
#include "TestFixture.h"
+#include "spirv/OpenCL.std.h"
namespace {
@@ -330,7 +331,7 @@
INSTANTIATE_TEST_CASE_P(
OpenCLMiscPrintf, ExtInstOpenCLStdRoundTripTest,
::testing::ValuesIn(std::vector<InstructionCase>({
- // Printf is interesting becuase it takes a variable number of arguments.
+ // Printf is interesting because it takes a variable number of arguments.
// Start with zero optional arguments.
{PREFIX, "%4", {4}},
{PREFIX, "%4 %5", {4, 5}},
diff --git a/test/ExtInstGLSLstd450.cpp b/test/ExtInstGLSLstd450.cpp
index 2035854..8f4039a 100644
--- a/test/ExtInstGLSLstd450.cpp
+++ b/test/ExtInstGLSLstd450.cpp
@@ -28,6 +28,7 @@
#include <vector>
#include "UnitSPIRV.h"
+#include "spirv/GLSL.std.450.h"
namespace {
@@ -49,7 +50,7 @@
using ExtInstGLSLstd450RoundTripTest = ::testing::TestWithParam<ExtInstContext>;
TEST_P(ExtInstGLSLstd450RoundTripTest, ParameterizedExtInst) {
- spv_context context = spvContextCreate();
+ spv_context context = spvContextCreate(SPV_ENV_UNIVERSAL_1_0);
const std::string spirv = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
@@ -94,8 +95,9 @@
EXPECT_NE(binary->code + binary->wordCount,
std::search(binary->code, binary->code + binary->wordCount,
expected_contains.begin(), expected_contains.end()))
- << "Cannot find\n" << spvtest::WordVector(expected_contains).str()
- << "in\n" << spvtest::WordVector(*binary).str();
+ << "Cannot find\n"
+ << spvtest::WordVector(expected_contains).str() << "in\n"
+ << spvtest::WordVector(*binary).str();
// Check round trip gives the same text.
spv_text output_text = nullptr;
@@ -205,6 +207,6 @@
{"NMin", "%5 %5", 79, 7, {5, 5}},
{"NMax", "%5 %5", 80, 7, {5, 5}},
{"NClamp", "%5 %5 %5", 81, 8, {5, 5, 5}},
- })),);
+ })), );
} // anonymous namespace
diff --git a/test/OpcodeRequiresCapabilities.cpp b/test/OpcodeRequiresCapabilities.cpp
index ff80964..c23fb5c 100644
--- a/test/OpcodeRequiresCapabilities.cpp
+++ b/test/OpcodeRequiresCapabilities.cpp
@@ -37,8 +37,7 @@
0,
{},
false,
- false,
- {}}) {}
+ false}) {}
virtual void SetUp() {}
@@ -65,10 +64,10 @@
SpvCapabilityClipDistance,
// Transformfeedback has value 53,
// and is the last capability.
- SpvCapabilityTransformFeedback),);
+ SpvCapabilityTransformFeedback), );
TEST(OpcodeRequiresCapability, None) {
- spv_opcode_desc_t entry = {nullptr, (SpvOp)0, 0, 0, {}, false, false, {}};
+ spv_opcode_desc_t entry = {nullptr, (SpvOp)0, 0, 0, {}, false, false};
ASSERT_EQ(0, spvOpcodeRequiresCapabilities(&entry));
}
@@ -133,6 +132,6 @@
ExpectedOpCodeCapabilities{SpvOpFunction, 0},
ExpectedOpCodeCapabilities{SpvOpConvertFToS, 0},
ExpectedOpCodeCapabilities{SpvOpEmitStreamVertex,
- mask(SpvCapabilityGeometryStreams)}),);
+ mask(SpvCapabilityGeometryStreams)}), );
} // anonymous namespace
diff --git a/test/OpcodeSplit.cpp b/test/OpcodeSplit.cpp
index 2e6a8ae..976708c 100644
--- a/test/OpcodeSplit.cpp
+++ b/test/OpcodeSplit.cpp
@@ -31,7 +31,7 @@
TEST(OpcodeSplit, Default) {
uint32_t word = spvOpcodeMake(42, (SpvOp)23);
uint16_t wordCount = 0;
- SpvOp opcode;
+ uint16_t opcode;
spvOpcodeSplit(word, &wordCount, &opcode);
ASSERT_EQ(42, wordCount);
ASSERT_EQ(23, opcode);
diff --git a/test/OperandCapabilities.cpp b/test/OperandCapabilities.cpp
index 684ec02..c3c84db 100644
--- a/test/OperandCapabilities.cpp
+++ b/test/OperandCapabilities.cpp
@@ -570,8 +570,8 @@
CASE0(CAPABILITY, CapabilityInt64),
CASE1(CAPABILITY, CapabilityInt64Atomics, Int64),
CASE1(CAPABILITY, CapabilityImageBasic, Kernel),
- CASE1(CAPABILITY, CapabilityImageReadWrite, Kernel),
- CASE1(CAPABILITY, CapabilityImageMipmap, Kernel),
+ CASE1(CAPABILITY, CapabilityImageReadWrite, ImageBasic),
+ CASE1(CAPABILITY, CapabilityImageMipmap, ImageBasic),
// Value 16 intentionally missing.
CASE1(CAPABILITY, CapabilityPipes, Kernel),
CASE0(CAPABILITY, CapabilityGroups),
diff --git a/test/OperandPattern.cpp b/test/OperandPattern.cpp
index a67c35f..f377469 100644
--- a/test/OperandPattern.cpp
+++ b/test/OperandPattern.cpp
@@ -189,9 +189,6 @@
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV}));
EXPECT_THAT(spvAlternatePatternFollowingImmediate({SPV_OPERAND_TYPE_ID}),
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV}));
- EXPECT_THAT(spvAlternatePatternFollowingImmediate(
- {SPV_OPERAND_TYPE_VARIABLE_EXECUTION_MODE}),
- Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV}));
}
TEST(AlternatePatternFollowingImmediate, SingleResultId) {
@@ -206,8 +203,7 @@
spvAlternatePatternFollowingImmediate(
{SPV_OPERAND_TYPE_VARIABLE_ID_LITERAL_INTEGER,
SPV_OPERAND_TYPE_CAPABILITY, SPV_OPERAND_TYPE_LOOP_CONTROL,
- SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER, SPV_OPERAND_TYPE_ID,
- SPV_OPERAND_TYPE_VARIABLE_EXECUTION_MODE}),
+ SPV_OPERAND_TYPE_OPTIONAL_LITERAL_INTEGER, SPV_OPERAND_TYPE_ID}),
Eq(spv_operand_pattern_t{SPV_OPERAND_TYPE_OPTIONAL_CIV}));
}
diff --git a/test/TestFixture.h b/test/TestFixture.h
index 77f51a2..c3edd32 100644
--- a/test/TestFixture.h
+++ b/test/TestFixture.h
@@ -43,7 +43,7 @@
const SpirvVector::size_type kFirstInstruction = 5;
TextToBinaryTestBase()
- : context(spvContextCreate()),
+ : context(spvContextCreate(SPV_ENV_UNIVERSAL_1_0)),
diagnostic(nullptr),
text(),
binary(nullptr) {
@@ -66,8 +66,8 @@
// Compiles SPIR-V text in the given assembly syntax format, asserting
// compilation success. Returns the compiled code.
SpirvVector CompileSuccessfully(const std::string& txt) {
- spv_result_t status = spvTextToBinary(context, txt.c_str(), txt.size(),
- &binary, &diagnostic);
+ spv_result_t status =
+ spvTextToBinary(context, txt.c_str(), txt.size(), &binary, &diagnostic);
EXPECT_EQ(SPV_SUCCESS, status) << txt;
SpirvVector code_copy;
if (status == SPV_SUCCESS) {
@@ -100,8 +100,8 @@
std::string EncodeAndDecodeSuccessfully(const std::string& txt,
uint32_t disassemble_options) {
DestroyBinary();
- spv_result_t error = spvTextToBinary(context, txt.c_str(), txt.size(),
- &binary, &diagnostic);
+ spv_result_t error =
+ spvTextToBinary(context, txt.c_str(), txt.size(), &binary, &diagnostic);
if (error) {
spvDiagnosticPrint(diagnostic);
spvDiagnosticDestroy(diagnostic);
diff --git a/test/TextAdvance.cpp b/test/TextAdvance.cpp
index 627d0d6..0f18530 100644
--- a/test/TextAdvance.cpp
+++ b/test/TextAdvance.cpp
@@ -96,4 +96,40 @@
ASSERT_EQ(SPV_END_OF_STREAM, data.advance());
}
+// Invokes AssemblyContext::advance() on text, asserts success, and returns
+// AssemblyContext::position().
+spv_position_t PositionAfterAdvance(const char* text) {
+ AutoText input(text);
+ AssemblyContext data(input, nullptr);
+ EXPECT_EQ(SPV_SUCCESS, data.advance());
+ return data.position();
+}
+
+TEST(TextAdvance, SkipOverCR) {
+ const auto pos = PositionAfterAdvance("\rWord");
+ EXPECT_EQ(1u, pos.column);
+ EXPECT_EQ(0u, pos.line);
+ EXPECT_EQ(1u, pos.index);
+}
+
+TEST(TextAdvance, SkipOverCRs) {
+ const auto pos = PositionAfterAdvance("\r\r\rWord");
+ EXPECT_EQ(3u, pos.column);
+ EXPECT_EQ(0u, pos.line);
+ EXPECT_EQ(3u, pos.index);
+}
+
+TEST(TextAdvance, SkipOverCRLF) {
+ const auto pos = PositionAfterAdvance("\r\nWord");
+ EXPECT_EQ(0u, pos.column);
+ EXPECT_EQ(1u, pos.line);
+ EXPECT_EQ(2u, pos.index);
+}
+
+TEST(TextAdvance, SkipOverCRLFs) {
+ const auto pos = PositionAfterAdvance("\r\n\r\nWord");
+ EXPECT_EQ(0u, pos.column);
+ EXPECT_EQ(2u, pos.line);
+ EXPECT_EQ(4u, pos.index);
+}
} // anonymous namespace
diff --git a/test/TextDestroy.cpp b/test/TextDestroy.cpp
index ef789ad..c721fdc 100644
--- a/test/TextDestroy.cpp
+++ b/test/TextDestroy.cpp
@@ -31,7 +31,7 @@
TEST(TextDestroy, DestroyNull) { spvBinaryDestroy(nullptr); }
TEST(TextDestroy, Default) {
- spv_context context = spvContextCreate();
+ spv_context context = spvContextCreate(SPV_ENV_UNIVERSAL_1_0);
char textStr[] = R"(
OpSource OpenCL_C 12
OpMemoryModel Physical64 OpenCL
diff --git a/test/TextToBinary.Extension.cpp b/test/TextToBinary.Extension.cpp
index 437736d..420f0d3 100644
--- a/test/TextToBinary.Extension.cpp
+++ b/test/TextToBinary.Extension.cpp
@@ -31,6 +31,8 @@
#include "TestFixture.h"
#include "gmock/gmock.h"
+#include "spirv/GLSL.std.450.h"
+#include "spirv/OpenCL.std.h"
namespace {
diff --git a/test/TextToBinary.ModeSetting.cpp b/test/TextToBinary.ModeSetting.cpp
index b61644d..36a5bae 100644
--- a/test/TextToBinary.ModeSetting.cpp
+++ b/test/TextToBinary.ModeSetting.cpp
@@ -198,6 +198,12 @@
Eq("Invalid execution mode 'xxyyzz'."));
}
+TEST_F(OpExecutionModeTest, TooManyModes) {
+ EXPECT_THAT(CompileFailure("OpExecutionMode %1 Xfb PointMode"),
+ Eq("Expected <opcode> or <result-id> at the beginning of an "
+ "instruction, found 'PointMode'."));
+}
+
// Test OpCapability
using OpCapabilityTest = spvtest::TextToBinaryTestBase<
diff --git a/test/TextToBinary.cpp b/test/TextToBinary.cpp
index a2e490a..812da40 100644
--- a/test/TextToBinary.cpp
+++ b/test/TextToBinary.cpp
@@ -25,6 +25,7 @@
// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
#include <algorithm>
+#include <cstring>
#include <utility>
#include <vector>
@@ -45,6 +46,8 @@
using spvtest::MakeInstruction;
using spvtest::TextToBinaryTest;
using testing::Eq;
+using testing::IsNull;
+using testing::NotNull;
// An mask parsing test case.
struct MaskCase {
@@ -56,7 +59,7 @@
using GoodMaskParseTest = ::testing::TestWithParam<MaskCase>;
TEST_P(GoodMaskParseTest, GoodMaskExpressions) {
- spv_context context = spvContextCreate();
+ spv_context context = spvContextCreate(SPV_ENV_UNIVERSAL_1_0);
uint32_t value;
EXPECT_EQ(SPV_SUCCESS,
@@ -96,12 +99,12 @@
{SPV_OPERAND_TYPE_FUNCTION_CONTROL, 4, "Pure"},
{SPV_OPERAND_TYPE_FUNCTION_CONTROL, 8, "Const"},
{SPV_OPERAND_TYPE_FUNCTION_CONTROL, 0xd, "Inline|Const|Pure"},
- }),);
+ }), );
using BadFPFastMathMaskParseTest = ::testing::TestWithParam<const char*>;
TEST_P(BadFPFastMathMaskParseTest, BadMaskExpressions) {
- spv_context context = spvContextCreate();
+ spv_context context = spvContextCreate(SPV_ENV_UNIVERSAL_1_0);
uint32_t value;
EXPECT_NE(SPV_SUCCESS,
@@ -116,7 +119,7 @@
nullptr, "", "NotValidEnum", "|", "NotInf|",
"|NotInf", "NotInf||NotNaN",
"Unroll" // A good word, but for the wrong enum
- }),);
+ }), );
TEST_F(TextToBinaryTest, InvalidText) {
ASSERT_EQ(SPV_ERROR_INVALID_TEXT,
@@ -192,6 +195,14 @@
EXPECT_EQ(6u, diagnostic->position.column + 1);
}
+TEST_F(TextToBinaryTest, CRLF) {
+ const std::string input =
+ "%i32 = OpTypeInt 32 1\r\n%c = OpConstant %i32 123\r\n";
+ EXPECT_THAT(CompiledInstructions(input),
+ Eq(Concatenate({MakeInstruction(SpvOpTypeInt, {1, 32, 1}),
+ MakeInstruction(SpvOpConstant, {1, 2, 123})})));
+}
+
using TextToBinaryFloatValueTest = spvtest::TextToBinaryTestBase<
::testing::TestWithParam<std::pair<std::string, uint32_t>>>;
@@ -220,7 +231,7 @@
{"-2.5", 0xc0200000},
{"!0xff800000", 0xff800000}, // -inf
{"!0xff800001", 0xff800001}, // NaN
- }),);
+ }), );
using TextToBinaryHalfValueTest = spvtest::TextToBinaryTestBase<
::testing::TestWithParam<std::pair<std::string, uint32_t>>>;
@@ -252,7 +263,7 @@
{"0x1.8p4", 0x00004e00},
{"0x1.801p4", 0x00004e00},
{"0x1.804p4", 0x00004e01},
- }),);
+ }), );
TEST(AssemblyContextParseNarrowSignedIntegers, Sample) {
AssemblyContext context(AutoText(""), nullptr);
@@ -538,4 +549,22 @@
spvDiagnosticDestroy(diag);
}
+TEST(CreateContext, InvalidEnvironment) {
+ spv_target_env env;
+ std::memset(&env, 99, sizeof(env));
+ EXPECT_THAT(spvContextCreate(env), IsNull());
+}
+
+TEST(CreateContext, UniversalEnvironment) {
+ auto c = spvContextCreate(SPV_ENV_UNIVERSAL_1_0);
+ EXPECT_THAT(c, NotNull());
+ spvContextDestroy(c);
+}
+
+TEST(CreateContext, VulkanEnvironment) {
+ auto c = spvContextCreate(SPV_ENV_VULKAN_1_0);
+ EXPECT_THAT(c, NotNull());
+ spvContextDestroy(c);
+}
+
} // anonymous namespace
diff --git a/test/TextWordGet.cpp b/test/TextWordGet.cpp
index 7abfee5..651f850 100644
--- a/test/TextWordGet.cpp
+++ b/test/TextWordGet.cpp
@@ -245,4 +245,19 @@
ASSERT_STREQ("word" BACKSLASH BACKSLASH, word.c_str());
}
+TEST(TextWordGet, CRLF) {
+ AutoText input("abc\r\nd");
+ AssemblyContext data(input, nullptr);
+ std::string word;
+ spv_position_t pos = {};
+ ASSERT_EQ(SPV_SUCCESS, data.getWord(&word, &pos));
+ EXPECT_EQ(3u, pos.column);
+ EXPECT_STREQ("abc", word.c_str());
+ data.setPosition(pos);
+ data.advance();
+ ASSERT_EQ(SPV_SUCCESS, data.getWord(&word, &pos));
+ EXPECT_EQ(1u, pos.column);
+ EXPECT_STREQ("d", word.c_str());
+}
+
} // anonymous namespace
diff --git a/test/UnitSPIRV.h b/test/UnitSPIRV.h
index 49eb2e2..6e89284 100644
--- a/test/UnitSPIRV.h
+++ b/test/UnitSPIRV.h
@@ -199,7 +199,7 @@
// each of which has a 4-byte UTF-8 encoding.
inline std::string MakeLongUTF8String(size_t num_4_byte_chars) {
// An example of a longest valid UTF-8 character.
- // Be explicit about the character type becuase Microsoft compilers can
+ // Be explicit about the character type because Microsoft compilers can
// otherwise interpret the character string as being over wide (16-bit)
// characters. Ideally, we would just use a C++11 UTF-8 string literal,
// but we want to support older Microsoft compilers.
diff --git a/test/Validate.Layout.cpp b/test/Validate.Layout.cpp
index 74a078c..c680be1 100644
--- a/test/Validate.Layout.cpp
+++ b/test/Validate.Layout.cpp
@@ -302,7 +302,7 @@
%funcl = OpLabel
OpNop
OpBranch %next
-%func2p = OpFunctionParameter %intt ;FunctionParameter appears in a function but not immediatly afterwards
+%func2p = OpFunctionParameter %intt ;FunctionParameter appears in a function but not immediately afterwards
%next = OpLabel
OpNop
OpReturn
diff --git a/test/ValidateFixtures.cpp b/test/ValidateFixtures.cpp
index e51a580..1830895 100644
--- a/test/ValidateFixtures.cpp
+++ b/test/ValidateFixtures.cpp
@@ -26,8 +26,8 @@
// Common validation fixtures for unit tests
-#include "UnitSPIRV.h"
#include "ValidateFixtures.h"
+#include "UnitSPIRV.h"
#include <functional>
#include <tuple>
@@ -37,7 +37,9 @@
template <typename T>
ValidateBase<T>::ValidateBase()
- : context_(spvContextCreate()), binary_(), diagnostic_() {}
+ : context_(spvContextCreate(SPV_ENV_UNIVERSAL_1_0)),
+ binary_(),
+ diagnostic_() {}
template <typename T>
ValidateBase<T>::~ValidateBase() {
diff --git a/test/ValidateID.cpp b/test/ValidateID.cpp
index 171ec97..808a90b 100644
--- a/test/ValidateID.cpp
+++ b/test/ValidateID.cpp
@@ -24,9 +24,10 @@
// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
// MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+#include <sstream>
#include <string>
-#include "UnitSPIRV.h"
+#include "TestFixture.h"
// NOTE: The tests in this file are ONLY testing ID usage, there for the input
// SPIR-V does not follow the logical layout rules from the spec in all cases in
@@ -36,6 +37,11 @@
namespace {
+using ::testing::ValuesIn;
+using std::ostringstream;
+using std::string;
+using std::vector;
+
class ValidateID : public ::testing::Test {
public:
virtual void TearDown() { spvBinaryDestroy(binary); }
@@ -69,16 +75,18 @@
OpMemoryModel Physical64 OpenCL
)";
+// TODO(dekimir): this can be removed by adding a method to ValidateID akin to
+// OpTypeArrayLengthTest::Val().
#define CHECK(str, expected) \
spv_diagnostic diagnostic; \
- spv_context context = spvContextCreate(); \
+ spv_context context = spvContextCreate(SPV_ENV_UNIVERSAL_1_0); \
std::string shader = std::string(kGLSL450MemoryModel) + str; \
spv_result_t error = spvTextToBinary(context, shader.c_str(), shader.size(), \
&binary, &diagnostic); \
if (error) { \
spvDiagnosticPrint(diagnostic); \
spvDiagnosticDestroy(diagnostic); \
- ASSERT_EQ(SPV_SUCCESS, error); \
+ ASSERT_EQ(SPV_SUCCESS, error) << shader; \
} \
spv_result_t result = spvValidate(context, get_const_binary(), &diagnostic); \
if (SPV_SUCCESS != result) { \
@@ -91,10 +99,10 @@
#define CHECK_KERNEL(str, expected, bitness) \
ASSERT_TRUE(bitness == 32 || bitness == 64); \
spv_diagnostic diagnostic; \
- spv_context context = spvContextCreate(); \
- std::string kernel = std::string(bitness == 32 ? \
- kOpenCLMemoryModel32 : \
- kOpenCLMemoryModel64) + str; \
+ spv_context context = spvContextCreate(SPV_ENV_UNIVERSAL_1_0); \
+ std::string kernel = std::string(bitness == 32 ? kOpenCLMemoryModel32 \
+ : kOpenCLMemoryModel64) + \
+ str; \
spv_result_t error = spvTextToBinary(context, kernel.c_str(), kernel.size(), \
&binary, &diagnostic); \
if (error) { \
@@ -371,6 +379,7 @@
%3 = OpTypeArray %1 %2)";
CHECK(spirv, SPV_SUCCESS);
}
+
TEST_F(ValidateID, OpTypeArrayElementTypeBad) {
const char* spirv = R"(
%1 = OpTypeInt 32 0
@@ -378,14 +387,117 @@
%3 = OpTypeArray %2 %2)";
CHECK(spirv, SPV_ERROR_INVALID_ID);
}
-TEST_F(ValidateID, OpTypeArrayLengthBad) {
+
+// Signed or unsigned.
+enum Signed { kSigned, kUnsigned };
+
+// Creates an assembly snippet declaring OpTypeArray with the given length.
+string MakeArrayLength(const string& len, Signed isSigned, int width) {
+ ostringstream ss;
+ ss << kGLSL450MemoryModel;
+ ss << " %t = OpTypeInt " << width << (isSigned == kSigned ? " 1" : " 0")
+ << " %l = OpConstant %t " << len << " %a = OpTypeArray %t %l";
+ return ss.str();
+}
+
+// Tests OpTypeArray. Parameter is the width (in bits) of the array-length's
+// type.
+class OpTypeArrayLengthTest
+ : public spvtest::TextToBinaryTestBase<::testing::TestWithParam<int>> {
+ protected:
+ OpTypeArrayLengthTest()
+ : position_(spv_position_t{0, 0, 0}),
+ diagnostic_(spvDiagnosticCreate(&position_, "")) {}
+
+ ~OpTypeArrayLengthTest() { spvDiagnosticDestroy(diagnostic_); }
+
+ // Runs spvValidate() on v, printing any errors via spvDiagnosticPrint().
+ spv_result_t Val(const SpirvVector& v) {
+ spv_const_binary_t cbinary{v.data(), v.size()};
+ const auto status = spvValidate(context, &cbinary, &diagnostic_);
+ if (status != SPV_SUCCESS) {
+ spvDiagnosticPrint(diagnostic_);
+ }
+ return status;
+ }
+
+ private:
+ spv_position_t position_; // For creating diagnostic_.
+ spv_diagnostic diagnostic_;
+};
+
+TEST_P(OpTypeArrayLengthTest, LengthPositive) {
+ const int width = GetParam();
+ EXPECT_EQ(SPV_SUCCESS,
+ Val(CompileSuccessfully(MakeArrayLength("1", kSigned, width))));
+ EXPECT_EQ(SPV_SUCCESS,
+ Val(CompileSuccessfully(MakeArrayLength("1", kUnsigned, width))));
+ EXPECT_EQ(SPV_SUCCESS,
+ Val(CompileSuccessfully(MakeArrayLength("2", kSigned, width))));
+ EXPECT_EQ(SPV_SUCCESS,
+ Val(CompileSuccessfully(MakeArrayLength("2", kUnsigned, width))));
+ EXPECT_EQ(SPV_SUCCESS,
+ Val(CompileSuccessfully(MakeArrayLength("55", kSigned, width))));
+ EXPECT_EQ(SPV_SUCCESS,
+ Val(CompileSuccessfully(MakeArrayLength("55", kUnsigned, width))));
+ const string fpad(width / 4 - 1, 'F');
+ EXPECT_EQ(
+ SPV_SUCCESS,
+ Val(CompileSuccessfully(MakeArrayLength("0x7" + fpad, kSigned, width))));
+ EXPECT_EQ(SPV_SUCCESS, Val(CompileSuccessfully(
+ MakeArrayLength("0xF" + fpad, kUnsigned, width))));
+}
+
+TEST_P(OpTypeArrayLengthTest, LengthZero) {
+ const int width = GetParam();
+ EXPECT_EQ(SPV_ERROR_INVALID_ID,
+ Val(CompileSuccessfully(MakeArrayLength("0", kSigned, width))));
+ EXPECT_EQ(SPV_ERROR_INVALID_ID,
+ Val(CompileSuccessfully(MakeArrayLength("0", kUnsigned, width))));
+}
+
+TEST_P(OpTypeArrayLengthTest, LengthNegative) {
+ const int width = GetParam();
+ EXPECT_EQ(SPV_ERROR_INVALID_ID,
+ Val(CompileSuccessfully(MakeArrayLength("-1", kSigned, width))));
+ EXPECT_EQ(SPV_ERROR_INVALID_ID,
+ Val(CompileSuccessfully(MakeArrayLength("-2", kSigned, width))));
+ EXPECT_EQ(SPV_ERROR_INVALID_ID,
+ Val(CompileSuccessfully(MakeArrayLength("-123", kSigned, width))));
+ const string neg_max = "0x8" + string(width / 4 - 1, '0');
+ EXPECT_EQ(SPV_ERROR_INVALID_ID,
+ Val(CompileSuccessfully(MakeArrayLength(neg_max, kSigned, width))));
+}
+
+INSTANTIATE_TEST_CASE_P(Widths, OpTypeArrayLengthTest,
+ ValuesIn(vector<int>{8, 16, 32, 48, 64}));
+
+TEST_F(ValidateID, OpTypeArrayLengthNull) {
const char* spirv = R"(
-%1 = OpTypeInt 32 0
-%2 = OpConstant %1 0
-%3 = OpTypeArray %1 %2)";
+%i32 = OpTypeInt 32 1
+%len = OpConstantNull %i32
+%ary = OpTypeArray %i32 %len)";
CHECK(spirv, SPV_ERROR_INVALID_ID);
}
+TEST_F(ValidateID, OpTypeArrayLengthSpecConst) {
+ const char* spirv = R"(
+%i32 = OpTypeInt 32 1
+%len = OpSpecConstant %i32 2
+%ary = OpTypeArray %i32 %len)";
+ CHECK(spirv, SPV_SUCCESS);
+}
+
+TEST_F(ValidateID, OpTypeArrayLengthSpecConstOp) {
+ const char* spirv = R"(
+%i32 = OpTypeInt 32 1
+%c1 = OpConstant %i32 1
+%c2 = OpConstant %i32 2
+%len = OpSpecConstantOp %i32 IAdd %c1 %c2
+%ary = OpTypeArray %i32 %len)";
+ CHECK(spirv, SPV_SUCCESS);
+}
+
TEST_F(ValidateID, OpTypeRuntimeArrayGood) {
const char* spirv = R"(
%1 = OpTypeInt 32 0
diff --git a/test/ValidationState.cpp b/test/ValidationState.cpp
index e38516d..bbc4f60 100644
--- a/test/ValidationState.cpp
+++ b/test/ValidationState.cpp
@@ -42,7 +42,8 @@
class ValidationStateTest : public testing::Test {
public:
ValidationStateTest()
- : context_(spvContextCreate()), state_(&diag_, context_) {}
+ : context_(spvContextCreate(SPV_ENV_UNIVERSAL_1_0)),
+ state_(&diag_, context_) {}
protected:
spv_diagnostic diag_;
diff --git a/tools/as/as.cpp b/tools/as/as.cpp
index 8166d76..214dcc1 100644
--- a/tools/as/as.cpp
+++ b/tools/as/as.cpp
@@ -54,7 +54,7 @@
const char kBuildVersion[] =
#include "build-version.inc"
-;
+ ;
int main(int argc, char** argv) {
const char* inFile = nullptr;
@@ -88,8 +88,8 @@
// Long options
if (0 == strcmp(argv[argi], "--version")) {
printf("%s\n", kBuildVersion);
- printf("Target: SPIR-V %d.%d rev %d\n", SPV_SPIRV_VERSION_MAJOR,
- SPV_SPIRV_VERSION_MINOR, SPV_SPIRV_VERSION_REVISION);
+ printf("Target: %s\n",
+ spvTargetEnvDescription(SPV_ENV_UNIVERSAL_1_0));
return 0;
}
if (0 == strcmp(argv[argi], "--help")) {
@@ -129,7 +129,7 @@
spv_binary binary;
spv_diagnostic diagnostic = nullptr;
- spv_context context = spvContextCreate();
+ spv_context context = spvContextCreate(SPV_ENV_UNIVERSAL_1_0);
spv_result_t error = spvTextToBinary(context, contents.data(),
contents.size(), &binary, &diagnostic);
spvContextDestroy(context);
diff --git a/tools/dis/dis.cpp b/tools/dis/dis.cpp
index 1f12f50..b8221c9 100644
--- a/tools/dis/dis.cpp
+++ b/tools/dis/dis.cpp
@@ -61,7 +61,7 @@
const char kBuildVersion[] =
#include "build-version.inc"
-;
+ ;
int main(int argc, char** argv) {
const char* inFile = nullptr;
@@ -101,8 +101,8 @@
return 0;
} else if (0 == strcmp(argv[argi], "--version")) {
printf("%s\n", kBuildVersion);
- printf("Target: SPIR-V %d.%d rev %d\n", SPV_SPIRV_VERSION_MAJOR,
- SPV_SPIRV_VERSION_MINOR, SPV_SPIRV_VERSION_REVISION);
+ printf("Target: %s\n",
+ spvTargetEnvDescription(SPV_ENV_UNIVERSAL_1_0));
return 0;
} else {
print_usage(argv[0]);
@@ -174,12 +174,11 @@
// into the output stream.
// If the printing option is off, then save the text in memory, so
// it can be emitted later in this function.
- const bool print_to_stdout =
- spvIsInBitfield(SPV_BINARY_TO_TEXT_OPTION_PRINT, options);
+ const bool print_to_stdout = SPV_BINARY_TO_TEXT_OPTION_PRINT & options;
spv_text text;
spv_text* textOrNull = print_to_stdout ? nullptr : &text;
spv_diagnostic diagnostic = nullptr;
- spv_context context = spvContextCreate();
+ spv_context context = spvContextCreate(SPV_ENV_UNIVERSAL_1_0);
spv_result_t error =
spvBinaryToText(context, contents.data(), contents.size(), options,
textOrNull, &diagnostic);
diff --git a/tools/val/val.cpp b/tools/val/val.cpp
index 76220fa..f9e19a4 100644
--- a/tools/val/val.cpp
+++ b/tools/val/val.cpp
@@ -52,22 +52,26 @@
const char kBuildVersion[] =
#include "build-version.inc"
-;
+ ;
int main(int argc, char** argv) {
const char* inFile = nullptr;
+ spv_target_env target_env = SPV_ENV_UNIVERSAL_1_0;
for (int argi = 1; argi < argc; ++argi) {
const char* cur_arg = argv[argi];
if ('-' == cur_arg[0]) {
if (0 == strcmp(cur_arg, "--version")) {
printf("%s\n", kBuildVersion);
- printf("Target: SPIR-V %d.%d rev %d\n", SPV_SPIRV_VERSION_MAJOR,
- SPV_SPIRV_VERSION_MINOR, SPV_SPIRV_VERSION_REVISION);
+ printf("Targets:\n %s\n %s\n",
+ spvTargetEnvDescription(SPV_ENV_UNIVERSAL_1_0),
+ spvTargetEnvDescription(SPV_ENV_VULKAN_1_0));
return 0;
} else if (0 == strcmp(cur_arg, "--help") || 0 == strcmp(cur_arg, "-h")) {
print_usage(argv[0]);
return 0;
+ } else if (0 == strcmp(cur_arg, "--vulkan")) {
+ target_env = SPV_ENV_VULKAN_1_0;
} else if (0 == cur_arg[1]) {
// Setting a filename of "-" to indicate stdin.
if (!inFile) {
@@ -108,7 +112,7 @@
spv_const_binary_t binary = {contents.data(), contents.size()};
spv_diagnostic diagnostic = nullptr;
- spv_context context = spvContextCreate();
+ spv_context context = spvContextCreate(target_env);
spv_result_t error = spvValidate(context, &binary, &diagnostic);
spvContextDestroy(context);
if (error) {
diff --git a/utils/generate_grammar_tables.py b/utils/generate_grammar_tables.py
new file mode 100755
index 0000000..b5ab592
--- /dev/null
+++ b/utils/generate_grammar_tables.py
@@ -0,0 +1,402 @@
+#!/usr/bin/env python
+"""Generates various info tables from SPIR-V JSON grammar."""
+
+from __future__ import print_function
+
+import functools
+import json
+import os.path
+import re
+
+# Prefix for all C variables generated by this script.
+PYGEN_VARIABLE_PREFIX = 'pygen_variable'
+
+CAPABILITY_BIT_MAPPING = {}
+
+
+def make_path_to_file(f):
+ """Makes all ancestor directories to the given file, if they
+ don't yet exist.
+
+ Arguments:
+ f: The file whose ancestor directories are to be created.
+ """
+ dir = os.path.dirname(os.path.abspath(f))
+ if not os.path.isdir(dir):
+ os.makedirs(dir)
+
+
+def populate_capability_bit_mapping_dict(cap_dict):
+ """Populates CAPABILITY_BIT_MAPPING.
+
+ Arguments:
+ - cap_dict: a dict containing all capability names and values
+ """
+ assert cap_dict['category'] == 'ValueEnum'
+ assert cap_dict['kind'] == 'Capability'
+ for enumerant in cap_dict['enumerants']:
+ CAPABILITY_BIT_MAPPING[enumerant['enumerant']] = enumerant['value']
+
+
+def compose_capability_mask(caps):
+ """Returns a bit mask for a sequence of capabilities
+
+ Arguments:
+ - caps: a sequence of capability names
+
+ Returns:
+ a string containing the hexadecimal value of the bit mask
+ """
+ assert len(CAPABILITY_BIT_MAPPING) != 0
+ bits = [CAPABILITY_BIT_MAPPING[c] for c in caps]
+ caps_mask = functools.reduce(lambda m, b: m | (1 << b), bits, 0)
+ return '0x{:04x}'.format(caps_mask)
+
+
+def convert_operand_kind(operand_tuple):
+ """Returns the corresponding operand type used in spirv-tools for
+ the given operand kind and quantifier used in the JSON grammar.
+
+ Arguments:
+ - operand_tuple: a tuple of two elements:
+ - operand kind: used in the JSON grammar
+ - quantifier: '', '?', or '*'
+
+ Returns:
+ a string of the enumerant name in spv_operand_type_t
+ """
+ kind, quantifier = operand_tuple
+ # The following cases are where we differ between the JSON grammar and
+ # spirv-tools.
+ if kind == 'IdResultType':
+ kind = 'TypeId'
+ elif kind == 'IdResult':
+ kind = 'ResultId'
+ elif kind == 'IdMemorySemantics' or kind == 'MemorySemantics':
+ kind = 'MemorySemanticsId'
+ elif kind == 'IdScope' or kind == 'Scope':
+ kind = 'ScopeId'
+ elif kind == 'IdRef':
+ kind = 'Id'
+
+ elif kind == 'ImageOperands':
+ kind = 'Image'
+ elif kind == 'Dim':
+ kind = 'Dimensionality'
+ elif kind == 'ImageFormat':
+ kind = 'SamplerImageFormat'
+ elif kind == 'KernelEnqueueFlags':
+ kind = 'KernelEnqFlags'
+
+ elif kind == 'LiteralExtInstInteger':
+ kind = 'ExtensionInstructionNumber'
+ elif kind == 'LiteralSpecConstantOpInteger':
+ kind = 'SpecConstantOpNumber'
+ elif kind == 'LiteralContextDependentNumber':
+ kind = 'TypedLiteralNumber'
+
+ elif kind == 'PairLiteralIntegerIdRef':
+ kind = 'LiteralIntegerId'
+ elif kind == 'PairIdRefLiteralInteger':
+ kind = 'IdLiteralInteger'
+ elif kind == 'PairIdRefIdRef': # Used by OpPhi in the grammar
+ kind = 'Id'
+
+ if kind == 'FPRoundingMode':
+ kind = 'FpRoundingMode'
+ elif kind == 'FPFastMathMode':
+ kind = 'FpFastMathMode'
+
+ if quantifier == '?':
+ kind = 'Optional{}'.format(kind)
+ elif quantifier == '*':
+ kind = 'Variable{}'.format(kind)
+
+ return 'SPV_OPERAND_TYPE_{}'.format(
+ re.sub(r'([a-z])([A-Z])', r'\1_\2', kind).upper())
+
+
+class InstInitializer(object):
+ """Instances holds a SPIR-V instruction suitable for printing as
+ the initializer for spv_opcode_desc_t."""
+
+ def __init__(self, opname, caps, operands):
+ """Initialization.
+
+ Arguments:
+ - opname: opcode name (with the 'Op' prefix)
+ - caps: a sequence of capability names required by this opcode
+ - operands: a sequence of (operand-kind, operand-quantifier) tuples
+ """
+ assert opname.startswith('Op')
+ self.opname = opname[2:] # Remove the "Op" prefix.
+ self.caps_mask = compose_capability_mask(caps)
+ self.operands = [convert_operand_kind(o) for o in operands]
+
+ operands = [o[0] for o in operands]
+ self.ref_type_id = 'IdResultType' in operands
+ self.def_result_id = 'IdResult' in operands
+
+ def __str__(self):
+ template = ['{{"{opname}"', 'SpvOp{opname}', '{caps_mask}',
+ '{num_operands}', '{{{operands}}}',
+ '{def_result_id}', '{ref_type_id}}}']
+ return ', '.join(template).format(
+ opname=self.opname,
+ caps_mask=self.caps_mask,
+ num_operands=len(self.operands),
+ operands=', '.join(self.operands),
+ def_result_id=(1 if self.def_result_id else 0),
+ ref_type_id=(1 if self.ref_type_id else 0))
+
+
+class ExtInstInitializer(object):
+ """Instances holds a SPIR-V extended instruction suitable for printing as
+ the initializer for spv_ext_inst_desc_t."""
+
+ def __init__(self, opname, opcode, caps, operands):
+ """Initialization.
+
+ Arguments:
+ - opname: opcode name
+ - opcode: enumerant value for this opcode
+ - caps: a sequence of capability names required by this opcode
+ - operands: a sequence of (operand-kind, operand-quantifier) tuples
+ """
+ self.opname = opname
+ self.opcode = opcode
+ self.caps_mask = compose_capability_mask(caps)
+ self.operands = [convert_operand_kind(o) for o in operands]
+ self.operands.append('SPV_OPERAND_TYPE_NONE')
+
+ def __str__(self):
+ template = ['{{"{opname}"', '{opcode}', '{caps_mask}',
+ '{{{operands}}}}}']
+ return ', '.join(template).format(
+ opname=self.opname,
+ opcode=self.opcode,
+ caps_mask=self.caps_mask,
+ operands=', '.join(self.operands))
+
+
+def generate_instruction(inst, is_ext_inst):
+ """Returns the C initializer for the given SPIR-V instruction.
+
+ Arguments:
+ - inst: a dict containing information about a SPIR-V instruction
+ - is_ext_inst: a bool indicating whether |inst| is an extended
+ instruction.
+
+ Returns:
+ a string containing the C initializer for spv_opcode_desc_t or
+ spv_ext_inst_desc_t
+ """
+ opname = inst.get('opname')
+ opcode = inst.get('opcode')
+ caps = inst.get('capabilities', [])
+ operands = inst.get('operands', {})
+ operands = [(o['kind'], o.get('quantifier', '')) for o in operands]
+
+ assert opname is not None
+
+ if is_ext_inst:
+ return str(ExtInstInitializer(opname, opcode, caps, operands))
+ else:
+ return str(InstInitializer(opname, caps, operands))
+
+
+def generate_instruction_table(inst_table, is_ext_inst):
+ """Returns the info table containing all SPIR-V instructions.
+
+ Arguments:
+ - inst_table: a dict containing all SPIR-V instructions.
+ - is_ext_inst: a bool indicating whether |inst_table| is for
+ an extended instruction set.
+ """
+ return ',\n'.join([generate_instruction(inst, is_ext_inst)
+ for inst in inst_table])
+
+
+class EnumerantInitializer(object):
+ """Prints an enumerant as the initializer for spv_operand_desc_t."""
+
+ def __init__(self, enumerant, value, caps, parameters):
+ """Initialization.
+
+ Arguments:
+ - enumerant: enumerant name
+ - value: enumerant value
+ - caps: a sequence of capability names required by this enumerant
+ - parameters: a sequence of (operand-kind, operand-quantifier) tuples
+ """
+ self.enumerant = enumerant
+ self.value = value
+ self.caps_mask = compose_capability_mask(caps)
+ self.parameters = [convert_operand_kind(p) for p in parameters]
+
+ def __str__(self):
+ template = ['{{"{enumerant}"', '{value}',
+ '{caps_mask}', '{{{parameters}}}}}']
+ return ', '.join(template).format(
+ enumerant=self.enumerant,
+ value=self.value,
+ caps_mask=self.caps_mask,
+ parameters=', '.join(self.parameters))
+
+
+def generate_enum_operand_kind_entry(entry):
+ """Returns the C initializer for the given operand enum entry.
+
+ Arguments:
+ - entry: a dict containing information about an enum entry
+
+ Returns:
+ a string containing the C initializer for spv_operand_desc_t
+ """
+ enumerant = entry.get('enumerant')
+ value = entry.get('value')
+ caps = entry.get('capabilities', [])
+ params = entry.get('parameters', [])
+ params = [p.get('kind') for p in params]
+ params = zip(params, [''] * len(params))
+
+ assert enumerant is not None
+ assert value is not None
+
+ return str(EnumerantInitializer(enumerant, value, caps, params))
+
+
+def generate_enum_operand_kind(enum):
+ """Returns the C definition for the given operand kind."""
+ kind = enum.get('kind')
+ assert kind is not None
+
+ name = '{}_{}Entries'.format(PYGEN_VARIABLE_PREFIX, kind)
+ entries = [' {}'.format(generate_enum_operand_kind_entry(e))
+ for e in enum.get('enumerants', [])]
+
+ template = ['static const spv_operand_desc_t {name}[] = {{',
+ '{entries}', '}};']
+ entries = '\n'.join(template).format(
+ name=name,
+ entries=',\n'.join(entries))
+
+ return kind, name, entries
+
+
+def generate_operand_kind_table(enums):
+ """Returns the info table containing all SPIR-V operand kinds."""
+ # We only need to output info tables for those operand kinds that are enums.
+ enums = [generate_enum_operand_kind(e)
+ for e in enums
+ if e.get('category') in ['ValueEnum', 'BitEnum']]
+ # We have three operand kinds that requires their optional counterpart to
+ # exist in the operand info table.
+ three_optional_enums = ['ImageOperands', 'AccessQualifier', 'MemoryAccess']
+ three_optional_enums = [e for e in enums if e[0] in three_optional_enums]
+ enums.extend(three_optional_enums)
+
+ enum_kinds, enum_names, enum_entries = zip(*enums)
+ # Mark the last three as optional ones.
+ enum_quantifiers = [''] * (len(enums) - 3) + ['?'] * 3
+ # And we don't want redefinition of them.
+ enum_entries = enum_entries[:-3]
+ enum_kinds = [convert_operand_kind(e)
+ for e in zip(enum_kinds, enum_quantifiers)]
+ table_entries = zip(enum_kinds, enum_names, enum_names)
+ table_entries = [' {{{}, ARRAY_SIZE({}), {}}}'.format(*e)
+ for e in table_entries]
+
+ template = [
+ 'static const spv_operand_desc_group_t {p}_OperandInfoTable[] = {{',
+ '{enums}', '}};']
+ table = '\n'.join(template).format(
+ p=PYGEN_VARIABLE_PREFIX, enums=',\n'.join(table_entries))
+
+ return '\n\n'.join(enum_entries + (table,))
+
+
+def main():
+ import argparse
+ parser = argparse.ArgumentParser(description='Generate SPIR-V info tables')
+ parser.add_argument('--spirv-core-grammar', metavar='<path>',
+ type=str, required=True,
+ help='input JSON grammar file for core SPIR-V '
+ 'instructions')
+ parser.add_argument('--extinst-glsl-grammar', metavar='<path>',
+ type=str, required=False, default=None,
+ help='input JSON grammar file for GLSL extended '
+ 'instruction set')
+ parser.add_argument('--extinst-opencl-grammar', metavar='<path>',
+ type=str, required=False, default=None,
+ help='input JSON grammar file for OpenGL extended '
+ 'instruction set')
+ parser.add_argument('--core-insts-output', metavar='<path>',
+ type=str, required=False, default=None,
+ help='output file for core SPIR-V instructions')
+ parser.add_argument('--glsl-insts-output', metavar='<path>',
+ type=str, required=False, default=None,
+ help='output file for GLSL extended instruction set')
+ parser.add_argument('--opencl-insts-output', metavar='<path>',
+ type=str, required=False, default=None,
+ help='output file for OpenCL extended instruction set')
+ parser.add_argument('--operand-kinds-output', metavar='<path>',
+ type=str, required=False, default=None,
+ help='output file for operand kinds')
+ args = parser.parse_args()
+
+ if (args.core_insts_output is None) != \
+ (args.operand_kinds_output is None):
+ print('error: --core-insts-output and --operand_kinds_output '
+ 'should be specified together.')
+ exit(1)
+ if (args.glsl_insts_output is None) != \
+ (args.extinst_glsl_grammar is None):
+ print('error: --glsl-insts-output and --extinst-glsl-grammar '
+ 'should be specified together.')
+ exit(1)
+ if (args.opencl_insts_output is None) != \
+ (args.extinst_opencl_grammar is None):
+ print('error: --opencl-insts-output and --extinst-opencl-grammar '
+ 'should be specified together.')
+ exit(1)
+ if all([args.core_insts_output is None,
+ args.glsl_insts_output is None,
+ args.opencl_insts_output is None]):
+ print('error: at least one output should be specified.')
+ exit(1)
+
+ with open(args.spirv_core_grammar) as json_file:
+ grammar = json.loads(json_file.read())
+
+ # Get the dict for the Capability operand kind.
+ cap_dict = [o for o in grammar['operand_kinds']
+ if o['kind'] == 'Capability']
+ assert len(cap_dict) == 1
+ populate_capability_bit_mapping_dict(cap_dict[0])
+
+ if args.core_insts_output is not None:
+ make_path_to_file(args.core_insts_output)
+ make_path_to_file(args.operand_kinds_output)
+ print(generate_instruction_table(grammar['instructions'], False),
+ file=open(args.core_insts_output, 'w'))
+ print(generate_operand_kind_table(grammar['operand_kinds']),
+ file=open(args.operand_kinds_output, 'w'))
+
+ if args.extinst_glsl_grammar is not None:
+ with open(args.extinst_glsl_grammar) as json_file:
+ grammar = json.loads(json_file.read())
+ make_path_to_file(args.glsl_insts_output)
+ print(generate_instruction_table(grammar['instructions'], True),
+ file=open(args.glsl_insts_output, 'w'))
+
+ if args.extinst_opencl_grammar is not None:
+ with open(args.extinst_opencl_grammar) as json_file:
+ grammar = json.loads(json_file.read())
+ make_path_to_file(args.opencl_insts_output)
+ print(generate_instruction_table(grammar['instructions'], True),
+ file=open(args.opencl_insts_output, 'w'))
+
+
+if __name__ == '__main__':
+ main()
