AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-12-01 23:40:04 +00:00
Code Issues Packages Projects Releases Wiki Activity
b029037aaa
SPIRV-Tools/source/opcode.cpp

775 lines
24 KiB
C++
Raw Normal View History

Add OpModuleProcessed to debug opcode (#4694)
2022-02-11 19:24:17 +00:00
// Copyright (c) 2015-2022 The Khronos Group Inc.
Add support for KHR_ray_{query,tracing} extensions (#3235) Update validator for SPV_KHR_ray_tracing. * Added handling for new enum types * Add SpvScopeShaderCallKHR as a valid scope * update spirv-headers Co-authored-by: alelenv <alele@nvidia.com> Co-authored-by: Torosdagli <ntorosda@amd.com> Co-authored-by: Tobias Hector <tobias.hector@amd.com> Co-authored-by: Steven Perron <stevenperron@google.com>
2020-03-17 19:30:19 +00:00
// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights
// reserved.
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
//
Relicense SPIRV-Tools under Apache 2.0 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/383 Finalize v2016.4
2016-09-01 19:33:59 +00:00
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
//
Relicense SPIRV-Tools under Apache 2.0 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/383 Finalize v2016.4
2016-09-01 19:33:59 +00:00
// http://www.apache.org/licenses/LICENSE-2.0
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
//
Relicense SPIRV-Tools under Apache 2.0 Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/383 Finalize v2016.4
2016-09-01 19:33:59 +00:00
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Cleanup includes. (#1795) This Cl cleans up the include paths to be relative to the top level directory. Various include-what-you-use fixes have been added.
2018-08-03 19:06:09 +00:00
#include "source/opcode.h"
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
#include <assert.h>
#include <string.h>
Get vendor tool info from the SPIR-V registry file Update old tests to use officially registered vendor names; this affected "Codeplay".
2016-12-09 19:01:43 +00:00
#include <algorithm>
Use opaque context object to hold SPIR-V info tables. Previously the opcode table is declared as an global array and we have spvOpcodeTableInitialize() modifying it. That can result in race condition. Now spvOpcodeTabelGet() copies the whole underlying array.
2015-11-12 18:48:30 +00:00
#include <cstdlib>
Cleanup includes. (#1795) This Cl cleans up the include paths to be relative to the top level directory. Various include-what-you-use fixes have been added.
2018-08-03 19:06:09 +00:00
#include "source/instruction.h"
#include "source/macro.h"
#include "source/spirv_constant.h"
#include "source/spirv_endian.h"
#include "source/spirv_target_env.h"
Rearrange headers Now we have public headers arranged as follows: $SPIRV_TOOLS_ROOT/include/spirv-tools/libspirv.h $SPIRV_TOOLS_ROOT/include/spirv/spirv.h $SPIRV_TOOLS_ROOT/include/spirv/GLSL.std.450.h $SPIRV_TOOLS_ROOT/include/spirv/OpenCL.std.h A project should use -I$SPIRV_TOOLS_ROOT/include and then #include "spirv-tools/libspirv.h" The headers from the SPIR-V Registry can be accessed as "spirv/spirv." for example. The install target should also install the headers from the SPIR-V Registry. The libspirv.h header is broken otherwise. The SPIRV-Tools library depends on the headers from the SPIR-V Registry. The util/bitutils.h and util/hex_float.h are pulled into the internal source tree. Those are not part of the public API to SPIRV-Tools.
2016-02-17 19:44:00 +00:00
#include "spirv-tools/libspirv.h"
Use quotation for libspirv.h and sort headers.
2015-11-11 17:45:23 +00:00
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
namespace {
Avoid using global static variables Previously we have several grammar tables defined as global static variables and these grammar table entries contains non-POD struct fields (CapabilitySet/ExtensionSet). The initialization of these non-POD struct fields may require calling operator new. If used as a library and the caller defines its own operator new, things can screw up. This pull request changes all global static variables into function static variables, which is lazy evaluated in a thread safe way as guaranteed by C++11.
2017-09-21 21:24:57 +00:00
struct OpcodeDescPtrLen {
const spv_opcode_desc_t* ptr;
uint32_t len;
Add SPIR-V 1.1 grammar. Switch to SPIR-V 1.1 as default. Introduce SPV_ENV_UNIVERSAL_1_1. Add "1_0" to the internal variable names. Add spv_target_env to spv*GetTable().
2016-04-07 18:41:34 +00:00
};
Avoid using global static variables Previously we have several grammar tables defined as global static variables and these grammar table entries contains non-POD struct fields (CapabilitySet/ExtensionSet). The initialization of these non-POD struct fields may require calling operator new. If used as a library and the caller defines its own operator new, things can screw up. This pull request changes all global static variables into function static variables, which is lazy evaluated in a thread safe way as guaranteed by C++11.
2017-09-21 21:24:57 +00:00
Cleanup includes. (#1795) This Cl cleans up the include paths to be relative to the top level directory. Various include-what-you-use fixes have been added.
2018-08-03 19:06:09 +00:00
#include "core.insts-unified1.inc"
Avoid using global static variables Previously we have several grammar tables defined as global static variables and these grammar table entries contains non-POD struct fields (CapabilitySet/ExtensionSet). The initialization of these non-POD struct fields may require calling operator new. If used as a library and the caller defines its own operator new, things can screw up. This pull request changes all global static variables into function static variables, which is lazy evaluated in a thread safe way as guaranteed by C++11.
2017-09-21 21:24:57 +00:00
Migrate to use unified grammar tables Previously we keep a separate static grammar table for opcodes/ operands per SPIR-V version. This commit changes that to use a single unified static grammar table for opcodes/operands. This essentially changes how grammar facts are queried against a certain target environment. There are only limited filtering according to the desired target environment; a symbol is considered as available as long as: 1. The target environment satisfies the minimal requirement of the symbol; or 2. There is at least one extension enabling this symbol. Note that the second rule assumes the extension enabling the symbol is indeed requested in the SPIR-V code; checking that should be the validator's work. Also fixed a few grammar related issues: * Rounding mode capability requirements are moved to client APIs. * Reserved symbols not available in any extension is no longer recognized by assembler.
2018-03-14 17:06:18 +00:00
static const spv_opcode_table_t kOpcodeTable = {ARRAY_SIZE(kOpcodeTableEntries),
kOpcodeTableEntries};
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
Fix various source comment (doxygen) typos (#4680) Found via `codespell -q 3 -L fo,lod,parm
2022-01-26 20:13:08 +00:00
// Represents a vendor tool entry in the SPIR-V XML Registry.
Get vendor tool info from the SPIR-V registry file Update old tests to use officially registered vendor names; this affected "Codeplay".
2016-12-09 19:01:43 +00:00
struct VendorTool {
uint32_t value;
const char* vendor;
Avoid using global static variables Previously we have several grammar tables defined as global static variables and these grammar table entries contains non-POD struct fields (CapabilitySet/ExtensionSet). The initialization of these non-POD struct fields may require calling operator new. If used as a library and the caller defines its own operator new, things can screw up. This pull request changes all global static variables into function static variables, which is lazy evaluated in a thread safe way as guaranteed by C++11.
2017-09-21 21:24:57 +00:00
const char* tool; // Might be empty string.
Fix various source comment (doxygen) typos (#4680) Found via `codespell -q 3 -L fo,lod,parm
2022-01-26 20:13:08 +00:00
const char* vendor_tool; // Combination of vendor and tool.
Get vendor tool info from the SPIR-V registry file Update old tests to use officially registered vendor names; this affected "Codeplay".
2016-12-09 19:01:43 +00:00
};
const VendorTool vendor_tools[] = {
#include "generators.inc"
};
Run clang-format.
2015-09-14 14:05:37 +00:00
} // anonymous namespace
Use opcode operand definitions from SPIR-V specification generator. The assembler and disassembler now use a dynamically adjusted sequence of expected operand types. (Internally, it is a deque, for readability.) Both parsers repeatedly pull an expected operand type from the left of this pattern list, and try to match the next input token against it. The expected pattern is adjusted during the parse to accommodate: - an extended instruction's expected operands, depending on the extended instruction's index. - when an operand itself has operands - to handle sequences of zero or more operands, or pairs of operands. These are expanded lazily during the parse. Adds spv::OperandClass from the SPIR-V specification generator. Modifies spv_operand_desc_t: - adds hasResult, hasType, and operandClass array to the opcode description type. - "wordCount" is replaced with "numTypes", which counts the number of entries in operandTypes. And each of those describes a *logical* operand, including the type id for the instruction, and the result id for the instruction. A logical operand could be variable-width, such as a literal string. Adds opcode.inc, an automatically-generated table of operation descriptions, with one line to describe each core instruction. Externally, we have modified the SPIR-V spec doc generator to emit this file. (We have hacked this copy to use the old semantics for OpLine.) Inside the assembler, parsing an operand may fail with new error code SPV_FAIL_MATCH. For an optional operand, this is not fatal, but should trigger backtracking at a higher level. The spvTextIsStartOfNewInst checks the case of the third letter of what might be an opcode. So now, "OpenCL" does not look like an opcode name. In assembly, the EntryPoint name field is mandatory, but can be an empty string. Adjust tests for changes to: - OpSampedImage - OpTypeSampler
2015-08-27 17:03:52 +00:00
Get vendor tool info from the SPIR-V registry file Update old tests to use officially registered vendor names; this affected "Codeplay".
2016-12-09 19:01:43 +00:00
// TODO(dneto): Move this to another file. It doesn't belong with opcode
// processing.
Run clang-format to enforce Google style globally. Note that we are more strict than Google style for one aspect: pointer/reference indicators are adjacent to their types, not their variables. find . -name "*.h" -exec clang-format -i {} \; find . -name "*.cpp" -exec clang-format -i {} \;
2015-11-02 14:41:20 +00:00
const char* spvGeneratorStr(uint32_t generator) {
Get vendor tool info from the SPIR-V registry file Update old tests to use officially registered vendor names; this affected "Codeplay".
2016-12-09 19:01:43 +00:00
auto where = std::find_if(
std::begin(vendor_tools), std::end(vendor_tools),
[generator](const VendorTool& vt) { return generator == vt.value; });
if (where != std::end(vendor_tools)) return where->vendor_tool;
return "Unknown";
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
uint32_t spvOpcodeMake(uint16_t wordCount, spv::Op opcode) {
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
return ((uint32_t)opcode) | (((uint32_t)wordCount) << 16);
}
Remove dependency on SPIR-V headers in libspirv.h. For fulfilling this purpose, the |opcode| field in the |spv_parsed_instruction_t| struct is changed to of type uint16_t. Also add functions to query the information of a given SPIR-V target environment.
2016-03-31 21:26:31 +00:00
void spvOpcodeSplit(const uint32_t word, uint16_t* pWordCount,
uint16_t* pOpcode) {
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
if (pWordCount) {
*pWordCount = (uint16_t)((0xffff0000 & word) >> 16);
}
if (pOpcode) {
Remove dependency on SPIR-V headers in libspirv.h. For fulfilling this purpose, the |opcode| field in the |spv_parsed_instruction_t| struct is changed to of type uint16_t. Also add functions to query the information of a given SPIR-V target environment.
2016-03-31 21:26:31 +00:00
*pOpcode = 0x0000ffff & word;
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
}
Migrate to use unified grammar tables Previously we keep a separate static grammar table for opcodes/ operands per SPIR-V version. This commit changes that to use a single unified static grammar table for opcodes/operands. This essentially changes how grammar facts are queried against a certain target environment. There are only limited filtering according to the desired target environment; a symbol is considered as available as long as: 1. The target environment satisfies the minimal requirement of the symbol; or 2. There is at least one extension enabling this symbol. Note that the second rule assumes the extension enabling the symbol is indeed requested in the SPIR-V code; checking that should be the validator's work. Also fixed a few grammar related issues: * Rounding mode capability requirements are moved to client APIs. * Reserved symbols not available in any extension is no longer recognized by assembler.
2018-03-14 17:06:18 +00:00
spv_result_t spvOpcodeTableGet(spv_opcode_table* pInstTable, spv_target_env) {
Limit the use of spvCheck and spvCheckReturn to validator. spvCheck is indeed just an if-statement. Defining such a macro doesn't help much.
2015-09-11 18:31:27 +00:00
if (!pInstTable) return SPV_ERROR_INVALID_POINTER;
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Avoid using global static variables Previously we have several grammar tables defined as global static variables and these grammar table entries contains non-POD struct fields (CapabilitySet/ExtensionSet). The initialization of these non-POD struct fields may require calling operator new. If used as a library and the caller defines its own operator new, things can screw up. This pull request changes all global static variables into function static variables, which is lazy evaluated in a thread safe way as guaranteed by C++11.
2017-09-21 21:24:57 +00:00
// Descriptions of each opcode. Each entry describes the format of the
// instruction that follows a particular opcode.
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Migrate to use unified grammar tables Previously we keep a separate static grammar table for opcodes/ operands per SPIR-V version. This commit changes that to use a single unified static grammar table for opcodes/operands. This essentially changes how grammar facts are queried against a certain target environment. There are only limited filtering according to the desired target environment; a symbol is considered as available as long as: 1. The target environment satisfies the minimal requirement of the symbol; or 2. There is at least one extension enabling this symbol. Note that the second rule assumes the extension enabling the symbol is indeed requested in the SPIR-V code; checking that should be the validator's work. Also fixed a few grammar related issues: * Rounding mode capability requirements are moved to client APIs. * Reserved symbols not available in any extension is no longer recognized by assembler.
2018-03-14 17:06:18 +00:00
*pInstTable = &kOpcodeTable;
return SPV_SUCCESS;
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Migrate to use unified grammar tables Previously we keep a separate static grammar table for opcodes/ operands per SPIR-V version. This commit changes that to use a single unified static grammar table for opcodes/operands. This essentially changes how grammar facts are queried against a certain target environment. There are only limited filtering according to the desired target environment; a symbol is considered as available as long as: 1. The target environment satisfies the minimal requirement of the symbol; or 2. There is at least one extension enabling this symbol. Note that the second rule assumes the extension enabling the symbol is indeed requested in the SPIR-V code; checking that should be the validator's work. Also fixed a few grammar related issues: * Rounding mode capability requirements are moved to client APIs. * Reserved symbols not available in any extension is no longer recognized by assembler.
2018-03-14 17:06:18 +00:00
spv_result_t spvOpcodeTableNameLookup(spv_target_env env,
const spv_opcode_table table,
Run clang-format to enforce Google style globally. Note that we are more strict than Google style for one aspect: pointer/reference indicators are adjacent to their types, not their variables. find . -name "*.h" -exec clang-format -i {} \; find . -name "*.cpp" -exec clang-format -i {} \;
2015-11-02 14:41:20 +00:00
const char* name,
spv_opcode_desc* pEntry) {
Limit the use of spvCheck and spvCheckReturn to validator. spvCheck is indeed just an if-statement. Defining such a macro doesn't help much.
2015-09-11 18:31:27 +00:00
if (!name || !pEntry) return SPV_ERROR_INVALID_POINTER;
if (!table) return SPV_ERROR_INVALID_TABLE;
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
// TODO: This lookup of the Opcode table is suboptimal! Binary sort would be
// preferable but the table requires sorting on the Opcode name, but it's
Migrate to use unified grammar tables Previously we keep a separate static grammar table for opcodes/ operands per SPIR-V version. This commit changes that to use a single unified static grammar table for opcodes/operands. This essentially changes how grammar facts are queried against a certain target environment. There are only limited filtering according to the desired target environment; a symbol is considered as available as long as: 1. The target environment satisfies the minimal requirement of the symbol; or 2. There is at least one extension enabling this symbol. Note that the second rule assumes the extension enabling the symbol is indeed requested in the SPIR-V code; checking that should be the validator's work. Also fixed a few grammar related issues: * Rounding mode capability requirements are moved to client APIs. * Reserved symbols not available in any extension is no longer recognized by assembler.
2018-03-14 17:06:18 +00:00
// static const initialized and matches the order of the spec.
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
const size_t nameLength = strlen(name);
Use last version (#2578) * Use grammar last version Fixes #2560 * Parse last version and use it in checks * Update grammar header generation * Fix NonWritable tests * Fix check and add specific tests
2019-05-10 15:02:01 +00:00
const auto version = spvVersionForTargetEnv(env);
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
for (uint64_t opcodeIndex = 0; opcodeIndex < table->count; ++opcodeIndex) {
Migrate to use unified grammar tables Previously we keep a separate static grammar table for opcodes/ operands per SPIR-V version. This commit changes that to use a single unified static grammar table for opcodes/operands. This essentially changes how grammar facts are queried against a certain target environment. There are only limited filtering according to the desired target environment; a symbol is considered as available as long as: 1. The target environment satisfies the minimal requirement of the symbol; or 2. There is at least one extension enabling this symbol. Note that the second rule assumes the extension enabling the symbol is indeed requested in the SPIR-V code; checking that should be the validator's work. Also fixed a few grammar related issues: * Rounding mode capability requirements are moved to client APIs. * Reserved symbols not available in any extension is no longer recognized by assembler.
2018-03-14 17:06:18 +00:00
const spv_opcode_desc_t& entry = table->entries[opcodeIndex];
// We considers the current opcode as available as long as
// 1. The target environment satisfies the minimal requirement of the
// opcode; or
// 2. There is at least one extension enabling this opcode.
//
// Note that the second rule assumes the extension enabling this instruction
// is indeed requested in the SPIR-V code; checking that should be
// validator's work.
Use last version (#2578) * Use grammar last version Fixes #2560 * Parse last version and use it in checks * Update grammar header generation * Fix NonWritable tests * Fix check and add specific tests
2019-05-10 15:02:01 +00:00
if (((version >= entry.minVersion && version <= entry.lastVersion) ||
Instruction lookup succeeds if it's enabled by a capability Also add a corresponding check for capabilities in the validator. Update previously existing test cases where an instruction used to fail assembling because of a version check, but now they succeed because the instruction is also guarded by a capability. Now it should assemble. Add tests to ensure that capabilities are checked appropriately. The explicitly reserved instructions OpImageSparseSampleProj* now assemble, but they fail validation. Fixes #1624
2018-06-19 13:54:33 +00:00
entry.numExtensions > 0u || entry.numCapabilities > 0u) &&
Migrate to use unified grammar tables Previously we keep a separate static grammar table for opcodes/ operands per SPIR-V version. This commit changes that to use a single unified static grammar table for opcodes/operands. This essentially changes how grammar facts are queried against a certain target environment. There are only limited filtering according to the desired target environment; a symbol is considered as available as long as: 1. The target environment satisfies the minimal requirement of the symbol; or 2. There is at least one extension enabling this symbol. Note that the second rule assumes the extension enabling the symbol is indeed requested in the SPIR-V code; checking that should be the validator's work. Also fixed a few grammar related issues: * Rounding mode capability requirements are moved to client APIs. * Reserved symbols not available in any extension is no longer recognized by assembler.
2018-03-14 17:06:18 +00:00
nameLength == strlen(entry.name) &&
!strncmp(name, entry.name, nameLength)) {
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
// NOTE: Found out Opcode!
Migrate to use unified grammar tables Previously we keep a separate static grammar table for opcodes/ operands per SPIR-V version. This commit changes that to use a single unified static grammar table for opcodes/operands. This essentially changes how grammar facts are queried against a certain target environment. There are only limited filtering according to the desired target environment; a symbol is considered as available as long as: 1. The target environment satisfies the minimal requirement of the symbol; or 2. There is at least one extension enabling this symbol. Note that the second rule assumes the extension enabling the symbol is indeed requested in the SPIR-V code; checking that should be the validator's work. Also fixed a few grammar related issues: * Rounding mode capability requirements are moved to client APIs. * Reserved symbols not available in any extension is no longer recognized by assembler.
2018-03-14 17:06:18 +00:00
*pEntry = &entry;
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
return SPV_SUCCESS;
}
}
return SPV_ERROR_INVALID_LOOKUP;
}
Migrate to use unified grammar tables Previously we keep a separate static grammar table for opcodes/ operands per SPIR-V version. This commit changes that to use a single unified static grammar table for opcodes/operands. This essentially changes how grammar facts are queried against a certain target environment. There are only limited filtering according to the desired target environment; a symbol is considered as available as long as: 1. The target environment satisfies the minimal requirement of the symbol; or 2. There is at least one extension enabling this symbol. Note that the second rule assumes the extension enabling the symbol is indeed requested in the SPIR-V code; checking that should be the validator's work. Also fixed a few grammar related issues: * Rounding mode capability requirements are moved to client APIs. * Reserved symbols not available in any extension is no longer recognized by assembler.
2018-03-14 17:06:18 +00:00
spv_result_t spvOpcodeTableValueLookup(spv_target_env env,
const spv_opcode_table table,
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
const spv::Op opcode,
Run clang-format to enforce Google style globally. Note that we are more strict than Google style for one aspect: pointer/reference indicators are adjacent to their types, not their variables. find . -name "*.h" -exec clang-format -i {} \; find . -name "*.cpp" -exec clang-format -i {} \;
2015-11-02 14:41:20 +00:00
spv_opcode_desc* pEntry) {
Limit the use of spvCheck and spvCheckReturn to validator. spvCheck is indeed just an if-statement. Defining such a macro doesn't help much.
2015-09-11 18:31:27 +00:00
if (!table) return SPV_ERROR_INVALID_TABLE;
if (!pEntry) return SPV_ERROR_INVALID_POINTER;
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
Use std::lower_bound for opcode lookup Use std::lower_bound for opcode-to-string Stable sort the generated instruction table.
2017-10-27 12:28:50 +00:00
const auto beg = table->entries;
const auto end = table->entries + table->count;
Migrate to use unified grammar tables Previously we keep a separate static grammar table for opcodes/ operands per SPIR-V version. This commit changes that to use a single unified static grammar table for opcodes/operands. This essentially changes how grammar facts are queried against a certain target environment. There are only limited filtering according to the desired target environment; a symbol is considered as available as long as: 1. The target environment satisfies the minimal requirement of the symbol; or 2. There is at least one extension enabling this symbol. Note that the second rule assumes the extension enabling the symbol is indeed requested in the SPIR-V code; checking that should be the validator's work. Also fixed a few grammar related issues: * Rounding mode capability requirements are moved to client APIs. * Reserved symbols not available in any extension is no longer recognized by assembler.
2018-03-14 17:06:18 +00:00
Use last version (#2578) * Use grammar last version Fixes #2560 * Parse last version and use it in checks * Update grammar header generation * Fix NonWritable tests * Fix check and add specific tests
2019-05-10 15:02:01 +00:00
spv_opcode_desc_t needle = {"", opcode, 0, nullptr, 0, {},
false, false, 0, nullptr, ~0u, ~0u};
Migrate to use unified grammar tables Previously we keep a separate static grammar table for opcodes/ operands per SPIR-V version. This commit changes that to use a single unified static grammar table for opcodes/operands. This essentially changes how grammar facts are queried against a certain target environment. There are only limited filtering according to the desired target environment; a symbol is considered as available as long as: 1. The target environment satisfies the minimal requirement of the symbol; or 2. There is at least one extension enabling this symbol. Note that the second rule assumes the extension enabling the symbol is indeed requested in the SPIR-V code; checking that should be the validator's work. Also fixed a few grammar related issues: * Rounding mode capability requirements are moved to client APIs. * Reserved symbols not available in any extension is no longer recognized by assembler.
2018-03-14 17:06:18 +00:00
Use std::lower_bound for opcode lookup Use std::lower_bound for opcode-to-string Stable sort the generated instruction table.
2017-10-27 12:28:50 +00:00
auto comp = [](const spv_opcode_desc_t& lhs, const spv_opcode_desc_t& rhs) {
return lhs.opcode < rhs.opcode;
};
Migrate to use unified grammar tables Previously we keep a separate static grammar table for opcodes/ operands per SPIR-V version. This commit changes that to use a single unified static grammar table for opcodes/operands. This essentially changes how grammar facts are queried against a certain target environment. There are only limited filtering according to the desired target environment; a symbol is considered as available as long as: 1. The target environment satisfies the minimal requirement of the symbol; or 2. There is at least one extension enabling this symbol. Note that the second rule assumes the extension enabling the symbol is indeed requested in the SPIR-V code; checking that should be the validator's work. Also fixed a few grammar related issues: * Rounding mode capability requirements are moved to client APIs. * Reserved symbols not available in any extension is no longer recognized by assembler.
2018-03-14 17:06:18 +00:00
// We need to loop here because there can exist multiple symbols for the same
// opcode value, and they can be introduced in different target environments,
// which means they can have different minimal version requirements.
// Assumes the underlying table is already sorted ascendingly according to
// opcode value.
Use last version (#2578) * Use grammar last version Fixes #2560 * Parse last version and use it in checks * Update grammar header generation * Fix NonWritable tests * Fix check and add specific tests
2019-05-10 15:02:01 +00:00
const auto version = spvVersionForTargetEnv(env);
Migrate to use unified grammar tables Previously we keep a separate static grammar table for opcodes/ operands per SPIR-V version. This commit changes that to use a single unified static grammar table for opcodes/operands. This essentially changes how grammar facts are queried against a certain target environment. There are only limited filtering according to the desired target environment; a symbol is considered as available as long as: 1. The target environment satisfies the minimal requirement of the symbol; or 2. There is at least one extension enabling this symbol. Note that the second rule assumes the extension enabling the symbol is indeed requested in the SPIR-V code; checking that should be the validator's work. Also fixed a few grammar related issues: * Rounding mode capability requirements are moved to client APIs. * Reserved symbols not available in any extension is no longer recognized by assembler.
2018-03-14 17:06:18 +00:00
for (auto it = std::lower_bound(beg, end, needle, comp);
it != end && it->opcode == opcode; ++it) {
// We considers the current opcode as available as long as
// 1. The target environment satisfies the minimal requirement of the
// opcode; or
// 2. There is at least one extension enabling this opcode.
//
// Note that the second rule assumes the extension enabling this instruction
// is indeed requested in the SPIR-V code; checking that should be
// validator's work.
Use last version (#2578) * Use grammar last version Fixes #2560 * Parse last version and use it in checks * Update grammar header generation * Fix NonWritable tests * Fix check and add specific tests
2019-05-10 15:02:01 +00:00
if ((version >= it->minVersion && version <= it->lastVersion) ||
Instruction lookup succeeds if it's enabled by a capability Also add a corresponding check for capabilities in the validator. Update previously existing test cases where an instruction used to fail assembling because of a version check, but now they succeed because the instruction is also guarded by a capability. Now it should assemble. Add tests to ensure that capabilities are checked appropriately. The explicitly reserved instructions OpImageSparseSampleProj* now assemble, but they fail validation. Fixes #1624
2018-06-19 13:54:33 +00:00
it->numExtensions > 0u || it->numCapabilities > 0u) {
Migrate to use unified grammar tables Previously we keep a separate static grammar table for opcodes/ operands per SPIR-V version. This commit changes that to use a single unified static grammar table for opcodes/operands. This essentially changes how grammar facts are queried against a certain target environment. There are only limited filtering according to the desired target environment; a symbol is considered as available as long as: 1. The target environment satisfies the minimal requirement of the symbol; or 2. There is at least one extension enabling this symbol. Note that the second rule assumes the extension enabling the symbol is indeed requested in the SPIR-V code; checking that should be the validator's work. Also fixed a few grammar related issues: * Rounding mode capability requirements are moved to client APIs. * Reserved symbols not available in any extension is no longer recognized by assembler.
2018-03-14 17:06:18 +00:00
*pEntry = it;
return SPV_SUCCESS;
}
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
return SPV_ERROR_INVALID_LOOKUP;
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
void spvInstructionCopy(const uint32_t* words, const spv::Op opcode,
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
const uint16_t wordCount, const spv_endianness_t endian,
Run clang-format to enforce Google style globally. Note that we are more strict than Google style for one aspect: pointer/reference indicators are adjacent to their types, not their variables. find . -name "*.h" -exec clang-format -i {} \; find . -name "*.cpp" -exec clang-format -i {} \;
2015-11-02 14:41:20 +00:00
spv_instruction_t* pInst) {
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
pInst->opcode = opcode;
Support strings with up to 65535 chars, and null. Move the definition of spv_instruction_t to an internal header file, since it now depends on C++ and is not used by the external interface. Use a std::vector<uint32_t> in spv_instruction_t instead of a fixed size array.
2015-10-06 20:22:00 +00:00
pInst->words.resize(wordCount);
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
for (uint16_t wordIndex = 0; wordIndex < wordCount; ++wordIndex) {
pInst->words[wordIndex] = spvFixWord(words[wordIndex], endian);
if (!wordIndex) {
uint16_t thisWordCount;
Remove dependency on SPIR-V headers in libspirv.h. For fulfilling this purpose, the |opcode| field in the |spv_parsed_instruction_t| struct is changed to of type uint16_t. Also add functions to query the information of a given SPIR-V target environment.
2016-03-31 21:26:31 +00:00
uint16_t thisOpcode;
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
spvOpcodeSplit(pInst->words[wordIndex], &thisWordCount, &thisOpcode);
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
assert(opcode == static_cast<spv::Op>(thisOpcode) &&
Remove dependency on SPIR-V headers in libspirv.h. For fulfilling this purpose, the |opcode| field in the |spv_parsed_instruction_t| struct is changed to of type uint16_t. Also add functions to query the information of a given SPIR-V target environment.
2016-03-31 21:26:31 +00:00
wordCount == thisWordCount && "Endianness failed!");
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
}
}
Make spvOpcodeString part of the public API (#3174) Fixes #3138
2020-02-20 19:07:57 +00:00
const char* spvOpcodeString(const uint32_t opcode) {
Migrate to use unified grammar tables Previously we keep a separate static grammar table for opcodes/ operands per SPIR-V version. This commit changes that to use a single unified static grammar table for opcodes/operands. This essentially changes how grammar facts are queried against a certain target environment. There are only limited filtering according to the desired target environment; a symbol is considered as available as long as: 1. The target environment satisfies the minimal requirement of the symbol; or 2. There is at least one extension enabling this symbol. Note that the second rule assumes the extension enabling the symbol is indeed requested in the SPIR-V code; checking that should be the validator's work. Also fixed a few grammar related issues: * Rounding mode capability requirements are moved to client APIs. * Reserved symbols not available in any extension is no longer recognized by assembler.
2018-03-14 17:06:18 +00:00
const auto beg = kOpcodeTableEntries;
const auto end = kOpcodeTableEntries + ARRAY_SIZE(kOpcodeTableEntries);
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
spv_opcode_desc_t needle = {"", static_cast<spv::Op>(opcode),
Make spvOpcodeString part of the public API (#3174) Fixes #3138
2020-02-20 19:07:57 +00:00
0, nullptr,
0, {},
false, false,
0, nullptr,
~0u, ~0u};
Use std::lower_bound for opcode lookup Use std::lower_bound for opcode-to-string Stable sort the generated instruction table.
2017-10-27 12:28:50 +00:00
auto comp = [](const spv_opcode_desc_t& lhs, const spv_opcode_desc_t& rhs) {
return lhs.opcode < rhs.opcode;
};
Migrate to use unified grammar tables Previously we keep a separate static grammar table for opcodes/ operands per SPIR-V version. This commit changes that to use a single unified static grammar table for opcodes/operands. This essentially changes how grammar facts are queried against a certain target environment. There are only limited filtering according to the desired target environment; a symbol is considered as available as long as: 1. The target environment satisfies the minimal requirement of the symbol; or 2. There is at least one extension enabling this symbol. Note that the second rule assumes the extension enabling the symbol is indeed requested in the SPIR-V code; checking that should be the validator's work. Also fixed a few grammar related issues: * Rounding mode capability requirements are moved to client APIs. * Reserved symbols not available in any extension is no longer recognized by assembler.
2018-03-14 17:06:18 +00:00
auto it = std::lower_bound(beg, end, needle, comp);
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
if (it != end && it->opcode == spv::Op(opcode)) {
Use std::lower_bound for opcode lookup Use std::lower_bound for opcode-to-string Stable sort the generated instruction table.
2017-10-27 12:28:50 +00:00
return it->name;
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
}
Avoid using global static variables Previously we have several grammar tables defined as global static variables and these grammar table entries contains non-POD struct fields (CapabilitySet/ExtensionSet). The initialization of these non-POD struct fields may require calling operator new. If used as a library and the caller defines its own operator new, things can screw up. This pull request changes all global static variables into function static variables, which is lazy evaluated in a thread safe way as guaranteed by C++11.
2017-09-21 21:24:57 +00:00
Use the JSON grammar file to generate various info tables. This patch uses a Python script to parse the JSON grammar file to generate the opcode table and operand kind tables. Now we don't need to do the post-processing (from OperandClass to spv_operand_type_t) and copying of the opcode info table is not required anymore!
2016-03-21 20:36:14 +00:00
assert(0 && "Unreachable!");
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
return "unknown";
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
const char* spvOpcodeString(const spv::Op opcode) {
return spvOpcodeString(static_cast<uint32_t>(opcode));
}
int32_t spvOpcodeIsScalarType(const spv::Op opcode) {
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpTypeInt:
case spv::Op::OpTypeFloat:
case spv::Op::OpTypeBool:
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
return true;
default:
return false;
}
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
int32_t spvOpcodeIsSpecConstant(const spv::Op opcode) {
Fixes #1403. Don't validate composite insert, extract and construct instructions against spec constant sized arrays. * Added predicate for spec constant opcodes * Added tests
2018-03-23 18:18:54 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpSpecConstantTrue:
case spv::Op::OpSpecConstantFalse:
case spv::Op::OpSpecConstant:
case spv::Op::OpSpecConstantComposite:
case spv::Op::OpSpecConstantOp:
Fixes #1403. Don't validate composite insert, extract and construct instructions against spec constant sized arrays. * Added predicate for spec constant opcodes * Added tests
2018-03-23 18:18:54 +00:00
return true;
default:
return false;
}
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
int32_t spvOpcodeIsConstant(const spv::Op opcode) {
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpConstantTrue:
case spv::Op::OpConstantFalse:
case spv::Op::OpConstant:
case spv::Op::OpConstantComposite:
case spv::Op::OpConstantSampler:
case spv::Op::OpConstantNull:
Remove duplicate lists of constant and type opcodes (#5106) Adding a new type instruction required making the same change in two places. Also remove IsCompileTimeConstantInst that was used in a single place and replace its use by an expression that better conveys the intent. Change-Id: I49330b74bd34a35db6369c438c053224805c18e0 Signed-off-by: Kevin Petit <kevin.petit@arm.com>
2023-02-15 20:09:55 +00:00
case spv::Op::OpConstantFunctionPointerINTEL:
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpSpecConstantTrue:
case spv::Op::OpSpecConstantFalse:
case spv::Op::OpSpecConstant:
case spv::Op::OpSpecConstantComposite:
case spv::Op::OpSpecConstantOp:
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
return true;
default:
return false;
}
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsConstantOrUndef(const spv::Op opcode) {
return opcode == spv::Op::OpUndef || spvOpcodeIsConstant(opcode);
Fix validator: OpUndef can be member of a constant composite This was enabled in SPIR-V 1.0 Rev 7 Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/414
2016-09-14 15:57:20 +00:00
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsScalarSpecConstant(const spv::Op opcode) {
Validate that SpecId decoration target is a OpSpecConstant instruction on a scalar Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/275
2017-02-25 01:43:28 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpSpecConstantTrue:
case spv::Op::OpSpecConstantFalse:
case spv::Op::OpSpecConstant:
Validate that SpecId decoration target is a OpSpecConstant instruction on a scalar Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/275
2017-02-25 01:43:28 +00:00
return true;
default:
return false;
}
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
int32_t spvOpcodeIsComposite(const spv::Op opcode) {
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpTypeVector:
case spv::Op::OpTypeMatrix:
case spv::Op::OpTypeArray:
case spv::Op::OpTypeStruct:
case spv::Op::OpTypeCooperativeMatrixNV:
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
return true;
default:
return false;
}
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeReturnsLogicalVariablePointer(const spv::Op opcode) {
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpVariable:
case spv::Op::OpAccessChain:
case spv::Op::OpInBoundsAccessChain:
case spv::Op::OpFunctionParameter:
case spv::Op::OpImageTexelPointer:
case spv::Op::OpCopyObject:
case spv::Op::OpSelect:
case spv::Op::OpPhi:
case spv::Op::OpFunctionCall:
case spv::Op::OpPtrAccessChain:
case spv::Op::OpLoad:
case spv::Op::OpConstantNull:
Validator support for Variable Pointer extension. If the variable_pointer extension is used: * OpLoad's pointer argument may be the result of any of the following: * OpSelect * OpPhi * OpFunctionCall * OpPtrAccessChain * OpCopyObject * OpLoad * OpConstantNull * Return value of a function may be a pointer. * It is valid to use a pointer as the return value of a function. * OpStore should allow a variable pointer argument.
2017-02-01 20:37:39 +00:00
return true;
default:
return false;
}
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
int32_t spvOpcodeReturnsLogicalPointer(const spv::Op opcode) {
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpVariable:
case spv::Op::OpAccessChain:
case spv::Op::OpInBoundsAccessChain:
case spv::Op::OpFunctionParameter:
case spv::Op::OpImageTexelPointer:
case spv::Op::OpCopyObject:
Code drop of the Codeplay spirv-tools source. This commit contains the source for the SPIRV static library, spirv-as, spirv-dis, and spirv-val tools.
2015-05-22 17:26:19 +00:00
return true;
default:
return false;
}
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
int32_t spvOpcodeGeneratesType(spv::Op op) {
Run clang-format to enforce Google style globally. Note that we are more strict than Google style for one aspect: pointer/reference indicators are adjacent to their types, not their variables. find . -name "*.h" -exec clang-format -i {} \; find . -name "*.cpp" -exec clang-format -i {} \;
2015-11-02 14:41:20 +00:00
switch (op) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpTypeVoid:
case spv::Op::OpTypeBool:
case spv::Op::OpTypeInt:
case spv::Op::OpTypeFloat:
case spv::Op::OpTypeVector:
case spv::Op::OpTypeMatrix:
case spv::Op::OpTypeImage:
case spv::Op::OpTypeSampler:
case spv::Op::OpTypeSampledImage:
case spv::Op::OpTypeArray:
case spv::Op::OpTypeRuntimeArray:
case spv::Op::OpTypeStruct:
case spv::Op::OpTypeOpaque:
case spv::Op::OpTypePointer:
case spv::Op::OpTypeFunction:
case spv::Op::OpTypeEvent:
case spv::Op::OpTypeDeviceEvent:
case spv::Op::OpTypeReserveId:
case spv::Op::OpTypeQueue:
case spv::Op::OpTypePipe:
case spv::Op::OpTypePipeStorage:
case spv::Op::OpTypeNamedBarrier:
case spv::Op::OpTypeAccelerationStructureNV:
case spv::Op::OpTypeCooperativeMatrixNV:
// case spv::Op::OpTypeAccelerationStructureKHR: covered by
// spv::Op::OpTypeAccelerationStructureNV
case spv::Op::OpTypeRayQueryKHR:
Add validation support for SPV_NV_shader_invocation_reorder. (#4979) Co-authored-by: Pankaj Mistry <pmistry@nvidia.com>
2022-11-24 14:50:45 +00:00
case spv::Op::OpTypeHitObjectNV:
Added tracking to types and validated certain instructions. We need to know how to generate correct SPIRV for cases like OpConstant %int64 42 since the current parser will encode the 42 as a 32-bit value incorrectly. This change is the first of a pair. This one tracks types, and makes sure that OpConstant and OpSpecConstant are only ever called with Integer or Float types, and OpSwitch is only called with integer generating values.
2015-09-29 15:28:34 +00:00
return true;
Consolidate: spvOpcodeIsType into spvOpcodeGeneratesType And fix the spvOpcodeGeneratesType: OpTypeForwardPointer does not generate a new type.
2015-11-02 19:59:02 +00:00
default:
// In particular, OpTypeForwardPointer does not generate a type,
// but declares a storage class for a pointer type generated
// by a different instruction.
break;
Added tracking to types and validated certain instructions. We need to know how to generate correct SPIRV for cases like OpConstant %int64 42 since the current parser will encode the 42 as a 32-bit value incorrectly. This change is the first of a pair. This one tracks types, and makes sure that OpConstant and OpSpecConstant are only ever called with Integer or Float types, and OpSwitch is only called with integer generating values.
2015-09-29 15:28:34 +00:00
}
return 0;
}
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsDecoration(const spv::Op opcode) {
Create a local value numbering pass Creates a pass that removes redundant instructions within the same basic block. This will be implemented using a hash based value numbering algorithm. Added a number of functions that check for the Vulkan descriptor types. These are used to determine if we are variables are read-only or not. Implemented a function to check if loads and variables are read-only. Implemented kernel specific and shader specific versions. A big change is that the Combinator analysis in ADCE is factored out into the IRContext as an analysis. This was done because it is being reused in the value number table.
2017-11-11 01:26:55 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpDecorate:
case spv::Op::OpDecorateId:
case spv::Op::OpMemberDecorate:
case spv::Op::OpGroupDecorate:
case spv::Op::OpGroupMemberDecorate:
case spv::Op::OpDecorateStringGOOGLE:
case spv::Op::OpMemberDecorateStringGOOGLE:
Add the decoration manager to the IRContext. To make the decoration manger available everywhere, and to reduce the number of times it needs to be build, I add one the IRContext. As the same time, I move code that modifies decoration instruction into the IRContext from mempass and the decoration manager. This will make it easier to keep everything up to date. This should take care of issue #928.
2017-11-13 20:31:43 +00:00
return true;
default:
break;
}
return false;
}
Create a local value numbering pass Creates a pass that removes redundant instructions within the same basic block. This will be implemented using a hash based value numbering algorithm. Added a number of functions that check for the Vulkan descriptor types. These are used to determine if we are variables are read-only or not. Implemented a function to check if loads and variables are read-only. Implemented kernel specific and shader specific versions. A big change is that the Combinator analysis in ADCE is factored out into the IRContext as an analysis. This was done because it is being reused in the value number table.
2017-11-11 01:26:55 +00:00
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsLoad(const spv::Op opcode) {
Create a local value numbering pass Creates a pass that removes redundant instructions within the same basic block. This will be implemented using a hash based value numbering algorithm. Added a number of functions that check for the Vulkan descriptor types. These are used to determine if we are variables are read-only or not. Implemented a function to check if loads and variables are read-only. Implemented kernel specific and shader specific versions. A big change is that the Combinator analysis in ADCE is factored out into the IRContext as an analysis. This was done because it is being reused in the value number table.
2017-11-11 01:26:55 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpLoad:
case spv::Op::OpImageSampleExplicitLod:
case spv::Op::OpImageSampleImplicitLod:
case spv::Op::OpImageSampleDrefImplicitLod:
case spv::Op::OpImageSampleDrefExplicitLod:
case spv::Op::OpImageSampleProjImplicitLod:
case spv::Op::OpImageSampleProjExplicitLod:
case spv::Op::OpImageSampleProjDrefImplicitLod:
case spv::Op::OpImageSampleProjDrefExplicitLod:
case spv::Op::OpImageFetch:
case spv::Op::OpImageGather:
case spv::Op::OpImageDrefGather:
case spv::Op::OpImageRead:
case spv::Op::OpImageSparseSampleImplicitLod:
case spv::Op::OpImageSparseSampleExplicitLod:
case spv::Op::OpImageSparseSampleDrefExplicitLod:
case spv::Op::OpImageSparseSampleDrefImplicitLod:
case spv::Op::OpImageSparseFetch:
case spv::Op::OpImageSparseGather:
case spv::Op::OpImageSparseDrefGather:
case spv::Op::OpImageSparseRead:
Create a local value numbering pass Creates a pass that removes redundant instructions within the same basic block. This will be implemented using a hash based value numbering algorithm. Added a number of functions that check for the Vulkan descriptor types. These are used to determine if we are variables are read-only or not. Implemented a function to check if loads and variables are read-only. Implemented kernel specific and shader specific versions. A big change is that the Combinator analysis in ADCE is factored out into the IRContext as an analysis. This was done because it is being reused in the value number table.
2017-11-11 01:26:55 +00:00
return true;
default:
return false;
}
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsBranch(spv::Op opcode) {
Generic value propagation engine. This class implements a generic value propagation algorithm based on the conditional constant propagation algorithm proposed in Constant propagation with conditional branches, Wegman and Zadeck, ACM TOPLAS 13(2):181-210. The implementation is based on A Propagation Engine for GCC Diego Novillo, GCC Summit 2005 http://ols.fedoraproject.org/GCC/Reprints-2005/novillo-Reprint.pdf The purpose of this implementation is to act as a common framework for any transformation that needs to propagate values from statements producing new values to statements using those values.
2017-11-17 13:59:25 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpBranch:
case spv::Op::OpBranchConditional:
case spv::Op::OpSwitch:
Generic value propagation engine. This class implements a generic value propagation algorithm based on the conditional constant propagation algorithm proposed in Constant propagation with conditional branches, Wegman and Zadeck, ACM TOPLAS 13(2):181-210. The implementation is based on A Propagation Engine for GCC Diego Novillo, GCC Summit 2005 http://ols.fedoraproject.org/GCC/Reprints-2005/novillo-Reprint.pdf The purpose of this implementation is to act as a common framework for any transformation that needs to propagate values from statements producing new values to statements using those values.
2017-11-17 13:59:25 +00:00
return true;
default:
return false;
}
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsAtomicWithLoad(const spv::Op opcode) {
Create a local value numbering pass Creates a pass that removes redundant instructions within the same basic block. This will be implemented using a hash based value numbering algorithm. Added a number of functions that check for the Vulkan descriptor types. These are used to determine if we are variables are read-only or not. Implemented a function to check if loads and variables are read-only. Implemented kernel specific and shader specific versions. A big change is that the Combinator analysis in ADCE is factored out into the IRContext as an analysis. This was done because it is being reused in the value number table.
2017-11-11 01:26:55 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpAtomicLoad:
case spv::Op::OpAtomicExchange:
case spv::Op::OpAtomicCompareExchange:
case spv::Op::OpAtomicCompareExchangeWeak:
case spv::Op::OpAtomicIIncrement:
case spv::Op::OpAtomicIDecrement:
case spv::Op::OpAtomicIAdd:
case spv::Op::OpAtomicFAddEXT:
case spv::Op::OpAtomicISub:
case spv::Op::OpAtomicSMin:
case spv::Op::OpAtomicUMin:
case spv::Op::OpAtomicFMinEXT:
case spv::Op::OpAtomicSMax:
case spv::Op::OpAtomicUMax:
case spv::Op::OpAtomicFMaxEXT:
case spv::Op::OpAtomicAnd:
case spv::Op::OpAtomicOr:
case spv::Op::OpAtomicXor:
case spv::Op::OpAtomicFlagTestAndSet:
Create a local value numbering pass Creates a pass that removes redundant instructions within the same basic block. This will be implemented using a hash based value numbering algorithm. Added a number of functions that check for the Vulkan descriptor types. These are used to determine if we are variables are read-only or not. Implemented a function to check if loads and variables are read-only. Implemented kernel specific and shader specific versions. A big change is that the Combinator analysis in ADCE is factored out into the IRContext as an analysis. This was done because it is being reused in the value number table.
2017-11-11 01:26:55 +00:00
return true;
default:
return false;
}
}
Generic value propagation engine. This class implements a generic value propagation algorithm based on the conditional constant propagation algorithm proposed in Constant propagation with conditional branches, Wegman and Zadeck, ACM TOPLAS 13(2):181-210. The implementation is based on A Propagation Engine for GCC Diego Novillo, GCC Summit 2005 http://ols.fedoraproject.org/GCC/Reprints-2005/novillo-Reprint.pdf The purpose of this implementation is to act as a common framework for any transformation that needs to propagate values from statements producing new values to statements using those values.
2017-11-17 13:59:25 +00:00
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsAtomicOp(const spv::Op opcode) {
return (spvOpcodeIsAtomicWithLoad(opcode) ||
opcode == spv::Op::OpAtomicStore ||
opcode == spv::Op::OpAtomicFlagClear);
Consider atomics that load when analyzing live stores in ADCE (#1956) (#1958) Consider atomics that load when analyzing live stores in ADCE. Previously it asserted that the base of an OpImageTexelPointer should be an image. It is actually a pointer to an image, so IsValidBasePointer should suffice.
2018-10-12 12:46:35 +00:00
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsReturn(spv::Op opcode) {
Generic value propagation engine. This class implements a generic value propagation algorithm based on the conditional constant propagation algorithm proposed in Constant propagation with conditional branches, Wegman and Zadeck, ACM TOPLAS 13(2):181-210. The implementation is based on A Propagation Engine for GCC Diego Novillo, GCC Summit 2005 http://ols.fedoraproject.org/GCC/Reprints-2005/novillo-Reprint.pdf The purpose of this implementation is to act as a common framework for any transformation that needs to propagate values from statements producing new values to statements using those values.
2017-11-17 13:59:25 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpReturn:
case spv::Op::OpReturnValue:
Generic value propagation engine. This class implements a generic value propagation algorithm based on the conditional constant propagation algorithm proposed in Constant propagation with conditional branches, Wegman and Zadeck, ACM TOPLAS 13(2):181-210. The implementation is based on A Propagation Engine for GCC Diego Novillo, GCC Summit 2005 http://ols.fedoraproject.org/GCC/Reprints-2005/novillo-Reprint.pdf The purpose of this implementation is to act as a common framework for any transformation that needs to propagate values from statements producing new values to statements using those values.
2017-11-17 13:59:25 +00:00
return true;
default:
return false;
}
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsAbort(spv::Op opcode) {
Take new (raytracing) termination instructions into account. (#4050) * Take new (raytracing) termination instructions into account. * Remove duplicate function and add unit test. * Use KHR for symbols in the test.
2020-12-07 15:26:05 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpKill:
case spv::Op::OpUnreachable:
case spv::Op::OpTerminateInvocation:
case spv::Op::OpTerminateRayKHR:
case spv::Op::OpIgnoreIntersectionKHR:
case spv::Op::OpEmitMeshTasksEXT:
Take new (raytracing) termination instructions into account. (#4050) * Take new (raytracing) termination instructions into account. * Remove duplicate function and add unit test. * Use KHR for symbols in the test.
2020-12-07 15:26:05 +00:00
return true;
default:
return false;
}
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsReturnOrAbort(spv::Op opcode) {
Take new (raytracing) termination instructions into account. (#4050) * Take new (raytracing) termination instructions into account. * Remove duplicate function and add unit test. * Use KHR for symbols in the test.
2020-12-07 15:26:05 +00:00
return spvOpcodeIsReturn(opcode) || spvOpcodeIsAbort(opcode);
Handle execution termination instructions when building edges. This fixes issue https://github.com/KhronosGroup/SPIRV-Tools/issues/1153. When building CFG edges, edges out of a OpKill and OpUnreachable instruction should be directed to the CFG's pseudo exit block.
2018-01-03 20:25:03 +00:00
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsBlockTerminator(spv::Op opcode) {
Handle execution termination instructions when building edges. This fixes issue https://github.com/KhronosGroup/SPIRV-Tools/issues/1153. When building CFG edges, edges out of a OpKill and OpUnreachable instruction should be directed to the CFG's pseudo exit block.
2018-01-03 20:25:03 +00:00
return spvOpcodeIsBranch(opcode) || spvOpcodeIsReturnOrAbort(opcode);
Generic value propagation engine. This class implements a generic value propagation algorithm based on the conditional constant propagation algorithm proposed in Constant propagation with conditional branches, Wegman and Zadeck, ACM TOPLAS 13(2):181-210. The implementation is based on A Propagation Engine for GCC Diego Novillo, GCC Summit 2005 http://ols.fedoraproject.org/GCC/Reprints-2005/novillo-Reprint.pdf The purpose of this implementation is to act as a common framework for any transformation that needs to propagate values from statements producing new values to statements using those values.
2017-11-17 13:59:25 +00:00
}
Allow pointers to pointers in logical addressing mode. A few optimizations are updates to handle code that is suppose to be using the logical addressing mode, but still has variables that contain pointers as long as the pointer are to opaque objects. This is called "relaxed logical addressing". |Instruction::GetBaseAddress| will check that pointers that are use meet the relaxed logical addressing rules. Optimization that now handle relaxed logical addressing instead of logical addressing are: - aggressive dead-code elimination - local access chain convert - local store elimination passes.
2017-12-11 18:10:24 +00:00
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsBaseOpaqueType(spv::Op opcode) {
Allow pointers to pointers in logical addressing mode. A few optimizations are updates to handle code that is suppose to be using the logical addressing mode, but still has variables that contain pointers as long as the pointer are to opaque objects. This is called "relaxed logical addressing". |Instruction::GetBaseAddress| will check that pointers that are use meet the relaxed logical addressing rules. Optimization that now handle relaxed logical addressing instead of logical addressing are: - aggressive dead-code elimination - local access chain convert - local store elimination passes.
2017-12-11 18:10:24 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpTypeImage:
case spv::Op::OpTypeSampler:
case spv::Op::OpTypeSampledImage:
case spv::Op::OpTypeOpaque:
case spv::Op::OpTypeEvent:
case spv::Op::OpTypeDeviceEvent:
case spv::Op::OpTypeReserveId:
case spv::Op::OpTypeQueue:
case spv::Op::OpTypePipe:
case spv::Op::OpTypeForwardPointer:
case spv::Op::OpTypePipeStorage:
case spv::Op::OpTypeNamedBarrier:
Allow pointers to pointers in logical addressing mode. A few optimizations are updates to handle code that is suppose to be using the logical addressing mode, but still has variables that contain pointers as long as the pointer are to opaque objects. This is called "relaxed logical addressing". |Instruction::GetBaseAddress| will check that pointers that are use meet the relaxed logical addressing rules. Optimization that now handle relaxed logical addressing instead of logical addressing are: - aggressive dead-code elimination - local access chain convert - local store elimination passes.
2017-12-11 18:10:24 +00:00
return true;
default:
return false;
}
}
Fixes #1480. Validate group non-uniform scopes. * Adds new pass for validating non-uniform group instructions * Currently on checks execution scope for Vulkan 1.1 and SPIR-V 1.3 * Added test framework
2018-04-17 14:18:59 +00:00
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsNonUniformGroupOperation(spv::Op opcode) {
Fixes #1480. Validate group non-uniform scopes. * Adds new pass for validating non-uniform group instructions * Currently on checks execution scope for Vulkan 1.1 and SPIR-V 1.3 * Added test framework
2018-04-17 14:18:59 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpGroupNonUniformElect:
case spv::Op::OpGroupNonUniformAll:
case spv::Op::OpGroupNonUniformAny:
case spv::Op::OpGroupNonUniformAllEqual:
case spv::Op::OpGroupNonUniformBroadcast:
case spv::Op::OpGroupNonUniformBroadcastFirst:
case spv::Op::OpGroupNonUniformBallot:
case spv::Op::OpGroupNonUniformInverseBallot:
case spv::Op::OpGroupNonUniformBallotBitExtract:
case spv::Op::OpGroupNonUniformBallotBitCount:
case spv::Op::OpGroupNonUniformBallotFindLSB:
case spv::Op::OpGroupNonUniformBallotFindMSB:
case spv::Op::OpGroupNonUniformShuffle:
case spv::Op::OpGroupNonUniformShuffleXor:
case spv::Op::OpGroupNonUniformShuffleUp:
case spv::Op::OpGroupNonUniformShuffleDown:
case spv::Op::OpGroupNonUniformIAdd:
case spv::Op::OpGroupNonUniformFAdd:
case spv::Op::OpGroupNonUniformIMul:
case spv::Op::OpGroupNonUniformFMul:
case spv::Op::OpGroupNonUniformSMin:
case spv::Op::OpGroupNonUniformUMin:
case spv::Op::OpGroupNonUniformFMin:
case spv::Op::OpGroupNonUniformSMax:
case spv::Op::OpGroupNonUniformUMax:
case spv::Op::OpGroupNonUniformFMax:
case spv::Op::OpGroupNonUniformBitwiseAnd:
case spv::Op::OpGroupNonUniformBitwiseOr:
case spv::Op::OpGroupNonUniformBitwiseXor:
case spv::Op::OpGroupNonUniformLogicalAnd:
case spv::Op::OpGroupNonUniformLogicalOr:
case spv::Op::OpGroupNonUniformLogicalXor:
case spv::Op::OpGroupNonUniformQuadBroadcast:
case spv::Op::OpGroupNonUniformQuadSwap:
case spv::Op::OpGroupNonUniformRotateKHR:
Fixes #1480. Validate group non-uniform scopes. * Adds new pass for validating non-uniform group instructions * Currently on checks execution scope for Vulkan 1.1 and SPIR-V 1.3 * Added test framework
2018-04-17 14:18:59 +00:00
return true;
default:
return false;
}
}
Vector DCE (#1512) Introduce a pass that does a DCE type analysis for vector elements instead of the whole vector as a single element. It will then rewrite instructions that are not used with something else. For example, an instruction whose value are not used, even though it is referenced, is replaced with an OpUndef.
2018-04-23 15:13:07 +00:00
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsScalarizable(spv::Op opcode) {
Vector DCE (#1512) Introduce a pass that does a DCE type analysis for vector elements instead of the whole vector as a single element. It will then rewrite instructions that are not used with something else. For example, an instruction whose value are not used, even though it is referenced, is replaced with an OpUndef.
2018-04-23 15:13:07 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpPhi:
case spv::Op::OpCopyObject:
case spv::Op::OpConvertFToU:
case spv::Op::OpConvertFToS:
case spv::Op::OpConvertSToF:
case spv::Op::OpConvertUToF:
case spv::Op::OpUConvert:
case spv::Op::OpSConvert:
case spv::Op::OpFConvert:
case spv::Op::OpQuantizeToF16:
case spv::Op::OpVectorInsertDynamic:
case spv::Op::OpSNegate:
case spv::Op::OpFNegate:
case spv::Op::OpIAdd:
case spv::Op::OpFAdd:
case spv::Op::OpISub:
case spv::Op::OpFSub:
case spv::Op::OpIMul:
case spv::Op::OpFMul:
case spv::Op::OpUDiv:
case spv::Op::OpSDiv:
case spv::Op::OpFDiv:
case spv::Op::OpUMod:
case spv::Op::OpSRem:
case spv::Op::OpSMod:
case spv::Op::OpFRem:
case spv::Op::OpFMod:
case spv::Op::OpVectorTimesScalar:
case spv::Op::OpIAddCarry:
case spv::Op::OpISubBorrow:
case spv::Op::OpUMulExtended:
case spv::Op::OpSMulExtended:
case spv::Op::OpShiftRightLogical:
case spv::Op::OpShiftRightArithmetic:
case spv::Op::OpShiftLeftLogical:
case spv::Op::OpBitwiseOr:
case spv::Op::OpBitwiseAnd:
case spv::Op::OpNot:
case spv::Op::OpBitFieldInsert:
case spv::Op::OpBitFieldSExtract:
case spv::Op::OpBitFieldUExtract:
case spv::Op::OpBitReverse:
case spv::Op::OpBitCount:
case spv::Op::OpIsNan:
case spv::Op::OpIsInf:
case spv::Op::OpIsFinite:
case spv::Op::OpIsNormal:
case spv::Op::OpSignBitSet:
case spv::Op::OpLessOrGreater:
case spv::Op::OpOrdered:
case spv::Op::OpUnordered:
case spv::Op::OpLogicalEqual:
case spv::Op::OpLogicalNotEqual:
case spv::Op::OpLogicalOr:
case spv::Op::OpLogicalAnd:
case spv::Op::OpLogicalNot:
case spv::Op::OpSelect:
case spv::Op::OpIEqual:
case spv::Op::OpINotEqual:
case spv::Op::OpUGreaterThan:
case spv::Op::OpSGreaterThan:
case spv::Op::OpUGreaterThanEqual:
case spv::Op::OpSGreaterThanEqual:
case spv::Op::OpULessThan:
case spv::Op::OpSLessThan:
case spv::Op::OpULessThanEqual:
case spv::Op::OpSLessThanEqual:
case spv::Op::OpFOrdEqual:
case spv::Op::OpFUnordEqual:
case spv::Op::OpFOrdNotEqual:
case spv::Op::OpFUnordNotEqual:
case spv::Op::OpFOrdLessThan:
case spv::Op::OpFUnordLessThan:
case spv::Op::OpFOrdGreaterThan:
case spv::Op::OpFUnordGreaterThan:
case spv::Op::OpFOrdLessThanEqual:
case spv::Op::OpFUnordLessThanEqual:
case spv::Op::OpFOrdGreaterThanEqual:
case spv::Op::OpFUnordGreaterThanEqual:
Vector DCE (#1512) Introduce a pass that does a DCE type analysis for vector elements instead of the whole vector as a single element. It will then rewrite instructions that are not used with something else. For example, an instruction whose value are not used, even though it is referenced, is replaced with an OpUndef.
2018-04-23 15:13:07 +00:00
return true;
default:
return false;
}
}
Validate that debugging instructions are not present for WebGPU (#2089) Validate that debugging instructions are not present for WebGPU For WebGPU execution environments, check that all of the debug instructions have already been stripped before validation. Fixes #2063
2018-11-20 21:12:28 +00:00
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsDebug(spv::Op opcode) {
Validate that debugging instructions are not present for WebGPU (#2089) Validate that debugging instructions are not present for WebGPU For WebGPU execution environments, check that all of the debug instructions have already been stripped before validation. Fixes #2063
2018-11-20 21:12:28 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpName:
case spv::Op::OpMemberName:
case spv::Op::OpSource:
case spv::Op::OpSourceContinued:
case spv::Op::OpSourceExtension:
case spv::Op::OpString:
case spv::Op::OpLine:
case spv::Op::OpNoLine:
case spv::Op::OpModuleProcessed:
Validate that debugging instructions are not present for WebGPU (#2089) Validate that debugging instructions are not present for WebGPU For WebGPU execution environments, check that all of the debug instructions have already been stripped before validation. Fixes #2063
2018-11-20 21:12:28 +00:00
return true;
default:
return false;
}
}
Add --strip-atomic-counter-memory (#2413) Adds an optimization pass to remove usages of AtomicCounterMemory bit. This bit is ignored in Vulkan environments and outright forbidden in WebGPU ones. Fixes #2242
2019-03-14 17:34:33 +00:00
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsCommutativeBinaryOperator(spv::Op opcode) {
spirv-fuzz: Add swap commutable operands transformation (#3205) In this PR, the classes that represent the swap commutable operands transformation and the fuzzer pass were implemented. Fixes #3205.
2020-03-05 08:18:39 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpPtrEqual:
case spv::Op::OpPtrNotEqual:
case spv::Op::OpIAdd:
case spv::Op::OpFAdd:
case spv::Op::OpIMul:
case spv::Op::OpFMul:
case spv::Op::OpDot:
case spv::Op::OpIAddCarry:
case spv::Op::OpUMulExtended:
case spv::Op::OpSMulExtended:
case spv::Op::OpBitwiseOr:
case spv::Op::OpBitwiseXor:
case spv::Op::OpBitwiseAnd:
case spv::Op::OpOrdered:
case spv::Op::OpUnordered:
case spv::Op::OpLogicalEqual:
case spv::Op::OpLogicalNotEqual:
case spv::Op::OpLogicalOr:
case spv::Op::OpLogicalAnd:
case spv::Op::OpIEqual:
case spv::Op::OpINotEqual:
case spv::Op::OpFOrdEqual:
case spv::Op::OpFUnordEqual:
case spv::Op::OpFOrdNotEqual:
case spv::Op::OpFUnordNotEqual:
spirv-fuzz: Add swap commutable operands transformation (#3205) In this PR, the classes that represent the swap commutable operands transformation and the fuzzer pass were implemented. Fixes #3205.
2020-03-05 08:18:39 +00:00
return true;
default:
return false;
}
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsLinearAlgebra(spv::Op opcode) {
spirv-fuzz: Add replace linear algebra instruction transformation (#3402) This PR implements a transformation that replaces a linear algebra instruction with its mathematical definition.
2020-06-16 10:20:51 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpTranspose:
case spv::Op::OpVectorTimesScalar:
case spv::Op::OpMatrixTimesScalar:
case spv::Op::OpVectorTimesMatrix:
case spv::Op::OpMatrixTimesVector:
case spv::Op::OpMatrixTimesMatrix:
case spv::Op::OpOuterProduct:
case spv::Op::OpDot:
spirv-fuzz: Add replace linear algebra instruction transformation (#3402) This PR implements a transformation that replaces a linear algebra instruction with its mathematical definition.
2020-06-16 10:20:51 +00:00
return true;
default:
return false;
}
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsImageSample(const spv::Op opcode) {
spirv-fuzz: Add image sample unused components transformation (#3439) Fixes #3375.
2020-07-08 16:07:04 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpImageSampleImplicitLod:
case spv::Op::OpImageSampleExplicitLod:
case spv::Op::OpImageSampleDrefImplicitLod:
case spv::Op::OpImageSampleDrefExplicitLod:
case spv::Op::OpImageSampleProjImplicitLod:
case spv::Op::OpImageSampleProjExplicitLod:
case spv::Op::OpImageSampleProjDrefImplicitLod:
case spv::Op::OpImageSampleProjDrefExplicitLod:
case spv::Op::OpImageSparseSampleImplicitLod:
case spv::Op::OpImageSparseSampleExplicitLod:
case spv::Op::OpImageSparseSampleDrefImplicitLod:
case spv::Op::OpImageSparseSampleDrefExplicitLod:
spirv-fuzz: Add image sample unused components transformation (#3439) Fixes #3375.
2020-07-08 16:07:04 +00:00
return true;
default:
return false;
}
}
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
std::vector<uint32_t> spvOpcodeMemorySemanticsOperandIndices(spv::Op opcode) {
Add --strip-atomic-counter-memory (#2413) Adds an optimization pass to remove usages of AtomicCounterMemory bit. This bit is ignored in Vulkan environments and outright forbidden in WebGPU ones. Fixes #2242
2019-03-14 17:34:33 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpMemoryBarrier:
Add --strip-atomic-counter-memory (#2413) Adds an optimization pass to remove usages of AtomicCounterMemory bit. This bit is ignored in Vulkan environments and outright forbidden in WebGPU ones. Fixes #2242
2019-03-14 17:34:33 +00:00
return {1};
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpAtomicStore:
case spv::Op::OpControlBarrier:
case spv::Op::OpAtomicFlagClear:
case spv::Op::OpMemoryNamedBarrier:
Add --strip-atomic-counter-memory (#2413) Adds an optimization pass to remove usages of AtomicCounterMemory bit. This bit is ignored in Vulkan environments and outright forbidden in WebGPU ones. Fixes #2242
2019-03-14 17:34:33 +00:00
return {2};
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpAtomicLoad:
case spv::Op::OpAtomicExchange:
case spv::Op::OpAtomicIIncrement:
case spv::Op::OpAtomicIDecrement:
case spv::Op::OpAtomicIAdd:
case spv::Op::OpAtomicFAddEXT:
case spv::Op::OpAtomicISub:
case spv::Op::OpAtomicSMin:
case spv::Op::OpAtomicUMin:
case spv::Op::OpAtomicSMax:
case spv::Op::OpAtomicUMax:
case spv::Op::OpAtomicAnd:
case spv::Op::OpAtomicOr:
case spv::Op::OpAtomicXor:
case spv::Op::OpAtomicFlagTestAndSet:
Add --strip-atomic-counter-memory (#2413) Adds an optimization pass to remove usages of AtomicCounterMemory bit. This bit is ignored in Vulkan environments and outright forbidden in WebGPU ones. Fixes #2242
2019-03-14 17:34:33 +00:00
return {4};
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpAtomicCompareExchange:
case spv::Op::OpAtomicCompareExchangeWeak:
Add --strip-atomic-counter-memory (#2413) Adds an optimization pass to remove usages of AtomicCounterMemory bit. This bit is ignored in Vulkan environments and outright forbidden in WebGPU ones. Fixes #2242
2019-03-14 17:34:33 +00:00
return {4, 5};
default:
return {};
}
}
spirv-opt: Add spvOpcodeIsAccessChain (#3682)
2020-08-11 15:21:36 +00:00
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsAccessChain(spv::Op opcode) {
spirv-opt: Add spvOpcodeIsAccessChain (#3682)
2020-08-11 15:21:36 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpAccessChain:
case spv::Op::OpInBoundsAccessChain:
case spv::Op::OpPtrAccessChain:
case spv::Op::OpInBoundsPtrAccessChain:
spirv-opt: Add spvOpcodeIsAccessChain (#3682)
2020-08-11 15:21:36 +00:00
return true;
default:
return false;
}
}
spirv-fuzz: Add bit instruction synonym transformation (#3775) This PR implements part of the add bit instruction synonym transformation. For now, the implementation covers the OpBitwiseOr, OpBitwiseXor and OpBitwiseAnd cases.
2020-09-15 22:36:23 +00:00
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
bool spvOpcodeIsBit(spv::Op opcode) {
spirv-fuzz: Add bit instruction synonym transformation (#3775) This PR implements part of the add bit instruction synonym transformation. For now, the implementation covers the OpBitwiseOr, OpBitwiseXor and OpBitwiseAnd cases.
2020-09-15 22:36:23 +00:00
switch (opcode) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
case spv::Op::OpShiftRightLogical:
case spv::Op::OpShiftRightArithmetic:
case spv::Op::OpShiftLeftLogical:
case spv::Op::OpBitwiseOr:
case spv::Op::OpBitwiseXor:
case spv::Op::OpBitwiseAnd:
case spv::Op::OpNot:
case spv::Op::OpBitReverse:
case spv::Op::OpBitCount:
spirv-fuzz: Add bit instruction synonym transformation (#3775) This PR implements part of the add bit instruction synonym transformation. For now, the implementation covers the OpBitwiseOr, OpBitwiseXor and OpBitwiseAnd cases.
2020-09-15 22:36:23 +00:00
return true;
default:
return false;
}
}
Reference in New Issue Copy Permalink