AuroraMiddleware/glslang
1
0
Fork 0
mirror of https://github.com/KhronosGroup/glslang synced 2024-11-09 12:00:05 +00:00
Code Issues Packages Projects Releases Wiki Activity
main
glslang/SPIRV/doc.cpp

3599 lines
199 KiB
C++
Raw Permalink Normal View History

Final round for line endings.
2015-06-26 22:58:36 +00:00
//
Non-functional: White space after "//", mostly for copyrights.
2017-01-06 19:34:14 +00:00
// Copyright (C) 2014-2015 LunarG, Inc.
Add GL_KHR_shader_subgroup_rotate support Co-authored-by: Neil Hickey <neil.hickey@arm.com> Co-authored-by: Stuart Brady <stuart.brady@arm.com> Signed-off-by: Sven van Haastregt <sven.vanhaastregt@arm.com>
2024-02-06 15:20:16 +00:00
// Copyright (C) 2022-2024 Arm Limited.
GL_EXT_ray_query updates
2020-03-19 15:09:57 +00:00
// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
Final round for line endings.
2015-06-26 22:58:36 +00:00
//
Non-functional: White space after "//", mostly for copyrights.
2017-01-06 19:34:14 +00:00
// All rights reserved.
Final round for line endings.
2015-06-26 22:58:36 +00:00
//
Non-functional: White space after "//", mostly for copyrights.
2017-01-06 19:34:14 +00:00
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
Final round for line endings.
2015-06-26 22:58:36 +00:00
//
// Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
//
// Neither the name of 3Dlabs Inc. Ltd. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
Non-functional: White space after "//", mostly for copyrights.
2017-01-06 19:34:14 +00:00
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
Final round for line endings.
2015-06-26 22:58:36 +00:00
//
Build: C++ headers: Replace PR #366 with a more directed version.
2016-08-05 20:04:23 +00:00
// 1) Programmatically fill in instruction/operand information.
Final round for line endings.
2015-06-26 22:58:36 +00:00
// This can be used for disassembly, printing documentation, etc.
//
// 2) Print documentation from this parameterization.
//
#include "doc.h"
Build: C++ headers: Replace PR #366 with a more directed version.
2016-08-05 20:04:23 +00:00
#include <cstdio>
#include <cstring>
Final round for line endings.
2015-06-26 22:58:36 +00:00
#include <algorithm>
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
#include <mutex>
Final round for line endings.
2015-06-26 22:58:36 +00:00
Implement 4 AMD-specific extensions. - Support GL_AMD_shader_ballot (SPV_AMD_shader_ballot). - Support GL_AMD_shader_trinary_minmax (SPV_AMD_shader_trinary_minmax). - Support GL_AMD_shader_explicit_vertex_parameter (SPV_AMD_shader_explicit_vertex_parameter). - Support GL_AMD_gcn_shader (SPV_AMD_gcn_shader).
2016-05-05 04:30:44 +00:00
namespace spv {
extern "C" {
// Include C-based headers that don't have a namespace
SPV: Implement new extensions GL_KHX_device_group and GL_KHX_multiview. These correspond to SPV_KHR_device_group and SPV_KHR_multiview. Also, bring tests up to date with Khronos internals, and some misc. related changes.
2017-02-27 08:20:51 +00:00
#include "GLSL.ext.KHR.h"
Add implementation of SPV_EXT_fragment_fully_covered This implementation uses the GLSL extension GL_NV_conservative_raster_underestimation to generate the new SPIR-V FullyCoveredEXT built in.
2017-12-13 20:07:22 +00:00
#include "GLSL.ext.EXT.h"
Implement 4 AMD-specific extensions. - Support GL_AMD_shader_ballot (SPV_AMD_shader_ballot). - Support GL_AMD_shader_trinary_minmax (SPV_AMD_shader_trinary_minmax). - Support GL_AMD_shader_explicit_vertex_parameter (SPV_AMD_shader_explicit_vertex_parameter). - Support GL_AMD_gcn_shader (SPV_AMD_gcn_shader).
2016-05-05 04:30:44 +00:00
#include "GLSL.ext.AMD.h"
Add support for SPV_NV_sample_mask_override_coverage
2016-12-20 00:29:34 +00:00
#include "GLSL.ext.NV.h"
GL_ARM_shader_core_builtins support Add support for GL_ARM_shader_core_builtins and SPV_ARM_core_builtins, including initial tests
2022-12-05 12:02:22 +00:00
#include "GLSL.ext.ARM.h"
extension: GL_QCOM_image_processing support
2023-08-22 00:14:52 +00:00
#include "GLSL.ext.QCOM.h"
Implement 4 AMD-specific extensions. - Support GL_AMD_shader_ballot (SPV_AMD_shader_ballot). - Support GL_AMD_shader_trinary_minmax (SPV_AMD_shader_trinary_minmax). - Support GL_AMD_shader_explicit_vertex_parameter (SPV_AMD_shader_explicit_vertex_parameter). - Support GL_AMD_gcn_shader (SPV_AMD_gcn_shader).
2016-05-05 04:30:44 +00:00
}
}
Final round for line endings.
2015-06-26 22:58:36 +00:00
namespace spv {
//
// Whole set of functions that translate enumerants to their text strings for
// the specification (or their sanitized versions for auto-generating the
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
// spirv headers.
Final round for line endings.
2015-06-26 22:58:36 +00:00
//
Non-Functional: Remove unused parts of the disassembler.
2018-03-30 06:11:39 +00:00
// Also, for masks the ceilings are declared next to these, to help keep them in sync.
Final round for line endings.
2015-06-26 22:58:36 +00:00
// Ceilings should be
// - one more than the maximum value an enumerant takes on, for non-mask enumerants
Non-functional: Fix typos in comments.
2017-04-07 21:40:30 +00:00
// (for non-sparse enums, this is the number of enumerants)
Final round for line endings.
2015-06-26 22:58:36 +00:00
// - the number of bits consumed by the set of masks
Non-functional: Fix typos in comments.
2017-04-07 21:40:30 +00:00
// (for non-sparse mask enums, this is the number of enumerants)
Final round for line endings.
2015-06-26 22:58:36 +00:00
//
const char* SourceString(int source)
{
switch (source) {
case 0: return "Unknown";
case 1: return "ESSL";
case 2: return "GLSL";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 3: return "OpenCL_C";
case 4: return "OpenCL_CPP";
Support multiple source languages, adding HLSL as an option.
2016-03-13 01:34:36 +00:00
case 5: return "HLSL";
Final round for line endings.
2015-06-26 22:58:36 +00:00
default: return "Bad";
}
}
const char* ExecutionModelString(int model)
{
switch (model) {
case 0: return "Vertex";
case 1: return "TessellationControl";
case 2: return "TessellationEvaluation";
case 3: return "Geometry";
case 4: return "Fragment";
case 5: return "GLCompute";
case 6: return "Kernel";
Add-support-for-SPV_NV_mesh_shader
2018-09-19 18:41:59 +00:00
case ExecutionModelTaskNV: return "TaskNV";
case ExecutionModelMeshNV: return "MeshNV";
GL_EXT_mesh_shader/SPV_EXT_mesh_shader implementation Added following updates to GL_EXT_mesh_shader implementation: 1. Added SPIRV and GLSL test cases 2. Added checks to ensure NV and EXT mesh shader builtins cannot be used interchangeably. 3. Updated the language name by removing the postfix "NV" to MeshShader and TaskShader. 4. Added checks for grammar checking to comply with the spec. 5. Added gl_NumWorkGroups builtin to Mesh shader 6. Fixed data type of gl_PrimitiveLineIndicesEXT and gl_PrimitiveTriangleIndicesEXT 7. Added new constants to the resources table 8. Updates to handle new storage qualifier "taskPayloadSharedEXT" 9. Updated test cases by replacing "taskEXT" with storage qualifier "taskPayloadSharedEXT" Addressed Review comments 1. Fixed instruction description used by glslang disassembly. 2. Updated OpEmitMeshTasksEXT as per spec update 3. Fixed implementation that errors out if there are more then one taskPayloadSharedEXT varjables. 4. Fixed miscellaneous error logs and removed unwanted code. SPIRV 1.6 related build failure fixes - Update SPIRV header to 1.6 - Fix conflict wiht SPIRV 1.6 change, where localSizeId is used for execution mode for mesh/task shaders Enable SPIRV generated for EXT_mesh_shader to be version 1.4 GL_EXT_mesh_shader: Add checks for atomic support and corresponding test cases
2021-08-25 20:41:32 +00:00
case ExecutionModelTaskEXT: return "TaskEXT";
case ExecutionModelMeshEXT: return "MeshEXT";
Final round for line endings.
2015-06-26 22:58:36 +00:00
default: return "Bad";
Add-support-for-SPV_NVX_raytracing
2018-09-19 18:42:24 +00:00
Add support for GLSL_EXT_ray_tracing and SPV_KHR_ray_tracing
2020-03-18 00:42:47 +00:00
case ExecutionModelRayGenerationKHR: return "RayGenerationKHR";
case ExecutionModelIntersectionKHR: return "IntersectionKHR";
case ExecutionModelAnyHitKHR: return "AnyHitKHR";
case ExecutionModelClosestHitKHR: return "ClosestHitKHR";
case ExecutionModelMissKHR: return "MissKHR";
case ExecutionModelCallableKHR: return "CallableKHR";
Final round for line endings.
2015-06-26 22:58:36 +00:00
}
}
const char* AddressingString(int addr)
{
switch (addr) {
case 0: return "Logical";
case 1: return "Physical32";
case 2: return "Physical64";
GL_EXT_buffer_reference
2019-01-06 23:58:04 +00:00
case AddressingModelPhysicalStorageBuffer64EXT: return "PhysicalStorageBuffer64EXT";
Final round for line endings.
2015-06-26 22:58:36 +00:00
default: return "Bad";
}
}
const char* MemoryString(int mem)
{
switch (mem) {
GL_KHR_memory_scope_semantics
2018-09-05 15:11:41 +00:00
case MemoryModelSimple: return "Simple";
case MemoryModelGLSL450: return "GLSL450";
case MemoryModelOpenCL: return "OpenCL";
case MemoryModelVulkanKHR: return "VulkanKHR";
Final round for line endings.
2015-06-26 22:58:36 +00:00
default: return "Bad";
}
}
SPIRV: Fix some disassembly issues - OpExecutionModeId is not supported in disassembly. - Some execution modes are missing in disassembled strings.
2020-09-07 03:09:21 +00:00
const int ExecutionModeCeiling = 40;
Final round for line endings.
2015-06-26 22:58:36 +00:00
const char* ExecutionModeString(int mode)
{
switch (mode) {
case 0: return "Invocations";
case 1: return "SpacingEqual";
case 2: return "SpacingFractionalEven";
case 3: return "SpacingFractionalOdd";
case 4: return "VertexOrderCw";
case 5: return "VertexOrderCcw";
case 6: return "PixelCenterInteger";
case 7: return "OriginUpperLeft";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 8: return "OriginLowerLeft";
case 9: return "EarlyFragmentTests";
case 10: return "PointMode";
case 11: return "Xfb";
case 12: return "DepthReplacing";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 13: return "Bad";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 14: return "DepthGreater";
case 15: return "DepthLess";
case 16: return "DepthUnchanged";
case 17: return "LocalSize";
case 18: return "LocalSizeHint";
case 19: return "InputPoints";
case 20: return "InputLines";
case 21: return "InputLinesAdjacency";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 22: return "Triangles";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 23: return "InputTrianglesAdjacency";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 24: return "Quads";
case 25: return "Isolines";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 26: return "OutputVertices";
case 27: return "OutputPoints";
case 28: return "OutputLineStrip";
case 29: return "OutputTriangleStrip";
case 30: return "VecTypeHint";
case 31: return "ContractionOff";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 32: return "Bad";
Final round for line endings.
2015-06-26 22:58:36 +00:00
Add SPV_AMD_shader_early_and_late_fragment_tests
2022-07-15 06:36:03 +00:00
case ExecutionModeInitializer: return "Initializer";
case ExecutionModeFinalizer: return "Finalizer";
case ExecutionModeSubgroupSize: return "SubgroupSize";
case ExecutionModeSubgroupsPerWorkgroup: return "SubgroupsPerWorkgroup";
case ExecutionModeSubgroupsPerWorkgroupId: return "SubgroupsPerWorkgroupId";
case ExecutionModeLocalSizeId: return "LocalSizeId";
case ExecutionModeLocalSizeHintId: return "LocalSizeHintId";
case ExecutionModePostDepthCoverage: return "PostDepthCoverage";
case ExecutionModeDenormPreserve: return "DenormPreserve";
case ExecutionModeDenormFlushToZero: return "DenormFlushToZero";
case ExecutionModeSignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve";
case ExecutionModeRoundingModeRTE: return "RoundingModeRTE";
case ExecutionModeRoundingModeRTZ: return "RoundingModeRTZ";
case ExecutionModeEarlyAndLateFragmentTestsAMD: return "EarlyAndLateFragmentTestsAMD";
case ExecutionModeStencilRefUnchangedFrontAMD: return "StencilRefUnchangedFrontAMD";
case ExecutionModeStencilRefLessFrontAMD: return "StencilRefLessFrontAMD";
case ExecutionModeStencilRefGreaterBackAMD: return "StencilRefGreaterBackAMD";
case ExecutionModeStencilRefReplacingEXT: return "StencilRefReplacingEXT";
Implement GL_EXT_subgroup_uniform_control_flow.
2020-06-05 10:15:43 +00:00
case ExecutionModeSubgroupUniformControlFlowKHR: return "SubgroupUniformControlFlow";
Implement GL_EXT_maximal_reconvergence
2022-01-07 01:47:45 +00:00
case ExecutionModeMaximallyReconvergesKHR: return "MaximallyReconverges";
Add-support-for-SPV_NV_compute_shader_derivatives
2018-09-19 18:40:45 +00:00
Add SPV_AMD_shader_early_and_late_fragment_tests
2022-07-15 06:36:03 +00:00
case ExecutionModeOutputLinesNV: return "OutputLinesNV";
case ExecutionModeOutputPrimitivesNV: return "OutputPrimitivesNV";
case ExecutionModeOutputTrianglesNV: return "OutputTrianglesNV";
case ExecutionModeDerivativeGroupQuadsNV: return "DerivativeGroupQuadsNV";
case ExecutionModeDerivativeGroupLinearNV: return "DerivativeGroupLinearNV";
Add-support-for-SPV_NV_compute_shader_derivatives
2018-09-19 18:40:45 +00:00
Support GL_ARB_fragment_shader_interlock
2019-06-03 16:33:50 +00:00
case ExecutionModePixelInterlockOrderedEXT: return "PixelInterlockOrderedEXT";
case ExecutionModePixelInterlockUnorderedEXT: return "PixelInterlockUnorderedEXT";
case ExecutionModeSampleInterlockOrderedEXT: return "SampleInterlockOrderedEXT";
case ExecutionModeSampleInterlockUnorderedEXT: return "SampleInterlockUnorderedEXT";
case ExecutionModeShadingRateInterlockOrderedEXT: return "ShadingRateInterlockOrderedEXT";
case ExecutionModeShadingRateInterlockUnorderedEXT: return "ShadingRateInterlockUnorderedEXT";
SPIRV: Fix some disassembly issues - OpExecutionModeId is not supported in disassembly. - Some execution modes are missing in disassembled strings.
2020-09-07 03:09:21 +00:00
case ExecutionModeMaxWorkgroupSizeINTEL: return "MaxWorkgroupSizeINTEL";
case ExecutionModeMaxWorkDimINTEL: return "MaxWorkDimINTEL";
case ExecutionModeNoGlobalOffsetINTEL: return "NoGlobalOffsetINTEL";
case ExecutionModeNumSIMDWorkitemsINTEL: return "NumSIMDWorkitemsINTEL";
Support extension EXT_shader_quad_control
2024-01-29 05:53:18 +00:00
case ExecutionModeRequireFullQuadsKHR: return "RequireFullQuadsKHR";
case ExecutionModeQuadDerivativesKHR: return "QuadDerivativesKHR";
Add GLSL_EXT_shader_tile_image
2023-03-30 15:50:56 +00:00
case ExecutionModeNonCoherentColorAttachmentReadEXT: return "NonCoherentColorAttachmentReadEXT";
case ExecutionModeNonCoherentDepthAttachmentReadEXT: return "NonCoherentDepthAttachmentReadEXT";
case ExecutionModeNonCoherentStencilAttachmentReadEXT: return "NonCoherentStencilAttachmentReadEXT";
Final round for line endings.
2015-06-26 22:58:36 +00:00
case ExecutionModeCeiling:
default: return "Bad";
}
}
const char* StorageClassString(int StorageClass)
{
switch (StorageClass) {
case 0: return "UniformConstant";
case 1: return "Input";
case 2: return "Uniform";
case 3: return "Output";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 4: return "Workgroup";
case 5: return "CrossWorkgroup";
case 6: return "Private";
Final round for line endings.
2015-06-26 22:58:36 +00:00
case 7: return "Function";
case 8: return "Generic";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 9: return "PushConstant";
Final round for line endings.
2015-06-26 22:58:36 +00:00
case 10: return "AtomicCounter";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 11: return "Image";
SPV: Support test #pragma for generating the StorageBuffer storage class. Longer term, this storage class should be generated based on the mode of compilation.
2017-04-20 00:34:49 +00:00
case 12: return "StorageBuffer";
Final round for line endings.
2015-06-26 22:58:36 +00:00
Add support for GLSL_EXT_ray_tracing and SPV_KHR_ray_tracing
2020-03-18 00:42:47 +00:00
case StorageClassRayPayloadKHR: return "RayPayloadKHR";
case StorageClassHitAttributeKHR: return "HitAttributeKHR";
case StorageClassIncomingRayPayloadKHR: return "IncomingRayPayloadKHR";
case StorageClassShaderRecordBufferKHR: return "ShaderRecordBufferKHR";
case StorageClassCallableDataKHR: return "CallableDataKHR";
case StorageClassIncomingCallableDataKHR: return "IncomingCallableDataKHR";
Add-support-for-SPV_NVX_raytracing
2018-09-19 18:42:24 +00:00
GL_EXT_buffer_reference
2019-01-06 23:58:04 +00:00
case StorageClassPhysicalStorageBufferEXT: return "PhysicalStorageBufferEXT";
GL_EXT_mesh_shader/SPV_EXT_mesh_shader implementation Added following updates to GL_EXT_mesh_shader implementation: 1. Added SPIRV and GLSL test cases 2. Added checks to ensure NV and EXT mesh shader builtins cannot be used interchangeably. 3. Updated the language name by removing the postfix "NV" to MeshShader and TaskShader. 4. Added checks for grammar checking to comply with the spec. 5. Added gl_NumWorkGroups builtin to Mesh shader 6. Fixed data type of gl_PrimitiveLineIndicesEXT and gl_PrimitiveTriangleIndicesEXT 7. Added new constants to the resources table 8. Updates to handle new storage qualifier "taskPayloadSharedEXT" 9. Updated test cases by replacing "taskEXT" with storage qualifier "taskPayloadSharedEXT" Addressed Review comments 1. Fixed instruction description used by glslang disassembly. 2. Updated OpEmitMeshTasksEXT as per spec update 3. Fixed implementation that errors out if there are more then one taskPayloadSharedEXT varjables. 4. Fixed miscellaneous error logs and removed unwanted code. SPIRV 1.6 related build failure fixes - Update SPIRV header to 1.6 - Fix conflict wiht SPIRV 1.6 change, where localSizeId is used for execution mode for mesh/task shaders Enable SPIRV generated for EXT_mesh_shader to be version 1.4 GL_EXT_mesh_shader: Add checks for atomic support and corresponding test cases
2021-08-25 20:41:32 +00:00
case StorageClassTaskPayloadWorkgroupEXT: return "TaskPayloadWorkgroupEXT";
Add support for GL_NV_shader_invocation_reorder. (#3054)
2022-12-09 20:19:08 +00:00
case StorageClassHitObjectAttributeNV: return "HitObjectAttributeNV";
Add GLSL_EXT_shader_tile_image
2023-03-30 15:50:56 +00:00
case StorageClassTileImageEXT: return "TileImageEXT";
Final round for line endings.
2015-06-26 22:58:36 +00:00
default: return "Bad";
}
}
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
const int DecorationCeiling = 45;
Final round for line endings.
2015-06-26 22:58:36 +00:00
const char* DecorationString(int decoration)
{
switch (decoration) {
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 0: return "RelaxedPrecision";
case 1: return "SpecId";
case 2: return "Block";
case 3: return "BufferBlock";
case 4: return "RowMajor";
case 5: return "ColMajor";
case 6: return "ArrayStride";
case 7: return "MatrixStride";
case 8: return "GLSLShared";
case 9: return "GLSLPacked";
case 10: return "CPacked";
case 11: return "BuiltIn";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 12: return "Bad";
case 13: return "NoPerspective";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 14: return "Flat";
case 15: return "Patch";
case 16: return "Centroid";
case 17: return "Sample";
case 18: return "Invariant";
case 19: return "Restrict";
case 20: return "Aliased";
case 21: return "Volatile";
case 22: return "Constant";
case 23: return "Coherent";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 24: return "NonWritable";
case 25: return "NonReadable";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 26: return "Uniform";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 27: return "Bad";
Final round for line endings.
2015-06-26 22:58:36 +00:00
case 28: return "SaturatedConversion";
case 29: return "Stream";
case 30: return "Location";
case 31: return "Component";
case 32: return "Index";
case 33: return "Binding";
case 34: return "DescriptorSet";
case 35: return "Offset";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 36: return "XfbBuffer";
case 37: return "XfbStride";
case 38: return "FuncParamAttr";
case 39: return "FP Rounding Mode";
case 40: return "FP Fast Math Mode";
case 41: return "Linkage Attributes";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 42: return "NoContraction";
case 43: return "InputAttachmentIndex";
case 44: return "Alignment";
Final round for line endings.
2015-06-26 22:58:36 +00:00
case DecorationCeiling:
default: return "Bad";
Implement 4 AMD-specific extensions. - Support GL_AMD_shader_ballot (SPV_AMD_shader_ballot). - Support GL_AMD_shader_trinary_minmax (SPV_AMD_shader_trinary_minmax). - Support GL_AMD_shader_explicit_vertex_parameter (SPV_AMD_shader_explicit_vertex_parameter). - Support GL_AMD_gcn_shader (SPV_AMD_gcn_shader).
2016-05-05 04:30:44 +00:00
extension: GL_QCOM_image_processing support
2023-08-22 00:14:52 +00:00
case DecorationWeightTextureQCOM: return "DecorationWeightTextureQCOM";
case DecorationBlockMatchTextureQCOM: return "DecorationBlockMatchTextureQCOM";
Support for SPV_QCOM_image_processing2 (#3539)
2024-03-20 22:56:00 +00:00
case DecorationBlockMatchSamplerQCOM: return "DecorationBlockMatchSamplerQCOM";
extension: GL_QCOM_image_processing support
2023-08-22 00:14:52 +00:00
case DecorationExplicitInterpAMD: return "ExplicitInterpAMD";
Non-Functional: Remove unused parts of the disassembler.
2018-03-30 06:11:39 +00:00
case DecorationOverrideCoverageNV: return "OverrideCoverageNV";
case DecorationPassthroughNV: return "PassthroughNV";
case DecorationViewportRelativeNV: return "ViewportRelativeNV";
case DecorationSecondaryViewportRelativeNV: return "SecondaryViewportRelativeNV";
Add-support-for-SPV_NV_mesh_shader
2018-09-19 18:41:59 +00:00
case DecorationPerPrimitiveNV: return "PerPrimitiveNV";
case DecorationPerViewNV: return "PerViewNV";
case DecorationPerTaskNV: return "PerTaskNV";
[glslang] Strip trailing whitespace There are many other files in the repo that have trailing whitespace but this PR only cleans `glslang/SPIRV` and `glslang/Standalone`.
2023-05-22 15:44:18 +00:00
Add support for VK_EXT_fragment_shader_barycentric
2022-05-13 16:23:29 +00:00
case DecorationPerVertexKHR: return "PerVertexKHR";
Implement SPV_GOOGLE_hlsl_functionality1. Enabled via -fhlsl_functionality1
2018-03-08 01:05:55 +00:00
GLSL/SPV: Implement SPV_EXT_descriptor_indexing and GL_EXT_nonuniform_qualifier
2018-04-05 17:25:02 +00:00
case DecorationNonUniformEXT: return "DecorationNonUniformEXT";
Implement SPV_GOOGLE_hlsl_functionality1. Enabled via -fhlsl_functionality1
2018-03-08 01:05:55 +00:00
case DecorationHlslCounterBufferGOOGLE: return "DecorationHlslCounterBufferGOOGLE";
case DecorationHlslSemanticGOOGLE: return "DecorationHlslSemanticGOOGLE";
GL_EXT_buffer_reference
2019-01-06 23:58:04 +00:00
case DecorationRestrictPointerEXT: return "DecorationRestrictPointerEXT";
case DecorationAliasedPointerEXT: return "DecorationAliasedPointerEXT";
Add support for GL_NV_shader_invocation_reorder. (#3054)
2022-12-09 20:19:08 +00:00
case DecorationHitObjectShaderRecordBufferNV: return "DecorationHitObjectShaderRecordBufferNV";
Final round for line endings.
2015-06-26 22:58:36 +00:00
}
}
const char* BuiltInString(int builtIn)
{
switch (builtIn) {
case 0: return "Position";
case 1: return "PointSize";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 2: return "Bad";
Final round for line endings.
2015-06-26 22:58:36 +00:00
case 3: return "ClipDistance";
case 4: return "CullDistance";
case 5: return "VertexId";
case 6: return "InstanceId";
case 7: return "PrimitiveId";
case 8: return "InvocationId";
case 9: return "Layer";
case 10: return "ViewportIndex";
case 11: return "TessLevelOuter";
case 12: return "TessLevelInner";
case 13: return "TessCoord";
case 14: return "PatchVertices";
case 15: return "FragCoord";
case 16: return "PointCoord";
case 17: return "FrontFacing";
case 18: return "SampleId";
case 19: return "SamplePosition";
case 20: return "SampleMask";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 21: return "Bad";
Final round for line endings.
2015-06-26 22:58:36 +00:00
case 22: return "FragDepth";
case 23: return "HelperInvocation";
case 24: return "NumWorkgroups";
case 25: return "WorkgroupSize";
case 26: return "WorkgroupId";
case 27: return "LocalInvocationId";
case 28: return "GlobalInvocationId";
case 29: return "LocalInvocationIndex";
case 30: return "WorkDim";
case 31: return "GlobalSize";
case 32: return "EnqueuedWorkgroupSize";
case 33: return "GlobalOffset";
case 34: return "GlobalLinearId";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 35: return "Bad";
Final round for line endings.
2015-06-26 22:58:36 +00:00
case 36: return "SubgroupSize";
case 37: return "SubgroupMaxSize";
case 38: return "NumSubgroups";
case 39: return "NumEnqueuedSubgroups";
case 40: return "SubgroupId";
case 41: return "SubgroupLocalInvocationId";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 42: return "VertexIndex"; // TBD: put next to VertexId?
case 43: return "InstanceIndex"; // TBD: put next to InstanceId?
Final round for line endings.
2015-06-26 22:58:36 +00:00
SPV: Implement the extension SPV_KHR_shader_ballot
2016-09-21 10:56:12 +00:00
case 4416: return "SubgroupEqMaskKHR";
case 4417: return "SubgroupGeMaskKHR";
case 4418: return "SubgroupGtMaskKHR";
case 4419: return "SubgroupLeMaskKHR";
case 4420: return "SubgroupLtMaskKHR";
SPV: Implement new extensions GL_KHX_device_group and GL_KHX_multiview. These correspond to SPV_KHR_device_group and SPV_KHR_multiview. Also, bring tests up to date with Khronos internals, and some misc. related changes.
2017-02-27 08:20:51 +00:00
case 4438: return "DeviceIndex";
case 4440: return "ViewIndex";
SPV: Implement extension SPV_KHR_shader_draw_parameters.
2016-07-22 10:15:31 +00:00
case 4424: return "BaseVertex";
case 4425: return "BaseInstance";
case 4426: return "DrawIndex";
Add GL_EXT_fragment_shading_rate
2020-07-02 07:50:36 +00:00
case 4432: return "PrimitiveShadingRateKHR";
case 4444: return "ShadingRateKHR";
SPV: Implement extension SPV_EXT_shader_stencil_export
2017-08-23 15:24:42 +00:00
case 5014: return "FragStencilRefEXT";
SPV: Implement extension SPV_KHR_shader_draw_parameters.
2016-07-22 10:15:31 +00:00
Implement 4 AMD-specific extensions. - Support GL_AMD_shader_ballot (SPV_AMD_shader_ballot). - Support GL_AMD_shader_trinary_minmax (SPV_AMD_shader_trinary_minmax). - Support GL_AMD_shader_explicit_vertex_parameter (SPV_AMD_shader_explicit_vertex_parameter). - Support GL_AMD_gcn_shader (SPV_AMD_gcn_shader).
2016-05-05 04:30:44 +00:00
case 4992: return "BaryCoordNoPerspAMD";
case 4993: return "BaryCoordNoPerspCentroidAMD";
case 4994: return "BaryCoordNoPerspSampleAMD";
case 4995: return "BaryCoordSmoothAMD";
case 4996: return "BaryCoordSmoothCentroidAMD";
case 4997: return "BaryCoordSmoothSampleAMD";
case 4998: return "BaryCoordPullModelAMD";
Add support for GLSL_EXT_ray_tracing and SPV_KHR_ray_tracing
2020-03-18 00:42:47 +00:00
case BuiltInLaunchIdKHR: return "LaunchIdKHR";
case BuiltInLaunchSizeKHR: return "LaunchSizeKHR";
case BuiltInWorldRayOriginKHR: return "WorldRayOriginKHR";
case BuiltInWorldRayDirectionKHR: return "WorldRayDirectionKHR";
case BuiltInObjectRayOriginKHR: return "ObjectRayOriginKHR";
case BuiltInObjectRayDirectionKHR: return "ObjectRayDirectionKHR";
case BuiltInRayTminKHR: return "RayTminKHR";
case BuiltInRayTmaxKHR: return "RayTmaxKHR";
Adding support for GL_EXT_ray_cull_mask
2022-05-05 10:56:04 +00:00
case BuiltInCullMaskKHR: return "CullMaskKHR";
GL_EXT_ray_tracing_position_fetch
2022-06-09 00:29:38 +00:00
case BuiltInHitTriangleVertexPositionsKHR: return "HitTriangleVertexPositionsKHR";
Add support for GL_NV_displacement_micromap. * Add support for GL_NV_displacement_micromap. * Update known_good for spirv-headers and spirv-tools.
2023-10-02 19:07:50 +00:00
case BuiltInHitMicroTriangleVertexPositionsNV: return "HitMicroTriangleVertexPositionsNV";
case BuiltInHitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV";
case BuiltInHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV";
case BuiltInHitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV";
Add support for GLSL_EXT_ray_tracing and SPV_KHR_ray_tracing
2020-03-18 00:42:47 +00:00
case BuiltInInstanceCustomIndexKHR: return "InstanceCustomIndexKHR";
case BuiltInRayGeometryIndexKHR: return "RayGeometryIndexKHR";
case BuiltInObjectToWorldKHR: return "ObjectToWorldKHR";
case BuiltInWorldToObjectKHR: return "WorldToObjectKHR";
update spirv-headers and fix handling of gl_HitTEXT (#2471) * update spirv-headers and fix handling of gl_HitTEXT Update spirv-headers known_good to f027d53ded7e230e008d37c8b47ede7cd308e19d and update SPIRV/spirv.hpp to copy from that version as well. In GLSL gl_HitTNV/gl_HitTEXT is defined as an alias of gl_RayTmaxNV/gl_RayTmaxEXT SPV_NV_ray_tracing has a dedicated HitTNV which gl_HitTNV maps to. For SPV_KHR_ray_tracing, gl_HitTEXT gets mapped to a RayTmaxKHR decoraged variable to simplify the SPIRV consumer. This change fixes the mapping for the GL_EXT_ray_tracing extension, and updates the test results to match. * update MissNV shader test to not use ObjectRay builtins They shouldn't existing in the miss stage because there is no object intersected
2020-11-30 16:57:34 +00:00
case BuiltInHitTNV: return "HitTNV";
Add support for GLSL_EXT_ray_tracing and SPV_KHR_ray_tracing
2020-03-18 00:42:47 +00:00
case BuiltInHitKindKHR: return "HitKindKHR";
case BuiltInIncomingRayFlagsKHR: return "IncomingRayFlagsKHR";
case BuiltInViewportMaskNV: return "ViewportMaskNV";
case BuiltInSecondaryPositionNV: return "SecondaryPositionNV";
case BuiltInSecondaryViewportMaskNV: return "SecondaryViewportMaskNV";
case BuiltInPositionPerViewNV: return "PositionPerViewNV";
case BuiltInViewportMaskPerViewNV: return "ViewportMaskPerViewNV";
Implement GL_EXT_fragment_invocation_density including SPV generation using SPV_EXT_fragment_invocation_density. This is an alias of the functionality in SPV_NV_shading_rate, and thus in some cases we can only have one set of the tokens present (switch statements), so we have picked the EXT version. This required updating the expected test results for SPV_NV_shading_rate. Also updated the known-good for spirv-headers so that the validator in spirv-tools knows about the new extension.
2018-11-26 15:01:58 +00:00
// case BuiltInFragmentSizeNV: return "FragmentSizeNV"; // superseded by BuiltInFragSizeEXT
// case BuiltInInvocationsPerPixelNV: return "InvocationsPerPixelNV"; // superseded by BuiltInFragInvocationCountEXT
Add support for VK_EXT_fragment_shader_barycentric
2022-05-13 16:23:29 +00:00
case BuiltInBaryCoordKHR: return "BaryCoordKHR";
case BuiltInBaryCoordNoPerspKHR: return "BaryCoordNoPerspKHR";
SPV: Implement new extensions GL_KHX_device_group and GL_KHX_multiview. These correspond to SPV_KHR_device_group and SPV_KHR_multiview. Also, bring tests up to date with Khronos internals, and some misc. related changes.
2017-02-27 08:20:51 +00:00
Add support for GLSL_EXT_ray_tracing and SPV_KHR_ray_tracing
2020-03-18 00:42:47 +00:00
case BuiltInFragSizeEXT: return "FragSizeEXT";
case BuiltInFragInvocationCountEXT: return "FragInvocationCountEXT";
Implement GL_EXT_fragment_invocation_density including SPV generation using SPV_EXT_fragment_invocation_density. This is an alias of the functionality in SPV_NV_shading_rate, and thus in some cases we can only have one set of the tokens present (switch statements), so we have picked the EXT version. This required updating the expected test results for SPV_NV_shading_rate. Also updated the known-good for spirv-headers so that the validator in spirv-tools knows about the new extension.
2018-11-26 15:01:58 +00:00
Add implementation of SPV_EXT_fragment_fully_covered This implementation uses the GLSL extension GL_NV_conservative_raster_underestimation to generate the new SPIR-V FullyCoveredEXT built in.
2017-12-13 20:07:22 +00:00
case 5264: return "FullyCoveredEXT";
Add-support-for-SPV_NV_mesh_shader
2018-09-19 18:41:59 +00:00
case BuiltInTaskCountNV: return "TaskCountNV";
case BuiltInPrimitiveCountNV: return "PrimitiveCountNV";
case BuiltInPrimitiveIndicesNV: return "PrimitiveIndicesNV";
case BuiltInClipDistancePerViewNV: return "ClipDistancePerViewNV";
case BuiltInCullDistancePerViewNV: return "CullDistancePerViewNV";
case BuiltInLayerPerViewNV: return "LayerPerViewNV";
case BuiltInMeshViewCountNV: return "MeshViewCountNV";
case BuiltInMeshViewIndicesNV: return "MeshViewIndicesNV";
Add support for GL_NV_shader_sm_builtins Including spirv and AST tests Also increase size of TBuiltInVariable bitfields since we've now exceeded 127 and add a static_assert to make this easier to find next time it happens!
2019-06-04 12:43:32 +00:00
case BuiltInWarpsPerSMNV: return "WarpsPerSMNV";
case BuiltInSMCountNV: return "SMCountNV";
case BuiltInWarpIDNV: return "WarpIDNV";
case BuiltInSMIDNV: return "SMIDNV";
Add support for GL_NV_ray_tracing_motion_blur.
2021-08-10 17:40:28 +00:00
case BuiltInCurrentRayTimeNV: return "CurrentRayTimeNV";
GL_EXT_mesh_shader/SPV_EXT_mesh_shader implementation Added following updates to GL_EXT_mesh_shader implementation: 1. Added SPIRV and GLSL test cases 2. Added checks to ensure NV and EXT mesh shader builtins cannot be used interchangeably. 3. Updated the language name by removing the postfix "NV" to MeshShader and TaskShader. 4. Added checks for grammar checking to comply with the spec. 5. Added gl_NumWorkGroups builtin to Mesh shader 6. Fixed data type of gl_PrimitiveLineIndicesEXT and gl_PrimitiveTriangleIndicesEXT 7. Added new constants to the resources table 8. Updates to handle new storage qualifier "taskPayloadSharedEXT" 9. Updated test cases by replacing "taskEXT" with storage qualifier "taskPayloadSharedEXT" Addressed Review comments 1. Fixed instruction description used by glslang disassembly. 2. Updated OpEmitMeshTasksEXT as per spec update 3. Fixed implementation that errors out if there are more then one taskPayloadSharedEXT varjables. 4. Fixed miscellaneous error logs and removed unwanted code. SPIRV 1.6 related build failure fixes - Update SPIRV header to 1.6 - Fix conflict wiht SPIRV 1.6 change, where localSizeId is used for execution mode for mesh/task shaders Enable SPIRV generated for EXT_mesh_shader to be version 1.4 GL_EXT_mesh_shader: Add checks for atomic support and corresponding test cases
2021-08-25 20:41:32 +00:00
case BuiltInPrimitivePointIndicesEXT: return "PrimitivePointIndicesEXT";
case BuiltInPrimitiveLineIndicesEXT: return "PrimitiveLineIndicesEXT";
case BuiltInPrimitiveTriangleIndicesEXT: return "PrimitiveTriangleIndicesEXT";
case BuiltInCullPrimitiveEXT: return "CullPrimitiveEXT";
GL_ARM_shader_core_builtins support Add support for GL_ARM_shader_core_builtins and SPV_ARM_core_builtins, including initial tests
2022-12-05 12:02:22 +00:00
case BuiltInCoreCountARM: return "CoreCountARM";
case BuiltInCoreIDARM: return "CoreIDARM";
case BuiltInCoreMaxIDARM: return "CoreMaxIDARM";
case BuiltInWarpIDARM: return "WarpIDARM";
case BuiltInWarpMaxIDARM: return "BuiltInWarpMaxIDARM";
Add-support-for-SPV_NV_mesh_shader
2018-09-19 18:41:59 +00:00
SPV: Implement new extensions GL_KHX_device_group and GL_KHX_multiview. These correspond to SPV_KHR_device_group and SPV_KHR_multiview. Also, bring tests up to date with Khronos internals, and some misc. related changes.
2017-02-27 08:20:51 +00:00
default: return "Bad";
Final round for line endings.
2015-06-26 22:58:36 +00:00
}
}
const char* DimensionString(int dim)
{
switch (dim) {
case 0: return "1D";
case 1: return "2D";
case 2: return "3D";
case 3: return "Cube";
case 4: return "Rect";
case 5: return "Buffer";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 6: return "SubpassData";
Add GLSL_EXT_shader_tile_image
2023-03-30 15:50:56 +00:00
case DimTileImageDataEXT: return "TileImageDataEXT";
Final round for line endings.
2015-06-26 22:58:36 +00:00
default: return "Bad";
}
}
const char* SamplerAddressingModeString(int mode)
{
switch (mode) {
case 0: return "None";
case 1: return "ClampToEdge";
case 2: return "Clamp";
case 3: return "Repeat";
case 4: return "RepeatMirrored";
default: return "Bad";
}
}
const char* SamplerFilterModeString(int mode)
{
switch (mode) {
case 0: return "Nearest";
case 1: return "Linear";
default: return "Bad";
}
}
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
const char* ImageFormatString(int format)
{
switch (format) {
case 0: return "Unknown";
// ES/Desktop float
case 1: return "Rgba32f";
case 2: return "Rgba16f";
case 3: return "R32f";
case 4: return "Rgba8";
case 5: return "Rgba8Snorm";
// Desktop float
case 6: return "Rg32f";
case 7: return "Rg16f";
case 8: return "R11fG11fB10f";
case 9: return "R16f";
case 10: return "Rgba16";
case 11: return "Rgb10A2";
case 12: return "Rg16";
case 13: return "Rg8";
case 14: return "R16";
case 15: return "R8";
case 16: return "Rgba16Snorm";
case 17: return "Rg16Snorm";
case 18: return "Rg8Snorm";
case 19: return "R16Snorm";
case 20: return "R8Snorm";
// ES/Desktop int
case 21: return "Rgba32i";
case 22: return "Rgba16i";
case 23: return "Rgba8i";
case 24: return "R32i";
// Desktop int
case 25: return "Rg32i";
case 26: return "Rg16i";
case 27: return "Rg8i";
case 28: return "R16i";
case 29: return "R8i";
// ES/Desktop uint
case 30: return "Rgba32ui";
case 31: return "Rgba16ui";
case 32: return "Rgba8ui";
case 33: return "R32ui";
// Desktop uint
case 34: return "Rgb10a2ui";
case 35: return "Rg32ui";
case 36: return "Rg16ui";
case 37: return "Rg8ui";
case 38: return "R16ui";
case 39: return "R8ui";
Add GL_EXT_shader_image_int64 support (#2409)
2020-11-04 16:24:23 +00:00
case 40: return "R64ui";
case 41: return "R64i";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
default:
return "Bad";
}
}
const char* ImageChannelOrderString(int format)
{
switch (format) {
case 0: return "R";
case 1: return "A";
case 2: return "RG";
case 3: return "RA";
case 4: return "RGB";
case 5: return "RGBA";
case 6: return "BGRA";
case 7: return "ARGB";
case 8: return "Intensity";
case 9: return "Luminance";
case 10: return "Rx";
case 11: return "RGx";
case 12: return "RGBx";
case 13: return "Depth";
case 14: return "DepthStencil";
case 15: return "sRGB";
case 16: return "sRGBx";
case 17: return "sRGBA";
case 18: return "sBGRA";
[glslang] Strip trailing whitespace There are many other files in the repo that have trailing whitespace but this PR only cleans `glslang/SPIRV` and `glslang/Standalone`.
2023-05-22 15:44:18 +00:00
default:
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
return "Bad";
}
}
const char* ImageChannelDataTypeString(int type)
{
switch (type)
{
case 0: return "SnormInt8";
case 1: return "SnormInt16";
case 2: return "UnormInt8";
case 3: return "UnormInt16";
case 4: return "UnormShort565";
case 5: return "UnormShort555";
case 6: return "UnormInt101010";
case 7: return "SignedInt8";
case 8: return "SignedInt16";
case 9: return "SignedInt32";
case 10: return "UnsignedInt8";
case 11: return "UnsignedInt16";
case 12: return "UnsignedInt32";
case 13: return "HalfFloat";
case 14: return "Float";
case 15: return "UnormInt24";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 16: return "UnormInt101010_2";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
default:
return "Bad";
}
}
SPV 1.4: Emit SignExtend and ZeroExtend for integer image reads/writes.
2019-03-31 16:51:57 +00:00
const int ImageOperandsCeiling = 14;
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
const char* ImageOperandsString(int format)
{
switch (format) {
GL_KHR_memory_scope_semantics
2018-09-05 15:11:41 +00:00
case ImageOperandsBiasShift: return "Bias";
case ImageOperandsLodShift: return "Lod";
case ImageOperandsGradShift: return "Grad";
case ImageOperandsConstOffsetShift: return "ConstOffset";
case ImageOperandsOffsetShift: return "Offset";
case ImageOperandsConstOffsetsShift: return "ConstOffsets";
case ImageOperandsSampleShift: return "Sample";
case ImageOperandsMinLodShift: return "MinLod";
case ImageOperandsMakeTexelAvailableKHRShift: return "MakeTexelAvailableKHR";
case ImageOperandsMakeTexelVisibleKHRShift: return "MakeTexelVisibleKHR";
case ImageOperandsNonPrivateTexelKHRShift: return "NonPrivateTexelKHR";
case ImageOperandsVolatileTexelKHRShift: return "VolatileTexelKHR";
SPV 1.4: Emit SignExtend and ZeroExtend for integer image reads/writes.
2019-03-31 16:51:57 +00:00
case ImageOperandsSignExtendShift: return "SignExtend";
case ImageOperandsZeroExtendShift: return "ZeroExtend";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case ImageOperandsCeiling:
default:
return "Bad";
}
}
Final round for line endings.
2015-06-26 22:58:36 +00:00
const char* FPFastMathString(int mode)
{
switch (mode) {
case 0: return "NotNaN";
case 1: return "NotInf";
case 2: return "NSZ";
case 3: return "AllowRecip";
case 4: return "Fast";
default: return "Bad";
}
}
const char* FPRoundingModeString(int mode)
{
switch (mode) {
case 0: return "RTE";
case 1: return "RTZ";
case 2: return "RTP";
case 3: return "RTN";
default: return "Bad";
}
}
const char* LinkageTypeString(int type)
{
switch (type) {
case 0: return "Export";
case 1: return "Import";
default: return "Bad";
}
}
const char* FuncParamAttrString(int attr)
{
switch (attr) {
case 0: return "Zext";
case 1: return "Sext";
case 2: return "ByVal";
case 3: return "Sret";
case 4: return "NoAlias";
case 5: return "NoCapture";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 6: return "NoWrite";
case 7: return "NoReadWrite";
Final round for line endings.
2015-06-26 22:58:36 +00:00
default: return "Bad";
}
}
const char* AccessQualifierString(int attr)
{
switch (attr) {
case 0: return "ReadOnly";
case 1: return "WriteOnly";
case 2: return "ReadWrite";
default: return "Bad";
}
}
const int SelectControlCeiling = 2;
const char* SelectControlString(int cont)
{
switch (cont) {
case 0: return "Flatten";
case 1: return "DontFlatten";
case SelectControlCeiling:
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
default: return "Bad";
Final round for line endings.
2015-06-26 22:58:36 +00:00
}
}
SPV 1.4: Implement the 5 new loop controls.
2019-01-12 10:31:41 +00:00
const int LoopControlCeiling = LoopControlPartialCountShift + 1;
Final round for line endings.
2015-06-26 22:58:36 +00:00
const char* LoopControlString(int cont)
{
switch (cont) {
SPV 1.4: Implement the 5 new loop controls.
2019-01-12 10:31:41 +00:00
case LoopControlUnrollShift: return "Unroll";
case LoopControlDontUnrollShift: return "DontUnroll";
case LoopControlDependencyInfiniteShift: return "DependencyInfinite";
case LoopControlDependencyLengthShift: return "DependencyLength";
case LoopControlMinIterationsShift: return "MinIterations";
case LoopControlMaxIterationsShift: return "MaxIterations";
case LoopControlIterationMultipleShift: return "IterationMultiple";
case LoopControlPeelCountShift: return "PeelCount";
case LoopControlPartialCountShift: return "PartialCount";
Final round for line endings.
2015-06-26 22:58:36 +00:00
case LoopControlCeiling:
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
default: return "Bad";
Final round for line endings.
2015-06-26 22:58:36 +00:00
}
}
const int FunctionControlCeiling = 4;
const char* FunctionControlString(int cont)
{
switch (cont) {
case 0: return "Inline";
case 1: return "DontInline";
case 2: return "Pure";
case 3: return "Const";
case FunctionControlCeiling:
default: return "Bad";
}
}
const char* MemorySemanticsString(int mem)
{
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
// Note: No bits set (None) means "Relaxed"
Final round for line endings.
2015-06-26 22:58:36 +00:00
switch (mem) {
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 0: return "Bad"; // Note: this is a placeholder for 'Consume'
case 1: return "Acquire";
case 2: return "Release";
case 3: return "AcquireRelease";
case 4: return "SequentiallyConsistent";
case 5: return "Bad"; // Note: reserved for future expansion
case 6: return "UniformMemory";
case 7: return "SubgroupMemory";
case 8: return "WorkgroupMemory";
case 9: return "CrossWorkgroupMemory";
case 10: return "AtomicCounterMemory";
case 11: return "ImageMemory";
Final round for line endings.
2015-06-26 22:58:36 +00:00
default: return "Bad";
}
}
GL_KHR_memory_scope_semantics
2018-09-05 15:11:41 +00:00
const int MemoryAccessCeiling = 6;
Final round for line endings.
2015-06-26 22:58:36 +00:00
const char* MemoryAccessString(int mem)
{
switch (mem) {
GL_KHR_memory_scope_semantics
2018-09-05 15:11:41 +00:00
case MemoryAccessVolatileShift: return "Volatile";
case MemoryAccessAlignedShift: return "Aligned";
case MemoryAccessNontemporalShift: return "Nontemporal";
case MemoryAccessMakePointerAvailableKHRShift: return "MakePointerAvailableKHR";
case MemoryAccessMakePointerVisibleKHRShift: return "MakePointerVisibleKHR";
case MemoryAccessNonPrivatePointerKHRShift: return "NonPrivatePointerKHR";
Final round for line endings.
2015-06-26 22:58:36 +00:00
default: return "Bad";
}
}
Implement support for GL_KHR_cooperative_matrix extension
2023-03-16 12:01:01 +00:00
const int CooperativeMatrixOperandsCeiling = 6;
const char* CooperativeMatrixOperandsString(int op)
{
switch (op) {
Align spirv.hpp to SPIRV-Headers for SPV_KHR_cooperative_matrix Some of the enumerants used by this extension were missing a KHR suffix.
2023-10-25 23:59:52 +00:00
case CooperativeMatrixOperandsMatrixASignedComponentsKHRShift: return "ASignedComponentsKHR";
case CooperativeMatrixOperandsMatrixBSignedComponentsKHRShift: return "BSignedComponentsKHR";
case CooperativeMatrixOperandsMatrixCSignedComponentsKHRShift: return "CSignedComponentsKHR";
case CooperativeMatrixOperandsMatrixResultSignedComponentsKHRShift: return "ResultSignedComponentsKHR";
case CooperativeMatrixOperandsSaturatingAccumulationKHRShift: return "SaturatingAccumulationKHR";
Implement support for GL_KHR_cooperative_matrix extension
2023-03-16 12:01:01 +00:00
default: return "Bad";
}
}
Implement GLSL_NV_cooperative_matrix2
2024-10-08 19:39:29 +00:00
const int TensorAddressingOperandsCeiling = 3;
const char* TensorAddressingOperandsString(int op)
{
switch (op) {
case TensorAddressingOperandsTensorViewShift: return "TensorView";
case TensorAddressingOperandsDecodeFuncShift: return "DecodeFunc";
default: return "Bad";
}
}
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
const char* ScopeString(int mem)
Final round for line endings.
2015-06-26 22:58:36 +00:00
{
switch (mem) {
case 0: return "CrossDevice";
case 1: return "Device";
case 2: return "Workgroup";
case 3: return "Subgroup";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 4: return "Invocation";
Final round for line endings.
2015-06-26 22:58:36 +00:00
default: return "Bad";
}
}
const char* GroupOperationString(int gop)
{
switch (gop)
{
Implement GL_NV_shader_subgroup_partitioned
2018-03-30 03:52:17 +00:00
case GroupOperationReduce: return "Reduce";
case GroupOperationInclusiveScan: return "InclusiveScan";
case GroupOperationExclusiveScan: return "ExclusiveScan";
case GroupOperationClusteredReduce: return "ClusteredReduce";
case GroupOperationPartitionedReduceNV: return "PartitionedReduceNV";
case GroupOperationPartitionedInclusiveScanNV: return "PartitionedInclusiveScanNV";
case GroupOperationPartitionedExclusiveScanNV: return "PartitionedExclusiveScanNV";
Final round for line endings.
2015-06-26 22:58:36 +00:00
default: return "Bad";
}
}
const char* KernelEnqueueFlagsString(int flag)
{
switch (flag)
{
case 0: return "NoWait";
case 1: return "WaitKernel";
case 2: return "WaitWorkGroup";
default: return "Bad";
}
}
const char* KernelProfilingInfoString(int info)
{
switch (info)
{
case 0: return "CmdExecTime";
default: return "Bad";
}
}
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
const char* CapabilityString(int info)
{
switch (info)
{
case 0: return "Matrix";
case 1: return "Shader";
case 2: return "Geometry";
case 3: return "Tessellation";
case 4: return "Addresses";
case 5: return "Linkage";
case 6: return "Kernel";
case 7: return "Vector16";
case 8: return "Float16Buffer";
case 9: return "Float16";
case 10: return "Float64";
case 11: return "Int64";
case 12: return "Int64Atomics";
case 13: return "ImageBasic";
case 14: return "ImageReadWrite";
case 15: return "ImageMipmap";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 16: return "Bad";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 17: return "Pipes";
case 18: return "Groups";
case 19: return "DeviceEnqueue";
case 20: return "LiteralSampler";
case 21: return "AtomicStorage";
case 22: return "Int16";
case 23: return "TessellationPointSize";
case 24: return "GeometryPointSize";
[glslang] Strip trailing whitespace There are many other files in the repo that have trailing whitespace but this PR only cleans `glslang/SPIRV` and `glslang/Standalone`.
2023-05-22 15:44:18 +00:00
case 25: return "ImageGatherExtended";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 26: return "Bad";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 27: return "StorageImageMultisample";
case 28: return "UniformBufferArrayDynamicIndexing";
case 29: return "SampledImageArrayDynamicIndexing";
case 30: return "StorageBufferArrayDynamicIndexing";
case 31: return "StorageImageArrayDynamicIndexing";
case 32: return "ClipDistance";
case 33: return "CullDistance";
case 34: return "ImageCubeArray";
case 35: return "SampleRateShading";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 36: return "ImageRect";
case 37: return "SampledRect";
case 38: return "GenericPointer";
case 39: return "Int8";
case 40: return "InputAttachment";
case 41: return "SparseResidency";
case 42: return "MinLod";
case 43: return "Sampled1D";
case 44: return "Image1D";
case 45: return "SampledCubeArray";
case 46: return "SampledBuffer";
case 47: return "ImageBuffer";
case 48: return "ImageMSArray";
case 49: return "StorageImageExtendedFormats";
case 50: return "ImageQuery";
case 51: return "DerivativeControl";
case 52: return "InterpolationFunction";
case 53: return "TransformFeedback";
case 54: return "GeometryStreams";
case 55: return "StorageImageReadWithoutFormat";
case 56: return "StorageImageWriteWithoutFormat";
SPV: Implement Vulkan version of GLSL (KHR_vulkan_glsl).
2016-02-16 03:58:50 +00:00
case 57: return "MultiViewport";
SPV: Implement Vulkan 1.1 features and extensions.
2018-03-06 23:12:04 +00:00
case 61: return "GroupNonUniform";
case 62: return "GroupNonUniformVote";
case 63: return "GroupNonUniformArithmetic";
case 64: return "GroupNonUniformBallot";
case 65: return "GroupNonUniformShuffle";
case 66: return "GroupNonUniformShuffleRelative";
case 67: return "GroupNonUniformClustered";
case 68: return "GroupNonUniformQuad";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
Non-Functional: Remove unused parts of the disassembler.
2018-03-30 06:11:39 +00:00
case CapabilitySubgroupBallotKHR: return "SubgroupBallotKHR";
case CapabilityDrawParameters: return "DrawParameters";
case CapabilitySubgroupVoteKHR: return "SubgroupVoteKHR";
Add GL_KHR_shader_subgroup_rotate support Co-authored-by: Neil Hickey <neil.hickey@arm.com> Co-authored-by: Stuart Brady <stuart.brady@arm.com> Signed-off-by: Sven van Haastregt <sven.vanhaastregt@arm.com>
2024-02-06 15:20:16 +00:00
case CapabilityGroupNonUniformRotateKHR: return "CapabilityGroupNonUniformRotateKHR";
Add support for SPV_NV_geometry_shader_passthrough
2016-12-20 21:28:52 +00:00
Non-Functional: Remove unused parts of the disassembler.
2018-03-30 06:11:39 +00:00
case CapabilityStorageUniformBufferBlock16: return "StorageUniformBufferBlock16";
case CapabilityStorageUniform16: return "StorageUniform16";
case CapabilityStoragePushConstant16: return "StoragePushConstant16";
case CapabilityStorageInputOutput16: return "StorageInputOutput16";
Implement the extension SPV_KHR_16bit_storage
2017-04-07 15:22:33 +00:00
Return consistent names from CapabilityString Don't prefix with "Capability" since the majority of them don't. Also add missing CapabilityImageFootprintNV
2019-05-28 19:23:10 +00:00
case CapabilityStorageBuffer8BitAccess: return "StorageBuffer8BitAccess";
case CapabilityUniformAndStorageBuffer8BitAccess: return "UniformAndStorageBuffer8BitAccess";
case CapabilityStoragePushConstant8: return "StoragePushConstant8";
Implement GL_EXT_shader_16bit_storage and GL_EXT_shader_8bit_storage extensions. These introduce limited support for 8/16-bit types such that they can only be accessed in buffer memory and converted to/from 32-bit types. Contributed from Khronos-internal work.
2018-07-03 19:19:51 +00:00
Non-Functional: Remove unused parts of the disassembler.
2018-03-30 06:11:39 +00:00
case CapabilityDeviceGroup: return "DeviceGroup";
case CapabilityMultiView: return "MultiView";
SPV Non-functional: fix ordering causing problems with another branch.
2017-04-13 23:08:11 +00:00
Remove the test spv.intrinsicsSpecConst According to current SPIR-V spec, we couldn't write a valid case that references OpExecutionModeId and OpDecorateId.
2021-11-22 12:05:06 +00:00
case CapabilityDenormPreserve: return "DenormPreserve";
case CapabilityDenormFlushToZero: return "DenormFlushToZero";
case CapabilitySignedZeroInfNanPreserve: return "SignedZeroInfNanPreserve";
case CapabilityRoundingModeRTE: return "RoundingModeRTE";
case CapabilityRoundingModeRTZ: return "RoundingModeRTZ";
Non-Functional: Remove unused parts of the disassembler.
2018-03-30 06:11:39 +00:00
case CapabilityStencilExportEXT: return "StencilExportEXT";
SPV: Implement extension SPV_EXT_shader_stencil_export
2017-08-23 15:24:42 +00:00
Non-Functional: Remove unused parts of the disassembler.
2018-03-30 06:11:39 +00:00
case CapabilityFloat16ImageAMD: return "Float16ImageAMD";
case CapabilityImageGatherBiasLodAMD: return "ImageGatherBiasLodAMD";
case CapabilityFragmentMaskAMD: return "FragmentMaskAMD";
case CapabilityImageReadWriteLodAMD: return "ImageReadWriteLodAMD";
Implement the extension GL_AMD_texture_gather_bias_lod
2016-11-17 09:47:59 +00:00
Non-Functional: Remove unused parts of the disassembler.
2018-03-30 06:11:39 +00:00
case CapabilityAtomicStorageOps: return "AtomicStorageOps";
GLSL 4.6: Implement atomic counter ops and SPV_KHR_shader_atomic_counter_ops.
2017-07-23 22:08:26 +00:00
Non-Functional: Remove unused parts of the disassembler.
2018-03-30 06:11:39 +00:00
case CapabilitySampleMaskPostDepthCoverage: return "SampleMaskPostDepthCoverage";
Add-support-for-SPV_NV_compute_shader_derivatives
2018-09-19 18:40:45 +00:00
case CapabilityGeometryShaderPassthroughNV: return "GeometryShaderPassthroughNV";
case CapabilityShaderViewportIndexLayerNV: return "ShaderViewportIndexLayerNV";
case CapabilityShaderViewportMaskNV: return "ShaderViewportMaskNV";
case CapabilityShaderStereoViewNV: return "ShaderStereoViewNV";
case CapabilityPerViewAttributesNV: return "PerViewAttributesNV";
case CapabilityGroupNonUniformPartitionedNV: return "GroupNonUniformPartitionedNV";
Multiple features and misc fixes for final raytracing non experimental version.
2018-10-22 23:41:44 +00:00
case CapabilityRayTracingNV: return "RayTracingNV";
Add support for GL_NV_ray_tracing_motion_blur.
2021-08-10 17:40:28 +00:00
case CapabilityRayTracingMotionBlurNV: return "RayTracingMotionBlurNV";
Updates for final Vulkan ray tracing extensions (#2466) * Fix traceRay/executeCallable to have id instead of constant. Update to final (non-provisional) SPIR-V capabilities (includes review feedback) - Change visibilty of findLinkerObjects. See merge request GLSL/glslang!78 * Add support for OpConvertUToAccelerationStructureKHR. GLSL : https://gitlab.khronos.org/GLSL/GLSL/-/merge_requests/60 SPV : https://gitlab.khronos.org/spirv/spirv-extensions/-/merge_requests/182 See merge request GLSL/glslang!77 * Add volatile qualifier to certain builtins for ray tracing. See merge request GLSL/glslang!81 * make gl_RayTmaxEXT volatile in intersection shader Vulkan Issue #2268 * Add testing for layouts on SBT vulkan/vulkan#2230 - no layout specified should be same as std430 - explicitly test std140, std430, scalar layouts See merge request GLSL/glslang!86 * Support for new opcodes OpIgnoreIntersectionKHR and OpTerminateRayKHR vulkan/vulkan#2374 Add support for ignoreIntersectionEXT and terminateRayEXT as block terminator statements. See merge request GLSL/glslang!87 * Fix code-generation issues with global ray query variables See merge request GLSL/glslang!88 * update dependencies for spirv-headers and tools And update mesh shader results * Fix indeterminate argument ordering Authored-by: David Neto <dneto@google.com> Co-authored-by: Ashwin Lele (NVIDIA Corporation) <alele@nvidia.com> Co-authored-by: Neslisah <Neslisah.Torosdagli@amd.com>
2020-11-23 20:41:27 +00:00
case CapabilityRayTracingKHR: return "RayTracingKHR";
Adding support for GL_EXT_ray_cull_mask
2022-05-05 10:56:04 +00:00
case CapabilityRayCullMaskKHR: return "RayCullMaskKHR";
Updates for final Vulkan ray tracing extensions (#2466) * Fix traceRay/executeCallable to have id instead of constant. Update to final (non-provisional) SPIR-V capabilities (includes review feedback) - Change visibilty of findLinkerObjects. See merge request GLSL/glslang!78 * Add support for OpConvertUToAccelerationStructureKHR. GLSL : https://gitlab.khronos.org/GLSL/GLSL/-/merge_requests/60 SPV : https://gitlab.khronos.org/spirv/spirv-extensions/-/merge_requests/182 See merge request GLSL/glslang!77 * Add volatile qualifier to certain builtins for ray tracing. See merge request GLSL/glslang!81 * make gl_RayTmaxEXT volatile in intersection shader Vulkan Issue #2268 * Add testing for layouts on SBT vulkan/vulkan#2230 - no layout specified should be same as std430 - explicitly test std140, std430, scalar layouts See merge request GLSL/glslang!86 * Support for new opcodes OpIgnoreIntersectionKHR and OpTerminateRayKHR vulkan/vulkan#2374 Add support for ignoreIntersectionEXT and terminateRayEXT as block terminator statements. See merge request GLSL/glslang!87 * Fix code-generation issues with global ray query variables See merge request GLSL/glslang!88 * update dependencies for spirv-headers and tools And update mesh shader results * Fix indeterminate argument ordering Authored-by: David Neto <dneto@google.com> Co-authored-by: Ashwin Lele (NVIDIA Corporation) <alele@nvidia.com> Co-authored-by: Neslisah <Neslisah.Torosdagli@amd.com>
2020-11-23 20:41:27 +00:00
case CapabilityRayQueryKHR: return "RayQueryKHR";
SPV: The capability string for RayTracingProvisionalKHR is missing Add it to GLSLang disassembler.
2021-03-04 09:00:49 +00:00
case CapabilityRayTracingProvisionalKHR: return "RayTracingProvisionalKHR";
Updates for final Vulkan ray tracing extensions (#2466) * Fix traceRay/executeCallable to have id instead of constant. Update to final (non-provisional) SPIR-V capabilities (includes review feedback) - Change visibilty of findLinkerObjects. See merge request GLSL/glslang!78 * Add support for OpConvertUToAccelerationStructureKHR. GLSL : https://gitlab.khronos.org/GLSL/GLSL/-/merge_requests/60 SPV : https://gitlab.khronos.org/spirv/spirv-extensions/-/merge_requests/182 See merge request GLSL/glslang!77 * Add volatile qualifier to certain builtins for ray tracing. See merge request GLSL/glslang!81 * make gl_RayTmaxEXT volatile in intersection shader Vulkan Issue #2268 * Add testing for layouts on SBT vulkan/vulkan#2230 - no layout specified should be same as std430 - explicitly test std140, std430, scalar layouts See merge request GLSL/glslang!86 * Support for new opcodes OpIgnoreIntersectionKHR and OpTerminateRayKHR vulkan/vulkan#2374 Add support for ignoreIntersectionEXT and terminateRayEXT as block terminator statements. See merge request GLSL/glslang!87 * Fix code-generation issues with global ray query variables See merge request GLSL/glslang!88 * update dependencies for spirv-headers and tools And update mesh shader results * Fix indeterminate argument ordering Authored-by: David Neto <dneto@google.com> Co-authored-by: Ashwin Lele (NVIDIA Corporation) <alele@nvidia.com> Co-authored-by: Neslisah <Neslisah.Torosdagli@amd.com>
2020-11-23 20:41:27 +00:00
case CapabilityRayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR";
GL_EXT_ray_tracing_position_fetch
2022-06-09 00:29:38 +00:00
case CapabilityRayTracingPositionFetchKHR: return "RayTracingPositionFetchKHR";
Add support for GL_NV_displacement_micromap. * Add support for GL_NV_displacement_micromap. * Update known_good for spirv-headers and spirv-tools.
2023-10-02 19:07:50 +00:00
case CapabilityDisplacementMicromapNV: return "DisplacementMicromapNV";
case CapabilityRayTracingDisplacementMicromapNV: return "CapabilityRayTracingDisplacementMicromapNV";
GL_EXT_ray_tracing_position_fetch
2022-06-09 00:29:38 +00:00
case CapabilityRayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR";
Add-support-for-SPV_NV_compute_shader_derivatives
2018-09-19 18:40:45 +00:00
case CapabilityComputeDerivativeGroupQuadsNV: return "ComputeDerivativeGroupQuadsNV";
case CapabilityComputeDerivativeGroupLinearNV: return "ComputeDerivativeGroupLinearNV";
Add support for VK_EXT_fragment_shader_barycentric
2022-05-13 16:23:29 +00:00
case CapabilityFragmentBarycentricKHR: return "FragmentBarycentricKHR";
Add-support-for-SPV_NV_mesh_shader
2018-09-19 18:41:59 +00:00
case CapabilityMeshShadingNV: return "MeshShadingNV";
Return consistent names from CapabilityString Don't prefix with "Capability" since the majority of them don't. Also add missing CapabilityImageFootprintNV
2019-05-28 19:23:10 +00:00
case CapabilityImageFootprintNV: return "ImageFootprintNV";
GL_EXT_mesh_shader/SPV_EXT_mesh_shader implementation Added following updates to GL_EXT_mesh_shader implementation: 1. Added SPIRV and GLSL test cases 2. Added checks to ensure NV and EXT mesh shader builtins cannot be used interchangeably. 3. Updated the language name by removing the postfix "NV" to MeshShader and TaskShader. 4. Added checks for grammar checking to comply with the spec. 5. Added gl_NumWorkGroups builtin to Mesh shader 6. Fixed data type of gl_PrimitiveLineIndicesEXT and gl_PrimitiveTriangleIndicesEXT 7. Added new constants to the resources table 8. Updates to handle new storage qualifier "taskPayloadSharedEXT" 9. Updated test cases by replacing "taskEXT" with storage qualifier "taskPayloadSharedEXT" Addressed Review comments 1. Fixed instruction description used by glslang disassembly. 2. Updated OpEmitMeshTasksEXT as per spec update 3. Fixed implementation that errors out if there are more then one taskPayloadSharedEXT varjables. 4. Fixed miscellaneous error logs and removed unwanted code. SPIRV 1.6 related build failure fixes - Update SPIRV header to 1.6 - Fix conflict wiht SPIRV 1.6 change, where localSizeId is used for execution mode for mesh/task shaders Enable SPIRV generated for EXT_mesh_shader to be version 1.4 GL_EXT_mesh_shader: Add checks for atomic support and corresponding test cases
2021-08-25 20:41:32 +00:00
case CapabilityMeshShadingEXT: return "MeshShadingEXT";
Return consistent names from CapabilityString Don't prefix with "Capability" since the majority of them don't. Also add missing CapabilityImageFootprintNV
2019-05-28 19:23:10 +00:00
// case CapabilityShadingRateNV: return "ShadingRateNV"; // superseded by FragmentDensityEXT
spirv: Generate missing SampleMaskOverrideCoverageNV capability op The SampleMaskOverrideCoverageNV capability should be declared when gl_SampleMask is used.
2019-07-12 21:33:02 +00:00
case CapabilitySampleMaskOverrideCoverageNV: return "SampleMaskOverrideCoverageNV";
Implement GL_EXT_fragment_invocation_density including SPV generation using SPV_EXT_fragment_invocation_density. This is an alias of the functionality in SPV_NV_shading_rate, and thus in some cases we can only have one set of the tokens present (switch statements), so we have picked the EXT version. This required updating the expected test results for SPV_NV_shading_rate. Also updated the known-good for spirv-headers so that the validator in spirv-tools knows about the new extension.
2018-11-26 15:01:58 +00:00
case CapabilityFragmentDensityEXT: return "FragmentDensityEXT";
Add support for SPV_NV_geometry_shader_passthrough
2016-12-20 21:28:52 +00:00
Non-Functional: Remove unused parts of the disassembler.
2018-03-30 06:11:39 +00:00
case CapabilityFragmentFullyCoveredEXT: return "FragmentFullyCoveredEXT";
Add implementation of SPV_EXT_fragment_fully_covered This implementation uses the GLSL extension GL_NV_conservative_raster_underestimation to generate the new SPIR-V FullyCoveredEXT built in.
2017-12-13 20:07:22 +00:00
Return consistent names from CapabilityString Don't prefix with "Capability" since the majority of them don't. Also add missing CapabilityImageFootprintNV
2019-05-28 19:23:10 +00:00
case CapabilityShaderNonUniformEXT: return "ShaderNonUniformEXT";
case CapabilityRuntimeDescriptorArrayEXT: return "RuntimeDescriptorArrayEXT";
case CapabilityInputAttachmentArrayDynamicIndexingEXT: return "InputAttachmentArrayDynamicIndexingEXT";
case CapabilityUniformTexelBufferArrayDynamicIndexingEXT: return "UniformTexelBufferArrayDynamicIndexingEXT";
case CapabilityStorageTexelBufferArrayDynamicIndexingEXT: return "StorageTexelBufferArrayDynamicIndexingEXT";
case CapabilityUniformBufferArrayNonUniformIndexingEXT: return "UniformBufferArrayNonUniformIndexingEXT";
case CapabilitySampledImageArrayNonUniformIndexingEXT: return "SampledImageArrayNonUniformIndexingEXT";
case CapabilityStorageBufferArrayNonUniformIndexingEXT: return "StorageBufferArrayNonUniformIndexingEXT";
case CapabilityStorageImageArrayNonUniformIndexingEXT: return "StorageImageArrayNonUniformIndexingEXT";
case CapabilityInputAttachmentArrayNonUniformIndexingEXT: return "InputAttachmentArrayNonUniformIndexingEXT";
case CapabilityUniformTexelBufferArrayNonUniformIndexingEXT: return "UniformTexelBufferArrayNonUniformIndexingEXT";
case CapabilityStorageTexelBufferArrayNonUniformIndexingEXT: return "StorageTexelBufferArrayNonUniformIndexingEXT";
GLSL/SPV: Implement SPV_EXT_descriptor_indexing and GL_EXT_nonuniform_qualifier
2018-04-05 17:25:02 +00:00
Return consistent names from CapabilityString Don't prefix with "Capability" since the majority of them don't. Also add missing CapabilityImageFootprintNV
2019-05-28 19:23:10 +00:00
case CapabilityVulkanMemoryModelKHR: return "VulkanMemoryModelKHR";
case CapabilityVulkanMemoryModelDeviceScopeKHR: return "VulkanMemoryModelDeviceScopeKHR";
GL_KHR_memory_scope_semantics
2018-09-05 15:11:41 +00:00
Return consistent names from CapabilityString Don't prefix with "Capability" since the majority of them don't. Also add missing CapabilityImageFootprintNV
2019-05-28 19:23:10 +00:00
case CapabilityPhysicalStorageBufferAddressesEXT: return "PhysicalStorageBufferAddressesEXT";
GL_EXT_buffer_reference
2019-01-06 23:58:04 +00:00
Return consistent names from CapabilityString Don't prefix with "Capability" since the majority of them don't. Also add missing CapabilityImageFootprintNV
2019-05-28 19:23:10 +00:00
case CapabilityVariablePointers: return "VariablePointers";
Implement GL_NV_cooperative_matrix
2019-02-19 19:10:32 +00:00
Return consistent names from CapabilityString Don't prefix with "Capability" since the majority of them don't. Also add missing CapabilityImageFootprintNV
2019-05-28 19:23:10 +00:00
case CapabilityCooperativeMatrixNV: return "CooperativeMatrixNV";
Implement support for GL_KHR_cooperative_matrix extension
2023-03-16 12:01:01 +00:00
case CapabilityCooperativeMatrixKHR: return "CooperativeMatrixKHR";
Implement GLSL_NV_cooperative_matrix2
2024-10-08 19:39:29 +00:00
case CapabilityCooperativeMatrixReductionsNV: return "CooperativeMatrixReductionsNV";
case CapabilityCooperativeMatrixConversionsNV: return "CooperativeMatrixConversionsNV";
case CapabilityCooperativeMatrixPerElementOperationsNV: return "CooperativeMatrixPerElementOperationsNV";
case CapabilityCooperativeMatrixTensorAddressingNV: return "CooperativeMatrixTensorAddressingNV";
case CapabilityCooperativeMatrixBlockLoadsNV: return "CooperativeMatrixBlockLoadsNV";
case CapabilityTensorAddressingNV: return "TensorAddressingNV";
Add support for GL_NV_shader_sm_builtins Including spirv and AST tests Also increase size of TBuiltInVariable bitfields since we've now exceeded 127 and add a static_assert to make this easier to find next time it happens!
2019-06-04 12:43:32 +00:00
case CapabilityShaderSMBuiltinsNV: return "ShaderSMBuiltinsNV";
Implement GL_NV_cooperative_matrix
2019-02-19 19:10:32 +00:00
Support GL_ARB_fragment_shader_interlock
2019-06-03 16:33:50 +00:00
case CapabilityFragmentShaderSampleInterlockEXT: return "CapabilityFragmentShaderSampleInterlockEXT";
case CapabilityFragmentShaderPixelInterlockEXT: return "CapabilityFragmentShaderPixelInterlockEXT";
case CapabilityFragmentShaderShadingRateInterlockEXT: return "CapabilityFragmentShaderShadingRateInterlockEXT";
Add GLSL_EXT_shader_tile_image
2023-03-30 15:50:56 +00:00
case CapabilityTileImageColorReadAccessEXT: return "TileImageColorReadAccessEXT";
case CapabilityTileImageDepthReadAccessEXT: return "TileImageDepthReadAccessEXT";
case CapabilityTileImageStencilReadAccessEXT: return "TileImageStencilReadAccessEXT";
Add support for the ARM extended matrix layout
2024-06-07 11:48:05 +00:00
case CapabilityCooperativeMatrixLayoutsARM: return "CooperativeMatrixLayoutsARM";
Add GL_EXT_fragment_shading_rate
2020-07-02 07:50:36 +00:00
case CapabilityFragmentShadingRateKHR: return "FragmentShadingRateKHR";
update spirv-headers to pick up demote_to_helper_invocation
2019-07-02 15:57:48 +00:00
case CapabilityDemoteToHelperInvocationEXT: return "DemoteToHelperInvocationEXT";
NV_shader_atomic_fp16_vector
2024-02-02 18:36:16 +00:00
case CapabilityAtomicFloat16VectorNV: return "AtomicFloat16VectorNV";
Add support for SPV_KHR_shader_clock
2019-07-11 01:14:38 +00:00
case CapabilityShaderClockKHR: return "ShaderClockKHR";
Support extension EXT_shader_quad_control
2024-01-29 05:53:18 +00:00
case CapabilityQuadControlKHR: return "QuadControlKHR";
Add GL_EXT_shader_image_int64 support (#2409)
2020-11-04 16:24:23 +00:00
case CapabilityInt64ImageEXT: return "Int64ImageEXT";
update spirv-headers to pick up demote_to_helper_invocation
2019-07-02 15:57:48 +00:00
INTEL_shader_integer_functions2: Add SPIR-V generation v2: Move addCapability and addExtension extension calls from TGlslangToSpvTraverser::createBinaryOperation to TGlslangToSpvTraverser::visitAggregate. Suggested by JohnK.
2019-01-21 16:57:25 +00:00
case CapabilityIntegerFunctions2INTEL: return "CapabilityIntegerFunctions2INTEL";
Add GL_EXT_expect_assume support Signed-off-by: Sven van Haastregt <sven.vanhaastregt@arm.com>
2024-02-13 13:45:26 +00:00
case CapabilityExpectAssumeKHR: return "ExpectAssumeKHR";
Implement GLSL_EXT_shader_atomic_float2
2021-01-13 20:36:17 +00:00
case CapabilityAtomicFloat16AddEXT: return "AtomicFloat16AddEXT";
Add changes for SPV_EXT_shader_atomic_float_add
2020-07-19 22:45:01 +00:00
case CapabilityAtomicFloat32AddEXT: return "AtomicFloat32AddEXT";
case CapabilityAtomicFloat64AddEXT: return "AtomicFloat64AddEXT";
Implement GLSL_EXT_shader_atomic_float2
2021-01-13 20:36:17 +00:00
case CapabilityAtomicFloat16MinMaxEXT: return "AtomicFloat16MinMaxEXT";
case CapabilityAtomicFloat32MinMaxEXT: return "AtomicFloat32MinMaxEXT";
case CapabilityAtomicFloat64MinMaxEXT: return "AtomicFloat64MinMaxEXT";
Add changes for SPV_EXT_shader_atomic_float_add
2020-07-19 22:45:01 +00:00
Add support for GL_EXT_shared_memory_block Uses SPV_KHR_workgroup_memory_explicit_layout. Note that if GL_EXT_scalar_block_layout is enabled, Workgroup blocks can also use scalar layout.
2020-06-02 23:58:51 +00:00
case CapabilityWorkgroupMemoryExplicitLayoutKHR: return "CapabilityWorkgroupMemoryExplicitLayoutKHR";
case CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR: return "CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR";
case CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR: return "CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR";
GL_ARM_shader_core_builtins support Add support for GL_ARM_shader_core_builtins and SPV_ARM_core_builtins, including initial tests
2022-12-05 12:02:22 +00:00
case CapabilityCoreBuiltinsARM: return "CoreBuiltinsARM";
Add support for GL_EXT_shared_memory_block Uses SPV_KHR_workgroup_memory_explicit_layout. Note that if GL_EXT_scalar_block_layout is enabled, Workgroup blocks can also use scalar layout.
2020-06-02 23:58:51 +00:00
Add support for GL_NV_shader_invocation_reorder. (#3054)
2022-12-09 20:19:08 +00:00
case CapabilityShaderInvocationReorderNV: return "ShaderInvocationReorderNV";
extension: GL_QCOM_image_processing support
2023-08-22 00:14:52 +00:00
case CapabilityTextureSampleWeightedQCOM: return "TextureSampleWeightedQCOM";
case CapabilityTextureBoxFilterQCOM: return "TextureBoxFilterQCOM";
case CapabilityTextureBlockMatchQCOM: return "TextureBlockMatchQCOM";
A couple of fixes to the GL_QCOM_image_processing2 support (#3578) 1) handle the extension requirements of GL_QCOM_image_processing2 correctly 2) add QCOM image processing decorations to ids only once.
2024-04-23 22:34:51 +00:00
case CapabilityTextureBlockMatch2QCOM: return "TextureBlockMatch2QCOM";
extension: GL_QCOM_image_processing support
2023-08-22 00:14:52 +00:00
Generate SPV_EXT_replicated_composites when requested by pragma. Implement GL_EXT_spec_constant_composites.
2024-05-31 17:00:03 +00:00
case CapabilityReplicatedCompositesEXT: return "CapabilityReplicatedCompositesEXT";
SPV: Implement new extensions GL_KHX_device_group and GL_KHX_multiview. These correspond to SPV_KHR_device_group and SPV_KHR_multiview. Also, bring tests up to date with Khronos internals, and some misc. related changes.
2017-02-27 08:20:51 +00:00
default: return "Bad";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
}
}
Final round for line endings.
2015-06-26 22:58:36 +00:00
const char* OpcodeString(int op)
{
switch (op) {
case 0: return "OpNop";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 1: return "OpUndef";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 2: return "OpSourceContinued";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 3: return "OpSource";
case 4: return "OpSourceExtension";
case 5: return "OpName";
case 6: return "OpMemberName";
case 7: return "OpString";
case 8: return "OpLine";
case 9: return "Bad";
case 10: return "OpExtension";
case 11: return "OpExtInstImport";
case 12: return "OpExtInst";
case 13: return "Bad";
case 14: return "OpMemoryModel";
case 15: return "OpEntryPoint";
case 16: return "OpExecutionMode";
case 17: return "OpCapability";
case 18: return "Bad";
case 19: return "OpTypeVoid";
case 20: return "OpTypeBool";
case 21: return "OpTypeInt";
case 22: return "OpTypeFloat";
case 23: return "OpTypeVector";
case 24: return "OpTypeMatrix";
case 25: return "OpTypeImage";
case 26: return "OpTypeSampler";
case 27: return "OpTypeSampledImage";
case 28: return "OpTypeArray";
case 29: return "OpTypeRuntimeArray";
case 30: return "OpTypeStruct";
case 31: return "OpTypeOpaque";
case 32: return "OpTypePointer";
case 33: return "OpTypeFunction";
case 34: return "OpTypeEvent";
case 35: return "OpTypeDeviceEvent";
case 36: return "OpTypeReserveId";
case 37: return "OpTypeQueue";
case 38: return "OpTypePipe";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 39: return "OpTypeForwardPointer";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 40: return "Bad";
case 41: return "OpConstantTrue";
case 42: return "OpConstantFalse";
case 43: return "OpConstant";
case 44: return "OpConstantComposite";
case 45: return "OpConstantSampler";
case 46: return "OpConstantNull";
case 47: return "Bad";
case 48: return "OpSpecConstantTrue";
case 49: return "OpSpecConstantFalse";
case 50: return "OpSpecConstant";
case 51: return "OpSpecConstantComposite";
case 52: return "OpSpecConstantOp";
case 53: return "Bad";
case 54: return "OpFunction";
case 55: return "OpFunctionParameter";
case 56: return "OpFunctionEnd";
case 57: return "OpFunctionCall";
case 58: return "Bad";
case 59: return "OpVariable";
case 60: return "OpImageTexelPointer";
case 61: return "OpLoad";
case 62: return "OpStore";
case 63: return "OpCopyMemory";
case 64: return "OpCopyMemorySized";
case 65: return "OpAccessChain";
case 66: return "OpInBoundsAccessChain";
case 67: return "OpPtrAccessChain";
case 68: return "OpArrayLength";
case 69: return "OpGenericPtrMemSemantics";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 70: return "OpInBoundsPtrAccessChain";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 71: return "OpDecorate";
case 72: return "OpMemberDecorate";
case 73: return "OpDecorationGroup";
case 74: return "OpGroupDecorate";
case 75: return "OpGroupMemberDecorate";
case 76: return "Bad";
case 77: return "OpVectorExtractDynamic";
case 78: return "OpVectorInsertDynamic";
case 79: return "OpVectorShuffle";
case 80: return "OpCompositeConstruct";
case 81: return "OpCompositeExtract";
case 82: return "OpCompositeInsert";
case 83: return "OpCopyObject";
case 84: return "OpTranspose";
SPV 1.4: Add support for OpCopyLogical, careful of Boolean differences.
2019-01-15 14:48:27 +00:00
case OpCopyLogical: return "OpCopyLogical";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 85: return "Bad";
case 86: return "OpSampledImage";
case 87: return "OpImageSampleImplicitLod";
case 88: return "OpImageSampleExplicitLod";
case 89: return "OpImageSampleDrefImplicitLod";
case 90: return "OpImageSampleDrefExplicitLod";
case 91: return "OpImageSampleProjImplicitLod";
case 92: return "OpImageSampleProjExplicitLod";
case 93: return "OpImageSampleProjDrefImplicitLod";
case 94: return "OpImageSampleProjDrefExplicitLod";
case 95: return "OpImageFetch";
case 96: return "OpImageGather";
case 97: return "OpImageDrefGather";
case 98: return "OpImageRead";
case 99: return "OpImageWrite";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 100: return "OpImage";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 101: return "OpImageQueryFormat";
case 102: return "OpImageQueryOrder";
case 103: return "OpImageQuerySizeLod";
case 104: return "OpImageQuerySize";
case 105: return "OpImageQueryLod";
case 106: return "OpImageQueryLevels";
case 107: return "OpImageQuerySamples";
case 108: return "Bad";
case 109: return "OpConvertFToU";
case 110: return "OpConvertFToS";
case 111: return "OpConvertSToF";
case 112: return "OpConvertUToF";
case 113: return "OpUConvert";
case 114: return "OpSConvert";
case 115: return "OpFConvert";
case 116: return "OpQuantizeToF16";
case 117: return "OpConvertPtrToU";
case 118: return "OpSatConvertSToU";
case 119: return "OpSatConvertUToS";
case 120: return "OpConvertUToPtr";
case 121: return "OpPtrCastToGeneric";
case 122: return "OpGenericCastToPtr";
case 123: return "OpGenericCastToPtrExplicit";
case 124: return "OpBitcast";
case 125: return "Bad";
case 126: return "OpSNegate";
case 127: return "OpFNegate";
case 128: return "OpIAdd";
case 129: return "OpFAdd";
case 130: return "OpISub";
case 131: return "OpFSub";
case 132: return "OpIMul";
case 133: return "OpFMul";
case 134: return "OpUDiv";
case 135: return "OpSDiv";
case 136: return "OpFDiv";
case 137: return "OpUMod";
case 138: return "OpSRem";
case 139: return "OpSMod";
case 140: return "OpFRem";
case 141: return "OpFMod";
case 142: return "OpVectorTimesScalar";
case 143: return "OpMatrixTimesScalar";
case 144: return "OpVectorTimesMatrix";
case 145: return "OpMatrixTimesVector";
case 146: return "OpMatrixTimesMatrix";
case 147: return "OpOuterProduct";
case 148: return "OpDot";
case 149: return "OpIAddCarry";
case 150: return "OpISubBorrow";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 151: return "OpUMulExtended";
case 152: return "OpSMulExtended";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 153: return "Bad";
case 154: return "OpAny";
case 155: return "OpAll";
case 156: return "OpIsNan";
case 157: return "OpIsInf";
case 158: return "OpIsFinite";
case 159: return "OpIsNormal";
case 160: return "OpSignBitSet";
case 161: return "OpLessOrGreater";
case 162: return "OpOrdered";
case 163: return "OpUnordered";
case 164: return "OpLogicalEqual";
case 165: return "OpLogicalNotEqual";
case 166: return "OpLogicalOr";
case 167: return "OpLogicalAnd";
case 168: return "OpLogicalNot";
case 169: return "OpSelect";
case 170: return "OpIEqual";
case 171: return "OpINotEqual";
case 172: return "OpUGreaterThan";
case 173: return "OpSGreaterThan";
case 174: return "OpUGreaterThanEqual";
case 175: return "OpSGreaterThanEqual";
case 176: return "OpULessThan";
case 177: return "OpSLessThan";
case 178: return "OpULessThanEqual";
case 179: return "OpSLessThanEqual";
case 180: return "OpFOrdEqual";
case 181: return "OpFUnordEqual";
case 182: return "OpFOrdNotEqual";
case 183: return "OpFUnordNotEqual";
case 184: return "OpFOrdLessThan";
case 185: return "OpFUnordLessThan";
case 186: return "OpFOrdGreaterThan";
case 187: return "OpFUnordGreaterThan";
case 188: return "OpFOrdLessThanEqual";
case 189: return "OpFUnordLessThanEqual";
case 190: return "OpFOrdGreaterThanEqual";
case 191: return "OpFUnordGreaterThanEqual";
case 192: return "Bad";
case 193: return "Bad";
case 194: return "OpShiftRightLogical";
case 195: return "OpShiftRightArithmetic";
case 196: return "OpShiftLeftLogical";
case 197: return "OpBitwiseOr";
case 198: return "OpBitwiseXor";
case 199: return "OpBitwiseAnd";
case 200: return "OpNot";
case 201: return "OpBitFieldInsert";
case 202: return "OpBitFieldSExtract";
case 203: return "OpBitFieldUExtract";
case 204: return "OpBitReverse";
case 205: return "OpBitCount";
case 206: return "Bad";
case 207: return "OpDPdx";
case 208: return "OpDPdy";
case 209: return "OpFwidth";
case 210: return "OpDPdxFine";
case 211: return "OpDPdyFine";
case 212: return "OpFwidthFine";
case 213: return "OpDPdxCoarse";
case 214: return "OpDPdyCoarse";
case 215: return "OpFwidthCoarse";
case 216: return "Bad";
case 217: return "Bad";
case 218: return "OpEmitVertex";
case 219: return "OpEndPrimitive";
case 220: return "OpEmitStreamVertex";
case 221: return "OpEndStreamPrimitive";
case 222: return "Bad";
case 223: return "Bad";
case 224: return "OpControlBarrier";
case 225: return "OpMemoryBarrier";
case 226: return "Bad";
case 227: return "OpAtomicLoad";
case 228: return "OpAtomicStore";
case 229: return "OpAtomicExchange";
case 230: return "OpAtomicCompareExchange";
case 231: return "OpAtomicCompareExchangeWeak";
case 232: return "OpAtomicIIncrement";
case 233: return "OpAtomicIDecrement";
case 234: return "OpAtomicIAdd";
case 235: return "OpAtomicISub";
case 236: return "OpAtomicSMin";
case 237: return "OpAtomicUMin";
case 238: return "OpAtomicSMax";
case 239: return "OpAtomicUMax";
case 240: return "OpAtomicAnd";
case 241: return "OpAtomicOr";
case 242: return "OpAtomicXor";
case 243: return "Bad";
case 244: return "Bad";
case 245: return "OpPhi";
case 246: return "OpLoopMerge";
case 247: return "OpSelectionMerge";
case 248: return "OpLabel";
case 249: return "OpBranch";
case 250: return "OpBranchConditional";
case 251: return "OpSwitch";
case 252: return "OpKill";
case 253: return "OpReturn";
case 254: return "OpReturnValue";
case 255: return "OpUnreachable";
case 256: return "OpLifetimeStart";
case 257: return "OpLifetimeStop";
case 258: return "Bad";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 259: return "OpGroupAsyncCopy";
case 260: return "OpGroupWaitEvents";
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
case 261: return "OpGroupAll";
case 262: return "OpGroupAny";
case 263: return "OpGroupBroadcast";
case 264: return "OpGroupIAdd";
case 265: return "OpGroupFAdd";
case 266: return "OpGroupFMin";
case 267: return "OpGroupUMin";
case 268: return "OpGroupSMin";
case 269: return "OpGroupFMax";
case 270: return "OpGroupUMax";
case 271: return "OpGroupSMax";
case 272: return "Bad";
case 273: return "Bad";
case 274: return "OpReadPipe";
case 275: return "OpWritePipe";
case 276: return "OpReservedReadPipe";
case 277: return "OpReservedWritePipe";
case 278: return "OpReserveReadPipePackets";
case 279: return "OpReserveWritePipePackets";
case 280: return "OpCommitReadPipe";
case 281: return "OpCommitWritePipe";
case 282: return "OpIsValidReserveId";
case 283: return "OpGetNumPipePackets";
case 284: return "OpGetMaxPipePackets";
case 285: return "OpGroupReserveReadPipePackets";
case 286: return "OpGroupReserveWritePipePackets";
case 287: return "OpGroupCommitReadPipe";
case 288: return "OpGroupCommitWritePipe";
case 289: return "Bad";
case 290: return "Bad";
case 291: return "OpEnqueueMarker";
case 292: return "OpEnqueueKernel";
case 293: return "OpGetKernelNDrangeSubGroupCount";
case 294: return "OpGetKernelNDrangeMaxSubGroupSize";
case 295: return "OpGetKernelWorkGroupSize";
case 296: return "OpGetKernelPreferredWorkGroupSizeMultiple";
case 297: return "OpRetainEvent";
case 298: return "OpReleaseEvent";
case 299: return "OpCreateUserEvent";
case 300: return "OpIsValidEvent";
case 301: return "OpSetUserEventStatus";
case 302: return "OpCaptureEventProfilingInfo";
case 303: return "OpGetDefaultQueue";
case 304: return "OpBuildNDRange";
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
case 305: return "OpImageSparseSampleImplicitLod";
case 306: return "OpImageSparseSampleExplicitLod";
case 307: return "OpImageSparseSampleDrefImplicitLod";
case 308: return "OpImageSparseSampleDrefExplicitLod";
case 309: return "OpImageSparseSampleProjImplicitLod";
case 310: return "OpImageSparseSampleProjExplicitLod";
case 311: return "OpImageSparseSampleProjDrefImplicitLod";
case 312: return "OpImageSparseSampleProjDrefExplicitLod";
case 313: return "OpImageSparseFetch";
case 314: return "OpImageSparseGather";
case 315: return "OpImageSparseDrefGather";
case 316: return "OpImageSparseTexelsResident";
case 317: return "OpNoLine";
case 318: return "OpAtomicFlagTestAndSet";
case 319: return "OpAtomicFlagClear";
SPV: Implement Vulkan version of GLSL (KHR_vulkan_glsl).
2016-02-16 03:58:50 +00:00
case 320: return "OpImageSparseRead";
Final round for line endings.
2015-06-26 22:58:36 +00:00
Fix typo.
2018-03-02 08:09:28 +00:00
case OpModuleProcessed: return "OpModuleProcessed";
SPIRV: Fix some disassembly issues - OpExecutionModeId is not supported in disassembly. - Some execution modes are missing in disassembled strings.
2020-09-07 03:09:21 +00:00
case OpExecutionModeId: return "OpExecutionModeId";
Implement SPV_GOOGLE_hlsl_functionality1. Enabled via -fhlsl_functionality1
2018-03-08 01:05:55 +00:00
case OpDecorateId: return "OpDecorateId";
SPV: Complete OpModuleProcessed implementation, enabled by have 1.2 headers.
2018-02-23 02:36:18 +00:00
SPV: Implement Vulkan 1.1 features and extensions.
2018-03-06 23:12:04 +00:00
case 333: return "OpGroupNonUniformElect";
case 334: return "OpGroupNonUniformAll";
case 335: return "OpGroupNonUniformAny";
case 336: return "OpGroupNonUniformAllEqual";
case 337: return "OpGroupNonUniformBroadcast";
case 338: return "OpGroupNonUniformBroadcastFirst";
case 339: return "OpGroupNonUniformBallot";
case 340: return "OpGroupNonUniformInverseBallot";
case 341: return "OpGroupNonUniformBallotBitExtract";
case 342: return "OpGroupNonUniformBallotBitCount";
case 343: return "OpGroupNonUniformBallotFindLSB";
case 344: return "OpGroupNonUniformBallotFindMSB";
case 345: return "OpGroupNonUniformShuffle";
case 346: return "OpGroupNonUniformShuffleXor";
case 347: return "OpGroupNonUniformShuffleUp";
case 348: return "OpGroupNonUniformShuffleDown";
case 349: return "OpGroupNonUniformIAdd";
case 350: return "OpGroupNonUniformFAdd";
case 351: return "OpGroupNonUniformIMul";
case 352: return "OpGroupNonUniformFMul";
case 353: return "OpGroupNonUniformSMin";
case 354: return "OpGroupNonUniformUMin";
case 355: return "OpGroupNonUniformFMin";
case 356: return "OpGroupNonUniformSMax";
case 357: return "OpGroupNonUniformUMax";
case 358: return "OpGroupNonUniformFMax";
case 359: return "OpGroupNonUniformBitwiseAnd";
case 360: return "OpGroupNonUniformBitwiseOr";
case 361: return "OpGroupNonUniformBitwiseXor";
case 362: return "OpGroupNonUniformLogicalAnd";
case 363: return "OpGroupNonUniformLogicalOr";
case 364: return "OpGroupNonUniformLogicalXor";
case 365: return "OpGroupNonUniformQuadBroadcast";
case 366: return "OpGroupNonUniformQuadSwap";
Implement GL_EXT_terminate_invocation (#2454) * Implement GL_EXT_terminate_invocation. * terminateInvocation: declare the SPV extension * Update test results for spirv-tools and bison version bumps Co-authored-by: John Kessenich <cepheus@frii.com>
2020-11-09 16:30:01 +00:00
case OpTerminateInvocation: return "OpTerminateInvocation";
SPV: Implement the extension SPV_KHR_shader_ballot
2016-09-21 10:56:12 +00:00
case 4421: return "OpSubgroupBallotKHR";
case 4422: return "OpSubgroupFirstInvocationKHR";
Fix mismatched doc string for SPV_KHR_subgroup_vote Text for opcodes OpSubgroupAllKHR and OpSubgroupAnyKHR was swapped.
2017-02-17 12:45:08 +00:00
case 4428: return "OpSubgroupAllKHR";
case 4429: return "OpSubgroupAnyKHR";
Implement SPV_KHR_subgroup_vote doc.cpp: Add capabilities, scope to the opcodes. Add opcode and capability strings. GLSL.ext.KHR.h: Add extension string. GlslangToSpv.cpp: Fix handling of opcodes to generate appropriate SPIR-V. spirv.hpp: Add capability and opcode enums. spv.shaderGroupVote.comp.out: Update SPIR-V output for test shader.
2017-01-18 22:16:49 +00:00
case 4430: return "OpSubgroupAllEqualKHR";
Modify shader ballot extension by adding OpSubgroupReadInvocationKHR
2016-12-20 20:44:35 +00:00
case 4432: return "OpSubgroupReadInvocationKHR";
Add the KHR suffix for OpExtInstWithForwardRefsKHR instruction
2024-06-06 22:07:12 +00:00
case 4433: return "OpExtInstWithForwardRefsKHR";
SPV: Implement the extension SPV_KHR_shader_ballot
2016-09-21 10:56:12 +00:00
Support extension EXT_shader_quad_control
2024-01-29 05:53:18 +00:00
case OpGroupNonUniformQuadAllKHR: return "OpGroupNonUniformQuadAllKHR";
case OpGroupNonUniformQuadAnyKHR: return "OpGroupNonUniformQuadAnyKHR";
Add changes for SPV_EXT_shader_atomic_float_add
2020-07-19 22:45:01 +00:00
case OpAtomicFAddEXT: return "OpAtomicFAddEXT";
Implement GLSL_EXT_shader_atomic_float2
2021-01-13 20:36:17 +00:00
case OpAtomicFMinEXT: return "OpAtomicFMinEXT";
case OpAtomicFMaxEXT: return "OpAtomicFMaxEXT";
Add changes for SPV_EXT_shader_atomic_float_add
2020-07-19 22:45:01 +00:00
SPV: Complete OpAssumeTrueKHR, OpExpectKHR
2023-09-01 09:03:35 +00:00
case OpAssumeTrueKHR: return "OpAssumeTrueKHR";
case OpExpectKHR: return "OpExpectKHR";
Implement 4 AMD-specific extensions. - Support GL_AMD_shader_ballot (SPV_AMD_shader_ballot). - Support GL_AMD_shader_trinary_minmax (SPV_AMD_shader_trinary_minmax). - Support GL_AMD_shader_explicit_vertex_parameter (SPV_AMD_shader_explicit_vertex_parameter). - Support GL_AMD_gcn_shader (SPV_AMD_gcn_shader).
2016-05-05 04:30:44 +00:00
case 5000: return "OpGroupIAddNonUniformAMD";
case 5001: return "OpGroupFAddNonUniformAMD";
case 5002: return "OpGroupFMinNonUniformAMD";
case 5003: return "OpGroupUMinNonUniformAMD";
case 5004: return "OpGroupSMinNonUniformAMD";
case 5005: return "OpGroupFMaxNonUniformAMD";
case 5006: return "OpGroupUMaxNonUniformAMD";
case 5007: return "OpGroupSMaxNonUniformAMD";
Implement the extension GL_AMD_shader_fragment_mask
2017-06-13 20:53:02 +00:00
case 5011: return "OpFragmentMaskFetchAMD";
case 5012: return "OpFragmentFetchAMD";
SPV: Implement new extensions GL_KHX_device_group and GL_KHX_multiview. These correspond to SPV_KHR_device_group and SPV_KHR_multiview. Also, bring tests up to date with Khronos internals, and some misc. related changes.
2017-02-27 08:20:51 +00:00
Add support for SPV_KHR_shader_clock
2019-07-11 01:14:38 +00:00
case OpReadClockKHR: return "OpReadClockKHR";
Implement SPV_GOOGLE_hlsl_functionality1. Enabled via -fhlsl_functionality1
2018-03-08 01:05:55 +00:00
case OpDecorateStringGOOGLE: return "OpDecorateStringGOOGLE";
case OpMemberDecorateStringGOOGLE: return "OpMemberDecorateStringGOOGLE";
Updates for final Vulkan ray tracing extensions (#2466) * Fix traceRay/executeCallable to have id instead of constant. Update to final (non-provisional) SPIR-V capabilities (includes review feedback) - Change visibilty of findLinkerObjects. See merge request GLSL/glslang!78 * Add support for OpConvertUToAccelerationStructureKHR. GLSL : https://gitlab.khronos.org/GLSL/GLSL/-/merge_requests/60 SPV : https://gitlab.khronos.org/spirv/spirv-extensions/-/merge_requests/182 See merge request GLSL/glslang!77 * Add volatile qualifier to certain builtins for ray tracing. See merge request GLSL/glslang!81 * make gl_RayTmaxEXT volatile in intersection shader Vulkan Issue #2268 * Add testing for layouts on SBT vulkan/vulkan#2230 - no layout specified should be same as std430 - explicitly test std140, std430, scalar layouts See merge request GLSL/glslang!86 * Support for new opcodes OpIgnoreIntersectionKHR and OpTerminateRayKHR vulkan/vulkan#2374 Add support for ignoreIntersectionEXT and terminateRayEXT as block terminator statements. See merge request GLSL/glslang!87 * Fix code-generation issues with global ray query variables See merge request GLSL/glslang!88 * update dependencies for spirv-headers and tools And update mesh shader results * Fix indeterminate argument ordering Authored-by: David Neto <dneto@google.com> Co-authored-by: Ashwin Lele (NVIDIA Corporation) <alele@nvidia.com> Co-authored-by: Neslisah <Neslisah.Torosdagli@amd.com>
2020-11-23 20:41:27 +00:00
case OpReportIntersectionKHR: return "OpReportIntersectionKHR";
case OpIgnoreIntersectionNV: return "OpIgnoreIntersectionNV";
case OpIgnoreIntersectionKHR: return "OpIgnoreIntersectionKHR";
case OpTerminateRayNV: return "OpTerminateRayNV";
case OpTerminateRayKHR: return "OpTerminateRayKHR";
case OpTraceNV: return "OpTraceNV";
Add support for GL_NV_ray_tracing_motion_blur.
2021-08-10 17:40:28 +00:00
case OpTraceRayMotionNV: return "OpTraceRayMotionNV";
Updates for final Vulkan ray tracing extensions (#2466) * Fix traceRay/executeCallable to have id instead of constant. Update to final (non-provisional) SPIR-V capabilities (includes review feedback) - Change visibilty of findLinkerObjects. See merge request GLSL/glslang!78 * Add support for OpConvertUToAccelerationStructureKHR. GLSL : https://gitlab.khronos.org/GLSL/GLSL/-/merge_requests/60 SPV : https://gitlab.khronos.org/spirv/spirv-extensions/-/merge_requests/182 See merge request GLSL/glslang!77 * Add volatile qualifier to certain builtins for ray tracing. See merge request GLSL/glslang!81 * make gl_RayTmaxEXT volatile in intersection shader Vulkan Issue #2268 * Add testing for layouts on SBT vulkan/vulkan#2230 - no layout specified should be same as std430 - explicitly test std140, std430, scalar layouts See merge request GLSL/glslang!86 * Support for new opcodes OpIgnoreIntersectionKHR and OpTerminateRayKHR vulkan/vulkan#2374 Add support for ignoreIntersectionEXT and terminateRayEXT as block terminator statements. See merge request GLSL/glslang!87 * Fix code-generation issues with global ray query variables See merge request GLSL/glslang!88 * update dependencies for spirv-headers and tools And update mesh shader results * Fix indeterminate argument ordering Authored-by: David Neto <dneto@google.com> Co-authored-by: Ashwin Lele (NVIDIA Corporation) <alele@nvidia.com> Co-authored-by: Neslisah <Neslisah.Torosdagli@amd.com>
2020-11-23 20:41:27 +00:00
case OpTraceRayKHR: return "OpTraceRayKHR";
case OpTypeAccelerationStructureKHR: return "OpTypeAccelerationStructureKHR";
case OpExecuteCallableNV: return "OpExecuteCallableNV";
case OpExecuteCallableKHR: return "OpExecuteCallableKHR";
case OpConvertUToAccelerationStructureKHR: return "OpConvertUToAccelerationStructureKHR";
Add-support-for-SPV_NV_mesh_shader
2018-09-19 18:41:59 +00:00
case OpGroupNonUniformPartitionNV: return "OpGroupNonUniformPartitionNV";
case OpImageSampleFootprintNV: return "OpImageSampleFootprintNV";
case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV";
GL_EXT_mesh_shader/SPV_EXT_mesh_shader implementation Added following updates to GL_EXT_mesh_shader implementation: 1. Added SPIRV and GLSL test cases 2. Added checks to ensure NV and EXT mesh shader builtins cannot be used interchangeably. 3. Updated the language name by removing the postfix "NV" to MeshShader and TaskShader. 4. Added checks for grammar checking to comply with the spec. 5. Added gl_NumWorkGroups builtin to Mesh shader 6. Fixed data type of gl_PrimitiveLineIndicesEXT and gl_PrimitiveTriangleIndicesEXT 7. Added new constants to the resources table 8. Updates to handle new storage qualifier "taskPayloadSharedEXT" 9. Updated test cases by replacing "taskEXT" with storage qualifier "taskPayloadSharedEXT" Addressed Review comments 1. Fixed instruction description used by glslang disassembly. 2. Updated OpEmitMeshTasksEXT as per spec update 3. Fixed implementation that errors out if there are more then one taskPayloadSharedEXT varjables. 4. Fixed miscellaneous error logs and removed unwanted code. SPIRV 1.6 related build failure fixes - Update SPIRV header to 1.6 - Fix conflict wiht SPIRV 1.6 change, where localSizeId is used for execution mode for mesh/task shaders Enable SPIRV generated for EXT_mesh_shader to be version 1.4 GL_EXT_mesh_shader: Add checks for atomic support and corresponding test cases
2021-08-25 20:41:32 +00:00
case OpEmitMeshTasksEXT: return "OpEmitMeshTasksEXT";
case OpSetMeshOutputsEXT: return "OpSetMeshOutputsEXT";
0003-Add-support-for-SPV_NV_shader_image_footprint
2018-09-19 18:41:27 +00:00
Add GL_KHR_shader_subgroup_rotate support Co-authored-by: Neil Hickey <neil.hickey@arm.com> Co-authored-by: Stuart Brady <stuart.brady@arm.com> Signed-off-by: Sven van Haastregt <sven.vanhaastregt@arm.com>
2024-02-06 15:20:16 +00:00
case OpGroupNonUniformRotateKHR: return "OpGroupNonUniformRotateKHR";
Add ray query capability if acceleration structure or ray query types declared (#2469) * Add ray query capability if acceleration structure used Fixes #2430 in non-ray tracing stages and the extension is enabled * Add ray query capability if ray query declared * Fix printing of TypeRayQueryKHR It's no longer spelled with "Provisional"
2020-11-25 04:06:16 +00:00
case OpTypeRayQueryKHR: return "OpTypeRayQueryKHR";
GL_EXT_ray_query updates
2020-03-19 15:09:57 +00:00
case OpRayQueryInitializeKHR: return "OpRayQueryInitializeKHR";
case OpRayQueryTerminateKHR: return "OpRayQueryTerminateKHR";
case OpRayQueryGenerateIntersectionKHR: return "OpRayQueryGenerateIntersectionKHR";
case OpRayQueryConfirmIntersectionKHR: return "OpRayQueryConfirmIntersectionKHR";
case OpRayQueryProceedKHR: return "OpRayQueryProceedKHR";
case OpRayQueryGetIntersectionTypeKHR: return "OpRayQueryGetIntersectionTypeKHR";
case OpRayQueryGetRayTMinKHR: return "OpRayQueryGetRayTMinKHR";
case OpRayQueryGetRayFlagsKHR: return "OpRayQueryGetRayFlagsKHR";
case OpRayQueryGetIntersectionTKHR: return "OpRayQueryGetIntersectionTKHR";
case OpRayQueryGetIntersectionInstanceCustomIndexKHR: return "OpRayQueryGetIntersectionInstanceCustomIndexKHR";
case OpRayQueryGetIntersectionInstanceIdKHR: return "OpRayQueryGetIntersectionInstanceIdKHR";
case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: return "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR";
case OpRayQueryGetIntersectionGeometryIndexKHR: return "OpRayQueryGetIntersectionGeometryIndexKHR";
case OpRayQueryGetIntersectionPrimitiveIndexKHR: return "OpRayQueryGetIntersectionPrimitiveIndexKHR";
case OpRayQueryGetIntersectionBarycentricsKHR: return "OpRayQueryGetIntersectionBarycentricsKHR";
case OpRayQueryGetIntersectionFrontFaceKHR: return "OpRayQueryGetIntersectionFrontFaceKHR";
case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: return "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR";
case OpRayQueryGetIntersectionObjectRayDirectionKHR: return "OpRayQueryGetIntersectionObjectRayDirectionKHR";
case OpRayQueryGetIntersectionObjectRayOriginKHR: return "OpRayQueryGetIntersectionObjectRayOriginKHR";
case OpRayQueryGetWorldRayDirectionKHR: return "OpRayQueryGetWorldRayDirectionKHR";
case OpRayQueryGetWorldRayOriginKHR: return "OpRayQueryGetWorldRayOriginKHR";
case OpRayQueryGetIntersectionObjectToWorldKHR: return "OpRayQueryGetIntersectionObjectToWorldKHR";
case OpRayQueryGetIntersectionWorldToObjectKHR: return "OpRayQueryGetIntersectionWorldToObjectKHR";
GL_EXT_ray_tracing_position_fetch
2022-06-09 00:29:38 +00:00
case OpRayQueryGetIntersectionTriangleVertexPositionsKHR: return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR";
GL_EXT_ray_query updates
2020-03-19 15:09:57 +00:00
Implement GL_NV_cooperative_matrix
2019-02-19 19:10:32 +00:00
case OpTypeCooperativeMatrixNV: return "OpTypeCooperativeMatrixNV";
case OpCooperativeMatrixLoadNV: return "OpCooperativeMatrixLoadNV";
case OpCooperativeMatrixStoreNV: return "OpCooperativeMatrixStoreNV";
case OpCooperativeMatrixMulAddNV: return "OpCooperativeMatrixMulAddNV";
case OpCooperativeMatrixLengthNV: return "OpCooperativeMatrixLengthNV";
Implement support for GL_KHR_cooperative_matrix extension
2023-03-16 12:01:01 +00:00
case OpTypeCooperativeMatrixKHR: return "OpTypeCooperativeMatrixKHR";
case OpCooperativeMatrixLoadKHR: return "OpCooperativeMatrixLoadKHR";
case OpCooperativeMatrixStoreKHR: return "OpCooperativeMatrixStoreKHR";
case OpCooperativeMatrixMulAddKHR: return "OpCooperativeMatrixMulAddKHR";
case OpCooperativeMatrixLengthKHR: return "OpCooperativeMatrixLengthKHR";
Implement GL_EXT_demote_to_helper_invocation
2019-07-01 14:23:23 +00:00
case OpDemoteToHelperInvocationEXT: return "OpDemoteToHelperInvocationEXT";
case OpIsHelperInvocationEXT: return "OpIsHelperInvocationEXT";
Implement GL_NV_cooperative_matrix
2019-02-19 19:10:32 +00:00
Implement GLSL_NV_cooperative_matrix2
2024-10-08 19:39:29 +00:00
case OpCooperativeMatrixConvertNV: return "OpCooperativeMatrixConvertNV";
case OpCooperativeMatrixTransposeNV: return "OpCooperativeMatrixTransposeNV";
case OpCooperativeMatrixReduceNV: return "OpCooperativeMatrixReduceNV";
case OpCooperativeMatrixLoadTensorNV: return "OpCooperativeMatrixLoadTensorNV";
case OpCooperativeMatrixStoreTensorNV: return "OpCooperativeMatrixStoreTensorNV";
case OpCooperativeMatrixPerElementOpNV: return "OpCooperativeMatrixPerElementOpNV";
case OpTypeTensorLayoutNV: return "OpTypeTensorLayoutNV";
case OpTypeTensorViewNV: return "OpTypeTensorViewNV";
case OpCreateTensorLayoutNV: return "OpCreateTensorLayoutNV";
case OpTensorLayoutSetBlockSizeNV: return "OpTensorLayoutSetBlockSizeNV";
case OpTensorLayoutSetDimensionNV: return "OpTensorLayoutSetDimensionNV";
case OpTensorLayoutSetStrideNV: return "OpTensorLayoutSetStrideNV";
case OpTensorLayoutSliceNV: return "OpTensorLayoutSliceNV";
case OpTensorLayoutSetClampValueNV: return "OpTensorLayoutSetClampValueNV";
case OpCreateTensorViewNV: return "OpCreateTensorViewNV";
case OpTensorViewSetDimensionNV: return "OpTensorViewSetDimensionNV";
case OpTensorViewSetStrideNV: return "OpTensorViewSetStrideNV";
case OpTensorViewSetClipNV: return "OpTensorViewSetClipNV";
Support GL_ARB_fragment_shader_interlock
2019-06-03 16:33:50 +00:00
case OpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT";
case OpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT";
Add support for GL_NV_shader_invocation_reorder. (#3054)
2022-12-09 20:19:08 +00:00
case OpTypeHitObjectNV: return "OpTypeHitObjectNV";
case OpHitObjectTraceRayNV: return "OpHitObjectTraceRayNV";
case OpHitObjectTraceRayMotionNV: return "OpHitObjectTraceRayMotionNV";
case OpHitObjectRecordHitNV: return "OpHitObjectRecordHitNV";
case OpHitObjectRecordHitMotionNV: return "OpHitObjectRecordHitMotionNV";
case OpHitObjectRecordHitWithIndexNV: return "OpHitObjectRecordHitWithIndexNV";
case OpHitObjectRecordHitWithIndexMotionNV: return "OpHitObjectRecordHitWithIndexMotionNV";
case OpHitObjectRecordMissNV: return "OpHitObjectRecordMissNV";
case OpHitObjectRecordMissMotionNV: return "OpHitObjectRecordMissMotionNV";
case OpHitObjectRecordEmptyNV: return "OpHitObjectRecordEmptyNV";
case OpHitObjectExecuteShaderNV: return "OpHitObjectExecuteShaderNV";
case OpReorderThreadWithHintNV: return "OpReorderThreadWithHintNV";
case OpReorderThreadWithHitObjectNV: return "OpReorderThreadWithHitObjectNV";
case OpHitObjectGetCurrentTimeNV: return "OpHitObjectGetCurrentTimeNV";
case OpHitObjectGetAttributesNV: return "OpHitObjectGetAttributesNV";
case OpHitObjectGetHitKindNV: return "OpHitObjectGetFrontFaceNV";
case OpHitObjectGetPrimitiveIndexNV: return "OpHitObjectGetPrimitiveIndexNV";
case OpHitObjectGetGeometryIndexNV: return "OpHitObjectGetGeometryIndexNV";
case OpHitObjectGetInstanceIdNV: return "OpHitObjectGetInstanceIdNV";
case OpHitObjectGetInstanceCustomIndexNV: return "OpHitObjectGetInstanceCustomIndexNV";
case OpHitObjectGetObjectRayDirectionNV: return "OpHitObjectGetObjectRayDirectionNV";
case OpHitObjectGetObjectRayOriginNV: return "OpHitObjectGetObjectRayOriginNV";
case OpHitObjectGetWorldRayDirectionNV: return "OpHitObjectGetWorldRayDirectionNV";
case OpHitObjectGetWorldRayOriginNV: return "OpHitObjectGetWorldRayOriginNV";
case OpHitObjectGetWorldToObjectNV: return "OpHitObjectGetWorldToObjectNV";
case OpHitObjectGetObjectToWorldNV: return "OpHitObjectGetObjectToWorldNV";
case OpHitObjectGetRayTMaxNV: return "OpHitObjectGetRayTMaxNV";
case OpHitObjectGetRayTMinNV: return "OpHitObjectGetRayTMinNV";
case OpHitObjectIsEmptyNV: return "OpHitObjectIsEmptyNV";
case OpHitObjectIsHitNV: return "OpHitObjectIsHitNV";
case OpHitObjectIsMissNV: return "OpHitObjectIsMissNV";
case OpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV";
case OpHitObjectGetShaderRecordBufferHandleNV: return "OpHitObjectGetShaderRecordBufferHandleNV";
Add support for GL_NV_displacement_micromap. * Add support for GL_NV_displacement_micromap. * Update known_good for spirv-headers and spirv-tools.
2023-10-02 19:07:50 +00:00
case OpFetchMicroTriangleVertexBarycentricNV: return "OpFetchMicroTriangleVertexBarycentricNV";
case OpFetchMicroTriangleVertexPositionNV: return "OpFetchMicroTriangleVertexPositionNV";
Add GLSL_EXT_shader_tile_image
2023-03-30 15:50:56 +00:00
case OpColorAttachmentReadEXT: return "OpColorAttachmentReadEXT";
case OpDepthAttachmentReadEXT: return "OpDepthAttachmentReadEXT";
case OpStencilAttachmentReadEXT: return "OpStencilAttachmentReadEXT";
extension: GL_QCOM_image_processing support
2023-08-22 00:14:52 +00:00
case OpImageSampleWeightedQCOM: return "OpImageSampleWeightedQCOM";
case OpImageBoxFilterQCOM: return "OpImageBoxFilterQCOM";
case OpImageBlockMatchSADQCOM: return "OpImageBlockMatchSADQCOM";
case OpImageBlockMatchSSDQCOM: return "OpImageBlockMatchSSDQCOM";
Support for SPV_QCOM_image_processing2 (#3539)
2024-03-20 22:56:00 +00:00
case OpImageBlockMatchWindowSSDQCOM: return "OpImageBlockMatchWindowSSDQCOM";
case OpImageBlockMatchWindowSADQCOM: return "OpImageBlockMatchWindowSADQCOM";
case OpImageBlockMatchGatherSSDQCOM: return "OpImageBlockMatchGatherSSDQCOM";
case OpImageBlockMatchGatherSADQCOM: return "OpImageBlockMatchGatherSADQCOM";
extension: GL_QCOM_image_processing support
2023-08-22 00:14:52 +00:00
Generate SPV_EXT_replicated_composites when requested by pragma. Implement GL_EXT_spec_constant_composites.
2024-05-31 17:00:03 +00:00
case OpConstantCompositeReplicateEXT: return "OpConstantCompositeReplicateEXT";
case OpSpecConstantCompositeReplicateEXT: return "OpSpecConstantCompositeReplicateEXT";
case OpCompositeConstructReplicateEXT: return "OpCompositeConstructReplicateEXT";
SPV: Implement new extensions GL_KHX_device_group and GL_KHX_multiview. These correspond to SPV_KHR_device_group and SPV_KHR_multiview. Also, bring tests up to date with Khronos internals, and some misc. related changes.
2017-02-27 08:20:51 +00:00
default:
return "Bad";
Final round for line endings.
2015-06-26 22:58:36 +00:00
}
}
// The set of objects that hold all the instruction/operand
// parameterization information.
Implement 4 AMD-specific extensions. - Support GL_AMD_shader_ballot (SPV_AMD_shader_ballot). - Support GL_AMD_shader_trinary_minmax (SPV_AMD_shader_trinary_minmax). - Support GL_AMD_shader_explicit_vertex_parameter (SPV_AMD_shader_explicit_vertex_parameter). - Support GL_AMD_gcn_shader (SPV_AMD_gcn_shader).
2016-05-05 04:30:44 +00:00
InstructionParameters InstructionDesc[OpCodeMask + 1];
Final round for line endings.
2015-06-26 22:58:36 +00:00
OperandParameters ExecutionModeOperands[ExecutionModeCeiling];
OperandParameters DecorationOperands[DecorationCeiling];
EnumDefinition OperandClassParams[OperandCount];
EnumParameters ExecutionModeParams[ExecutionModeCeiling];
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
EnumParameters ImageOperandsParams[ImageOperandsCeiling];
Final round for line endings.
2015-06-26 22:58:36 +00:00
EnumParameters DecorationParams[DecorationCeiling];
EnumParameters LoopControlParams[FunctionControlCeiling];
EnumParameters SelectionControlParams[SelectControlCeiling];
EnumParameters FunctionControlParams[FunctionControlCeiling];
GL_KHR_memory_scope_semantics
2018-09-05 15:11:41 +00:00
EnumParameters MemoryAccessParams[MemoryAccessCeiling];
Implement support for GL_KHR_cooperative_matrix extension
2023-03-16 12:01:01 +00:00
EnumParameters CooperativeMatrixOperandsParams[CooperativeMatrixOperandsCeiling];
Implement GLSL_NV_cooperative_matrix2
2024-10-08 19:39:29 +00:00
EnumParameters TensorAddressingOperandsParams[TensorAddressingOperandsCeiling];
Final round for line endings.
2015-06-26 22:58:36 +00:00
// Set up all the parameterizing descriptions of the opcodes, operands, etc.
void Parameterize()
{
// only do this once.
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
static std::once_flag initialized;
std::call_once(initialized, [](){
// Exceptions to having a result <id> and a resulting type <id>.
// (Everything is initialized to have both).
InstructionDesc[OpNop].setResultAndType(false, false);
InstructionDesc[OpSource].setResultAndType(false, false);
InstructionDesc[OpSourceContinued].setResultAndType(false, false);
InstructionDesc[OpSourceExtension].setResultAndType(false, false);
InstructionDesc[OpExtension].setResultAndType(false, false);
InstructionDesc[OpExtInstImport].setResultAndType(true, false);
InstructionDesc[OpCapability].setResultAndType(false, false);
InstructionDesc[OpMemoryModel].setResultAndType(false, false);
InstructionDesc[OpEntryPoint].setResultAndType(false, false);
InstructionDesc[OpExecutionMode].setResultAndType(false, false);
InstructionDesc[OpExecutionModeId].setResultAndType(false, false);
InstructionDesc[OpTypeVoid].setResultAndType(true, false);
InstructionDesc[OpTypeBool].setResultAndType(true, false);
InstructionDesc[OpTypeInt].setResultAndType(true, false);
InstructionDesc[OpTypeFloat].setResultAndType(true, false);
InstructionDesc[OpTypeVector].setResultAndType(true, false);
InstructionDesc[OpTypeMatrix].setResultAndType(true, false);
InstructionDesc[OpTypeImage].setResultAndType(true, false);
InstructionDesc[OpTypeSampler].setResultAndType(true, false);
InstructionDesc[OpTypeSampledImage].setResultAndType(true, false);
InstructionDesc[OpTypeArray].setResultAndType(true, false);
InstructionDesc[OpTypeRuntimeArray].setResultAndType(true, false);
InstructionDesc[OpTypeStruct].setResultAndType(true, false);
InstructionDesc[OpTypeOpaque].setResultAndType(true, false);
InstructionDesc[OpTypePointer].setResultAndType(true, false);
InstructionDesc[OpTypeForwardPointer].setResultAndType(false, false);
InstructionDesc[OpTypeFunction].setResultAndType(true, false);
InstructionDesc[OpTypeEvent].setResultAndType(true, false);
InstructionDesc[OpTypeDeviceEvent].setResultAndType(true, false);
InstructionDesc[OpTypeReserveId].setResultAndType(true, false);
InstructionDesc[OpTypeQueue].setResultAndType(true, false);
InstructionDesc[OpTypePipe].setResultAndType(true, false);
InstructionDesc[OpFunctionEnd].setResultAndType(false, false);
InstructionDesc[OpStore].setResultAndType(false, false);
InstructionDesc[OpImageWrite].setResultAndType(false, false);
InstructionDesc[OpDecorationGroup].setResultAndType(true, false);
InstructionDesc[OpDecorate].setResultAndType(false, false);
InstructionDesc[OpDecorateId].setResultAndType(false, false);
InstructionDesc[OpDecorateStringGOOGLE].setResultAndType(false, false);
InstructionDesc[OpMemberDecorate].setResultAndType(false, false);
InstructionDesc[OpMemberDecorateStringGOOGLE].setResultAndType(false, false);
InstructionDesc[OpGroupDecorate].setResultAndType(false, false);
InstructionDesc[OpGroupMemberDecorate].setResultAndType(false, false);
InstructionDesc[OpName].setResultAndType(false, false);
InstructionDesc[OpMemberName].setResultAndType(false, false);
InstructionDesc[OpString].setResultAndType(true, false);
InstructionDesc[OpLine].setResultAndType(false, false);
InstructionDesc[OpNoLine].setResultAndType(false, false);
InstructionDesc[OpCopyMemory].setResultAndType(false, false);
InstructionDesc[OpCopyMemorySized].setResultAndType(false, false);
InstructionDesc[OpEmitVertex].setResultAndType(false, false);
InstructionDesc[OpEndPrimitive].setResultAndType(false, false);
InstructionDesc[OpEmitStreamVertex].setResultAndType(false, false);
InstructionDesc[OpEndStreamPrimitive].setResultAndType(false, false);
InstructionDesc[OpControlBarrier].setResultAndType(false, false);
InstructionDesc[OpMemoryBarrier].setResultAndType(false, false);
InstructionDesc[OpAtomicStore].setResultAndType(false, false);
InstructionDesc[OpLoopMerge].setResultAndType(false, false);
InstructionDesc[OpSelectionMerge].setResultAndType(false, false);
InstructionDesc[OpLabel].setResultAndType(true, false);
InstructionDesc[OpBranch].setResultAndType(false, false);
InstructionDesc[OpBranchConditional].setResultAndType(false, false);
InstructionDesc[OpSwitch].setResultAndType(false, false);
InstructionDesc[OpKill].setResultAndType(false, false);
InstructionDesc[OpTerminateInvocation].setResultAndType(false, false);
InstructionDesc[OpReturn].setResultAndType(false, false);
InstructionDesc[OpReturnValue].setResultAndType(false, false);
InstructionDesc[OpUnreachable].setResultAndType(false, false);
InstructionDesc[OpLifetimeStart].setResultAndType(false, false);
InstructionDesc[OpLifetimeStop].setResultAndType(false, false);
InstructionDesc[OpCommitReadPipe].setResultAndType(false, false);
InstructionDesc[OpCommitWritePipe].setResultAndType(false, false);
InstructionDesc[OpGroupCommitWritePipe].setResultAndType(false, false);
InstructionDesc[OpGroupCommitReadPipe].setResultAndType(false, false);
InstructionDesc[OpCaptureEventProfilingInfo].setResultAndType(false, false);
InstructionDesc[OpSetUserEventStatus].setResultAndType(false, false);
InstructionDesc[OpRetainEvent].setResultAndType(false, false);
InstructionDesc[OpReleaseEvent].setResultAndType(false, false);
InstructionDesc[OpGroupWaitEvents].setResultAndType(false, false);
InstructionDesc[OpAtomicFlagClear].setResultAndType(false, false);
InstructionDesc[OpModuleProcessed].setResultAndType(false, false);
InstructionDesc[OpTypeCooperativeMatrixNV].setResultAndType(true, false);
InstructionDesc[OpCooperativeMatrixStoreNV].setResultAndType(false, false);
Implement support for GL_KHR_cooperative_matrix extension
2023-03-16 12:01:01 +00:00
InstructionDesc[OpTypeCooperativeMatrixKHR].setResultAndType(true, false);
InstructionDesc[OpCooperativeMatrixStoreKHR].setResultAndType(false, false);
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpBeginInvocationInterlockEXT].setResultAndType(false, false);
InstructionDesc[OpEndInvocationInterlockEXT].setResultAndType(false, false);
SPV: Complete OpAssumeTrueKHR, OpExpectKHR
2023-09-01 09:03:35 +00:00
InstructionDesc[OpAssumeTrueKHR].setResultAndType(false, false);
Implement GLSL_NV_cooperative_matrix2
2024-10-08 19:39:29 +00:00
InstructionDesc[OpTypeTensorLayoutNV].setResultAndType(true, false);
InstructionDesc[OpTypeTensorViewNV].setResultAndType(true, false);
InstructionDesc[OpCooperativeMatrixStoreTensorNV].setResultAndType(false, false);
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
// Specific additional context-dependent operands
ExecutionModeOperands[ExecutionModeInvocations].push(OperandLiteralNumber, "'Number of <<Invocation,invocations>>'");
ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'x size'");
ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'y size'");
ExecutionModeOperands[ExecutionModeLocalSize].push(OperandLiteralNumber, "'z size'");
ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'x size'");
ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'y size'");
ExecutionModeOperands[ExecutionModeLocalSizeHint].push(OperandLiteralNumber, "'z size'");
ExecutionModeOperands[ExecutionModeOutputVertices].push(OperandLiteralNumber, "'Vertex count'");
ExecutionModeOperands[ExecutionModeVecTypeHint].push(OperandLiteralNumber, "'Vector type'");
DecorationOperands[DecorationStream].push(OperandLiteralNumber, "'Stream Number'");
DecorationOperands[DecorationLocation].push(OperandLiteralNumber, "'Location'");
DecorationOperands[DecorationComponent].push(OperandLiteralNumber, "'Component'");
DecorationOperands[DecorationIndex].push(OperandLiteralNumber, "'Index'");
DecorationOperands[DecorationBinding].push(OperandLiteralNumber, "'Binding Point'");
DecorationOperands[DecorationDescriptorSet].push(OperandLiteralNumber, "'Descriptor Set'");
DecorationOperands[DecorationOffset].push(OperandLiteralNumber, "'Byte Offset'");
DecorationOperands[DecorationXfbBuffer].push(OperandLiteralNumber, "'XFB Buffer Number'");
DecorationOperands[DecorationXfbStride].push(OperandLiteralNumber, "'XFB Stride'");
DecorationOperands[DecorationArrayStride].push(OperandLiteralNumber, "'Array Stride'");
DecorationOperands[DecorationMatrixStride].push(OperandLiteralNumber, "'Matrix Stride'");
DecorationOperands[DecorationBuiltIn].push(OperandLiteralNumber, "See <<BuiltIn,*BuiltIn*>>");
DecorationOperands[DecorationFPRoundingMode].push(OperandFPRoundingMode, "'Floating-Point Rounding Mode'");
DecorationOperands[DecorationFPFastMathMode].push(OperandFPFastMath, "'Fast-Math Mode'");
DecorationOperands[DecorationLinkageAttributes].push(OperandLiteralString, "'Name'");
DecorationOperands[DecorationLinkageAttributes].push(OperandLinkageType, "'Linkage Type'");
DecorationOperands[DecorationFuncParamAttr].push(OperandFuncParamAttr, "'Function Parameter Attribute'");
DecorationOperands[DecorationSpecId].push(OperandLiteralNumber, "'Specialization Constant ID'");
DecorationOperands[DecorationInputAttachmentIndex].push(OperandLiteralNumber, "'Attachment Index'");
DecorationOperands[DecorationAlignment].push(OperandLiteralNumber, "'Alignment'");
OperandClassParams[OperandSource].set(0, SourceString, nullptr);
OperandClassParams[OperandExecutionModel].set(0, ExecutionModelString, nullptr);
OperandClassParams[OperandAddressing].set(0, AddressingString, nullptr);
OperandClassParams[OperandMemory].set(0, MemoryString, nullptr);
OperandClassParams[OperandExecutionMode].set(ExecutionModeCeiling, ExecutionModeString, ExecutionModeParams);
OperandClassParams[OperandExecutionMode].setOperands(ExecutionModeOperands);
OperandClassParams[OperandStorage].set(0, StorageClassString, nullptr);
OperandClassParams[OperandDimensionality].set(0, DimensionString, nullptr);
OperandClassParams[OperandSamplerAddressingMode].set(0, SamplerAddressingModeString, nullptr);
OperandClassParams[OperandSamplerFilterMode].set(0, SamplerFilterModeString, nullptr);
OperandClassParams[OperandSamplerImageFormat].set(0, ImageFormatString, nullptr);
OperandClassParams[OperandImageChannelOrder].set(0, ImageChannelOrderString, nullptr);
OperandClassParams[OperandImageChannelDataType].set(0, ImageChannelDataTypeString, nullptr);
OperandClassParams[OperandImageOperands].set(ImageOperandsCeiling, ImageOperandsString, ImageOperandsParams, true);
OperandClassParams[OperandFPFastMath].set(0, FPFastMathString, nullptr, true);
OperandClassParams[OperandFPRoundingMode].set(0, FPRoundingModeString, nullptr);
OperandClassParams[OperandLinkageType].set(0, LinkageTypeString, nullptr);
OperandClassParams[OperandFuncParamAttr].set(0, FuncParamAttrString, nullptr);
OperandClassParams[OperandAccessQualifier].set(0, AccessQualifierString, nullptr);
OperandClassParams[OperandDecoration].set(DecorationCeiling, DecorationString, DecorationParams);
OperandClassParams[OperandDecoration].setOperands(DecorationOperands);
OperandClassParams[OperandBuiltIn].set(0, BuiltInString, nullptr);
OperandClassParams[OperandSelect].set(SelectControlCeiling, SelectControlString, SelectionControlParams, true);
OperandClassParams[OperandLoop].set(LoopControlCeiling, LoopControlString, LoopControlParams, true);
OperandClassParams[OperandFunction].set(FunctionControlCeiling, FunctionControlString, FunctionControlParams, true);
OperandClassParams[OperandMemorySemantics].set(0, MemorySemanticsString, nullptr, true);
OperandClassParams[OperandMemoryAccess].set(MemoryAccessCeiling, MemoryAccessString, MemoryAccessParams, true);
OperandClassParams[OperandScope].set(0, ScopeString, nullptr);
OperandClassParams[OperandGroupOperation].set(0, GroupOperationString, nullptr);
OperandClassParams[OperandKernelEnqueueFlags].set(0, KernelEnqueueFlagsString, nullptr);
OperandClassParams[OperandKernelProfilingInfo].set(0, KernelProfilingInfoString, nullptr, true);
OperandClassParams[OperandCapability].set(0, CapabilityString, nullptr);
Implement support for GL_KHR_cooperative_matrix extension
2023-03-16 12:01:01 +00:00
OperandClassParams[OperandCooperativeMatrixOperands].set(CooperativeMatrixOperandsCeiling, CooperativeMatrixOperandsString, CooperativeMatrixOperandsParams, true);
Implement GLSL_NV_cooperative_matrix2
2024-10-08 19:39:29 +00:00
OperandClassParams[OperandTensorAddressingOperands].set(TensorAddressingOperandsCeiling, TensorAddressingOperandsString, TensorAddressingOperandsParams, true);
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
OperandClassParams[OperandOpcode].set(OpCodeMask + 1, OpcodeString, nullptr);
// set name of operator, an initial set of <id> style operands, and the description
InstructionDesc[OpSource].operands.push(OperandSource, "");
InstructionDesc[OpSource].operands.push(OperandLiteralNumber, "'Version'");
InstructionDesc[OpSource].operands.push(OperandId, "'File'", true);
InstructionDesc[OpSource].operands.push(OperandLiteralString, "'Source'", true);
InstructionDesc[OpSourceContinued].operands.push(OperandLiteralString, "'Continued Source'");
InstructionDesc[OpSourceExtension].operands.push(OperandLiteralString, "'Extension'");
InstructionDesc[OpName].operands.push(OperandId, "'Target'");
InstructionDesc[OpName].operands.push(OperandLiteralString, "'Name'");
InstructionDesc[OpMemberName].operands.push(OperandId, "'Type'");
InstructionDesc[OpMemberName].operands.push(OperandLiteralNumber, "'Member'");
InstructionDesc[OpMemberName].operands.push(OperandLiteralString, "'Name'");
InstructionDesc[OpString].operands.push(OperandLiteralString, "'String'");
InstructionDesc[OpLine].operands.push(OperandId, "'File'");
InstructionDesc[OpLine].operands.push(OperandLiteralNumber, "'Line'");
InstructionDesc[OpLine].operands.push(OperandLiteralNumber, "'Column'");
InstructionDesc[OpExtension].operands.push(OperandLiteralString, "'Name'");
InstructionDesc[OpExtInstImport].operands.push(OperandLiteralString, "'Name'");
InstructionDesc[OpCapability].operands.push(OperandCapability, "'Capability'");
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpMemoryModel].operands.push(OperandAddressing, "");
InstructionDesc[OpMemoryModel].operands.push(OperandMemory, "");
InstructionDesc[OpEntryPoint].operands.push(OperandExecutionModel, "");
InstructionDesc[OpEntryPoint].operands.push(OperandId, "'Entry Point'");
InstructionDesc[OpEntryPoint].operands.push(OperandLiteralString, "'Name'");
InstructionDesc[OpEntryPoint].operands.push(OperandVariableIds, "'Interface'");
InstructionDesc[OpExecutionMode].operands.push(OperandId, "'Entry Point'");
InstructionDesc[OpExecutionMode].operands.push(OperandExecutionMode, "'Mode'");
InstructionDesc[OpExecutionMode].operands.push(OperandOptionalLiteral, "See <<Execution_Mode,Execution Mode>>");
InstructionDesc[OpExecutionModeId].operands.push(OperandId, "'Entry Point'");
InstructionDesc[OpExecutionModeId].operands.push(OperandExecutionMode, "'Mode'");
InstructionDesc[OpExecutionModeId].operands.push(OperandVariableIds, "See <<Execution_Mode,Execution Mode>>");
InstructionDesc[OpTypeInt].operands.push(OperandLiteralNumber, "'Width'");
InstructionDesc[OpTypeInt].operands.push(OperandLiteralNumber, "'Signedness'");
InstructionDesc[OpTypeFloat].operands.push(OperandLiteralNumber, "'Width'");
InstructionDesc[OpTypeVector].operands.push(OperandId, "'Component Type'");
InstructionDesc[OpTypeVector].operands.push(OperandLiteralNumber, "'Component Count'");
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpTypeMatrix].operands.push(OperandId, "'Column Type'");
InstructionDesc[OpTypeMatrix].operands.push(OperandLiteralNumber, "'Column Count'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpTypeImage].operands.push(OperandId, "'Sampled Type'");
InstructionDesc[OpTypeImage].operands.push(OperandDimensionality, "");
InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'Depth'");
InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'Arrayed'");
InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'MS'");
InstructionDesc[OpTypeImage].operands.push(OperandLiteralNumber, "'Sampled'");
InstructionDesc[OpTypeImage].operands.push(OperandSamplerImageFormat, "");
InstructionDesc[OpTypeImage].operands.push(OperandAccessQualifier, "", true);
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpTypeSampledImage].operands.push(OperandId, "'Image Type'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpTypeArray].operands.push(OperandId, "'Element Type'");
InstructionDesc[OpTypeArray].operands.push(OperandId, "'Length'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpTypeRuntimeArray].operands.push(OperandId, "'Element Type'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpTypeStruct].operands.push(OperandVariableIds, "'Member 0 type', +\n'member 1 type', +\n...");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpTypeOpaque].operands.push(OperandLiteralString, "The name of the opaque type.");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpTypePointer].operands.push(OperandStorage, "");
InstructionDesc[OpTypePointer].operands.push(OperandId, "'Type'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpTypeForwardPointer].operands.push(OperandId, "'Pointer Type'");
InstructionDesc[OpTypeForwardPointer].operands.push(OperandStorage, "");
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpTypePipe].operands.push(OperandAccessQualifier, "'Qualifier'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpTypeFunction].operands.push(OperandId, "'Return Type'");
InstructionDesc[OpTypeFunction].operands.push(OperandVariableIds, "'Parameter 0 Type', +\n'Parameter 1 Type', +\n...");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpConstant].operands.push(OperandVariableLiterals, "'Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpConstantComposite].operands.push(OperandVariableIds, "'Constituents'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpConstantSampler].operands.push(OperandSamplerAddressingMode, "");
InstructionDesc[OpConstantSampler].operands.push(OperandLiteralNumber, "'Param'");
InstructionDesc[OpConstantSampler].operands.push(OperandSamplerFilterMode, "");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSpecConstant].operands.push(OperandVariableLiterals, "'Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSpecConstantComposite].operands.push(OperandVariableIds, "'Constituents'");
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSpecConstantOp].operands.push(OperandLiteralNumber, "'Opcode'");
InstructionDesc[OpSpecConstantOp].operands.push(OperandVariableIds, "'Operands'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpVariable].operands.push(OperandStorage, "");
InstructionDesc[OpVariable].operands.push(OperandId, "'Initializer'", true);
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFunction].operands.push(OperandFunction, "");
InstructionDesc[OpFunction].operands.push(OperandId, "'Function Type'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFunctionCall].operands.push(OperandId, "'Function'");
InstructionDesc[OpFunctionCall].operands.push(OperandVariableIds, "'Argument 0', +\n'Argument 1', +\n...");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpExtInst].operands.push(OperandId, "'Set'");
InstructionDesc[OpExtInst].operands.push(OperandLiteralNumber, "'Instruction'");
InstructionDesc[OpExtInst].operands.push(OperandVariableIds, "'Operand 1', +\n'Operand 2', +\n...");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Add the KHR suffix for OpExtInstWithForwardRefsKHR instruction
2024-06-06 22:07:12 +00:00
InstructionDesc[OpExtInstWithForwardRefsKHR].operands.push(OperandId, "'Set'");
InstructionDesc[OpExtInstWithForwardRefsKHR].operands.push(OperandLiteralNumber, "'Instruction'");
InstructionDesc[OpExtInstWithForwardRefsKHR].operands.push(OperandVariableIds, "'Operand 1', +\n'Operand 2', +\n...");
Add support for OpExtInstWithForwardRefs
2024-03-11 22:24:45 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpLoad].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpLoad].operands.push(OperandMemoryAccess, "", true);
InstructionDesc[OpLoad].operands.push(OperandLiteralNumber, "", true);
InstructionDesc[OpLoad].operands.push(OperandId, "", true);
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpStore].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpStore].operands.push(OperandId, "'Object'");
InstructionDesc[OpStore].operands.push(OperandMemoryAccess, "", true);
InstructionDesc[OpStore].operands.push(OperandLiteralNumber, "", true);
InstructionDesc[OpStore].operands.push(OperandId, "", true);
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpPhi].operands.push(OperandVariableIds, "'Variable, Parent, ...'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpDecorate].operands.push(OperandId, "'Target'");
InstructionDesc[OpDecorate].operands.push(OperandDecoration, "");
InstructionDesc[OpDecorate].operands.push(OperandVariableLiterals, "See <<Decoration,'Decoration'>>.");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpDecorateId].operands.push(OperandId, "'Target'");
InstructionDesc[OpDecorateId].operands.push(OperandDecoration, "");
InstructionDesc[OpDecorateId].operands.push(OperandVariableIds, "See <<Decoration,'Decoration'>>.");
Implement SPV_GOOGLE_hlsl_functionality1. Enabled via -fhlsl_functionality1
2018-03-08 01:05:55 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpDecorateStringGOOGLE].operands.push(OperandId, "'Target'");
InstructionDesc[OpDecorateStringGOOGLE].operands.push(OperandDecoration, "");
InstructionDesc[OpDecorateStringGOOGLE].operands.push(OperandVariableLiteralStrings, "'Literal Strings'");
Implement SPV_GOOGLE_hlsl_functionality1. Enabled via -fhlsl_functionality1
2018-03-08 01:05:55 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpMemberDecorate].operands.push(OperandId, "'Structure Type'");
InstructionDesc[OpMemberDecorate].operands.push(OperandLiteralNumber, "'Member'");
InstructionDesc[OpMemberDecorate].operands.push(OperandDecoration, "");
InstructionDesc[OpMemberDecorate].operands.push(OperandVariableLiterals, "See <<Decoration,'Decoration'>>.");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandId, "'Structure Type'");
InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandLiteralNumber, "'Member'");
InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandDecoration, "");
InstructionDesc[OpMemberDecorateStringGOOGLE].operands.push(OperandVariableLiteralStrings, "'Literal Strings'");
Implement SPV_GOOGLE_hlsl_functionality1. Enabled via -fhlsl_functionality1
2018-03-08 01:05:55 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpGroupDecorate].operands.push(OperandId, "'Decoration Group'");
InstructionDesc[OpGroupDecorate].operands.push(OperandVariableIds, "'Targets'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpGroupMemberDecorate].operands.push(OperandId, "'Decoration Group'");
InstructionDesc[OpGroupMemberDecorate].operands.push(OperandVariableIdLiteral, "'Targets'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpVectorExtractDynamic].operands.push(OperandId, "'Vector'");
InstructionDesc[OpVectorExtractDynamic].operands.push(OperandId, "'Index'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Vector'");
InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Component'");
InstructionDesc[OpVectorInsertDynamic].operands.push(OperandId, "'Index'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpVectorShuffle].operands.push(OperandId, "'Vector 1'");
InstructionDesc[OpVectorShuffle].operands.push(OperandId, "'Vector 2'");
InstructionDesc[OpVectorShuffle].operands.push(OperandVariableLiterals, "'Components'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpCompositeConstruct].operands.push(OperandVariableIds, "'Constituents'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpCompositeExtract].operands.push(OperandId, "'Composite'");
InstructionDesc[OpCompositeExtract].operands.push(OperandVariableLiterals, "'Indexes'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpCompositeInsert].operands.push(OperandId, "'Object'");
InstructionDesc[OpCompositeInsert].operands.push(OperandId, "'Composite'");
InstructionDesc[OpCompositeInsert].operands.push(OperandVariableLiterals, "'Indexes'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpCopyObject].operands.push(OperandId, "'Operand'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpCopyMemory].operands.push(OperandId, "'Target'");
InstructionDesc[OpCopyMemory].operands.push(OperandId, "'Source'");
InstructionDesc[OpCopyMemory].operands.push(OperandMemoryAccess, "", true);
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Target'");
InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Source'");
InstructionDesc[OpCopyMemorySized].operands.push(OperandId, "'Size'");
InstructionDesc[OpCopyMemorySized].operands.push(OperandMemoryAccess, "", true);
InstructionDesc[OpSampledImage].operands.push(OperandId, "'Image'");
InstructionDesc[OpSampledImage].operands.push(OperandId, "'Sampler'");
InstructionDesc[OpImage].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageRead].operands.push(OperandId, "'Image'");
InstructionDesc[OpImageRead].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageRead].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageRead].operands.push(OperandVariableIds, "", true);
InstructionDesc[OpImageWrite].operands.push(OperandId, "'Image'");
InstructionDesc[OpImageWrite].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageWrite].operands.push(OperandId, "'Texel'");
InstructionDesc[OpImageWrite].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageWrite].operands.push(OperandVariableIds, "", true);
InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSampleImplicitLod].operands.push(OperandVariableIds, "", true);
InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSampleExplicitLod].operands.push(OperandVariableIds, "", true);
InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandId, "'D~ref~'");
InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSampleDrefImplicitLod].operands.push(OperandVariableIds, "", true);
InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandId, "'D~ref~'");
InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSampleDrefExplicitLod].operands.push(OperandVariableIds, "", true);
InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSampleProjImplicitLod].operands.push(OperandVariableIds, "", true);
InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSampleProjExplicitLod].operands.push(OperandVariableIds, "", true);
InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandId, "'D~ref~'");
InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSampleProjDrefImplicitLod].operands.push(OperandVariableIds, "", true);
InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandId, "'D~ref~'");
InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSampleProjDrefExplicitLod].operands.push(OperandVariableIds, "", true);
InstructionDesc[OpImageFetch].operands.push(OperandId, "'Image'");
InstructionDesc[OpImageFetch].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageFetch].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageFetch].operands.push(OperandVariableIds, "", true);
InstructionDesc[OpImageGather].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageGather].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageGather].operands.push(OperandId, "'Component'");
InstructionDesc[OpImageGather].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageGather].operands.push(OperandVariableIds, "", true);
InstructionDesc[OpImageDrefGather].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageDrefGather].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageDrefGather].operands.push(OperandId, "'D~ref~'");
InstructionDesc[OpImageDrefGather].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageDrefGather].operands.push(OperandVariableIds, "", true);
InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSparseSampleImplicitLod].operands.push(OperandVariableIds, "", true);
InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSparseSampleExplicitLod].operands.push(OperandVariableIds, "", true);
InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandId, "'D~ref~'");
InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSparseSampleDrefImplicitLod].operands.push(OperandVariableIds, "", true);
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandId, "'D~ref~'");
InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSparseSampleDrefExplicitLod].operands.push(OperandVariableIds, "", true);
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSparseSampleProjImplicitLod].operands.push(OperandVariableIds, "", true);
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSparseSampleProjExplicitLod].operands.push(OperandVariableIds, "", true);
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandId, "'D~ref~'");
InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSparseSampleProjDrefImplicitLod].operands.push(OperandVariableIds, "", true);
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandId, "'D~ref~'");
InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSparseSampleProjDrefExplicitLod].operands.push(OperandVariableIds, "", true);
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageSparseFetch].operands.push(OperandId, "'Image'");
InstructionDesc[OpImageSparseFetch].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSparseFetch].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSparseFetch].operands.push(OperandVariableIds, "", true);
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageSparseGather].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSparseGather].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSparseGather].operands.push(OperandId, "'Component'");
InstructionDesc[OpImageSparseGather].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSparseGather].operands.push(OperandVariableIds, "", true);
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageSparseDrefGather].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSparseDrefGather].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSparseDrefGather].operands.push(OperandId, "'D~ref~'");
InstructionDesc[OpImageSparseDrefGather].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSparseDrefGather].operands.push(OperandVariableIds, "", true);
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageSparseRead].operands.push(OperandId, "'Image'");
InstructionDesc[OpImageSparseRead].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSparseRead].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSparseRead].operands.push(OperandVariableIds, "", true);
SPV: Implement Vulkan version of GLSL (KHR_vulkan_glsl).
2016-02-16 03:58:50 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageSparseTexelsResident].operands.push(OperandId, "'Resident Code'");
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageQuerySizeLod].operands.push(OperandId, "'Image'");
InstructionDesc[OpImageQuerySizeLod].operands.push(OperandId, "'Level of Detail'");
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageQuerySize].operands.push(OperandId, "'Image'");
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageQueryLod].operands.push(OperandId, "'Image'");
InstructionDesc[OpImageQueryLod].operands.push(OperandId, "'Coordinate'");
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageQueryLevels].operands.push(OperandId, "'Image'");
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageQuerySamples].operands.push(OperandId, "'Image'");
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageQueryFormat].operands.push(OperandId, "'Image'");
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageQueryOrder].operands.push(OperandId, "'Image'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAccessChain].operands.push(OperandId, "'Base'");
InstructionDesc[OpAccessChain].operands.push(OperandVariableIds, "'Indexes'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpInBoundsAccessChain].operands.push(OperandId, "'Base'");
InstructionDesc[OpInBoundsAccessChain].operands.push(OperandVariableIds, "'Indexes'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpPtrAccessChain].operands.push(OperandId, "'Base'");
InstructionDesc[OpPtrAccessChain].operands.push(OperandId, "'Element'");
InstructionDesc[OpPtrAccessChain].operands.push(OperandVariableIds, "'Indexes'");
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpInBoundsPtrAccessChain].operands.push(OperandId, "'Base'");
InstructionDesc[OpInBoundsPtrAccessChain].operands.push(OperandId, "'Element'");
InstructionDesc[OpInBoundsPtrAccessChain].operands.push(OperandVariableIds, "'Indexes'");
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSNegate].operands.push(OperandId, "'Operand'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFNegate].operands.push(OperandId, "'Operand'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpNot].operands.push(OperandId, "'Operand'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAny].operands.push(OperandId, "'Vector'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAll].operands.push(OperandId, "'Vector'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpConvertFToU].operands.push(OperandId, "'Float Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpConvertFToS].operands.push(OperandId, "'Float Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpConvertSToF].operands.push(OperandId, "'Signed Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpConvertUToF].operands.push(OperandId, "'Unsigned Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpUConvert].operands.push(OperandId, "'Unsigned Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSConvert].operands.push(OperandId, "'Signed Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFConvert].operands.push(OperandId, "'Float Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSatConvertSToU].operands.push(OperandId, "'Signed Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSatConvertUToS].operands.push(OperandId, "'Unsigned Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpConvertPtrToU].operands.push(OperandId, "'Pointer'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpConvertUToPtr].operands.push(OperandId, "'Integer Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpPtrCastToGeneric].operands.push(OperandId, "'Pointer'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpGenericCastToPtr].operands.push(OperandId, "'Pointer'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpGenericCastToPtrExplicit].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpGenericCastToPtrExplicit].operands.push(OperandStorage, "'Storage'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpGenericPtrMemSemantics].operands.push(OperandId, "'Pointer'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpBitcast].operands.push(OperandId, "'Operand'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpQuantizeToF16].operands.push(OperandId, "'Value'");
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpTranspose].operands.push(OperandId, "'Matrix'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpCopyLogical].operands.push(OperandId, "'Operand'");
SPV 1.4: Add support for OpCopyLogical, careful of Boolean differences.
2019-01-15 14:48:27 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpIsNan].operands.push(OperandId, "'x'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpIsInf].operands.push(OperandId, "'x'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpIsFinite].operands.push(OperandId, "'x'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpIsNormal].operands.push(OperandId, "'x'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSignBitSet].operands.push(OperandId, "'x'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpLessOrGreater].operands.push(OperandId, "'x'");
InstructionDesc[OpLessOrGreater].operands.push(OperandId, "'y'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpOrdered].operands.push(OperandId, "'x'");
InstructionDesc[OpOrdered].operands.push(OperandId, "'y'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpUnordered].operands.push(OperandId, "'x'");
InstructionDesc[OpUnordered].operands.push(OperandId, "'y'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpArrayLength].operands.push(OperandId, "'Structure'");
InstructionDesc[OpArrayLength].operands.push(OperandLiteralNumber, "'Array member'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpIAdd].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpIAdd].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFAdd].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFAdd].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpISub].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpISub].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFSub].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFSub].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpIMul].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpIMul].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFMul].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFMul].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpUDiv].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpUDiv].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSDiv].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpSDiv].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFDiv].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFDiv].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpUMod].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpUMod].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSRem].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpSRem].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSMod].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpSMod].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFRem].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFRem].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFMod].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFMod].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpVectorTimesScalar].operands.push(OperandId, "'Vector'");
InstructionDesc[OpVectorTimesScalar].operands.push(OperandId, "'Scalar'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpMatrixTimesScalar].operands.push(OperandId, "'Matrix'");
InstructionDesc[OpMatrixTimesScalar].operands.push(OperandId, "'Scalar'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpVectorTimesMatrix].operands.push(OperandId, "'Vector'");
InstructionDesc[OpVectorTimesMatrix].operands.push(OperandId, "'Matrix'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpMatrixTimesVector].operands.push(OperandId, "'Matrix'");
InstructionDesc[OpMatrixTimesVector].operands.push(OperandId, "'Vector'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpMatrixTimesMatrix].operands.push(OperandId, "'LeftMatrix'");
InstructionDesc[OpMatrixTimesMatrix].operands.push(OperandId, "'RightMatrix'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpOuterProduct].operands.push(OperandId, "'Vector 1'");
InstructionDesc[OpOuterProduct].operands.push(OperandId, "'Vector 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpDot].operands.push(OperandId, "'Vector 1'");
InstructionDesc[OpDot].operands.push(OperandId, "'Vector 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpIAddCarry].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpIAddCarry].operands.push(OperandId, "'Operand 2'");
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpISubBorrow].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpISubBorrow].operands.push(OperandId, "'Operand 2'");
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpUMulExtended].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpUMulExtended].operands.push(OperandId, "'Operand 2'");
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSMulExtended].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpSMulExtended].operands.push(OperandId, "'Operand 2'");
SPIR-V: Move from Version .99 Rev 31 to Version 1.0, Rev 2.
2015-11-16 04:33:39 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpShiftRightLogical].operands.push(OperandId, "'Base'");
InstructionDesc[OpShiftRightLogical].operands.push(OperandId, "'Shift'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpShiftRightArithmetic].operands.push(OperandId, "'Base'");
InstructionDesc[OpShiftRightArithmetic].operands.push(OperandId, "'Shift'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpShiftLeftLogical].operands.push(OperandId, "'Base'");
InstructionDesc[OpShiftLeftLogical].operands.push(OperandId, "'Shift'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpLogicalOr].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpLogicalOr].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpLogicalAnd].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpLogicalAnd].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpLogicalEqual].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpLogicalEqual].operands.push(OperandId, "'Operand 2'");
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpLogicalNotEqual].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpLogicalNotEqual].operands.push(OperandId, "'Operand 2'");
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpLogicalNot].operands.push(OperandId, "'Operand'");
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpBitwiseOr].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpBitwiseOr].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpBitwiseXor].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpBitwiseXor].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpBitwiseAnd].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpBitwiseAnd].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Base'");
InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Insert'");
InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Offset'");
InstructionDesc[OpBitFieldInsert].operands.push(OperandId, "'Count'");
Non-Functional: Remove unused parts of the disassembler.
2018-03-30 06:11:39 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Base'");
InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Offset'");
InstructionDesc[OpBitFieldSExtract].operands.push(OperandId, "'Count'");
[glslang] Strip trailing whitespace There are many other files in the repo that have trailing whitespace but this PR only cleans `glslang/SPIRV` and `glslang/Standalone`.
2023-05-22 15:44:18 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Base'");
InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Offset'");
InstructionDesc[OpBitFieldUExtract].operands.push(OperandId, "'Count'");
[glslang] Strip trailing whitespace There are many other files in the repo that have trailing whitespace but this PR only cleans `glslang/SPIRV` and `glslang/Standalone`.
2023-05-22 15:44:18 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpBitReverse].operands.push(OperandId, "'Base'");
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpBitCount].operands.push(OperandId, "'Base'");
Move to revision 31 of SPIR-V.
2015-08-07 04:53:06 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSelect].operands.push(OperandId, "'Condition'");
InstructionDesc[OpSelect].operands.push(OperandId, "'Object 1'");
InstructionDesc[OpSelect].operands.push(OperandId, "'Object 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpIEqual].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpIEqual].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFOrdEqual].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFOrdEqual].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFUnordEqual].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFUnordEqual].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpINotEqual].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpINotEqual].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFOrdNotEqual].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFOrdNotEqual].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFUnordNotEqual].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFUnordNotEqual].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpULessThan].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpULessThan].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSLessThan].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpSLessThan].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFOrdLessThan].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFOrdLessThan].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFUnordLessThan].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFUnordLessThan].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpUGreaterThan].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpUGreaterThan].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSGreaterThan].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpSGreaterThan].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFOrdGreaterThan].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFOrdGreaterThan].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFUnordGreaterThan].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFUnordGreaterThan].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpULessThanEqual].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpULessThanEqual].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSLessThanEqual].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpSLessThanEqual].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFOrdLessThanEqual].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFOrdLessThanEqual].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFUnordLessThanEqual].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFUnordLessThanEqual].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpUGreaterThanEqual].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpUGreaterThanEqual].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSGreaterThanEqual].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpSGreaterThanEqual].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFOrdGreaterThanEqual].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFOrdGreaterThanEqual].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFUnordGreaterThanEqual].operands.push(OperandId, "'Operand 1'");
InstructionDesc[OpFUnordGreaterThanEqual].operands.push(OperandId, "'Operand 2'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpDPdx].operands.push(OperandId, "'P'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpDPdy].operands.push(OperandId, "'P'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFwidth].operands.push(OperandId, "'P'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpDPdxFine].operands.push(OperandId, "'P'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpDPdyFine].operands.push(OperandId, "'P'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFwidthFine].operands.push(OperandId, "'P'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpDPdxCoarse].operands.push(OperandId, "'P'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpDPdyCoarse].operands.push(OperandId, "'P'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpFwidthCoarse].operands.push(OperandId, "'P'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpEmitStreamVertex].operands.push(OperandId, "'Stream'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpEndStreamPrimitive].operands.push(OperandId, "'Stream'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpControlBarrier].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpControlBarrier].operands.push(OperandScope, "'Memory'");
InstructionDesc[OpControlBarrier].operands.push(OperandMemorySemantics, "'Semantics'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpMemoryBarrier].operands.push(OperandScope, "'Memory'");
InstructionDesc[OpMemoryBarrier].operands.push(OperandMemorySemantics, "'Semantics'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageTexelPointer].operands.push(OperandId, "'Image'");
InstructionDesc[OpImageTexelPointer].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageTexelPointer].operands.push(OperandId, "'Sample'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAtomicLoad].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicLoad].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicLoad].operands.push(OperandMemorySemantics, "'Semantics'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAtomicStore].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicStore].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicStore].operands.push(OperandMemorySemantics, "'Semantics'");
InstructionDesc[OpAtomicStore].operands.push(OperandId, "'Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAtomicExchange].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicExchange].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicExchange].operands.push(OperandMemorySemantics, "'Semantics'");
InstructionDesc[OpAtomicExchange].operands.push(OperandId, "'Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicCompareExchange].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicCompareExchange].operands.push(OperandMemorySemantics, "'Equal'");
InstructionDesc[OpAtomicCompareExchange].operands.push(OperandMemorySemantics, "'Unequal'");
InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Value'");
InstructionDesc[OpAtomicCompareExchange].operands.push(OperandId, "'Comparator'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandMemorySemantics, "'Equal'");
InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandMemorySemantics, "'Unequal'");
InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Value'");
InstructionDesc[OpAtomicCompareExchangeWeak].operands.push(OperandId, "'Comparator'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAtomicIIncrement].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicIIncrement].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicIIncrement].operands.push(OperandMemorySemantics, "'Semantics'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAtomicIDecrement].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicIDecrement].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicIDecrement].operands.push(OperandMemorySemantics, "'Semantics'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAtomicIAdd].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicIAdd].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicIAdd].operands.push(OperandMemorySemantics, "'Semantics'");
InstructionDesc[OpAtomicIAdd].operands.push(OperandId, "'Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAtomicFAddEXT].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicFAddEXT].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicFAddEXT].operands.push(OperandMemorySemantics, "'Semantics'");
InstructionDesc[OpAtomicFAddEXT].operands.push(OperandId, "'Value'");
Add changes for SPV_EXT_shader_atomic_float_add
2020-07-19 22:45:01 +00:00
SPV: Complete OpAssumeTrueKHR, OpExpectKHR
2023-09-01 09:03:35 +00:00
InstructionDesc[OpAssumeTrueKHR].operands.push(OperandId, "'Condition'");
InstructionDesc[OpExpectKHR].operands.push(OperandId, "'Value'");
InstructionDesc[OpExpectKHR].operands.push(OperandId, "'ExpectedValue'");
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAtomicISub].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicISub].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicISub].operands.push(OperandMemorySemantics, "'Semantics'");
InstructionDesc[OpAtomicISub].operands.push(OperandId, "'Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAtomicUMin].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicUMin].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicUMin].operands.push(OperandMemorySemantics, "'Semantics'");
InstructionDesc[OpAtomicUMin].operands.push(OperandId, "'Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAtomicUMax].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicUMax].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicUMax].operands.push(OperandMemorySemantics, "'Semantics'");
InstructionDesc[OpAtomicUMax].operands.push(OperandId, "'Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAtomicSMin].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicSMin].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicSMin].operands.push(OperandMemorySemantics, "'Semantics'");
InstructionDesc[OpAtomicSMin].operands.push(OperandId, "'Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAtomicSMax].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicSMax].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicSMax].operands.push(OperandMemorySemantics, "'Semantics'");
InstructionDesc[OpAtomicSMax].operands.push(OperandId, "'Value'");
Final round for line endings.
2015-06-26 22:58:36 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAtomicFMinEXT].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicFMinEXT].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicFMinEXT].operands.push(OperandMemorySemantics, "'Semantics'");
InstructionDesc[OpAtomicFMinEXT].operands.push(OperandId, "'Value'");
Implement GLSL_EXT_shader_atomic_float2
2021-01-13 20:36:17 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAtomicFMaxEXT].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicFMaxEXT].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicFMaxEXT].operands.push(OperandMemorySemantics, "'Semantics'");
InstructionDesc[OpAtomicFMaxEXT].operands.push(OperandId, "'Value'");
Implement GLSL_EXT_shader_atomic_float2
2021-01-13 20:36:17 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpAtomicAnd].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicAnd].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicAnd].operands.push(OperandMemorySemantics, "'Semantics'");
InstructionDesc[OpAtomicAnd].operands.push(OperandId, "'Value'");
InstructionDesc[OpAtomicOr].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicOr].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicOr].operands.push(OperandMemorySemantics, "'Semantics'");
InstructionDesc[OpAtomicOr].operands.push(OperandId, "'Value'");
InstructionDesc[OpAtomicXor].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicXor].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicXor].operands.push(OperandMemorySemantics, "'Semantics'");
InstructionDesc[OpAtomicXor].operands.push(OperandId, "'Value'");
InstructionDesc[OpAtomicFlagTestAndSet].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicFlagTestAndSet].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicFlagTestAndSet].operands.push(OperandMemorySemantics, "'Semantics'");
InstructionDesc[OpAtomicFlagClear].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpAtomicFlagClear].operands.push(OperandScope, "'Scope'");
InstructionDesc[OpAtomicFlagClear].operands.push(OperandMemorySemantics, "'Semantics'");
InstructionDesc[OpLoopMerge].operands.push(OperandId, "'Merge Block'");
InstructionDesc[OpLoopMerge].operands.push(OperandId, "'Continue Target'");
InstructionDesc[OpLoopMerge].operands.push(OperandLoop, "");
InstructionDesc[OpLoopMerge].operands.push(OperandOptionalLiteral, "");
InstructionDesc[OpSelectionMerge].operands.push(OperandId, "'Merge Block'");
InstructionDesc[OpSelectionMerge].operands.push(OperandSelect, "");
InstructionDesc[OpBranch].operands.push(OperandId, "'Target Label'");
InstructionDesc[OpBranchConditional].operands.push(OperandId, "'Condition'");
InstructionDesc[OpBranchConditional].operands.push(OperandId, "'True Label'");
InstructionDesc[OpBranchConditional].operands.push(OperandId, "'False Label'");
InstructionDesc[OpBranchConditional].operands.push(OperandVariableLiterals, "'Branch weights'");
InstructionDesc[OpSwitch].operands.push(OperandId, "'Selector'");
InstructionDesc[OpSwitch].operands.push(OperandId, "'Default'");
InstructionDesc[OpSwitch].operands.push(OperandVariableLiteralId, "'Target'");
InstructionDesc[OpReturnValue].operands.push(OperandId, "'Value'");
InstructionDesc[OpLifetimeStart].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpLifetimeStart].operands.push(OperandLiteralNumber, "'Size'");
InstructionDesc[OpLifetimeStop].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpLifetimeStop].operands.push(OperandLiteralNumber, "'Size'");
InstructionDesc[OpGroupAsyncCopy].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Destination'");
InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Source'");
InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Num Elements'");
InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Stride'");
InstructionDesc[OpGroupAsyncCopy].operands.push(OperandId, "'Event'");
InstructionDesc[OpGroupWaitEvents].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupWaitEvents].operands.push(OperandId, "'Num Events'");
InstructionDesc[OpGroupWaitEvents].operands.push(OperandId, "'Events List'");
InstructionDesc[OpGroupAll].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupAll].operands.push(OperandId, "'Predicate'");
InstructionDesc[OpGroupAny].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupAny].operands.push(OperandId, "'Predicate'");
InstructionDesc[OpGroupBroadcast].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupBroadcast].operands.push(OperandId, "'Value'");
InstructionDesc[OpGroupBroadcast].operands.push(OperandId, "'LocalId'");
InstructionDesc[OpGroupIAdd].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupIAdd].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupIAdd].operands.push(OperandId, "'X'");
InstructionDesc[OpGroupFAdd].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupFAdd].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupFAdd].operands.push(OperandId, "'X'");
InstructionDesc[OpGroupUMin].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupUMin].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupUMin].operands.push(OperandId, "'X'");
InstructionDesc[OpGroupSMin].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupSMin].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupSMin].operands.push(OperandId, "X");
InstructionDesc[OpGroupFMin].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupFMin].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupFMin].operands.push(OperandId, "X");
InstructionDesc[OpGroupUMax].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupUMax].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupUMax].operands.push(OperandId, "X");
InstructionDesc[OpGroupSMax].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupSMax].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupSMax].operands.push(OperandId, "X");
InstructionDesc[OpGroupFMax].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupFMax].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupFMax].operands.push(OperandId, "X");
InstructionDesc[OpReadPipe].operands.push(OperandId, "'Pipe'");
InstructionDesc[OpReadPipe].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpReadPipe].operands.push(OperandId, "'Packet Size'");
InstructionDesc[OpReadPipe].operands.push(OperandId, "'Packet Alignment'");
InstructionDesc[OpWritePipe].operands.push(OperandId, "'Pipe'");
InstructionDesc[OpWritePipe].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpWritePipe].operands.push(OperandId, "'Packet Size'");
InstructionDesc[OpWritePipe].operands.push(OperandId, "'Packet Alignment'");
InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Pipe'");
InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Reserve Id'");
InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Index'");
InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Packet Size'");
InstructionDesc[OpReservedReadPipe].operands.push(OperandId, "'Packet Alignment'");
InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Pipe'");
InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Reserve Id'");
InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Index'");
InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Packet Size'");
InstructionDesc[OpReservedWritePipe].operands.push(OperandId, "'Packet Alignment'");
InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Pipe'");
InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Num Packets'");
InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Packet Size'");
InstructionDesc[OpReserveReadPipePackets].operands.push(OperandId, "'Packet Alignment'");
InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Pipe'");
InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Num Packets'");
InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Packet Size'");
InstructionDesc[OpReserveWritePipePackets].operands.push(OperandId, "'Packet Alignment'");
InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Pipe'");
InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Reserve Id'");
InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Packet Size'");
InstructionDesc[OpCommitReadPipe].operands.push(OperandId, "'Packet Alignment'");
InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Pipe'");
InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Reserve Id'");
InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Packet Size'");
InstructionDesc[OpCommitWritePipe].operands.push(OperandId, "'Packet Alignment'");
InstructionDesc[OpIsValidReserveId].operands.push(OperandId, "'Reserve Id'");
InstructionDesc[OpGetNumPipePackets].operands.push(OperandId, "'Pipe'");
InstructionDesc[OpGetNumPipePackets].operands.push(OperandId, "'Packet Size'");
InstructionDesc[OpGetNumPipePackets].operands.push(OperandId, "'Packet Alignment'");
InstructionDesc[OpGetMaxPipePackets].operands.push(OperandId, "'Pipe'");
InstructionDesc[OpGetMaxPipePackets].operands.push(OperandId, "'Packet Size'");
InstructionDesc[OpGetMaxPipePackets].operands.push(OperandId, "'Packet Alignment'");
InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Pipe'");
InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Num Packets'");
InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Packet Size'");
InstructionDesc[OpGroupReserveReadPipePackets].operands.push(OperandId, "'Packet Alignment'");
InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Pipe'");
InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Num Packets'");
InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Packet Size'");
InstructionDesc[OpGroupReserveWritePipePackets].operands.push(OperandId, "'Packet Alignment'");
InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Pipe'");
InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Reserve Id'");
InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Packet Size'");
InstructionDesc[OpGroupCommitReadPipe].operands.push(OperandId, "'Packet Alignment'");
InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Pipe'");
InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Reserve Id'");
InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Packet Size'");
InstructionDesc[OpGroupCommitWritePipe].operands.push(OperandId, "'Packet Alignment'");
InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'GlobalWorkSize'");
InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'LocalWorkSize'");
InstructionDesc[OpBuildNDRange].operands.push(OperandId, "'GlobalWorkOffset'");
InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandId, "'Event'");
InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandId, "'Profiling Info'");
InstructionDesc[OpCaptureEventProfilingInfo].operands.push(OperandId, "'Value'");
InstructionDesc[OpSetUserEventStatus].operands.push(OperandId, "'Event'");
InstructionDesc[OpSetUserEventStatus].operands.push(OperandId, "'Status'");
InstructionDesc[OpIsValidEvent].operands.push(OperandId, "'Event'");
InstructionDesc[OpRetainEvent].operands.push(OperandId, "'Event'");
InstructionDesc[OpReleaseEvent].operands.push(OperandId, "'Event'");
InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Invoke'");
InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Param'");
InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Param Size'");
InstructionDesc[OpGetKernelWorkGroupSize].operands.push(OperandId, "'Param Align'");
InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Invoke'");
InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Param'");
InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Param Size'");
InstructionDesc[OpGetKernelPreferredWorkGroupSizeMultiple].operands.push(OperandId, "'Param Align'");
InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'ND Range'");
InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Invoke'");
InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Param'");
InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Param Size'");
InstructionDesc[OpGetKernelNDrangeSubGroupCount].operands.push(OperandId, "'Param Align'");
InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'ND Range'");
InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Invoke'");
InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Param'");
InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Param Size'");
InstructionDesc[OpGetKernelNDrangeMaxSubGroupSize].operands.push(OperandId, "'Param Align'");
InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Queue'");
InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Flags'");
InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'ND Range'");
InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Num Events'");
InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Wait Events'");
InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Ret Event'");
InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Invoke'");
InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param'");
InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param Size'");
InstructionDesc[OpEnqueueKernel].operands.push(OperandId, "'Param Align'");
InstructionDesc[OpEnqueueKernel].operands.push(OperandVariableIds, "'Local Size'");
InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Queue'");
InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Num Events'");
InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Wait Events'");
InstructionDesc[OpEnqueueMarker].operands.push(OperandId, "'Ret Event'");
InstructionDesc[OpGroupNonUniformElect].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformAll].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformAll].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformAny].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformAny].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformAllEqual].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformAllEqual].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformBroadcast].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformBroadcast].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformBroadcast].operands.push(OperandId, "ID");
InstructionDesc[OpGroupNonUniformBroadcastFirst].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformBroadcastFirst].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformBallot].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformBallot].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformInverseBallot].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformInverseBallot].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformBallotBitExtract].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformBallotBitExtract].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformBallotBitExtract].operands.push(OperandId, "Bit");
InstructionDesc[OpGroupNonUniformBallotBitCount].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformBallotBitCount].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupNonUniformBallotBitCount].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformBallotFindLSB].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformBallotFindLSB].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformBallotFindMSB].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformBallotFindMSB].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformShuffle].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformShuffle].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformShuffle].operands.push(OperandId, "'Id'");
InstructionDesc[OpGroupNonUniformShuffleXor].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformShuffleXor].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformShuffleXor].operands.push(OperandId, "Mask");
InstructionDesc[OpGroupNonUniformShuffleUp].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformShuffleUp].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformShuffleUp].operands.push(OperandId, "Offset");
InstructionDesc[OpGroupNonUniformShuffleDown].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformShuffleDown].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformShuffleDown].operands.push(OperandId, "Offset");
InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformIAdd].operands.push(OperandId, "'ClusterSize'", true);
InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformFAdd].operands.push(OperandId, "'ClusterSize'", true);
InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformIMul].operands.push(OperandId, "'ClusterSize'", true);
InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformFMul].operands.push(OperandId, "'ClusterSize'", true);
InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformSMin].operands.push(OperandId, "'ClusterSize'", true);
InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformUMin].operands.push(OperandId, "'ClusterSize'", true);
InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformFMin].operands.push(OperandId, "'ClusterSize'", true);
SPV: Implement Vulkan 1.1 features and extensions.
2018-03-06 23:12:04 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformSMax].operands.push(OperandId, "'ClusterSize'", true);
SPV: Implement Vulkan 1.1 features and extensions.
2018-03-06 23:12:04 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformUMax].operands.push(OperandId, "'ClusterSize'", true);
SPV: Implement Vulkan 1.1 features and extensions.
2018-03-06 23:12:04 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformFMax].operands.push(OperandId, "'ClusterSize'", true);
SPV: Implement Vulkan 1.1 features and extensions.
2018-03-06 23:12:04 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformBitwiseAnd].operands.push(OperandId, "'ClusterSize'", true);
SPV: Implement Vulkan 1.1 features and extensions.
2018-03-06 23:12:04 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformBitwiseOr].operands.push(OperandId, "'ClusterSize'", true);
InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformBitwiseXor].operands.push(OperandId, "'ClusterSize'", true);
InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformLogicalAnd].operands.push(OperandId, "'ClusterSize'", true);
InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformLogicalOr].operands.push(OperandId, "'ClusterSize'", true);
InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformLogicalXor].operands.push(OperandId, "'ClusterSize'", true);
InstructionDesc[OpGroupNonUniformQuadBroadcast].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformQuadBroadcast].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformQuadBroadcast].operands.push(OperandId, "'Id'");
InstructionDesc[OpGroupNonUniformQuadSwap].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformQuadSwap].operands.push(OperandId, "X");
InstructionDesc[OpGroupNonUniformQuadSwap].operands.push(OperandId, "'Direction'");
InstructionDesc[OpSubgroupBallotKHR].operands.push(OperandId, "'Predicate'");
InstructionDesc[OpSubgroupFirstInvocationKHR].operands.push(OperandId, "'Value'");
InstructionDesc[OpSubgroupAnyKHR].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpSubgroupAnyKHR].operands.push(OperandId, "'Predicate'");
InstructionDesc[OpSubgroupAllKHR].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpSubgroupAllKHR].operands.push(OperandId, "'Predicate'");
InstructionDesc[OpSubgroupAllEqualKHR].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpSubgroupAllEqualKHR].operands.push(OperandId, "'Predicate'");
Add GL_KHR_shader_subgroup_rotate support Co-authored-by: Neil Hickey <neil.hickey@arm.com> Co-authored-by: Stuart Brady <stuart.brady@arm.com> Signed-off-by: Sven van Haastregt <sven.vanhaastregt@arm.com>
2024-02-06 15:20:16 +00:00
InstructionDesc[OpGroupNonUniformRotateKHR].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupNonUniformRotateKHR].operands.push(OperandId, "'X'");
InstructionDesc[OpGroupNonUniformRotateKHR].operands.push(OperandId, "'Delta'");
InstructionDesc[OpGroupNonUniformRotateKHR].operands.push(OperandId, "'ClusterSize'", true);
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSubgroupReadInvocationKHR].operands.push(OperandId, "'Value'");
InstructionDesc[OpSubgroupReadInvocationKHR].operands.push(OperandId, "'Index'");
InstructionDesc[OpModuleProcessed].operands.push(OperandLiteralString, "'process'");
InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupIAddNonUniformAMD].operands.push(OperandId, "'X'");
InstructionDesc[OpGroupFAddNonUniformAMD].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupFAddNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupFAddNonUniformAMD].operands.push(OperandId, "'X'");
InstructionDesc[OpGroupUMinNonUniformAMD].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupUMinNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupUMinNonUniformAMD].operands.push(OperandId, "'X'");
InstructionDesc[OpGroupSMinNonUniformAMD].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupSMinNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupSMinNonUniformAMD].operands.push(OperandId, "X");
InstructionDesc[OpGroupFMinNonUniformAMD].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupFMinNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupFMinNonUniformAMD].operands.push(OperandId, "X");
InstructionDesc[OpGroupUMaxNonUniformAMD].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupUMaxNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupUMaxNonUniformAMD].operands.push(OperandId, "X");
InstructionDesc[OpGroupSMaxNonUniformAMD].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupSMaxNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupSMaxNonUniformAMD].operands.push(OperandId, "X");
InstructionDesc[OpGroupFMaxNonUniformAMD].operands.push(OperandScope, "'Execution'");
InstructionDesc[OpGroupFMaxNonUniformAMD].operands.push(OperandGroupOperation, "'Operation'");
InstructionDesc[OpGroupFMaxNonUniformAMD].operands.push(OperandId, "X");
InstructionDesc[OpFragmentMaskFetchAMD].operands.push(OperandId, "'Image'");
InstructionDesc[OpFragmentMaskFetchAMD].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpFragmentFetchAMD].operands.push(OperandId, "'Image'");
InstructionDesc[OpFragmentFetchAMD].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpFragmentFetchAMD].operands.push(OperandId, "'Fragment Index'");
InstructionDesc[OpGroupNonUniformPartitionNV].operands.push(OperandId, "X");
Support extension EXT_shader_quad_control
2024-01-29 05:53:18 +00:00
InstructionDesc[OpGroupNonUniformQuadAllKHR].operands.push(OperandId, "'Predicate'");
InstructionDesc[OpGroupNonUniformQuadAnyKHR].operands.push(OperandId, "'Predicate'");
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpTypeAccelerationStructureKHR].setResultAndType(true, false);
InstructionDesc[OpTraceNV].operands.push(OperandId, "'Acceleration Structure'");
InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Flags'");
InstructionDesc[OpTraceNV].operands.push(OperandId, "'Cull Mask'");
InstructionDesc[OpTraceNV].operands.push(OperandId, "'SBT Record Offset'");
InstructionDesc[OpTraceNV].operands.push(OperandId, "'SBT Record Stride'");
InstructionDesc[OpTraceNV].operands.push(OperandId, "'Miss Index'");
InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Origin'");
InstructionDesc[OpTraceNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Direction'");
InstructionDesc[OpTraceNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpTraceNV].operands.push(OperandId, "'Payload'");
InstructionDesc[OpTraceNV].setResultAndType(false, false);
InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Acceleration Structure'");
InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Ray Flags'");
InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Cull Mask'");
InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'SBT Record Offset'");
InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'SBT Record Stride'");
InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Miss Index'");
InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Ray Origin'");
InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Ray Direction'");
InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Time'");
InstructionDesc[OpTraceRayMotionNV].operands.push(OperandId, "'Payload'");
InstructionDesc[OpTraceRayMotionNV].setResultAndType(false, false);
InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Acceleration Structure'");
InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Ray Flags'");
InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Cull Mask'");
InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'SBT Record Offset'");
InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'SBT Record Stride'");
InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Miss Index'");
InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Ray Origin'");
InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'TMin'");
InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Ray Direction'");
InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'TMax'");
InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Payload'");
InstructionDesc[OpTraceRayKHR].setResultAndType(false, false);
InstructionDesc[OpReportIntersectionKHR].operands.push(OperandId, "'Hit Parameter'");
InstructionDesc[OpReportIntersectionKHR].operands.push(OperandId, "'Hit Kind'");
InstructionDesc[OpIgnoreIntersectionNV].setResultAndType(false, false);
InstructionDesc[OpIgnoreIntersectionKHR].setResultAndType(false, false);
InstructionDesc[OpTerminateRayNV].setResultAndType(false, false);
InstructionDesc[OpTerminateRayKHR].setResultAndType(false, false);
InstructionDesc[OpExecuteCallableNV].operands.push(OperandId, "SBT Record Index");
InstructionDesc[OpExecuteCallableNV].operands.push(OperandId, "CallableData ID");
InstructionDesc[OpExecuteCallableNV].setResultAndType(false, false);
InstructionDesc[OpExecuteCallableKHR].operands.push(OperandId, "SBT Record Index");
InstructionDesc[OpExecuteCallableKHR].operands.push(OperandId, "CallableData");
InstructionDesc[OpExecuteCallableKHR].setResultAndType(false, false);
InstructionDesc[OpConvertUToAccelerationStructureKHR].operands.push(OperandId, "Value");
InstructionDesc[OpConvertUToAccelerationStructureKHR].setResultAndType(true, true);
// Ray Query
InstructionDesc[OpTypeAccelerationStructureKHR].setResultAndType(true, false);
InstructionDesc[OpTypeRayQueryKHR].setResultAndType(true, false);
InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'AccelerationS'");
InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'RayFlags'");
InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'CullMask'");
InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Origin'");
InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Tmin'");
InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Direction'");
InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Tmax'");
InstructionDesc[OpRayQueryInitializeKHR].setResultAndType(false, false);
InstructionDesc[OpRayQueryTerminateKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryTerminateKHR].setResultAndType(false, false);
InstructionDesc[OpRayQueryGenerateIntersectionKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGenerateIntersectionKHR].operands.push(OperandId, "'THit'");
InstructionDesc[OpRayQueryGenerateIntersectionKHR].setResultAndType(false, false);
InstructionDesc[OpRayQueryConfirmIntersectionKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryConfirmIntersectionKHR].setResultAndType(false, false);
InstructionDesc[OpRayQueryProceedKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryProceedKHR].setResultAndType(true, true);
InstructionDesc[OpRayQueryGetIntersectionTypeKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetIntersectionTypeKHR].operands.push(OperandId, "'Committed'");
InstructionDesc[OpRayQueryGetIntersectionTypeKHR].setResultAndType(true, true);
InstructionDesc[OpRayQueryGetRayTMinKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetRayTMinKHR].setResultAndType(true, true);
InstructionDesc[OpRayQueryGetRayFlagsKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetRayFlagsKHR].setResultAndType(true, true);
InstructionDesc[OpRayQueryGetIntersectionTKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetIntersectionTKHR].operands.push(OperandId, "'Committed'");
InstructionDesc[OpRayQueryGetIntersectionTKHR].setResultAndType(true, true);
InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].operands.push(OperandId, "'Committed'");
InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].setResultAndType(true, true);
InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].operands.push(OperandId, "'Committed'");
InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].setResultAndType(true, true);
InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].operands.push(OperandId, "'Committed'");
InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].setResultAndType(true, true);
InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].operands.push(OperandId, "'Committed'");
InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].setResultAndType(true, true);
InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].operands.push(OperandId, "'Committed'");
InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].setResultAndType(true, true);
GL_EXT_ray_query updates
2020-03-19 15:09:57 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].operands.push(OperandId, "'Committed'");
InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].setResultAndType(true, true);
GL_EXT_ray_query updates
2020-03-19 15:09:57 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].operands.push(OperandId, "'Committed'");
InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].setResultAndType(true, true);
GL_EXT_ray_query updates
2020-03-19 15:09:57 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpRayQueryGetIntersectionCandidateAABBOpaqueKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetIntersectionCandidateAABBOpaqueKHR].setResultAndType(true, true);
GL_EXT_ray_query updates
2020-03-19 15:09:57 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].operands.push(OperandId, "'Committed'");
InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].setResultAndType(true, true);
GL_EXT_ray_query updates
2020-03-19 15:09:57 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].operands.push(OperandId, "'Committed'");
InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].setResultAndType(true, true);
GL_EXT_ray_query updates
2020-03-19 15:09:57 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpRayQueryGetWorldRayDirectionKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetWorldRayDirectionKHR].setResultAndType(true, true);
GL_EXT_ray_query updates
2020-03-19 15:09:57 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpRayQueryGetWorldRayOriginKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetWorldRayOriginKHR].setResultAndType(true, true);
GL_EXT_ray_query updates
2020-03-19 15:09:57 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].operands.push(OperandId, "'Committed'");
InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].setResultAndType(true, true);
GL_EXT_ray_query updates
2020-03-19 15:09:57 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].operands.push(OperandId, "'Committed'");
InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].setResultAndType(true, true);
GL_EXT_ray_query updates
2020-03-19 15:09:57 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpRayQueryGetIntersectionTriangleVertexPositionsKHR].operands.push(OperandId, "'RayQuery'");
InstructionDesc[OpRayQueryGetIntersectionTriangleVertexPositionsKHR].operands.push(OperandId, "'Committed'");
Add support for GL_NV_displacement_micromap. * Add support for GL_NV_displacement_micromap. * Update known_good for spirv-headers and spirv-tools.
2023-10-02 19:07:50 +00:00
InstructionDesc[OpRayQueryGetIntersectionTriangleVertexPositionsKHR].setResultAndType(true, true);
GL_EXT_ray_tracing_position_fetch
2022-06-09 00:29:38 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Granularity'");
InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coarse'");
InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandVariableIds, "", true);
[glslang] Strip trailing whitespace There are many other files in the repo that have trailing whitespace but this PR only cleans `glslang/SPIRV` and `glslang/Standalone`.
2023-05-22 15:44:18 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Index Offset'");
InstructionDesc[OpWritePackedPrimitiveIndices4x8NV].operands.push(OperandId, "'Packed Indices'");
Implement GL_NV_cooperative_matrix
2019-02-19 19:10:32 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'groupCountX'");
InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'groupCountY'");
InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'groupCountZ'");
InstructionDesc[OpEmitMeshTasksEXT].operands.push(OperandId, "'Payload'");
InstructionDesc[OpEmitMeshTasksEXT].setResultAndType(false, false);
GL_EXT_mesh_shader/SPV_EXT_mesh_shader implementation Added following updates to GL_EXT_mesh_shader implementation: 1. Added SPIRV and GLSL test cases 2. Added checks to ensure NV and EXT mesh shader builtins cannot be used interchangeably. 3. Updated the language name by removing the postfix "NV" to MeshShader and TaskShader. 4. Added checks for grammar checking to comply with the spec. 5. Added gl_NumWorkGroups builtin to Mesh shader 6. Fixed data type of gl_PrimitiveLineIndicesEXT and gl_PrimitiveTriangleIndicesEXT 7. Added new constants to the resources table 8. Updates to handle new storage qualifier "taskPayloadSharedEXT" 9. Updated test cases by replacing "taskEXT" with storage qualifier "taskPayloadSharedEXT" Addressed Review comments 1. Fixed instruction description used by glslang disassembly. 2. Updated OpEmitMeshTasksEXT as per spec update 3. Fixed implementation that errors out if there are more then one taskPayloadSharedEXT varjables. 4. Fixed miscellaneous error logs and removed unwanted code. SPIRV 1.6 related build failure fixes - Update SPIRV header to 1.6 - Fix conflict wiht SPIRV 1.6 change, where localSizeId is used for execution mode for mesh/task shaders Enable SPIRV generated for EXT_mesh_shader to be version 1.4 GL_EXT_mesh_shader: Add checks for atomic support and corresponding test cases
2021-08-25 20:41:32 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpSetMeshOutputsEXT].operands.push(OperandId, "'vertexCount'");
InstructionDesc[OpSetMeshOutputsEXT].operands.push(OperandId, "'primitiveCount'");
InstructionDesc[OpSetMeshOutputsEXT].setResultAndType(false, false);
GL_EXT_mesh_shader/SPV_EXT_mesh_shader implementation Added following updates to GL_EXT_mesh_shader implementation: 1. Added SPIRV and GLSL test cases 2. Added checks to ensure NV and EXT mesh shader builtins cannot be used interchangeably. 3. Updated the language name by removing the postfix "NV" to MeshShader and TaskShader. 4. Added checks for grammar checking to comply with the spec. 5. Added gl_NumWorkGroups builtin to Mesh shader 6. Fixed data type of gl_PrimitiveLineIndicesEXT and gl_PrimitiveTriangleIndicesEXT 7. Added new constants to the resources table 8. Updates to handle new storage qualifier "taskPayloadSharedEXT" 9. Updated test cases by replacing "taskEXT" with storage qualifier "taskPayloadSharedEXT" Addressed Review comments 1. Fixed instruction description used by glslang disassembly. 2. Updated OpEmitMeshTasksEXT as per spec update 3. Fixed implementation that errors out if there are more then one taskPayloadSharedEXT varjables. 4. Fixed miscellaneous error logs and removed unwanted code. SPIRV 1.6 related build failure fixes - Update SPIRV header to 1.6 - Fix conflict wiht SPIRV 1.6 change, where localSizeId is used for execution mode for mesh/task shaders Enable SPIRV generated for EXT_mesh_shader to be version 1.4 GL_EXT_mesh_shader: Add checks for atomic support and corresponding test cases
2021-08-25 20:41:32 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Component Type'");
InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Scope'");
InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Rows'");
InstructionDesc[OpTypeCooperativeMatrixNV].operands.push(OperandId, "'Columns'");
Implement GL_NV_cooperative_matrix
2019-02-19 19:10:32 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Stride'");
InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "'Column Major'");
InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandMemoryAccess, "'Memory Access'");
InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandLiteralNumber, "", true);
InstructionDesc[OpCooperativeMatrixLoadNV].operands.push(OperandId, "", true);
Implement GL_NV_cooperative_matrix
2019-02-19 19:10:32 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Object'");
InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Stride'");
InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "'Column Major'");
InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandMemoryAccess, "'Memory Access'");
InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandLiteralNumber, "", true);
InstructionDesc[OpCooperativeMatrixStoreNV].operands.push(OperandId, "", true);
Implement GL_NV_cooperative_matrix
2019-02-19 19:10:32 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'A'");
InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'B'");
InstructionDesc[OpCooperativeMatrixMulAddNV].operands.push(OperandId, "'C'");
Implement GL_NV_cooperative_matrix
2019-02-19 19:10:32 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpCooperativeMatrixLengthNV].operands.push(OperandId, "'Type'");
Implement GL_EXT_demote_to_helper_invocation
2019-07-01 14:23:23 +00:00
Implement support for GL_KHR_cooperative_matrix extension
2023-03-16 12:01:01 +00:00
InstructionDesc[OpTypeCooperativeMatrixKHR].operands.push(OperandId, "'Component Type'");
InstructionDesc[OpTypeCooperativeMatrixKHR].operands.push(OperandId, "'Scope'");
InstructionDesc[OpTypeCooperativeMatrixKHR].operands.push(OperandId, "'Rows'");
InstructionDesc[OpTypeCooperativeMatrixKHR].operands.push(OperandId, "'Columns'");
InstructionDesc[OpTypeCooperativeMatrixKHR].operands.push(OperandId, "'Use'");
InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandId, "'Memory Layout'");
InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandId, "'Stride'");
InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandMemoryAccess, "'Memory Access'");
InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandLiteralNumber, "", true);
InstructionDesc[OpCooperativeMatrixLoadKHR].operands.push(OperandId, "", true);
InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandId, "'Object'");
InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandId, "'Memory Layout'");
InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandId, "'Stride'");
InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandMemoryAccess, "'Memory Access'");
InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandLiteralNumber, "", true);
InstructionDesc[OpCooperativeMatrixStoreKHR].operands.push(OperandId, "", true);
InstructionDesc[OpCooperativeMatrixMulAddKHR].operands.push(OperandId, "'A'");
InstructionDesc[OpCooperativeMatrixMulAddKHR].operands.push(OperandId, "'B'");
InstructionDesc[OpCooperativeMatrixMulAddKHR].operands.push(OperandId, "'C'");
InstructionDesc[OpCooperativeMatrixMulAddKHR].operands.push(OperandCooperativeMatrixOperands, "'Cooperative Matrix Operands'", true);
InstructionDesc[OpCooperativeMatrixLengthKHR].operands.push(OperandId, "'Type'");
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpDemoteToHelperInvocationEXT].setResultAndType(false, false);
Add support for SPV_KHR_shader_clock
2019-07-11 01:14:38 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpReadClockKHR].operands.push(OperandScope, "'Scope'");
Add support for GL_NV_shader_invocation_reorder. (#3054)
2022-12-09 20:19:08 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpTypeHitObjectNV].setResultAndType(true, false);
[glslang] Strip trailing whitespace There are many other files in the repo that have trailing whitespace but this PR only cleans `glslang/SPIRV` and `glslang/Standalone`.
2023-05-22 15:44:18 +00:00
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpHitObjectGetShaderRecordBufferHandleNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetShaderRecordBufferHandleNV].setResultAndType(true, true);
InstructionDesc[OpReorderThreadWithHintNV].operands.push(OperandId, "'Hint'");
InstructionDesc[OpReorderThreadWithHintNV].operands.push(OperandId, "'Bits'");
InstructionDesc[OpReorderThreadWithHintNV].setResultAndType(false, false);
InstructionDesc[OpReorderThreadWithHitObjectNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpReorderThreadWithHitObjectNV].operands.push(OperandId, "'Hint'");
InstructionDesc[OpReorderThreadWithHitObjectNV].operands.push(OperandId, "'Bits'");
InstructionDesc[OpReorderThreadWithHitObjectNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectGetCurrentTimeNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetCurrentTimeNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetHitKindNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetHitKindNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetPrimitiveIndexNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetPrimitiveIndexNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetGeometryIndexNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetGeometryIndexNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetInstanceIdNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetInstanceIdNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetInstanceCustomIndexNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetInstanceCustomIndexNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetObjectRayDirectionNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetObjectRayDirectionNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetObjectRayOriginNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetObjectRayOriginNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetWorldRayDirectionNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetWorldRayDirectionNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetWorldRayOriginNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetWorldRayOriginNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetWorldToObjectNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetWorldToObjectNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetObjectToWorldNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetObjectToWorldNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetRayTMaxNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetRayTMaxNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetRayTMinNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetRayTMinNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetShaderBindingTableRecordIndexNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetShaderBindingTableRecordIndexNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectIsEmptyNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectIsEmptyNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectIsHitNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectIsHitNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectIsMissNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectIsMissNV].setResultAndType(true, true);
InstructionDesc[OpHitObjectGetAttributesNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectGetAttributesNV].operands.push(OperandId, "'HitObjectAttribute'");
InstructionDesc[OpHitObjectGetAttributesNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectExecuteShaderNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectExecuteShaderNV].operands.push(OperandId, "'Payload'");
InstructionDesc[OpHitObjectExecuteShaderNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'Acceleration Structure'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'InstanceId'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'PrimitiveId'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'GeometryIndex'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'HitKind'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'SBT Record Offset'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'SBT Record Stride'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'Origin'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'Direction'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpHitObjectRecordHitNV].operands.push(OperandId, "'HitObject Attribute'");
InstructionDesc[OpHitObjectRecordHitNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'Acceleration Structure'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'InstanceId'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'PrimitiveId'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'GeometryIndex'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'HitKind'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'SBT Record Offset'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'SBT Record Stride'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'Origin'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'Direction'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'Current Time'");
InstructionDesc[OpHitObjectRecordHitMotionNV].operands.push(OperandId, "'HitObject Attribute'");
InstructionDesc[OpHitObjectRecordHitMotionNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'Acceleration Structure'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'InstanceId'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'PrimitiveId'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'GeometryIndex'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'HitKind'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'SBT Record Index'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'Origin'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'Direction'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].operands.push(OperandId, "'HitObject Attribute'");
InstructionDesc[OpHitObjectRecordHitWithIndexNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'Acceleration Structure'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'InstanceId'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'PrimitiveId'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'GeometryIndex'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'HitKind'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'SBT Record Index'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'Origin'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'Direction'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'Current Time'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].operands.push(OperandId, "'HitObject Attribute'");
InstructionDesc[OpHitObjectRecordHitWithIndexMotionNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'SBT Index'");
InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'Origin'");
InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'Direction'");
InstructionDesc[OpHitObjectRecordMissNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpHitObjectRecordMissNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'SBT Index'");
InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'Origin'");
InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'Direction'");
InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpHitObjectRecordMissMotionNV].operands.push(OperandId, "'Current Time'");
InstructionDesc[OpHitObjectRecordMissMotionNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectRecordEmptyNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectRecordEmptyNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Acceleration Structure'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'RayFlags'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Cullmask'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'SBT Record Offset'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'SBT Record Stride'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Miss Index'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Origin'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Direction'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpHitObjectTraceRayNV].operands.push(OperandId, "'Payload'");
InstructionDesc[OpHitObjectTraceRayNV].setResultAndType(false, false);
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'HitObject'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Acceleration Structure'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'RayFlags'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Cullmask'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'SBT Record Offset'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'SBT Record Stride'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Miss Index'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Origin'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'TMin'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Direction'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'TMax'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Time'");
InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Payload'");
InstructionDesc[OpHitObjectTraceRayMotionNV].setResultAndType(false, false);
Add support for GL_NV_displacement_micromap. * Add support for GL_NV_displacement_micromap. * Update known_good for spirv-headers and spirv-tools.
2023-10-02 19:07:50 +00:00
InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Acceleration Structure'");
InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Instance ID'");
InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Geometry Index'");
InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Primitive Index'");
InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Barycentrics'");
InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].setResultAndType(true, true);
InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Acceleration Structure'");
InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Instance ID'");
InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Geometry Index'");
InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Primitive Index'");
InstructionDesc[OpFetchMicroTriangleVertexPositionNV].operands.push(OperandId, "'Barycentrics'");
InstructionDesc[OpFetchMicroTriangleVertexPositionNV].setResultAndType(true, true);
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
InstructionDesc[OpColorAttachmentReadEXT].operands.push(OperandId, "'Attachment'");
InstructionDesc[OpColorAttachmentReadEXT].operands.push(OperandId, "'Sample'", true);
InstructionDesc[OpStencilAttachmentReadEXT].operands.push(OperandId, "'Sample'", true);
InstructionDesc[OpDepthAttachmentReadEXT].operands.push(OperandId, "'Sample'", true);
extension: GL_QCOM_image_processing support
2023-08-22 00:14:52 +00:00
InstructionDesc[OpImageSampleWeightedQCOM].operands.push(OperandId, "'source texture'");
InstructionDesc[OpImageSampleWeightedQCOM].operands.push(OperandId, "'texture coordinates'");
InstructionDesc[OpImageSampleWeightedQCOM].operands.push(OperandId, "'weights texture'");
InstructionDesc[OpImageSampleWeightedQCOM].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageSampleWeightedQCOM].setResultAndType(true, true);
InstructionDesc[OpImageBoxFilterQCOM].operands.push(OperandId, "'source texture'");
InstructionDesc[OpImageBoxFilterQCOM].operands.push(OperandId, "'texture coordinates'");
InstructionDesc[OpImageBoxFilterQCOM].operands.push(OperandId, "'box size'");
InstructionDesc[OpImageBoxFilterQCOM].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageBoxFilterQCOM].setResultAndType(true, true);
InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'target texture'");
InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'target coordinates'");
InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'reference texture'");
InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'reference coordinates'");
InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandId, "'block size'");
InstructionDesc[OpImageBlockMatchSADQCOM].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageBlockMatchSADQCOM].setResultAndType(true, true);
InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'target texture'");
InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'target coordinates'");
InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'reference texture'");
InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'reference coordinates'");
InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandId, "'block size'");
InstructionDesc[OpImageBlockMatchSSDQCOM].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageBlockMatchSSDQCOM].setResultAndType(true, true);
Support for SPV_QCOM_image_processing2 (#3539)
2024-03-20 22:56:00 +00:00
InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandId, "'target texture'");
InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandId, "'target coordinates'");
InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandId, "'reference texture'");
InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandId, "'reference coordinates'");
InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandId, "'block size'");
InstructionDesc[OpImageBlockMatchWindowSSDQCOM].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageBlockMatchWindowSSDQCOM].setResultAndType(true, true);
InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandId, "'target texture'");
InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandId, "'target coordinates'");
InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandId, "'reference texture'");
InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandId, "'reference coordinates'");
InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandId, "'block size'");
InstructionDesc[OpImageBlockMatchWindowSADQCOM].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageBlockMatchWindowSADQCOM].setResultAndType(true, true);
InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandId, "'target texture'");
InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandId, "'target coordinates'");
InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandId, "'reference texture'");
InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandId, "'reference coordinates'");
InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandId, "'block size'");
InstructionDesc[OpImageBlockMatchGatherSSDQCOM].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageBlockMatchGatherSSDQCOM].setResultAndType(true, true);
InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandId, "'target texture'");
InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandId, "'target coordinates'");
InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandId, "'reference texture'");
InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandId, "'reference coordinates'");
InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandId, "'block size'");
InstructionDesc[OpImageBlockMatchGatherSADQCOM].operands.push(OperandImageOperands, "", true);
InstructionDesc[OpImageBlockMatchGatherSADQCOM].setResultAndType(true, true);
Generate SPV_EXT_replicated_composites when requested by pragma. Implement GL_EXT_spec_constant_composites.
2024-05-31 17:00:03 +00:00
InstructionDesc[OpConstantCompositeReplicateEXT].operands.push(OperandId, "'Value'");
InstructionDesc[OpSpecConstantCompositeReplicateEXT].operands.push(OperandId, "'Value'");
InstructionDesc[OpCompositeConstructReplicateEXT].operands.push(OperandId, "'Value'");
Implement GLSL_NV_cooperative_matrix2
2024-10-08 19:39:29 +00:00
InstructionDesc[OpCooperativeMatrixConvertNV].operands.push(OperandId, "'Value'");
InstructionDesc[OpCooperativeMatrixTransposeNV].operands.push(OperandId, "'Matrix'");
InstructionDesc[OpCooperativeMatrixReduceNV].operands.push(OperandId, "'Matrix'");
InstructionDesc[OpCooperativeMatrixReduceNV].operands.push(OperandLiteralNumber, "'ReduceMask'");
InstructionDesc[OpCooperativeMatrixReduceNV].operands.push(OperandId, "'CombineFunc'");
InstructionDesc[OpCooperativeMatrixPerElementOpNV].operands.push(OperandId, "'Matrix'");
InstructionDesc[OpCooperativeMatrixPerElementOpNV].operands.push(OperandId, "'Operation'");
InstructionDesc[OpCooperativeMatrixPerElementOpNV].operands.push(OperandVariableIds, "'Operands'");
InstructionDesc[OpCooperativeMatrixLoadTensorNV].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpCooperativeMatrixLoadTensorNV].operands.push(OperandId, "'Object'");
InstructionDesc[OpCooperativeMatrixLoadTensorNV].operands.push(OperandId, "'TensorLayout'");
InstructionDesc[OpCooperativeMatrixLoadTensorNV].operands.push(OperandMemoryAccess, "'Memory Access'");
InstructionDesc[OpCooperativeMatrixLoadTensorNV].operands.push(OperandTensorAddressingOperands, "'Tensor Addressing Operands'");
InstructionDesc[OpCooperativeMatrixStoreTensorNV].operands.push(OperandId, "'Pointer'");
InstructionDesc[OpCooperativeMatrixStoreTensorNV].operands.push(OperandId, "'Object'");
InstructionDesc[OpCooperativeMatrixStoreTensorNV].operands.push(OperandId, "'TensorLayout'");
InstructionDesc[OpCooperativeMatrixStoreTensorNV].operands.push(OperandMemoryAccess, "'Memory Access'");
InstructionDesc[OpCooperativeMatrixStoreTensorNV].operands.push(OperandTensorAddressingOperands, "'Tensor Addressing Operands'");
InstructionDesc[OpCooperativeMatrixReduceNV].operands.push(OperandId, "'Matrix'");
InstructionDesc[OpCooperativeMatrixReduceNV].operands.push(OperandLiteralNumber, "'ReduceMask'");
InstructionDesc[OpTypeTensorLayoutNV].operands.push(OperandId, "'Dim'");
InstructionDesc[OpTypeTensorLayoutNV].operands.push(OperandId, "'ClampMode'");
InstructionDesc[OpTypeTensorViewNV].operands.push(OperandId, "'Dim'");
InstructionDesc[OpTypeTensorViewNV].operands.push(OperandId, "'HasDimensions'");
InstructionDesc[OpTypeTensorViewNV].operands.push(OperandVariableIds, "'p'");
InstructionDesc[OpTensorLayoutSetBlockSizeNV].operands.push(OperandId, "'TensorLayout'");
InstructionDesc[OpTensorLayoutSetBlockSizeNV].operands.push(OperandVariableIds, "'BlockSize'");
InstructionDesc[OpTensorLayoutSetDimensionNV].operands.push(OperandId, "'TensorLayout'");
InstructionDesc[OpTensorLayoutSetDimensionNV].operands.push(OperandVariableIds, "'Dim'");
InstructionDesc[OpTensorLayoutSetStrideNV].operands.push(OperandId, "'TensorLayout'");
InstructionDesc[OpTensorLayoutSetStrideNV].operands.push(OperandVariableIds, "'Stride'");
InstructionDesc[OpTensorLayoutSliceNV].operands.push(OperandId, "'TensorLayout'");
InstructionDesc[OpTensorLayoutSliceNV].operands.push(OperandVariableIds, "'Operands'");
InstructionDesc[OpTensorLayoutSetClampValueNV].operands.push(OperandId, "'TensorLayout'");
InstructionDesc[OpTensorLayoutSetClampValueNV].operands.push(OperandId, "'Value'");
InstructionDesc[OpTensorViewSetDimensionNV].operands.push(OperandId, "'TensorView'");
InstructionDesc[OpTensorViewSetDimensionNV].operands.push(OperandVariableIds, "'Dim'");
InstructionDesc[OpTensorViewSetStrideNV].operands.push(OperandId, "'TensorView'");
InstructionDesc[OpTensorViewSetStrideNV].operands.push(OperandVariableIds, "'Stride'");
InstructionDesc[OpTensorViewSetClipNV].operands.push(OperandId, "'TensorView'");
InstructionDesc[OpTensorViewSetClipNV].operands.push(OperandId, "'ClipRowOffset'");
InstructionDesc[OpTensorViewSetClipNV].operands.push(OperandId, "'ClipRowSpan'");
InstructionDesc[OpTensorViewSetClipNV].operands.push(OperandId, "'ClipColOffset'");
InstructionDesc[OpTensorViewSetClipNV].operands.push(OperandId, "'ClipColSpan'");
Use std::call_once in spv::Parameterize() There was a race condition in this function as it used a static variable to attempt to ensure global initialization was only done once, which was not thread-safe. Instead, use std::call_once, which was added to C++11 for this exact case. Fixes #342
2023-07-13 21:26:56 +00:00
});
Final round for line endings.
2015-06-26 22:58:36 +00:00
}
Remove extra semicolons Fix various "extra ';'" compiler warnings. No functional changes. Signed-off-by: Sven van Haastregt <sven.vanhaastregt@arm.com>
2024-10-04 10:44:01 +00:00
} // end spv namespace
Reference in New Issue Copy Permalink