summaryrefslogtreecommitdiffstats
path: root/thirdparty/glslang/SPIRV
diff options
context:
space:
mode:
Diffstat (limited to 'thirdparty/glslang/SPIRV')
-rw-r--r--thirdparty/glslang/SPIRV/GLSL.ext.ARM.h35
-rw-r--r--thirdparty/glslang/SPIRV/GLSL.ext.EXT.h1
-rw-r--r--thirdparty/glslang/SPIRV/GLSL.ext.KHR.h1
-rw-r--r--thirdparty/glslang/SPIRV/GLSL.ext.NV.h3
-rw-r--r--thirdparty/glslang/SPIRV/GlslangToSpv.cpp627
-rw-r--r--thirdparty/glslang/SPIRV/SPVRemapper.cpp6
-rw-r--r--thirdparty/glslang/SPIRV/SPVRemapper.h28
-rw-r--r--thirdparty/glslang/SPIRV/SpvBuilder.cpp107
-rw-r--r--thirdparty/glslang/SPIRV/SpvBuilder.h4
-rw-r--r--thirdparty/glslang/SPIRV/SpvPostProcess.cpp1
-rw-r--r--thirdparty/glslang/SPIRV/SpvTools.cpp53
-rw-r--r--thirdparty/glslang/SPIRV/SpvTools.h19
-rw-r--r--thirdparty/glslang/SPIRV/disassemble.cpp61
-rw-r--r--thirdparty/glslang/SPIRV/doc.cpp261
-rw-r--r--thirdparty/glslang/SPIRV/doc.h4
-rw-r--r--thirdparty/glslang/SPIRV/hex_float.h13
-rw-r--r--thirdparty/glslang/SPIRV/spirv.hpp218
17 files changed, 1272 insertions, 170 deletions
diff --git a/thirdparty/glslang/SPIRV/GLSL.ext.ARM.h b/thirdparty/glslang/SPIRV/GLSL.ext.ARM.h
new file mode 100644
index 0000000000..14425be1e3
--- /dev/null
+++ b/thirdparty/glslang/SPIRV/GLSL.ext.ARM.h
@@ -0,0 +1,35 @@
+/*
+** Copyright (c) 2022 ARM Limited
+**
+** Permission is hereby granted, free of charge, to any person obtaining a copy
+** of this software and/or associated documentation files (the "Materials"),
+** to deal in the Materials without restriction, including without limitation
+** the rights to use, copy, modify, merge, publish, distribute, sublicense,
+** and/or sell copies of the Materials, and to permit persons to whom the
+** Materials are furnished to do so, subject to the following conditions:
+**
+** The above copyright notice and this permission notice shall be included in
+** all copies or substantial portions of the Materials.
+**
+** MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
+** STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
+** HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
+**
+** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+** OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+** THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+** FROM,OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE USE OR OTHER DEALINGS
+** IN THE MATERIALS.
+*/
+
+#ifndef GLSLextARM_H
+#define GLSLextARM_H
+
+static const int GLSLextARMVersion = 100;
+static const int GLSLextARMRevision = 1;
+
+static const char * const E_SPV_ARM_core_builtins = "SPV_ARM_core_builtins";
+
+#endif // #ifndef GLSLextARM_H
diff --git a/thirdparty/glslang/SPIRV/GLSL.ext.EXT.h b/thirdparty/glslang/SPIRV/GLSL.ext.EXT.h
index a247b4cd13..caab279382 100644
--- a/thirdparty/glslang/SPIRV/GLSL.ext.EXT.h
+++ b/thirdparty/glslang/SPIRV/GLSL.ext.EXT.h
@@ -39,6 +39,7 @@ static const char* const E_SPV_EXT_shader_atomic_float_add = "SPV_EXT_shader_ato
static const char* const E_SPV_EXT_shader_atomic_float16_add = "SPV_EXT_shader_atomic_float16_add";
static const char* const E_SPV_EXT_shader_atomic_float_min_max = "SPV_EXT_shader_atomic_float_min_max";
static const char* const E_SPV_EXT_shader_image_int64 = "SPV_EXT_shader_image_int64";
+static const char* const E_SPV_EXT_shader_tile_image = "SPV_EXT_shader_tile_image";
static const char* const E_SPV_EXT_mesh_shader = "SPV_EXT_mesh_shader";
#endif // #ifndef GLSLextEXT_H
diff --git a/thirdparty/glslang/SPIRV/GLSL.ext.KHR.h b/thirdparty/glslang/SPIRV/GLSL.ext.KHR.h
index d5c670f0e1..45549c1434 100644
--- a/thirdparty/glslang/SPIRV/GLSL.ext.KHR.h
+++ b/thirdparty/glslang/SPIRV/GLSL.ext.KHR.h
@@ -54,5 +54,6 @@ static const char* const E_SPV_KHR_workgroup_memory_explicit_layout = "SPV_KHR_w
static const char* const E_SPV_KHR_subgroup_uniform_control_flow = "SPV_KHR_subgroup_uniform_control_flow";
static const char* const E_SPV_KHR_fragment_shader_barycentric = "SPV_KHR_fragment_shader_barycentric";
static const char* const E_SPV_AMD_shader_early_and_late_fragment_tests = "SPV_AMD_shader_early_and_late_fragment_tests";
+static const char* const E_SPV_KHR_ray_tracing_position_fetch = "SPV_KHR_ray_tracing_position_fetch";
#endif // #ifndef GLSLextKHR_H
diff --git a/thirdparty/glslang/SPIRV/GLSL.ext.NV.h b/thirdparty/glslang/SPIRV/GLSL.ext.NV.h
index 93c98bf626..5b0f7eb17e 100644
--- a/thirdparty/glslang/SPIRV/GLSL.ext.NV.h
+++ b/thirdparty/glslang/SPIRV/GLSL.ext.NV.h
@@ -81,4 +81,7 @@ const char* const E_SPV_NV_cooperative_matrix = "SPV_NV_cooperative_matrix";
//SPV_NV_shader_sm_builtins
const char* const E_SPV_NV_shader_sm_builtins = "SPV_NV_shader_sm_builtins";
+//SPV_NV_shader_execution_reorder
+const char* const E_SPV_NV_shader_invocation_reorder = "SPV_NV_shader_invocation_reorder";
+
#endif // #ifndef GLSLextNV_H
diff --git a/thirdparty/glslang/SPIRV/GlslangToSpv.cpp b/thirdparty/glslang/SPIRV/GlslangToSpv.cpp
index ccb4602be2..5926582fa6 100644
--- a/thirdparty/glslang/SPIRV/GlslangToSpv.cpp
+++ b/thirdparty/glslang/SPIRV/GlslangToSpv.cpp
@@ -49,6 +49,7 @@ namespace spv {
#include "GLSL.ext.EXT.h"
#include "GLSL.ext.AMD.h"
#include "GLSL.ext.NV.h"
+ #include "GLSL.ext.ARM.h"
#include "NonSemanticDebugPrintf.h"
}
@@ -174,7 +175,7 @@ protected:
spv::Id convertGlslangStructToSpvType(const glslang::TType&, const glslang::TTypeList* glslangStruct,
glslang::TLayoutPacking, const glslang::TQualifier&);
void decorateStructType(const glslang::TType&, const glslang::TTypeList* glslangStruct, glslang::TLayoutPacking,
- const glslang::TQualifier&, spv::Id);
+ const glslang::TQualifier&, spv::Id, const std::vector<spv::Id>& spvMembers);
spv::Id makeArraySizeId(const glslang::TArraySizes&, int dim);
spv::Id accessChainLoad(const glslang::TType& type);
void accessChainStore(const glslang::TType& type, spv::Id rvalue);
@@ -277,12 +278,10 @@ protected:
// requiring local translation to and from SPIR-V type on every access.
// Maps <builtin-variable-id -> AST-required-type-id>
std::unordered_map<spv::Id, spv::Id> forceType;
-
- // Used later for generating OpTraceKHR/OpExecuteCallableKHR
- std::unordered_map<unsigned int, glslang::TIntermSymbol *> locationToSymbol[2];
-
// Used by Task shader while generating opearnds for OpEmitMeshTasksEXT
spv::Id taskPayloadID;
+ // Used later for generating OpTraceKHR/OpExecuteCallableKHR/OpHitObjectRecordHit*/OpHitObjectGetShaderBindingTableData
+ std::unordered_map<unsigned int, glslang::TIntermSymbol *> locationToSymbol[4];
};
//
@@ -294,8 +293,6 @@ spv::SourceLanguage TranslateSourceLanguage(glslang::EShSource source, EProfile
{
#ifdef GLSLANG_WEB
return spv::SourceLanguageESSL;
-#elif defined(GLSLANG_ANGLE)
- return spv::SourceLanguageGLSL;
#endif
switch (source) {
@@ -354,6 +351,7 @@ spv::Dim TranslateDimensionality(const glslang::TSampler& sampler)
case glslang::EsdRect: return spv::DimRect;
case glslang::EsdBuffer: return spv::DimBuffer;
case glslang::EsdSubpass: return spv::DimSubpassData;
+ case glslang::EsdAttachmentEXT: return spv::DimTileImageDataEXT;
default:
assert(0);
return spv::Dim2D;
@@ -378,26 +376,25 @@ spv::Decoration TranslatePrecisionDecoration(const glslang::TType& type)
}
// Translate glslang type to SPIR-V block decorations.
-spv::Decoration TranslateBlockDecoration(const glslang::TType& type, bool useStorageBuffer)
+spv::Decoration TranslateBlockDecoration(const glslang::TStorageQualifier storage, bool useStorageBuffer)
{
- if (type.getBasicType() == glslang::EbtBlock) {
- switch (type.getQualifier().storage) {
- case glslang::EvqUniform: return spv::DecorationBlock;
- case glslang::EvqBuffer: return useStorageBuffer ? spv::DecorationBlock : spv::DecorationBufferBlock;
- case glslang::EvqVaryingIn: return spv::DecorationBlock;
- case glslang::EvqVaryingOut: return spv::DecorationBlock;
- case glslang::EvqShared: return spv::DecorationBlock;
+ switch (storage) {
+ case glslang::EvqUniform: return spv::DecorationBlock;
+ case glslang::EvqBuffer: return useStorageBuffer ? spv::DecorationBlock : spv::DecorationBufferBlock;
+ case glslang::EvqVaryingIn: return spv::DecorationBlock;
+ case glslang::EvqVaryingOut: return spv::DecorationBlock;
+ case glslang::EvqShared: return spv::DecorationBlock;
#ifndef GLSLANG_WEB
- case glslang::EvqPayload: return spv::DecorationBlock;
- case glslang::EvqPayloadIn: return spv::DecorationBlock;
- case glslang::EvqHitAttr: return spv::DecorationBlock;
- case glslang::EvqCallableData: return spv::DecorationBlock;
- case glslang::EvqCallableDataIn: return spv::DecorationBlock;
+ case glslang::EvqPayload: return spv::DecorationBlock;
+ case glslang::EvqPayloadIn: return spv::DecorationBlock;
+ case glslang::EvqHitAttr: return spv::DecorationBlock;
+ case glslang::EvqCallableData: return spv::DecorationBlock;
+ case glslang::EvqCallableDataIn: return spv::DecorationBlock;
+ case glslang::EvqHitObjectAttrNV: return spv::DecorationBlock;
#endif
- default:
- assert(0);
- break;
- }
+ default:
+ assert(0);
+ break;
}
return spv::DecorationMax;
@@ -470,6 +467,7 @@ spv::Decoration TranslateLayoutDecoration(const glslang::TType& type, glslang::T
case glslang::EvqHitAttr:
case glslang::EvqCallableData:
case glslang::EvqCallableDataIn:
+ case glslang::EvqHitObjectAttrNV:
return spv::DecorationMax;
#endif
default:
@@ -1013,6 +1011,8 @@ spv::BuiltIn TGlslangToSpvTraverser::TranslateBuiltInDecoration(glslang::TBuiltI
return spv::BuiltInRayTmaxKHR;
case glslang::EbvCullMask:
return spv::BuiltInCullMaskKHR;
+ case glslang::EbvPositionFetch:
+ return spv::BuiltInHitTriangleVertexPositionsKHR;
case glslang::EbvInstanceCustomIndex:
return spv::BuiltInInstanceCustomIndexKHR;
case glslang::EbvHitT:
@@ -1108,6 +1108,28 @@ spv::BuiltIn TGlslangToSpvTraverser::TranslateBuiltInDecoration(glslang::TBuiltI
builder.addExtension(spv::E_SPV_NV_shader_sm_builtins);
builder.addCapability(spv::CapabilityShaderSMBuiltinsNV);
return spv::BuiltInSMIDNV;
+
+ // ARM builtins
+ case glslang::EbvCoreCountARM:
+ builder.addExtension(spv::E_SPV_ARM_core_builtins);
+ builder.addCapability(spv::CapabilityCoreBuiltinsARM);
+ return spv::BuiltInCoreCountARM;
+ case glslang::EbvCoreIDARM:
+ builder.addExtension(spv::E_SPV_ARM_core_builtins);
+ builder.addCapability(spv::CapabilityCoreBuiltinsARM);
+ return spv::BuiltInCoreIDARM;
+ case glslang::EbvCoreMaxIDARM:
+ builder.addExtension(spv::E_SPV_ARM_core_builtins);
+ builder.addCapability(spv::CapabilityCoreBuiltinsARM);
+ return spv::BuiltInCoreMaxIDARM;
+ case glslang::EbvWarpIDARM:
+ builder.addExtension(spv::E_SPV_ARM_core_builtins);
+ builder.addCapability(spv::CapabilityCoreBuiltinsARM);
+ return spv::BuiltInWarpIDARM;
+ case glslang::EbvWarpMaxIDARM:
+ builder.addExtension(spv::E_SPV_ARM_core_builtins);
+ builder.addCapability(spv::CapabilityCoreBuiltinsARM);
+ return spv::BuiltInWarpMaxIDARM;
#endif
default:
@@ -1278,7 +1300,7 @@ spv::LoopControlMask TGlslangToSpvTraverser::TranslateLoopControl(const glslang:
// Translate glslang type to SPIR-V storage class.
spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::TType& type)
{
- if (type.getBasicType() == glslang::EbtRayQuery)
+ if (type.getBasicType() == glslang::EbtRayQuery || type.getBasicType() == glslang::EbtHitObjectNV)
return spv::StorageClassPrivate;
#ifndef GLSLANG_WEB
if (type.getQualifier().isSpirvByReference()) {
@@ -1290,12 +1312,17 @@ spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::T
return spv::StorageClassInput;
if (type.getQualifier().isPipeOutput())
return spv::StorageClassOutput;
+ if (type.getQualifier().storage == glslang::EvqTileImageEXT || type.isAttachmentEXT()) {
+ builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
+ builder.addCapability(spv::CapabilityTileImageColorReadAccessEXT);
+ return spv::StorageClassTileImageEXT;
+ }
if (glslangIntermediate->getSource() != glslang::EShSourceHlsl ||
type.getQualifier().storage == glslang::EvqUniform) {
if (type.isAtomic())
return spv::StorageClassAtomicCounter;
- if (type.containsOpaque())
+ if (type.containsOpaque() && !glslangIntermediate->getBindlessMode())
return spv::StorageClassUniformConstant;
}
@@ -1335,6 +1362,7 @@ spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::T
case glslang::EvqCallableData: return spv::StorageClassCallableDataKHR;
case glslang::EvqCallableDataIn: return spv::StorageClassIncomingCallableDataKHR;
case glslang::EvqtaskPayloadSharedEXT : return spv::StorageClassTaskPayloadWorkgroupEXT;
+ case glslang::EvqHitObjectAttrNV: return spv::StorageClassHitObjectAttributeNV;
case glslang::EvqSpirvStorageClass: return static_cast<spv::StorageClass>(type.getQualifier().spirvStorageClass);
#endif
default:
@@ -1660,6 +1688,24 @@ TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion,
builder.addExtension(spv::E_SPV_KHR_post_depth_coverage);
}
+ if (glslangIntermediate->getNonCoherentColorAttachmentReadEXT()) {
+ builder.addCapability(spv::CapabilityTileImageColorReadAccessEXT);
+ builder.addExecutionMode(shaderEntry, spv::ExecutionModeNonCoherentColorAttachmentReadEXT);
+ builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
+ }
+
+ if (glslangIntermediate->getNonCoherentDepthAttachmentReadEXT()) {
+ builder.addCapability(spv::CapabilityTileImageDepthReadAccessEXT);
+ builder.addExecutionMode(shaderEntry, spv::ExecutionModeNonCoherentDepthAttachmentReadEXT);
+ builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
+ }
+
+ if (glslangIntermediate->getNonCoherentStencilAttachmentReadEXT()) {
+ builder.addCapability(spv::CapabilityTileImageStencilReadAccessEXT);
+ builder.addExecutionMode(shaderEntry, spv::ExecutionModeNonCoherentStencilAttachmentReadEXT);
+ builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
+ }
+
if (glslangIntermediate->isDepthReplacing())
builder.addExecutionMode(shaderEntry, spv::ExecutionModeDepthReplacing);
@@ -1837,13 +1883,16 @@ TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion,
builder.addCapability(spv::CapabilityRayTracingNV);
builder.addExtension("SPV_NV_ray_tracing");
}
- if (glslangIntermediate->getStage() != EShLangRayGen && glslangIntermediate->getStage() != EShLangCallable)
- {
- if (extensions.find("GL_EXT_ray_cull_mask") != extensions.end()) {
- builder.addCapability(spv::CapabilityRayCullMaskKHR);
- builder.addExtension("SPV_KHR_ray_cull_mask");
- }
- }
+ if (glslangIntermediate->getStage() != EShLangRayGen && glslangIntermediate->getStage() != EShLangCallable) {
+ if (extensions.find("GL_EXT_ray_cull_mask") != extensions.end()) {
+ builder.addCapability(spv::CapabilityRayCullMaskKHR);
+ builder.addExtension("SPV_KHR_ray_cull_mask");
+ }
+ if (extensions.find("GL_EXT_ray_tracing_position_fetch") != extensions.end()) {
+ builder.addCapability(spv::CapabilityRayTracingPositionFetchKHR);
+ builder.addExtension("SPV_KHR_ray_tracing_position_fetch");
+ }
+ }
break;
}
case EShLangTask:
@@ -1984,6 +2033,10 @@ void TGlslangToSpvTraverser::dumpSpv(std::vector<unsigned int>& out)
//
void TGlslangToSpvTraverser::visitSymbol(glslang::TIntermSymbol* symbol)
{
+ // We update the line information even though no code might be generated here
+ // This is helpful to yield correct lines for control flow instructions
+ builder.setLine(symbol->getLoc().line, symbol->getLoc().getFilename());
+
SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder);
if (symbol->getType().isStruct())
glslangTypeToIdMap[symbol->getType().getStruct()] = symbol->getId();
@@ -2135,6 +2188,9 @@ bool TGlslangToSpvTraverser::visitBinary(glslang::TVisit /* visit */, glslang::T
node->getRight()->traverse(this);
spv::Id rValue = accessChainLoad(node->getRight()->getType());
+ // reset line number for assignment
+ builder.setLine(node->getLoc().line, node->getLoc().getFilename());
+
if (node->getOp() != glslang::EOpAssign) {
// the left is also an r-value
builder.setAccessChain(lValue);
@@ -2561,6 +2617,35 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI
spv::Builder::AccessChain::CoherentFlags lvalueCoherentFlags;
+ const auto hitObjectOpsWithLvalue = [](glslang::TOperator op) {
+ switch(op) {
+ case glslang::EOpReorderThreadNV:
+ case glslang::EOpHitObjectGetCurrentTimeNV:
+ case glslang::EOpHitObjectGetHitKindNV:
+ case glslang::EOpHitObjectGetPrimitiveIndexNV:
+ case glslang::EOpHitObjectGetGeometryIndexNV:
+ case glslang::EOpHitObjectGetInstanceIdNV:
+ case glslang::EOpHitObjectGetInstanceCustomIndexNV:
+ case glslang::EOpHitObjectGetObjectRayDirectionNV:
+ case glslang::EOpHitObjectGetObjectRayOriginNV:
+ case glslang::EOpHitObjectGetWorldRayDirectionNV:
+ case glslang::EOpHitObjectGetWorldRayOriginNV:
+ case glslang::EOpHitObjectGetWorldToObjectNV:
+ case glslang::EOpHitObjectGetObjectToWorldNV:
+ case glslang::EOpHitObjectGetRayTMaxNV:
+ case glslang::EOpHitObjectGetRayTMinNV:
+ case glslang::EOpHitObjectIsEmptyNV:
+ case glslang::EOpHitObjectIsHitNV:
+ case glslang::EOpHitObjectIsMissNV:
+ case glslang::EOpHitObjectRecordEmptyNV:
+ case glslang::EOpHitObjectGetShaderBindingTableRecordIndexNV:
+ case glslang::EOpHitObjectGetShaderRecordBufferHandleNV:
+ return true;
+ default:
+ return false;
+ }
+ };
+
#ifndef GLSLANG_WEB
if (node->getOp() == glslang::EOpAtomicCounterIncrement ||
node->getOp() == glslang::EOpAtomicCounterDecrement ||
@@ -2575,7 +2660,8 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI
node->getOp() == glslang::EOpRayQueryGetIntersectionCandidateAABBOpaque ||
node->getOp() == glslang::EOpRayQueryTerminate ||
node->getOp() == glslang::EOpRayQueryConfirmIntersection ||
- (node->getOp() == glslang::EOpSpirvInst && operandNode->getAsTyped()->getQualifier().isSpirvByReference())) {
+ (node->getOp() == glslang::EOpSpirvInst && operandNode->getAsTyped()->getQualifier().isSpirvByReference()) ||
+ hitObjectOpsWithLvalue(node->getOp())) {
operand = builder.accessChainGetLValue(); // Special case l-value operands
lvalueCoherentFlags = builder.getAccessChain().coherentFlags;
lvalueCoherentFlags |= TranslateCoherent(operandNode->getAsTyped()->getType());
@@ -2710,6 +2796,12 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI
case glslang::EOpRayQueryConfirmIntersection:
builder.createNoResultOp(spv::OpRayQueryConfirmIntersectionKHR, operand);
return false;
+ case glslang::EOpReorderThreadNV:
+ builder.createNoResultOp(spv::OpReorderThreadWithHitObjectNV, operand);
+ return false;
+ case glslang::EOpHitObjectRecordEmptyNV:
+ builder.createNoResultOp(spv::OpHitObjectRecordEmptyNV, operand);
+ return false;
#endif
default:
@@ -3201,6 +3293,48 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
builder.addExtension(spv::E_SPV_EXT_fragment_shader_interlock);
noReturnValue = true;
break;
+
+ case glslang::EOpHitObjectTraceRayNV:
+ case glslang::EOpHitObjectTraceRayMotionNV:
+ case glslang::EOpHitObjectGetAttributesNV:
+ case glslang::EOpHitObjectExecuteShaderNV:
+ case glslang::EOpHitObjectRecordEmptyNV:
+ case glslang::EOpHitObjectRecordMissNV:
+ case glslang::EOpHitObjectRecordMissMotionNV:
+ case glslang::EOpHitObjectRecordHitNV:
+ case glslang::EOpHitObjectRecordHitMotionNV:
+ case glslang::EOpHitObjectRecordHitWithIndexNV:
+ case glslang::EOpHitObjectRecordHitWithIndexMotionNV:
+ case glslang::EOpReorderThreadNV:
+ noReturnValue = true;
+ //Fallthrough
+ case glslang::EOpHitObjectIsEmptyNV:
+ case glslang::EOpHitObjectIsMissNV:
+ case glslang::EOpHitObjectIsHitNV:
+ case glslang::EOpHitObjectGetRayTMinNV:
+ case glslang::EOpHitObjectGetRayTMaxNV:
+ case glslang::EOpHitObjectGetObjectRayOriginNV:
+ case glslang::EOpHitObjectGetObjectRayDirectionNV:
+ case glslang::EOpHitObjectGetWorldRayOriginNV:
+ case glslang::EOpHitObjectGetWorldRayDirectionNV:
+ case glslang::EOpHitObjectGetObjectToWorldNV:
+ case glslang::EOpHitObjectGetWorldToObjectNV:
+ case glslang::EOpHitObjectGetInstanceCustomIndexNV:
+ case glslang::EOpHitObjectGetInstanceIdNV:
+ case glslang::EOpHitObjectGetGeometryIndexNV:
+ case glslang::EOpHitObjectGetPrimitiveIndexNV:
+ case glslang::EOpHitObjectGetHitKindNV:
+ case glslang::EOpHitObjectGetCurrentTimeNV:
+ case glslang::EOpHitObjectGetShaderBindingTableRecordIndexNV:
+ case glslang::EOpHitObjectGetShaderRecordBufferHandleNV:
+ builder.addExtension(spv::E_SPV_NV_shader_invocation_reorder);
+ builder.addCapability(spv::CapabilityShaderInvocationReorderNV);
+ break;
+ case glslang::EOpRayQueryGetIntersectionTriangleVertexPositionsEXT:
+ builder.addExtension(spv::E_SPV_KHR_ray_tracing_position_fetch);
+ builder.addCapability(spv::CapabilityRayQueryPositionFetchKHR);
+ noReturnValue = true;
+ break;
#endif
case glslang::EOpDebugPrintf:
@@ -3258,6 +3392,22 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
lvalue = true;
break;
+
+
+ case glslang::EOpHitObjectRecordHitNV:
+ case glslang::EOpHitObjectRecordHitMotionNV:
+ case glslang::EOpHitObjectRecordHitWithIndexNV:
+ case glslang::EOpHitObjectRecordHitWithIndexMotionNV:
+ case glslang::EOpHitObjectTraceRayNV:
+ case glslang::EOpHitObjectTraceRayMotionNV:
+ case glslang::EOpHitObjectExecuteShaderNV:
+ case glslang::EOpHitObjectRecordMissNV:
+ case glslang::EOpHitObjectRecordMissMotionNV:
+ case glslang::EOpHitObjectGetAttributesNV:
+ if (arg == 0)
+ lvalue = true;
+ break;
+
case glslang::EOpRayQueryInitialize:
case glslang::EOpRayQueryTerminate:
case glslang::EOpRayQueryConfirmIntersection:
@@ -3358,6 +3508,15 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
if (glslangOperands[arg]->getAsTyped()->getQualifier().isSpirvByReference())
lvalue = true;
break;
+ case glslang::EOpReorderThreadNV:
+ //Three variants of reorderThreadNV, two of them use hitObjectNV
+ if (arg == 0 && glslangOperands.size() != 2)
+ lvalue = true;
+ break;
+ case glslang::EOpRayQueryGetIntersectionTriangleVertexPositionsEXT:
+ if (arg == 0 || arg == 2)
+ lvalue = true;
+ break;
#endif
default:
break;
@@ -3414,7 +3573,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
} else if (arg == 2) {
continue;
}
- }
+ }
#endif
// for l-values, pass the address, for r-values, pass the value
@@ -3450,17 +3609,30 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
glslangOp == glslang::EOpRayQueryGetIntersectionObjectRayDirection ||
glslangOp == glslang::EOpRayQueryGetIntersectionObjectRayOrigin ||
glslangOp == glslang::EOpRayQueryGetIntersectionObjectToWorld ||
- glslangOp == glslang::EOpRayQueryGetIntersectionWorldToObject
+ glslangOp == glslang::EOpRayQueryGetIntersectionWorldToObject ||
+ glslangOp == glslang::EOpRayQueryGetIntersectionTriangleVertexPositionsEXT
)) {
bool cond = glslangOperands[arg]->getAsConstantUnion()->getConstArray()[0].getBConst();
operands.push_back(builder.makeIntConstant(cond ? 1 : 0));
} else if ((arg == 10 && glslangOp == glslang::EOpTraceKHR) ||
(arg == 11 && glslangOp == glslang::EOpTraceRayMotionNV) ||
- (arg == 1 && glslangOp == glslang::EOpExecuteCallableKHR)) {
- const int opdNum = glslangOp == glslang::EOpTraceKHR ? 10 : (glslangOp == glslang::EOpTraceRayMotionNV ? 11 : 1);
+ (arg == 1 && glslangOp == glslang::EOpExecuteCallableKHR) ||
+ (arg == 1 && glslangOp == glslang::EOpHitObjectExecuteShaderNV) ||
+ (arg == 11 && glslangOp == glslang::EOpHitObjectTraceRayNV) ||
+ (arg == 12 && glslangOp == glslang::EOpHitObjectTraceRayMotionNV)) {
const int set = glslangOp == glslang::EOpExecuteCallableKHR ? 1 : 0;
-
- const int location = glslangOperands[opdNum]->getAsConstantUnion()->getConstArray()[0].getUConst();
+ const int location = glslangOperands[arg]->getAsConstantUnion()->getConstArray()[0].getUConst();
+ auto itNode = locationToSymbol[set].find(location);
+ visitSymbol(itNode->second);
+ spv::Id symId = getSymbolId(itNode->second);
+ operands.push_back(symId);
+ } else if ((arg == 12 && glslangOp == glslang::EOpHitObjectRecordHitNV) ||
+ (arg == 13 && glslangOp == glslang::EOpHitObjectRecordHitMotionNV) ||
+ (arg == 11 && glslangOp == glslang::EOpHitObjectRecordHitWithIndexNV) ||
+ (arg == 12 && glslangOp == glslang::EOpHitObjectRecordHitWithIndexMotionNV) ||
+ (arg == 1 && glslangOp == glslang::EOpHitObjectGetAttributesNV)) {
+ const int location = glslangOperands[arg]->getAsConstantUnion()->getConstArray()[0].getUConst();
+ const int set = 2;
auto itNode = locationToSymbol[set].find(location);
visitSymbol(itNode->second);
spv::Id symId = getSymbolId(itNode->second);
@@ -3504,6 +3676,19 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
builder.createNoResultOp(spv::OpCooperativeMatrixStoreNV, idImmOps);
result = 0;
+ } else if (node->getOp() == glslang::EOpRayQueryGetIntersectionTriangleVertexPositionsEXT) {
+ std::vector<spv::IdImmediate> idImmOps;
+
+ idImmOps.push_back(spv::IdImmediate(true, operands[0])); // q
+ idImmOps.push_back(spv::IdImmediate(true, operands[1])); // committed
+
+ spv::Id typeId = builder.makeArrayType(builder.makeVectorType(builder.makeFloatType(32), 3),
+ builder.makeUintConstant(3), 0);
+ // do the op
+ spv::Id result = builder.createOp(spv::OpRayQueryGetIntersectionTriangleVertexPositionsKHR, typeId, idImmOps);
+ // store the result to the pointer (out param 'm')
+ builder.createStore(result, operands[2]);
+ result = 0;
} else
#endif
if (atomic) {
@@ -3656,10 +3841,11 @@ bool TGlslangToSpvTraverser::visitSelection(glslang::TVisit /* visit */, glslang
// Find a way of executing both sides and selecting the right result.
const auto executeBothSides = [&]() -> void {
// execute both sides
+ spv::Id resultType = convertGlslangToSpvType(node->getType());
node->getTrueBlock()->traverse(this);
spv::Id trueValue = accessChainLoad(node->getTrueBlock()->getAsTyped()->getType());
node->getFalseBlock()->traverse(this);
- spv::Id falseValue = accessChainLoad(node->getTrueBlock()->getAsTyped()->getType());
+ spv::Id falseValue = accessChainLoad(node->getFalseBlock()->getAsTyped()->getType());
builder.setLine(node->getLoc().line, node->getLoc().getFilename());
@@ -3668,8 +3854,8 @@ bool TGlslangToSpvTraverser::visitSelection(glslang::TVisit /* visit */, glslang
return;
// emit code to select between trueValue and falseValue
-
- // see if OpSelect can handle it
+ // see if OpSelect can handle the result type, and that the SPIR-V types
+ // of the inputs match the result type.
if (isOpSelectable()) {
// Emit OpSelect for this selection.
@@ -3681,10 +3867,18 @@ bool TGlslangToSpvTraverser::visitSelection(glslang::TVisit /* visit */, glslang
builder.getNumComponents(trueValue)));
}
+ // If the types do not match, it is because of mismatched decorations on aggregates.
+ // Since isOpSelectable only lets us get here for SPIR-V >= 1.4, we can use OpCopyObject
+ // to get matching types.
+ if (builder.getTypeId(trueValue) != resultType) {
+ trueValue = builder.createUnaryOp(spv::OpCopyLogical, resultType, trueValue);
+ }
+ if (builder.getTypeId(falseValue) != resultType) {
+ falseValue = builder.createUnaryOp(spv::OpCopyLogical, resultType, falseValue);
+ }
+
// OpSelect
- result = builder.createTriOp(spv::OpSelect,
- convertGlslangToSpvType(node->getType()), condition,
- trueValue, falseValue);
+ result = builder.createTriOp(spv::OpSelect, resultType, condition, trueValue, falseValue);
builder.clearAccessChain();
builder.setAccessChainRValue(result);
@@ -3692,7 +3886,7 @@ bool TGlslangToSpvTraverser::visitSelection(glslang::TVisit /* visit */, glslang
// We need control flow to select the result.
// TODO: Once SPIR-V OpSelect allows arbitrary types, eliminate this path.
result = builder.createVariable(TranslatePrecisionDecoration(node->getType()),
- spv::StorageClassFunction, convertGlslangToSpvType(node->getType()));
+ spv::StorageClassFunction, resultType);
// Selection control:
const spv::SelectionControlMask control = TranslateSelectionControl(*node);
@@ -3701,10 +3895,15 @@ bool TGlslangToSpvTraverser::visitSelection(glslang::TVisit /* visit */, glslang
spv::Builder::If ifBuilder(condition, control, builder);
// emit the "then" statement
- builder.createStore(trueValue, result);
+ builder.clearAccessChain();
+ builder.setAccessChainLValue(result);
+ multiTypeStore(node->getType(), trueValue);
+
ifBuilder.makeBeginElse();
// emit the "else" statement
- builder.createStore(falseValue, result);
+ builder.clearAccessChain();
+ builder.setAccessChainLValue(result);
+ multiTypeStore(node->getType(), falseValue);
// finish off the control flow
ifBuilder.makeEndIf();
@@ -3731,16 +3930,26 @@ bool TGlslangToSpvTraverser::visitSelection(glslang::TVisit /* visit */, glslang
// emit the "then" statement
if (node->getTrueBlock() != nullptr) {
node->getTrueBlock()->traverse(this);
- if (result != spv::NoResult)
- builder.createStore(accessChainLoad(node->getTrueBlock()->getAsTyped()->getType()), result);
+ if (result != spv::NoResult) {
+ spv::Id load = accessChainLoad(node->getTrueBlock()->getAsTyped()->getType());
+
+ builder.clearAccessChain();
+ builder.setAccessChainLValue(result);
+ multiTypeStore(node->getType(), load);
+ }
}
if (node->getFalseBlock() != nullptr) {
ifBuilder.makeBeginElse();
// emit the "else" statement
node->getFalseBlock()->traverse(this);
- if (result != spv::NoResult)
- builder.createStore(accessChainLoad(node->getFalseBlock()->getAsTyped()->getType()), result);
+ if (result != spv::NoResult) {
+ spv::Id load = accessChainLoad(node->getFalseBlock()->getAsTyped()->getType());
+
+ builder.clearAccessChain();
+ builder.setAccessChainLValue(result);
+ multiTypeStore(node->getType(), load);
+ }
}
// finish off the control flow
@@ -4286,6 +4495,13 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty
case glslang::EbtString:
// no type used for OpString
return 0;
+
+ case glslang::EbtHitObjectNV: {
+ builder.addExtension(spv::E_SPV_NV_shader_invocation_reorder);
+ builder.addCapability(spv::CapabilityShaderInvocationReorderNV);
+ spvType = builder.makeHitObjectNVType();
+ }
+ break;
#ifndef GLSLANG_WEB
case glslang::EbtSpirvType: {
// GL_EXT_spirv_intrinsics
@@ -4537,7 +4753,7 @@ spv::Id TGlslangToSpvTraverser::convertGlslangStructToSpvType(const glslang::TTy
structMap[explicitLayout][qualifier.layoutMatrix][glslangMembers] = spvType;
// Decorate it
- decorateStructType(type, glslangMembers, explicitLayout, qualifier, spvType);
+ decorateStructType(type, glslangMembers, explicitLayout, qualifier, spvType, spvMembers);
for (int i = 0; i < (int)deferredForwardPointers.size(); ++i) {
auto it = deferredForwardPointers[i];
@@ -4551,7 +4767,8 @@ void TGlslangToSpvTraverser::decorateStructType(const glslang::TType& type,
const glslang::TTypeList* glslangMembers,
glslang::TLayoutPacking explicitLayout,
const glslang::TQualifier& qualifier,
- spv::Id spvType)
+ spv::Id spvType,
+ const std::vector<spv::Id>& spvMembers)
{
// Name and decorate the non-hidden members
int offset = -1;
@@ -4704,7 +4921,19 @@ void TGlslangToSpvTraverser::decorateStructType(const glslang::TType& type,
// Decorate the structure
builder.addDecoration(spvType, TranslateLayoutDecoration(type, qualifier.layoutMatrix));
- builder.addDecoration(spvType, TranslateBlockDecoration(type, glslangIntermediate->usingStorageBuffer()));
+ const auto basicType = type.getBasicType();
+ const auto typeStorageQualifier = type.getQualifier().storage;
+ if (basicType == glslang::EbtBlock) {
+ builder.addDecoration(spvType, TranslateBlockDecoration(typeStorageQualifier, glslangIntermediate->usingStorageBuffer()));
+ } else if (basicType == glslang::EbtStruct && glslangIntermediate->getSpv().vulkan > 0) {
+ const auto hasRuntimeArray = !spvMembers.empty() && builder.getOpCode(spvMembers.back()) == spv::OpTypeRuntimeArray;
+ if (hasRuntimeArray) {
+ builder.addDecoration(spvType, TranslateBlockDecoration(typeStorageQualifier, glslangIntermediate->usingStorageBuffer()));
+ }
+ }
+
+ if (qualifier.hasHitObjectShaderRecordNV())
+ builder.addDecoration(spvType, spv::DecorationHitObjectShaderRecordBufferNV);
}
// Turn the expression forming the array size into an id.
@@ -4741,6 +4970,16 @@ spv::Id TGlslangToSpvTraverser::accessChainLoad(const glslang::TType& type)
spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags;
coherentFlags |= TranslateCoherent(type);
+ spv::MemoryAccessMask accessMask = spv::MemoryAccessMask(TranslateMemoryAccess(coherentFlags) & ~spv::MemoryAccessMakePointerAvailableKHRMask);
+ // If the value being loaded is HelperInvocation, SPIR-V 1.6 is being generated (so that
+ // SPV_EXT_demote_to_helper_invocation is in core) and the memory model is in use, add
+ // the Volatile MemoryAccess semantic.
+ if (type.getQualifier().builtIn == glslang::EbvHelperInvocation &&
+ glslangIntermediate->usingVulkanMemoryModel() &&
+ glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
+ accessMask = spv::MemoryAccessMask(accessMask | spv::MemoryAccessVolatileMask);
+ }
+
unsigned int alignment = builder.getAccessChain().alignment;
alignment |= type.getBufferReferenceAlignment();
@@ -4748,7 +4987,7 @@ spv::Id TGlslangToSpvTraverser::accessChainLoad(const glslang::TType& type)
TranslateNonUniformDecoration(builder.getAccessChain().coherentFlags),
TranslateNonUniformDecoration(type.getQualifier()),
nominalTypeId,
- spv::MemoryAccessMask(TranslateMemoryAccess(coherentFlags) & ~spv::MemoryAccessMakePointerAvailableKHRMask),
+ accessMask,
TranslateMemoryScope(coherentFlags),
alignment);
@@ -5075,7 +5314,7 @@ bool TGlslangToSpvTraverser::originalParam(glslang::TStorageQualifier qualifier,
return true;
if (glslangIntermediate->getSource() == glslang::EShSourceHlsl)
return paramType.getBasicType() == glslang::EbtBlock;
- return paramType.containsOpaque() || // sampler, etc.
+ return (paramType.containsOpaque() && !glslangIntermediate->getBindlessMode()) || // sampler, etc.
#ifndef GLSLANG_WEB
paramType.getQualifier().isSpirvByReference() || // spirv_by_reference
#endif
@@ -5222,6 +5461,10 @@ void TGlslangToSpvTraverser::collectRayTracingLinkerObjects()
set = 1;
break;
+ case glslang::EvqHitObjectAttrNV:
+ set = 2;
+ break;
+
default:
set = -1;
}
@@ -5370,6 +5613,10 @@ void TGlslangToSpvTraverser::translateArguments(const glslang::TIntermAggregate&
if (i == 7)
lvalue = true;
break;
+ case glslang::EOpRayQueryGetIntersectionTriangleVertexPositionsEXT:
+ if (i == 2)
+ lvalue = true;
+ break;
default:
break;
}
@@ -5529,6 +5776,17 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO
return result;
}
+ if (cracked.attachmentEXT) {
+ if (opIt != arguments.end()) {
+ spv::IdImmediate sample = { true, *opIt };
+ operands.push_back(sample);
+ }
+ spv::Id result = builder.createOp(spv::OpColorAttachmentReadEXT, resultType(), operands);
+ builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
+ builder.setPrecision(result, precision);
+ return result;
+ }
+
spv::IdImmediate coord = { true, *(opIt++) };
operands.push_back(coord);
if (node->getOp() == glslang::EOpImageLoad || node->getOp() == glslang::EOpImageLoadLod) {
@@ -6866,12 +7124,102 @@ spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, OpDe
case glslang::EOpConvUvec2ToAccStruct:
unaryOp = spv::OpConvertUToAccelerationStructureKHR;
break;
+
+ case glslang::EOpHitObjectIsEmptyNV:
+ unaryOp = spv::OpHitObjectIsEmptyNV;
+ break;
+
+ case glslang::EOpHitObjectIsMissNV:
+ unaryOp = spv::OpHitObjectIsMissNV;
+ break;
+
+ case glslang::EOpHitObjectIsHitNV:
+ unaryOp = spv::OpHitObjectIsHitNV;
+ break;
+
+ case glslang::EOpHitObjectGetObjectRayOriginNV:
+ unaryOp = spv::OpHitObjectGetObjectRayOriginNV;
+ break;
+
+ case glslang::EOpHitObjectGetObjectRayDirectionNV:
+ unaryOp = spv::OpHitObjectGetObjectRayDirectionNV;
+ break;
+
+ case glslang::EOpHitObjectGetWorldRayOriginNV:
+ unaryOp = spv::OpHitObjectGetWorldRayOriginNV;
+ break;
+
+ case glslang::EOpHitObjectGetWorldRayDirectionNV:
+ unaryOp = spv::OpHitObjectGetWorldRayDirectionNV;
+ break;
+
+ case glslang::EOpHitObjectGetObjectToWorldNV:
+ unaryOp = spv::OpHitObjectGetObjectToWorldNV;
+ break;
+
+ case glslang::EOpHitObjectGetWorldToObjectNV:
+ unaryOp = spv::OpHitObjectGetWorldToObjectNV;
+ break;
+
+ case glslang::EOpHitObjectGetRayTMinNV:
+ unaryOp = spv::OpHitObjectGetRayTMinNV;
+ break;
+
+ case glslang::EOpHitObjectGetRayTMaxNV:
+ unaryOp = spv::OpHitObjectGetRayTMaxNV;
+ break;
+
+ case glslang::EOpHitObjectGetPrimitiveIndexNV:
+ unaryOp = spv::OpHitObjectGetPrimitiveIndexNV;
+ break;
+
+ case glslang::EOpHitObjectGetInstanceIdNV:
+ unaryOp = spv::OpHitObjectGetInstanceIdNV;
+ break;
+
+ case glslang::EOpHitObjectGetInstanceCustomIndexNV:
+ unaryOp = spv::OpHitObjectGetInstanceCustomIndexNV;
+ break;
+
+ case glslang::EOpHitObjectGetGeometryIndexNV:
+ unaryOp = spv::OpHitObjectGetGeometryIndexNV;
+ break;
+
+ case glslang::EOpHitObjectGetHitKindNV:
+ unaryOp = spv::OpHitObjectGetHitKindNV;
+ break;
+
+ case glslang::EOpHitObjectGetCurrentTimeNV:
+ unaryOp = spv::OpHitObjectGetCurrentTimeNV;
+ break;
+
+ case glslang::EOpHitObjectGetShaderBindingTableRecordIndexNV:
+ unaryOp = spv::OpHitObjectGetShaderBindingTableRecordIndexNV;
+ break;
+
+ case glslang::EOpHitObjectGetShaderRecordBufferHandleNV:
+ unaryOp = spv::OpHitObjectGetShaderRecordBufferHandleNV;
+ break;
+
#endif
case glslang::EOpCopyObject:
unaryOp = spv::OpCopyObject;
break;
+ case glslang::EOpDepthAttachmentReadEXT:
+ builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
+ builder.addCapability(spv::CapabilityTileImageDepthReadAccessEXT);
+ unaryOp = spv::OpDepthAttachmentReadEXT;
+ decorations.precision = spv::NoPrecision;
+ break;
+ case glslang::EOpStencilAttachmentReadEXT:
+ builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
+ builder.addCapability(spv::CapabilityTileImageStencilReadAccessEXT);
+ unaryOp = spv::OpStencilAttachmentReadEXT;
+ decorations.precision = spv::DecorationRelaxedPrecision;
+ break;
+
default:
return 0;
}
@@ -8607,6 +8955,122 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::
case glslang::EOpCooperativeMatrixMulAdd:
opCode = spv::OpCooperativeMatrixMulAddNV;
break;
+ case glslang::EOpHitObjectTraceRayNV:
+ builder.createNoResultOp(spv::OpHitObjectTraceRayNV, operands);
+ return 0;
+ case glslang::EOpHitObjectTraceRayMotionNV:
+ builder.createNoResultOp(spv::OpHitObjectTraceRayMotionNV, operands);
+ return 0;
+ case glslang::EOpHitObjectRecordHitNV:
+ builder.createNoResultOp(spv::OpHitObjectRecordHitNV, operands);
+ return 0;
+ case glslang::EOpHitObjectRecordHitMotionNV:
+ builder.createNoResultOp(spv::OpHitObjectRecordHitMotionNV, operands);
+ return 0;
+ case glslang::EOpHitObjectRecordHitWithIndexNV:
+ builder.createNoResultOp(spv::OpHitObjectRecordHitWithIndexNV, operands);
+ return 0;
+ case glslang::EOpHitObjectRecordHitWithIndexMotionNV:
+ builder.createNoResultOp(spv::OpHitObjectRecordHitWithIndexMotionNV, operands);
+ return 0;
+ case glslang::EOpHitObjectRecordMissNV:
+ builder.createNoResultOp(spv::OpHitObjectRecordMissNV, operands);
+ return 0;
+ case glslang::EOpHitObjectRecordMissMotionNV:
+ builder.createNoResultOp(spv::OpHitObjectRecordMissMotionNV, operands);
+ return 0;
+ case glslang::EOpHitObjectExecuteShaderNV:
+ builder.createNoResultOp(spv::OpHitObjectExecuteShaderNV, operands);
+ return 0;
+ case glslang::EOpHitObjectIsEmptyNV:
+ typeId = builder.makeBoolType();
+ opCode = spv::OpHitObjectIsEmptyNV;
+ break;
+ case glslang::EOpHitObjectIsMissNV:
+ typeId = builder.makeBoolType();
+ opCode = spv::OpHitObjectIsMissNV;
+ break;
+ case glslang::EOpHitObjectIsHitNV:
+ typeId = builder.makeBoolType();
+ opCode = spv::OpHitObjectIsHitNV;
+ break;
+ case glslang::EOpHitObjectGetRayTMinNV:
+ typeId = builder.makeFloatType(32);
+ opCode = spv::OpHitObjectGetRayTMinNV;
+ break;
+ case glslang::EOpHitObjectGetRayTMaxNV:
+ typeId = builder.makeFloatType(32);
+ opCode = spv::OpHitObjectGetRayTMaxNV;
+ break;
+ case glslang::EOpHitObjectGetObjectRayOriginNV:
+ typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
+ opCode = spv::OpHitObjectGetObjectRayOriginNV;
+ break;
+ case glslang::EOpHitObjectGetObjectRayDirectionNV:
+ typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
+ opCode = spv::OpHitObjectGetObjectRayDirectionNV;
+ break;
+ case glslang::EOpHitObjectGetWorldRayOriginNV:
+ typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
+ opCode = spv::OpHitObjectGetWorldRayOriginNV;
+ break;
+ case glslang::EOpHitObjectGetWorldRayDirectionNV:
+ typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
+ opCode = spv::OpHitObjectGetWorldRayDirectionNV;
+ break;
+ case glslang::EOpHitObjectGetWorldToObjectNV:
+ typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
+ opCode = spv::OpHitObjectGetWorldToObjectNV;
+ break;
+ case glslang::EOpHitObjectGetObjectToWorldNV:
+ typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
+ opCode = spv::OpHitObjectGetObjectToWorldNV;
+ break;
+ case glslang::EOpHitObjectGetInstanceCustomIndexNV:
+ typeId = builder.makeIntegerType(32, 1);
+ opCode = spv::OpHitObjectGetInstanceCustomIndexNV;
+ break;
+ case glslang::EOpHitObjectGetInstanceIdNV:
+ typeId = builder.makeIntegerType(32, 1);
+ opCode = spv::OpHitObjectGetInstanceIdNV;
+ break;
+ case glslang::EOpHitObjectGetGeometryIndexNV:
+ typeId = builder.makeIntegerType(32, 1);
+ opCode = spv::OpHitObjectGetGeometryIndexNV;
+ break;
+ case glslang::EOpHitObjectGetPrimitiveIndexNV:
+ typeId = builder.makeIntegerType(32, 1);
+ opCode = spv::OpHitObjectGetPrimitiveIndexNV;
+ break;
+ case glslang::EOpHitObjectGetHitKindNV:
+ typeId = builder.makeIntegerType(32, 0);
+ opCode = spv::OpHitObjectGetHitKindNV;
+ break;
+ case glslang::EOpHitObjectGetCurrentTimeNV:
+ typeId = builder.makeFloatType(32);
+ opCode = spv::OpHitObjectGetCurrentTimeNV;
+ break;
+ case glslang::EOpHitObjectGetShaderBindingTableRecordIndexNV:
+ typeId = builder.makeIntegerType(32, 0);
+ opCode = spv::OpHitObjectGetShaderBindingTableRecordIndexNV;
+ return 0;
+ case glslang::EOpHitObjectGetAttributesNV:
+ builder.createNoResultOp(spv::OpHitObjectGetAttributesNV, operands);
+ return 0;
+ case glslang::EOpHitObjectGetShaderRecordBufferHandleNV:
+ typeId = builder.makeVectorType(builder.makeUintType(32), 2);
+ opCode = spv::OpHitObjectGetShaderRecordBufferHandleNV;
+ break;
+ case glslang::EOpReorderThreadNV: {
+ if (operands.size() == 2) {
+ builder.createNoResultOp(spv::OpReorderThreadWithHintNV, operands);
+ } else {
+ builder.createNoResultOp(spv::OpReorderThreadWithHitObjectNV, operands);
+ }
+ return 0;
+
+ }
+ break;
#endif // GLSLANG_WEB
default:
return 0;
@@ -8846,6 +9310,30 @@ spv::Id TGlslangToSpvTraverser::createNoArgOperation(glslang::TOperator op, spv:
return builder.createOp(spv::OpReadClockKHR, typeId, args);
}
#endif
+ case glslang::EOpStencilAttachmentReadEXT:
+ case glslang::EOpDepthAttachmentReadEXT:
+ {
+ builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
+
+ spv::Decoration precision;
+ spv::Op spv_op;
+ if (op == glslang::EOpStencilAttachmentReadEXT)
+ {
+ precision = spv::DecorationRelaxedPrecision;
+ spv_op = spv::OpStencilAttachmentReadEXT;
+ builder.addCapability(spv::CapabilityTileImageStencilReadAccessEXT);
+ }
+ else
+ {
+ precision = spv::NoPrecision;
+ spv_op = spv::OpDepthAttachmentReadEXT;
+ builder.addCapability(spv::CapabilityTileImageDepthReadAccessEXT);
+ }
+
+ std::vector<spv::Id> args; // Dummy args
+ spv::Id result = builder.createOp(spv_op, typeId, args);
+ return builder.setPrecision(result, precision);
+ }
default:
break;
}
@@ -8916,13 +9404,17 @@ spv::Id TGlslangToSpvTraverser::getSymbolId(const glslang::TIntermSymbol* symbol
}
if (symbol->getQualifier().hasLocation()) {
- if (!(glslangIntermediate->isRayTracingStage() && glslangIntermediate->IsRequestedExtension(glslang::E_GL_EXT_ray_tracing)
+ if (!(glslangIntermediate->isRayTracingStage() &&
+ (glslangIntermediate->IsRequestedExtension(glslang::E_GL_EXT_ray_tracing) ||
+ glslangIntermediate->IsRequestedExtension(glslang::E_GL_NV_shader_invocation_reorder))
&& (builder.getStorageClass(id) == spv::StorageClassRayPayloadKHR ||
builder.getStorageClass(id) == spv::StorageClassIncomingRayPayloadKHR ||
builder.getStorageClass(id) == spv::StorageClassCallableDataKHR ||
- builder.getStorageClass(id) == spv::StorageClassIncomingCallableDataKHR))) {
- // Location values are used to link TraceRayKHR and ExecuteCallableKHR to corresponding variables
- // but are not valid in SPIRV since they are supported only for Input/Output Storage classes.
+ builder.getStorageClass(id) == spv::StorageClassIncomingCallableDataKHR ||
+ builder.getStorageClass(id) == spv::StorageClassHitObjectAttributeNV))) {
+ // Location values are used to link TraceRayKHR/ExecuteCallableKHR/HitObjectGetAttributesNV
+ // to corresponding variables but are not valid in SPIRV since they are supported only
+ // for Input/Output Storage classes.
builder.addDecoration(id, spv::DecorationLocation, symbol->getQualifier().layoutLocation);
}
}
@@ -8968,6 +9460,7 @@ spv::Id TGlslangToSpvTraverser::getSymbolId(const glslang::TIntermSymbol* symbol
// Add volatile decoration to HelperInvocation for spirv1.6 and beyond
if (builtIn == spv::BuiltInHelperInvocation &&
+ !glslangIntermediate->usingVulkanMemoryModel() &&
glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
builder.addDecoration(id, spv::DecorationVolatile);
}
@@ -9060,10 +9553,10 @@ spv::Id TGlslangToSpvTraverser::getSymbolId(const glslang::TIntermSymbol* symbol
std::vector<spv::Id> operandIds;
assert(!decorateId.second.empty());
for (auto extraOperand : decorateId.second) {
- if (extraOperand->getQualifier().isSpecConstant())
- operandIds.push_back(getSymbolId(extraOperand->getAsSymbolNode()));
- else
+ if (extraOperand->getQualifier().isFrontEndConstant())
operandIds.push_back(createSpvConstant(*extraOperand));
+ else
+ operandIds.push_back(getSymbolId(extraOperand->getAsSymbolNode()));
}
builder.addDecorationId(id, static_cast<spv::Decoration>(decorateId.first), operandIds);
}
@@ -9559,7 +10052,7 @@ void OutputSpvBin(const std::vector<unsigned int>& spirv, const char* baseName)
// Write SPIR-V out to a text file with 32-bit hexadecimal words
void OutputSpvHex(const std::vector<unsigned int>& spirv, const char* baseName, const char* varName)
{
-#if !defined(GLSLANG_WEB) && !defined(GLSLANG_ANGLE)
+#if !defined(GLSLANG_WEB)
std::ofstream out;
out.open(baseName, std::ios::binary | std::ios::out);
if (out.fail())
@@ -9606,7 +10099,7 @@ void GlslangToSpv(const TIntermediate& intermediate, std::vector<unsigned int>&
{
TIntermNode* root = intermediate.getTreeRoot();
- if (root == 0)
+ if (root == nullptr)
return;
SpvOptions defaultOptions;
diff --git a/thirdparty/glslang/SPIRV/SPVRemapper.cpp b/thirdparty/glslang/SPIRV/SPVRemapper.cpp
index 6aca8cbcf0..4b2c4395ed 100644
--- a/thirdparty/glslang/SPIRV/SPVRemapper.cpp
+++ b/thirdparty/glslang/SPIRV/SPVRemapper.cpp
@@ -36,10 +36,6 @@
#include "SPVRemapper.h"
#include "doc.h"
-#if !defined (use_cpp11)
-// ... not supported before C++11
-#else // defined (use_cpp11)
-
#include <algorithm>
#include <cassert>
#include "../glslang/Include/Common.h"
@@ -1528,5 +1524,3 @@ namespace spv {
} // namespace SPV
-#endif // defined (use_cpp11)
-
diff --git a/thirdparty/glslang/SPIRV/SPVRemapper.h b/thirdparty/glslang/SPIRV/SPVRemapper.h
index d21694635a..42b01686ee 100644
--- a/thirdparty/glslang/SPIRV/SPVRemapper.h
+++ b/thirdparty/glslang/SPIRV/SPVRemapper.h
@@ -43,12 +43,6 @@
namespace spv {
-// MSVC defines __cplusplus as an older value, even when it supports almost all of 11.
-// We handle that here by making our own symbol.
-#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1700)
-# define use_cpp11 1
-#endif
-
class spirvbin_base_t
{
public:
@@ -74,27 +68,6 @@ public:
} // namespace SPV
-#if !defined (use_cpp11)
-#include <cstdio>
-#include <cstdint>
-
-namespace spv {
-class spirvbin_t : public spirvbin_base_t
-{
-public:
- spirvbin_t(int /*verbose = 0*/) { }
-
- void remap(std::vector<std::uint32_t>& /*spv*/, unsigned int /*opts = 0*/)
- {
- printf("Tool not compiled for C++11, which is required for SPIR-V remapping.\n");
- exit(5);
- }
-};
-
-} // namespace SPV
-
-#else // defined (use_cpp11)
-
#include <functional>
#include <cstdint>
#include <unordered_map>
@@ -308,5 +281,4 @@ private:
} // namespace SPV
-#endif // defined (use_cpp11)
#endif // SPIRVREMAPPER_H
diff --git a/thirdparty/glslang/SPIRV/SpvBuilder.cpp b/thirdparty/glslang/SPIRV/SpvBuilder.cpp
index 7c5ea874ba..9d07334258 100644
--- a/thirdparty/glslang/SPIRV/SpvBuilder.cpp
+++ b/thirdparty/glslang/SPIRV/SpvBuilder.cpp
@@ -71,9 +71,9 @@ Builder::Builder(unsigned int spvVersion, unsigned int magicNumber, SpvBuildLogg
addressModel(AddressingModelLogical),
memoryModel(MemoryModelGLSL450),
builderNumber(magicNumber),
- buildPoint(0),
+ buildPoint(nullptr),
uniqueId(0),
- entryPointFunction(0),
+ entryPointFunction(nullptr),
generatingOpCodeForSpecConst(false),
logger(buildLogger)
{
@@ -144,6 +144,7 @@ void Builder::addLine(Id fileName, int lineNum, int column)
void Builder::addDebugScopeAndLine(Id fileName, int lineNum, int column)
{
+ assert(!currentDebugScopeId.empty());
if (currentDebugScopeId.top() != lastDebugScopeId) {
spv::Id resultId = getUniqueId();
Instruction* scopeInst = new Instruction(resultId, makeVoidType(), OpExtInst);
@@ -650,8 +651,12 @@ Id Builder::makeDebugFunctionType(Id returnType, const std::vector<Id>& paramTyp
type->addIdOperand(makeUintConstant(NonSemanticShaderDebugInfo100FlagIsPublic));
type->addIdOperand(debugId[returnType]);
for (auto const paramType : paramTypes) {
- assert(isPointerType(paramType) || isArrayType(paramType));
- type->addIdOperand(debugId[getContainedTypeId(paramType)]);
+ if (isPointerType(paramType) || isArrayType(paramType)) {
+ type->addIdOperand(debugId[getContainedTypeId(paramType)]);
+ }
+ else {
+ type->addIdOperand(debugId[paramType]);
+ }
}
constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
module.mapInstruction(type);
@@ -1067,6 +1072,12 @@ Id Builder::makeDebugCompilationUnit() {
constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(sourceInst));
module.mapInstruction(sourceInst);
nonSemanticShaderCompilationUnitId = resultId;
+
+ // We can reasonably assume that makeDebugCompilationUnit will be called before any of
+ // debug-scope stack. Function scopes and lexical scopes will occur afterward.
+ assert(currentDebugScopeId.empty());
+ currentDebugScopeId.push(nonSemanticShaderCompilationUnitId);
+
return resultId;
}
@@ -1096,6 +1107,8 @@ Id Builder::createDebugGlobalVariable(Id const type, char const*const name, Id c
Id Builder::createDebugLocalVariable(Id type, char const*const name, size_t const argNumber)
{
assert(name != nullptr);
+ assert(!currentDebugScopeId.empty());
+
Instruction* inst = new Instruction(getUniqueId(), makeVoidType(), OpExtInst);
inst->addIdOperand(nonSemanticShaderDebugInfo);
inst->addImmediateOperand(NonSemanticShaderDebugInfo100DebugLocalVariable);
@@ -1176,6 +1189,21 @@ Id Builder::makeRayQueryType()
return type->getResultId();
}
+
+Id Builder::makeHitObjectNVType()
+{
+ Instruction *type;
+ if (groupedTypes[OpTypeHitObjectNV].size() == 0) {
+ type = new Instruction(getUniqueId(), NoType, OpTypeHitObjectNV);
+ groupedTypes[OpTypeHitObjectNV].push_back(type);
+ constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+ module.mapInstruction(type);
+ } else {
+ type = groupedTypes[OpTypeHitObjectNV].back();
+ }
+
+ return type->getResultId();
+}
#endif
Id Builder::getDerefTypeId(Id resultId) const
@@ -1675,7 +1703,7 @@ Id Builder::importNonSemanticShaderDebugInfoInstructions()
Id Builder::findCompositeConstant(Op typeClass, Id typeId, const std::vector<Id>& comps)
{
- Instruction* constant = 0;
+ Instruction* constant = nullptr;
bool found = false;
for (int i = 0; i < (int)groupedConstants[typeClass].size(); ++i) {
constant = groupedConstants[typeClass][i];
@@ -1702,7 +1730,7 @@ Id Builder::findCompositeConstant(Op typeClass, Id typeId, const std::vector<Id>
Id Builder::findStructConstant(Id typeId, const std::vector<Id>& comps)
{
- Instruction* constant = 0;
+ Instruction* constant = nullptr;
bool found = false;
for (int i = 0; i < (int)groupedStructConstants[typeId].size(); ++i) {
constant = groupedStructConstants[typeId][i];
@@ -2047,11 +2075,16 @@ Function* Builder::makeFunctionEntry(Decoration precision, Id returnType, const
assert(paramTypes.size() == paramNames.size());
for(size_t p = 0; p < paramTypes.size(); ++p)
{
- auto const& paramType = paramTypes[p];
- assert(isPointerType(paramType) || isArrayType(paramType));
- assert(debugId[getContainedTypeId(paramType)] != 0);
+ auto getParamTypeId = [this](Id const& typeId) {
+ if (isPointerType(typeId) || isArrayType(typeId)) {
+ return getContainedTypeId(typeId);
+ }
+ else {
+ return typeId;
+ }
+ };
auto const& paramName = paramNames[p];
- auto const debugLocalVariableId = createDebugLocalVariable(debugId[getContainedTypeId(paramType)], paramName, p+1);
+ auto const debugLocalVariableId = createDebugLocalVariable(debugId[getParamTypeId(paramTypes[p])], paramName, p+1);
debugId[firstParamId + p] = debugLocalVariableId;
makeDebugDeclare(debugLocalVariableId, firstParamId + p);
@@ -2095,6 +2128,8 @@ Id Builder::makeDebugFunction(Function* function, Id nameId, Id funcTypeId) {
}
Id Builder::makeDebugLexicalBlock(uint32_t line) {
+ assert(!currentDebugScopeId.empty());
+
Id lexId = getUniqueId();
auto lex = new Instruction(lexId, makeVoidType(), OpExtInst);
lex->addIdOperand(nonSemanticShaderDebugInfo);
@@ -2734,52 +2769,49 @@ Id Builder::createBuiltinCall(Id resultType, Id builtins, int entryPoint, const
Id Builder::createTextureCall(Decoration precision, Id resultType, bool sparse, bool fetch, bool proj, bool gather,
bool noImplicitLod, const TextureParameters& parameters, ImageOperandsMask signExtensionMask)
{
- static const int maxTextureArgs = 10;
- Id texArgs[maxTextureArgs] = {};
+ std::vector<Id> texArgs;
//
// Set up the fixed arguments
//
- int numArgs = 0;
bool explicitLod = false;
- texArgs[numArgs++] = parameters.sampler;
- texArgs[numArgs++] = parameters.coords;
+ texArgs.push_back(parameters.sampler);
+ texArgs.push_back(parameters.coords);
if (parameters.Dref != NoResult)
- texArgs[numArgs++] = parameters.Dref;
+ texArgs.push_back(parameters.Dref);
if (parameters.component != NoResult)
- texArgs[numArgs++] = parameters.component;
+ texArgs.push_back(parameters.component);
#ifndef GLSLANG_WEB
if (parameters.granularity != NoResult)
- texArgs[numArgs++] = parameters.granularity;
+ texArgs.push_back(parameters.granularity);
if (parameters.coarse != NoResult)
- texArgs[numArgs++] = parameters.coarse;
+ texArgs.push_back(parameters.coarse);
#endif
//
// Set up the optional arguments
//
- int optArgNum = numArgs; // track which operand, if it exists, is the mask of optional arguments
- ++numArgs; // speculatively make room for the mask operand
+ size_t optArgNum = texArgs.size(); // the position of the mask for the optional arguments, if any.
ImageOperandsMask mask = ImageOperandsMaskNone; // the mask operand
if (parameters.bias) {
mask = (ImageOperandsMask)(mask | ImageOperandsBiasMask);
- texArgs[numArgs++] = parameters.bias;
+ texArgs.push_back(parameters.bias);
}
if (parameters.lod) {
mask = (ImageOperandsMask)(mask | ImageOperandsLodMask);
- texArgs[numArgs++] = parameters.lod;
+ texArgs.push_back(parameters.lod);
explicitLod = true;
} else if (parameters.gradX) {
mask = (ImageOperandsMask)(mask | ImageOperandsGradMask);
- texArgs[numArgs++] = parameters.gradX;
- texArgs[numArgs++] = parameters.gradY;
+ texArgs.push_back(parameters.gradX);
+ texArgs.push_back(parameters.gradY);
explicitLod = true;
} else if (noImplicitLod && ! fetch && ! gather) {
// have to explicitly use lod of 0 if not allowed to have them be implicit, and
// we would otherwise be about to issue an implicit instruction
mask = (ImageOperandsMask)(mask | ImageOperandsLodMask);
- texArgs[numArgs++] = makeFloatConstant(0.0);
+ texArgs.push_back(makeFloatConstant(0.0));
explicitLod = true;
}
if (parameters.offset) {
@@ -2789,24 +2821,24 @@ Id Builder::createTextureCall(Decoration precision, Id resultType, bool sparse,
addCapability(CapabilityImageGatherExtended);
mask = (ImageOperandsMask)(mask | ImageOperandsOffsetMask);
}
- texArgs[numArgs++] = parameters.offset;
+ texArgs.push_back(parameters.offset);
}
if (parameters.offsets) {
addCapability(CapabilityImageGatherExtended);
mask = (ImageOperandsMask)(mask | ImageOperandsConstOffsetsMask);
- texArgs[numArgs++] = parameters.offsets;
+ texArgs.push_back(parameters.offsets);
}
#ifndef GLSLANG_WEB
if (parameters.sample) {
mask = (ImageOperandsMask)(mask | ImageOperandsSampleMask);
- texArgs[numArgs++] = parameters.sample;
+ texArgs.push_back(parameters.sample);
}
if (parameters.lodClamp) {
// capability if this bit is used
addCapability(CapabilityMinLod);
mask = (ImageOperandsMask)(mask | ImageOperandsMinLodMask);
- texArgs[numArgs++] = parameters.lodClamp;
+ texArgs.push_back(parameters.lodClamp);
}
if (parameters.nonprivate) {
mask = mask | ImageOperandsNonPrivateTexelKHRMask;
@@ -2816,10 +2848,9 @@ Id Builder::createTextureCall(Decoration precision, Id resultType, bool sparse,
}
#endif
mask = mask | signExtensionMask;
- if (mask == ImageOperandsMaskNone)
- --numArgs; // undo speculative reservation for the mask argument
- else
- texArgs[optArgNum] = mask;
+ // insert the operand for the mask, if any bits were set.
+ if (mask != ImageOperandsMaskNone)
+ texArgs.insert(texArgs.begin() + optArgNum, mask);
//
// Set up the instruction
@@ -2923,11 +2954,11 @@ Id Builder::createTextureCall(Decoration precision, Id resultType, bool sparse,
// Build the SPIR-V instruction
Instruction* textureInst = new Instruction(getUniqueId(), resultType, opCode);
- for (int op = 0; op < optArgNum; ++op)
+ for (size_t op = 0; op < optArgNum; ++op)
textureInst->addIdOperand(texArgs[op]);
- if (optArgNum < numArgs)
+ if (optArgNum < texArgs.size())
textureInst->addImmediateOperand(texArgs[optArgNum]);
- for (int op = optArgNum + 1; op < numArgs; ++op)
+ for (size_t op = optArgNum + 1; op < texArgs.size(); ++op)
textureInst->addIdOperand(texArgs[op]);
setPrecision(textureInst->getResultId(), precision);
buildPoint->addInstruction(std::unique_ptr<Instruction>(textureInst));
@@ -3332,7 +3363,7 @@ Builder::If::If(Id cond, unsigned int ctrl, Builder& gb) :
builder(gb),
condition(cond),
control(ctrl),
- elseBlock(0)
+ elseBlock(nullptr)
{
function = &builder.getBuildPoint()->getParent();
diff --git a/thirdparty/glslang/SPIRV/SpvBuilder.h b/thirdparty/glslang/SPIRV/SpvBuilder.h
index f7fdc6ad84..02e9cf4005 100644
--- a/thirdparty/glslang/SPIRV/SpvBuilder.h
+++ b/thirdparty/glslang/SPIRV/SpvBuilder.h
@@ -240,6 +240,8 @@ public:
Id makeAccelerationStructureType();
// rayQueryEXT type
Id makeRayQueryType();
+ // hitObjectNV type
+ Id makeHitObjectNVType();
// For querying about types.
Id getTypeId(Id resultId) const { return module.getTypeId(resultId); }
@@ -414,7 +416,7 @@ public:
// The returned pointer is only valid for the lifetime of this builder.
Function* makeFunctionEntry(Decoration precision, Id returnType, const char* name,
const std::vector<Id>& paramTypes, const std::vector<char const*>& paramNames,
- const std::vector<std::vector<Decoration>>& precisions, Block **entry = 0);
+ const std::vector<std::vector<Decoration>>& precisions, Block **entry = nullptr);
// Create a return. An 'implicit' return is one not appearing in the source
// code. In the case of an implicit return, no post-return block is inserted.
diff --git a/thirdparty/glslang/SPIRV/SpvPostProcess.cpp b/thirdparty/glslang/SPIRV/SpvPostProcess.cpp
index dd6dabce0d..b185f61bb8 100644
--- a/thirdparty/glslang/SPIRV/SpvPostProcess.cpp
+++ b/thirdparty/glslang/SPIRV/SpvPostProcess.cpp
@@ -52,6 +52,7 @@ namespace spv {
#include "GLSL.ext.EXT.h"
#include "GLSL.ext.AMD.h"
#include "GLSL.ext.NV.h"
+ #include "GLSL.ext.ARM.h"
}
namespace spv {
diff --git a/thirdparty/glslang/SPIRV/SpvTools.cpp b/thirdparty/glslang/SPIRV/SpvTools.cpp
index 25299937a3..ff04f4f967 100644
--- a/thirdparty/glslang/SPIRV/SpvTools.cpp
+++ b/thirdparty/glslang/SPIRV/SpvTools.cpp
@@ -212,8 +212,7 @@ void SpirvToolsTransform(const glslang::TIntermediate& intermediate, std::vector
optimizer.RegisterPass(spvtools::CreateInterpolateFixupPass());
if (options->optimizeSize) {
optimizer.RegisterPass(spvtools::CreateRedundancyEliminationPass());
- if (intermediate.getStage() == EShLanguage::EShLangVertex)
- optimizer.RegisterPass(spvtools::CreateEliminateDeadInputComponentsPass());
+ optimizer.RegisterPass(spvtools::CreateEliminateDeadInputComponentsSafePass());
}
optimizer.RegisterPass(spvtools::CreateAggressiveDCEPass());
optimizer.RegisterPass(spvtools::CreateCFGCleanupPass());
@@ -224,6 +223,56 @@ void SpirvToolsTransform(const glslang::TIntermediate& intermediate, std::vector
optimizer.Run(spirv.data(), spirv.size(), &spirv, spvOptOptions);
}
+bool SpirvToolsAnalyzeDeadOutputStores(spv_target_env target_env, std::vector<unsigned int>& spirv,
+ std::unordered_set<uint32_t>* live_locs,
+ std::unordered_set<uint32_t>* live_builtins,
+ spv::SpvBuildLogger*)
+{
+ spvtools::Optimizer optimizer(target_env);
+ optimizer.SetMessageConsumer(OptimizerMesssageConsumer);
+
+ optimizer.RegisterPass(spvtools::CreateAnalyzeLiveInputPass(live_locs, live_builtins));
+
+ spvtools::OptimizerOptions spvOptOptions;
+ optimizer.SetTargetEnv(target_env);
+ spvOptOptions.set_run_validator(false);
+ return optimizer.Run(spirv.data(), spirv.size(), &spirv, spvOptOptions);
+}
+
+void SpirvToolsEliminateDeadOutputStores(spv_target_env target_env, std::vector<unsigned int>& spirv,
+ std::unordered_set<uint32_t>* live_locs,
+ std::unordered_set<uint32_t>* live_builtins,
+ spv::SpvBuildLogger*)
+{
+ spvtools::Optimizer optimizer(target_env);
+ optimizer.SetMessageConsumer(OptimizerMesssageConsumer);
+
+ optimizer.RegisterPass(spvtools::CreateEliminateDeadOutputStoresPass(live_locs, live_builtins));
+ optimizer.RegisterPass(spvtools::CreateAggressiveDCEPass(false, true));
+ optimizer.RegisterPass(spvtools::CreateEliminateDeadOutputComponentsPass());
+ optimizer.RegisterPass(spvtools::CreateAggressiveDCEPass(false, true));
+
+ spvtools::OptimizerOptions spvOptOptions;
+ optimizer.SetTargetEnv(target_env);
+ spvOptOptions.set_run_validator(false);
+ optimizer.Run(spirv.data(), spirv.size(), &spirv, spvOptOptions);
+}
+
+void SpirvToolsEliminateDeadInputComponents(spv_target_env target_env, std::vector<unsigned int>& spirv,
+ spv::SpvBuildLogger*)
+{
+ spvtools::Optimizer optimizer(target_env);
+ optimizer.SetMessageConsumer(OptimizerMesssageConsumer);
+
+ optimizer.RegisterPass(spvtools::CreateEliminateDeadInputComponentsPass());
+ optimizer.RegisterPass(spvtools::CreateAggressiveDCEPass());
+
+ spvtools::OptimizerOptions spvOptOptions;
+ optimizer.SetTargetEnv(target_env);
+ spvOptOptions.set_run_validator(false);
+ optimizer.Run(spirv.data(), spirv.size(), &spirv, spvOptOptions);
+}
+
// Apply the SPIRV-Tools optimizer to strip debug info from SPIR-V. This is implicitly done by
// SpirvToolsTransform if spvOptions->stripDebugInfo is set, but can be called separately if
// optimization is disabled.
diff --git a/thirdparty/glslang/SPIRV/SpvTools.h b/thirdparty/glslang/SPIRV/SpvTools.h
index 5386048ab6..6fc4e40b02 100644
--- a/thirdparty/glslang/SPIRV/SpvTools.h
+++ b/thirdparty/glslang/SPIRV/SpvTools.h
@@ -65,6 +65,9 @@ struct SpvOptions {
#if ENABLE_OPT
+// Translate glslang's view of target versioning to what SPIRV-Tools uses.
+spv_target_env MapToSpirvToolsEnv(const SpvVersion& spvVersion, spv::SpvBuildLogger* logger);
+
// Use the SPIRV-Tools disassembler to print SPIR-V using a SPV_ENV_UNIVERSAL_1_3 environment.
void SpirvToolsDisassemble(std::ostream& out, const std::vector<unsigned int>& spirv);
@@ -80,6 +83,22 @@ void SpirvToolsValidate(const glslang::TIntermediate& intermediate, std::vector<
void SpirvToolsTransform(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
spv::SpvBuildLogger*, const SpvOptions*);
+// Apply the SPIRV-Tools EliminateDeadInputComponents pass to generated SPIR-V. Put result in |spirv|.
+void SpirvToolsEliminateDeadInputComponents(spv_target_env target_env, std::vector<unsigned int>& spirv,
+ spv::SpvBuildLogger*);
+
+// Apply the SPIRV-Tools AnalyzeDeadOutputStores pass to generated SPIR-V. Put result in |live_locs|.
+// Return true if the result is valid.
+bool SpirvToolsAnalyzeDeadOutputStores(spv_target_env target_env, std::vector<unsigned int>& spirv,
+ std::unordered_set<uint32_t>* live_locs,
+ std::unordered_set<uint32_t>* live_builtins, spv::SpvBuildLogger*);
+
+// Apply the SPIRV-Tools EliminateDeadOutputStores and AggressiveDeadCodeElimination passes to generated SPIR-V using
+// |live_locs|. Put result in |spirv|.
+void SpirvToolsEliminateDeadOutputStores(spv_target_env target_env, std::vector<unsigned int>& spirv,
+ std::unordered_set<uint32_t>* live_locs,
+ std::unordered_set<uint32_t>* live_builtins, spv::SpvBuildLogger*);
+
// Apply the SPIRV-Tools optimizer to strip debug info from SPIR-V. This is implicitly done by
// SpirvToolsTransform if spvOptions->stripDebugInfo is set, but can be called separately if
// optimization is disabled.
diff --git a/thirdparty/glslang/SPIRV/disassemble.cpp b/thirdparty/glslang/SPIRV/disassemble.cpp
index 74dd605409..f943fd5645 100644
--- a/thirdparty/glslang/SPIRV/disassemble.cpp
+++ b/thirdparty/glslang/SPIRV/disassemble.cpp
@@ -54,6 +54,8 @@ namespace spv {
#include "GLSL.std.450.h"
#include "GLSL.ext.AMD.h"
#include "GLSL.ext.NV.h"
+ #include "GLSL.ext.ARM.h"
+ #include "NonSemanticShaderDebugInfo100.h"
}
}
const char* GlslStd450DebugNames[spv::GLSLstd450Count];
@@ -62,6 +64,7 @@ namespace spv {
static const char* GLSLextAMDGetDebugNames(const char*, unsigned);
static const char* GLSLextNVGetDebugNames(const char*, unsigned);
+static const char* NonSemanticShaderDebugInfo100GetDebugNames(unsigned);
static void Kill(std::ostream& out, const char* message)
{
@@ -76,6 +79,7 @@ enum ExtInstSet {
GLSLextNVInst,
OpenCLExtInst,
NonSemanticDebugPrintfExtInst,
+ NonSemanticShaderDebugInfo100
};
// Container class for a single instance of a SPIR-V stream, with methods for disassembly.
@@ -501,6 +505,8 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
extInstSet = OpenCLExtInst;
} else if (strcmp("NonSemantic.DebugPrintf", name) == 0) {
extInstSet = NonSemanticDebugPrintfExtInst;
+ } else if (strcmp("NonSemantic.Shader.DebugInfo.100", name) == 0) {
+ extInstSet = NonSemanticShaderDebugInfo100;
} else if (strcmp(spv::E_SPV_AMD_shader_ballot, name) == 0 ||
strcmp(spv::E_SPV_AMD_shader_trinary_minmax, name) == 0 ||
strcmp(spv::E_SPV_AMD_shader_explicit_vertex_parameter, name) == 0 ||
@@ -526,6 +532,8 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
out << "(" << GLSLextNVGetDebugNames(name, entrypoint) << ")";
} else if (extInstSet == NonSemanticDebugPrintfExtInst) {
out << "(DebugPrintf)";
+ } else if (extInstSet == NonSemanticShaderDebugInfo100) {
+ out << "(" << NonSemanticShaderDebugInfo100GetDebugNames(entrypoint) << ")";
}
}
break;
@@ -749,6 +757,59 @@ static const char* GLSLextNVGetDebugNames(const char* name, unsigned entrypoint)
return "Bad";
}
+static const char* NonSemanticShaderDebugInfo100GetDebugNames(unsigned entrypoint)
+{
+ switch (entrypoint) {
+ case NonSemanticShaderDebugInfo100DebugInfoNone: return "DebugInfoNone";
+ case NonSemanticShaderDebugInfo100DebugCompilationUnit: return "DebugCompilationUnit";
+ case NonSemanticShaderDebugInfo100DebugTypeBasic: return "DebugTypeBasic";
+ case NonSemanticShaderDebugInfo100DebugTypePointer: return "DebugTypePointer";
+ case NonSemanticShaderDebugInfo100DebugTypeQualifier: return "DebugTypeQualifier";
+ case NonSemanticShaderDebugInfo100DebugTypeArray: return "DebugTypeArray";
+ case NonSemanticShaderDebugInfo100DebugTypeVector: return "DebugTypeVector";
+ case NonSemanticShaderDebugInfo100DebugTypedef: return "DebugTypedef";
+ case NonSemanticShaderDebugInfo100DebugTypeFunction: return "DebugTypeFunction";
+ case NonSemanticShaderDebugInfo100DebugTypeEnum: return "DebugTypeEnum";
+ case NonSemanticShaderDebugInfo100DebugTypeComposite: return "DebugTypeComposite";
+ case NonSemanticShaderDebugInfo100DebugTypeMember: return "DebugTypeMember";
+ case NonSemanticShaderDebugInfo100DebugTypeInheritance: return "DebugTypeInheritance";
+ case NonSemanticShaderDebugInfo100DebugTypePtrToMember: return "DebugTypePtrToMember";
+ case NonSemanticShaderDebugInfo100DebugTypeTemplate: return "DebugTypeTemplate";
+ case NonSemanticShaderDebugInfo100DebugTypeTemplateParameter: return "DebugTypeTemplateParameter";
+ case NonSemanticShaderDebugInfo100DebugTypeTemplateTemplateParameter: return "DebugTypeTemplateTemplateParameter";
+ case NonSemanticShaderDebugInfo100DebugTypeTemplateParameterPack: return "DebugTypeTemplateParameterPack";
+ case NonSemanticShaderDebugInfo100DebugGlobalVariable: return "DebugGlobalVariable";
+ case NonSemanticShaderDebugInfo100DebugFunctionDeclaration: return "DebugFunctionDeclaration";
+ case NonSemanticShaderDebugInfo100DebugFunction: return "DebugFunction";
+ case NonSemanticShaderDebugInfo100DebugLexicalBlock: return "DebugLexicalBlock";
+ case NonSemanticShaderDebugInfo100DebugLexicalBlockDiscriminator: return "DebugLexicalBlockDiscriminator";
+ case NonSemanticShaderDebugInfo100DebugScope: return "DebugScope";
+ case NonSemanticShaderDebugInfo100DebugNoScope: return "DebugNoScope";
+ case NonSemanticShaderDebugInfo100DebugInlinedAt: return "DebugInlinedAt";
+ case NonSemanticShaderDebugInfo100DebugLocalVariable: return "DebugLocalVariable";
+ case NonSemanticShaderDebugInfo100DebugInlinedVariable: return "DebugInlinedVariable";
+ case NonSemanticShaderDebugInfo100DebugDeclare: return "DebugDeclare";
+ case NonSemanticShaderDebugInfo100DebugValue: return "DebugValue";
+ case NonSemanticShaderDebugInfo100DebugOperation: return "DebugOperation";
+ case NonSemanticShaderDebugInfo100DebugExpression: return "DebugExpression";
+ case NonSemanticShaderDebugInfo100DebugMacroDef: return "DebugMacroDef";
+ case NonSemanticShaderDebugInfo100DebugMacroUndef: return "DebugMacroUndef";
+ case NonSemanticShaderDebugInfo100DebugImportedEntity: return "DebugImportedEntity";
+ case NonSemanticShaderDebugInfo100DebugSource: return "DebugSource";
+ case NonSemanticShaderDebugInfo100DebugFunctionDefinition: return "DebugFunctionDefinition";
+ case NonSemanticShaderDebugInfo100DebugSourceContinued: return "DebugSourceContinued";
+ case NonSemanticShaderDebugInfo100DebugLine: return "DebugLine";
+ case NonSemanticShaderDebugInfo100DebugNoLine: return "DebugNoLine";
+ case NonSemanticShaderDebugInfo100DebugBuildIdentifier: return "DebugBuildIdentifier";
+ case NonSemanticShaderDebugInfo100DebugStoragePath: return "DebugStoragePath";
+ case NonSemanticShaderDebugInfo100DebugEntryPoint: return "DebugEntryPoint";
+ case NonSemanticShaderDebugInfo100DebugTypeMatrix: return "DebugTypeMatrix";
+ default: return "Bad";
+ }
+
+ return "Bad";
+}
+
void Disassemble(std::ostream& out, const std::vector<unsigned int>& stream)
{
SpirvStream SpirvStream(out, stream);
diff --git a/thirdparty/glslang/SPIRV/doc.cpp b/thirdparty/glslang/SPIRV/doc.cpp
index b7fe3e7424..571ef78802 100644
--- a/thirdparty/glslang/SPIRV/doc.cpp
+++ b/thirdparty/glslang/SPIRV/doc.cpp
@@ -53,6 +53,7 @@ namespace spv {
#include "GLSL.ext.EXT.h"
#include "GLSL.ext.AMD.h"
#include "GLSL.ext.NV.h"
+ #include "GLSL.ext.ARM.h"
}
}
@@ -214,6 +215,10 @@ const char* ExecutionModeString(int mode)
case ExecutionModeNoGlobalOffsetINTEL: return "NoGlobalOffsetINTEL";
case ExecutionModeNumSIMDWorkitemsINTEL: return "NumSIMDWorkitemsINTEL";
+ case ExecutionModeNonCoherentColorAttachmentReadEXT: return "NonCoherentColorAttachmentReadEXT";
+ case ExecutionModeNonCoherentDepthAttachmentReadEXT: return "NonCoherentDepthAttachmentReadEXT";
+ case ExecutionModeNonCoherentStencilAttachmentReadEXT: return "NonCoherentStencilAttachmentReadEXT";
+
case ExecutionModeCeiling:
default: return "Bad";
}
@@ -245,6 +250,8 @@ const char* StorageClassString(int StorageClass)
case StorageClassPhysicalStorageBufferEXT: return "PhysicalStorageBufferEXT";
case StorageClassTaskPayloadWorkgroupEXT: return "TaskPayloadWorkgroupEXT";
+ case StorageClassHitObjectAttributeNV: return "HitObjectAttributeNV";
+ case StorageClassTileImageEXT: return "TileImageEXT";
default: return "Bad";
}
}
@@ -319,6 +326,8 @@ const char* DecorationString(int decoration)
case DecorationHlslSemanticGOOGLE: return "DecorationHlslSemanticGOOGLE";
case DecorationRestrictPointerEXT: return "DecorationRestrictPointerEXT";
case DecorationAliasedPointerEXT: return "DecorationAliasedPointerEXT";
+
+ case DecorationHitObjectShaderRecordBufferNV: return "DecorationHitObjectShaderRecordBufferNV";
}
}
@@ -400,6 +409,7 @@ const char* BuiltInString(int builtIn)
case BuiltInRayTminKHR: return "RayTminKHR";
case BuiltInRayTmaxKHR: return "RayTmaxKHR";
case BuiltInCullMaskKHR: return "CullMaskKHR";
+ case BuiltInHitTriangleVertexPositionsKHR: return "HitTriangleVertexPositionsKHR";
case BuiltInInstanceCustomIndexKHR: return "InstanceCustomIndexKHR";
case BuiltInRayGeometryIndexKHR: return "RayGeometryIndexKHR";
case BuiltInObjectToWorldKHR: return "ObjectToWorldKHR";
@@ -439,6 +449,11 @@ const char* BuiltInString(int builtIn)
case BuiltInPrimitiveLineIndicesEXT: return "PrimitiveLineIndicesEXT";
case BuiltInPrimitiveTriangleIndicesEXT: return "PrimitiveTriangleIndicesEXT";
case BuiltInCullPrimitiveEXT: return "CullPrimitiveEXT";
+ case BuiltInCoreCountARM: return "CoreCountARM";
+ case BuiltInCoreIDARM: return "CoreIDARM";
+ case BuiltInCoreMaxIDARM: return "CoreMaxIDARM";
+ case BuiltInWarpIDARM: return "WarpIDARM";
+ case BuiltInWarpMaxIDARM: return "BuiltInWarpMaxIDARM";
default: return "Bad";
}
@@ -454,6 +469,7 @@ const char* DimensionString(int dim)
case 4: return "Rect";
case 5: return "Buffer";
case 6: return "SubpassData";
+ case DimTileImageDataEXT: return "TileImageDataEXT";
default: return "Bad";
}
@@ -941,6 +957,8 @@ const char* CapabilityString(int info)
case CapabilityRayQueryKHR: return "RayQueryKHR";
case CapabilityRayTracingProvisionalKHR: return "RayTracingProvisionalKHR";
case CapabilityRayTraversalPrimitiveCullingKHR: return "RayTraversalPrimitiveCullingKHR";
+ case CapabilityRayTracingPositionFetchKHR: return "RayTracingPositionFetchKHR";
+ case CapabilityRayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR";
case CapabilityComputeDerivativeGroupQuadsNV: return "ComputeDerivativeGroupQuadsNV";
case CapabilityComputeDerivativeGroupLinearNV: return "ComputeDerivativeGroupLinearNV";
case CapabilityFragmentBarycentricKHR: return "FragmentBarycentricKHR";
@@ -980,6 +998,10 @@ const char* CapabilityString(int info)
case CapabilityFragmentShaderPixelInterlockEXT: return "CapabilityFragmentShaderPixelInterlockEXT";
case CapabilityFragmentShaderShadingRateInterlockEXT: return "CapabilityFragmentShaderShadingRateInterlockEXT";
+ case CapabilityTileImageColorReadAccessEXT: return "TileImageColorReadAccessEXT";
+ case CapabilityTileImageDepthReadAccessEXT: return "TileImageDepthReadAccessEXT";
+ case CapabilityTileImageStencilReadAccessEXT: return "TileImageStencilReadAccessEXT";
+
case CapabilityFragmentShadingRateKHR: return "FragmentShadingRateKHR";
case CapabilityDemoteToHelperInvocationEXT: return "DemoteToHelperInvocationEXT";
@@ -998,7 +1020,9 @@ const char* CapabilityString(int info)
case CapabilityWorkgroupMemoryExplicitLayoutKHR: return "CapabilityWorkgroupMemoryExplicitLayoutKHR";
case CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR: return "CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR";
case CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR: return "CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR";
+ case CapabilityCoreBuiltinsARM: return "CoreBuiltinsARM";
+ case CapabilityShaderInvocationReorderNV: return "ShaderInvocationReorderNV";
default: return "Bad";
}
}
@@ -1441,6 +1465,7 @@ const char* OpcodeString(int op)
case OpRayQueryGetWorldRayOriginKHR: return "OpRayQueryGetWorldRayOriginKHR";
case OpRayQueryGetIntersectionObjectToWorldKHR: return "OpRayQueryGetIntersectionObjectToWorldKHR";
case OpRayQueryGetIntersectionWorldToObjectKHR: return "OpRayQueryGetIntersectionWorldToObjectKHR";
+ case OpRayQueryGetIntersectionTriangleVertexPositionsKHR: return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR";
case OpTypeCooperativeMatrixNV: return "OpTypeCooperativeMatrixNV";
case OpCooperativeMatrixLoadNV: return "OpCooperativeMatrixLoadNV";
@@ -1453,6 +1478,44 @@ const char* OpcodeString(int op)
case OpBeginInvocationInterlockEXT: return "OpBeginInvocationInterlockEXT";
case OpEndInvocationInterlockEXT: return "OpEndInvocationInterlockEXT";
+ 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";
+
+ case OpColorAttachmentReadEXT: return "OpColorAttachmentReadEXT";
+ case OpDepthAttachmentReadEXT: return "OpDepthAttachmentReadEXT";
+ case OpStencilAttachmentReadEXT: return "OpStencilAttachmentReadEXT";
+
default:
return "Bad";
}
@@ -1607,7 +1670,7 @@ void Parameterize()
DecorationOperands[DecorationInputAttachmentIndex].push(OperandLiteralNumber, "'Attachment Index'");
DecorationOperands[DecorationAlignment].push(OperandLiteralNumber, "'Alignment'");
- OperandClassParams[OperandSource].set(0, SourceString, 0);
+ OperandClassParams[OperandSource].set(0, SourceString, nullptr);
OperandClassParams[OperandExecutionModel].set(0, ExecutionModelString, nullptr);
OperandClassParams[OperandAddressing].set(0, AddressingString, nullptr);
OperandClassParams[OperandMemory].set(0, MemoryString, nullptr);
@@ -1639,7 +1702,7 @@ void Parameterize()
OperandClassParams[OperandKernelEnqueueFlags].set(0, KernelEnqueueFlagsString, nullptr);
OperandClassParams[OperandKernelProfilingInfo].set(0, KernelProfilingInfoString, nullptr, true);
OperandClassParams[OperandCapability].set(0, CapabilityString, nullptr);
- OperandClassParams[OperandOpcode].set(OpCodeMask + 1, OpcodeString, 0);
+ OperandClassParams[OperandOpcode].set(OpCodeMask + 1, OpcodeString, nullptr);
// set name of operator, an initial set of <id> style operands, and the description
@@ -2980,6 +3043,10 @@ void Parameterize()
InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].operands.push(OperandId, "'Committed'");
InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].setResultAndType(true, true);
+ InstructionDesc[OpRayQueryGetIntersectionTriangleVertexPositionsKHR].operands.push(OperandId, "'RayQuery'");
+ InstructionDesc[OpRayQueryGetIntersectionTriangleVertexPositionsKHR].operands.push(OperandId, "'Committed'");
+ InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].setResultAndType(true, true);
+
InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Sampled Image'");
InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coordinate'");
InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Granularity'");
@@ -3030,6 +3097,196 @@ void Parameterize()
InstructionDesc[OpDemoteToHelperInvocationEXT].setResultAndType(false, false);
InstructionDesc[OpReadClockKHR].operands.push(OperandScope, "'Scope'");
+
+ InstructionDesc[OpTypeHitObjectNV].setResultAndType(true, false);
+
+ 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);
+
+ 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);
}
}; // end spv namespace
diff --git a/thirdparty/glslang/SPIRV/doc.h b/thirdparty/glslang/SPIRV/doc.h
index 2a0b28c6b3..7e1559950e 100644
--- a/thirdparty/glslang/SPIRV/doc.h
+++ b/thirdparty/glslang/SPIRV/doc.h
@@ -190,7 +190,7 @@ protected:
// Parameterize an enumerant
class EnumParameters {
public:
- EnumParameters() : desc(0) { }
+ EnumParameters() : desc(nullptr) { }
const char* desc;
};
@@ -198,7 +198,7 @@ public:
class EnumDefinition : public EnumParameters {
public:
EnumDefinition() :
- ceiling(0), bitmask(false), getName(0), enumParams(0), operandParams(0) { }
+ ceiling(0), bitmask(false), getName(nullptr), enumParams(nullptr), operandParams(nullptr) { }
void set(int ceil, const char* (*name)(int), EnumParameters* ep, bool mask = false)
{
ceiling = ceil;
diff --git a/thirdparty/glslang/SPIRV/hex_float.h b/thirdparty/glslang/SPIRV/hex_float.h
index 8be8e9f7e3..785e8af11f 100644
--- a/thirdparty/glslang/SPIRV/hex_float.h
+++ b/thirdparty/glslang/SPIRV/hex_float.h
@@ -23,19 +23,6 @@
#include <limits>
#include <sstream>
-#if defined(_MSC_VER) && _MSC_VER < 1800
-namespace std {
-bool isnan(double f)
-{
- return ::_isnan(f) != 0;
-}
-bool isinf(double f)
-{
- return ::_finite(f) == 0;
-}
-}
-#endif
-
#include "bitutils.h"
namespace spvutils {
diff --git a/thirdparty/glslang/SPIRV/spirv.hpp b/thirdparty/glslang/SPIRV/spirv.hpp
index f85469d441..111285326d 100644
--- a/thirdparty/glslang/SPIRV/spirv.hpp
+++ b/thirdparty/glslang/SPIRV/spirv.hpp
@@ -1,19 +1,19 @@
// Copyright (c) 2014-2020 The Khronos Group Inc.
-//
+//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and/or associated documentation files (the "Materials"),
// to deal in the Materials without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Materials, and to permit persons to whom the
// Materials are furnished to do so, subject to the following conditions:
-//
+//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Materials.
-//
+//
// MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
// STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
-// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
-//
+// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
+//
// THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
@@ -26,8 +26,8 @@
// the Binary Section of the SPIR-V specification.
// Enumeration tokens for SPIR-V, in various styles:
-// C, C++, C++11, JSON, Lua, Python, C#, D
-//
+// C, C++, C++11, JSON, Lua, Python, C#, D, Beef
+//
// - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
// - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
// - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
@@ -36,7 +36,9 @@
// - C# will use enum classes in the Specification class located in the "Spv" namespace,
// e.g.: Spv.Specification.SourceLanguage.GLSL
// - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL
-//
+// - Beef will use enum classes in the Specification class located in the "Spv" namespace,
+// e.g.: Spv.Specification.SourceLanguage.GLSL
+//
// Some tokens act like mask values, which can be OR'd together,
// while others are mutually exclusive. The mask-like ones have
// "Mask" in their name, and a parallel enum that has the shift
@@ -66,6 +68,7 @@ enum SourceLanguage {
SourceLanguageOpenCL_CPP = 4,
SourceLanguageHLSL = 5,
SourceLanguageCPP_for_OpenCL = 6,
+ SourceLanguageSYCL = 7,
SourceLanguageMax = 0x7fffffff,
};
@@ -153,6 +156,9 @@ enum ExecutionMode {
ExecutionModeSubgroupsPerWorkgroupId = 37,
ExecutionModeLocalSizeId = 38,
ExecutionModeLocalSizeHintId = 39,
+ ExecutionModeNonCoherentColorAttachmentReadEXT = 4169,
+ ExecutionModeNonCoherentDepthAttachmentReadEXT = 4170,
+ ExecutionModeNonCoherentStencilAttachmentReadEXT = 4171,
ExecutionModeSubgroupUniformControlFlowKHR = 4421,
ExecutionModePostDepthCoverage = 4446,
ExecutionModeDenormPreserve = 4459,
@@ -192,6 +198,8 @@ enum ExecutionMode {
ExecutionModeNoGlobalOffsetINTEL = 5895,
ExecutionModeNumSIMDWorkitemsINTEL = 5896,
ExecutionModeSchedulerTargetFmaxMhzINTEL = 5903,
+ ExecutionModeStreamingInterfaceINTEL = 6154,
+ ExecutionModeNamedBarrierCountINTEL = 6417,
ExecutionModeMax = 0x7fffffff,
};
@@ -209,6 +217,7 @@ enum StorageClass {
StorageClassAtomicCounter = 10,
StorageClassImage = 11,
StorageClassStorageBuffer = 12,
+ StorageClassTileImageEXT = 4172,
StorageClassCallableDataKHR = 5328,
StorageClassCallableDataNV = 5328,
StorageClassIncomingCallableDataKHR = 5329,
@@ -223,6 +232,7 @@ enum StorageClass {
StorageClassShaderRecordBufferNV = 5343,
StorageClassPhysicalStorageBuffer = 5349,
StorageClassPhysicalStorageBufferEXT = 5349,
+ StorageClassHitObjectAttributeNV = 5385,
StorageClassTaskPayloadWorkgroupEXT = 5402,
StorageClassCodeSectionINTEL = 5605,
StorageClassDeviceOnlyINTEL = 5936,
@@ -238,6 +248,7 @@ enum Dim {
DimRect = 4,
DimBuffer = 5,
DimSubpassData = 6,
+ DimTileImageDataEXT = 4173,
DimMax = 0x7fffffff,
};
@@ -448,6 +459,7 @@ enum FunctionParameterAttribute {
FunctionParameterAttributeNoCapture = 5,
FunctionParameterAttributeNoWrite = 6,
FunctionParameterAttributeNoReadWrite = 7,
+ FunctionParameterAttributeRuntimeAlignedINTEL = 5940,
FunctionParameterAttributeMax = 0x7fffffff,
};
@@ -518,6 +530,7 @@ enum Decoration {
DecorationRestrictPointerEXT = 5355,
DecorationAliasedPointer = 5356,
DecorationAliasedPointerEXT = 5356,
+ DecorationHitObjectShaderRecordBufferNV = 5386,
DecorationBindlessSamplerNV = 5398,
DecorationBindlessImageNV = 5399,
DecorationBoundSamplerNV = 5400,
@@ -556,12 +569,27 @@ enum Decoration {
DecorationPrefetchINTEL = 5902,
DecorationStallEnableINTEL = 5905,
DecorationFuseLoopsInFunctionINTEL = 5907,
+ DecorationMathOpDSPModeINTEL = 5909,
+ DecorationAliasScopeINTEL = 5914,
+ DecorationNoAliasINTEL = 5915,
+ DecorationInitiationIntervalINTEL = 5917,
+ DecorationMaxConcurrencyINTEL = 5918,
+ DecorationPipelineEnableINTEL = 5919,
DecorationBufferLocationINTEL = 5921,
DecorationIOPipeStorageINTEL = 5944,
DecorationFunctionFloatingPointModeINTEL = 6080,
DecorationSingleElementVectorINTEL = 6085,
DecorationVectorComputeCallableFunctionINTEL = 6087,
DecorationMediaBlockIOINTEL = 6140,
+ DecorationConduitKernelArgumentINTEL = 6175,
+ DecorationRegisterMapKernelArgumentINTEL = 6176,
+ DecorationMMHostInterfaceAddressWidthINTEL = 6177,
+ DecorationMMHostInterfaceDataWidthINTEL = 6178,
+ DecorationMMHostInterfaceLatencyINTEL = 6179,
+ DecorationMMHostInterfaceReadWriteModeINTEL = 6180,
+ DecorationMMHostInterfaceMaxBurstINTEL = 6181,
+ DecorationMMHostInterfaceWaitRequestINTEL = 6182,
+ DecorationStableKernelArgumentINTEL = 6183,
DecorationMax = 0x7fffffff,
};
@@ -607,6 +635,11 @@ enum BuiltIn {
BuiltInSubgroupLocalInvocationId = 41,
BuiltInVertexIndex = 42,
BuiltInInstanceIndex = 43,
+ BuiltInCoreIDARM = 4160,
+ BuiltInCoreCountARM = 4161,
+ BuiltInCoreMaxIDARM = 4162,
+ BuiltInWarpIDARM = 4163,
+ BuiltInWarpMaxIDARM = 4164,
BuiltInSubgroupEqMask = 4416,
BuiltInSubgroupEqMaskKHR = 4416,
BuiltInSubgroupGeMask = 4417,
@@ -684,6 +717,7 @@ enum BuiltIn {
BuiltInHitKindKHR = 5333,
BuiltInHitKindNV = 5333,
BuiltInCurrentRayTimeNV = 5334,
+ BuiltInHitTriangleVertexPositionsKHR = 5335,
BuiltInIncomingRayFlagsKHR = 5351,
BuiltInIncomingRayFlagsNV = 5351,
BuiltInRayGeometryIndexKHR = 5352,
@@ -725,6 +759,8 @@ enum LoopControlShift {
LoopControlMaxInterleavingINTELShift = 21,
LoopControlSpeculatedIterationsINTELShift = 22,
LoopControlNoFusionINTELShift = 23,
+ LoopControlLoopCountINTELShift = 24,
+ LoopControlMaxReinvocationDelayINTELShift = 25,
LoopControlMax = 0x7fffffff,
};
@@ -747,6 +783,8 @@ enum LoopControlMask {
LoopControlMaxInterleavingINTELMask = 0x00200000,
LoopControlSpeculatedIterationsINTELMask = 0x00400000,
LoopControlNoFusionINTELMask = 0x00800000,
+ LoopControlLoopCountINTELMask = 0x01000000,
+ LoopControlMaxReinvocationDelayINTELMask = 0x02000000,
};
enum FunctionControlShift {
@@ -819,6 +857,8 @@ enum MemoryAccessShift {
MemoryAccessMakePointerVisibleKHRShift = 4,
MemoryAccessNonPrivatePointerShift = 5,
MemoryAccessNonPrivatePointerKHRShift = 5,
+ MemoryAccessAliasScopeINTELMaskShift = 16,
+ MemoryAccessNoAliasINTELMaskShift = 17,
MemoryAccessMax = 0x7fffffff,
};
@@ -833,6 +873,8 @@ enum MemoryAccessMask {
MemoryAccessMakePointerVisibleKHRMask = 0x00000010,
MemoryAccessNonPrivatePointerMask = 0x00000020,
MemoryAccessNonPrivatePointerKHRMask = 0x00000020,
+ MemoryAccessAliasScopeINTELMaskMask = 0x00010000,
+ MemoryAccessNoAliasINTELMaskMask = 0x00020000,
};
enum Scope {
@@ -946,6 +988,10 @@ enum Capability {
CapabilityShaderLayer = 69,
CapabilityShaderViewportIndex = 70,
CapabilityUniformDecoration = 71,
+ CapabilityCoreBuiltinsARM = 4165,
+ CapabilityTileImageColorReadAccessEXT = 4166,
+ CapabilityTileImageDepthReadAccessEXT = 4167,
+ CapabilityTileImageStencilReadAccessEXT = 4168,
CapabilityFragmentShadingRateKHR = 4422,
CapabilitySubgroupBallotKHR = 4423,
CapabilityDrawParameters = 4427,
@@ -995,7 +1041,7 @@ enum Capability {
CapabilityMeshShadingNV = 5266,
CapabilityImageFootprintNV = 5282,
CapabilityMeshShadingEXT = 5283,
- CapabilityFragmentBarycentricKHR = 5284,
+ CapabilityFragmentBarycentricKHR = 5284,
CapabilityFragmentBarycentricNV = 5284,
CapabilityComputeDerivativeGroupQuadsNV = 5288,
CapabilityFragmentDensityEXT = 5291,
@@ -1025,6 +1071,7 @@ enum Capability {
CapabilityUniformTexelBufferArrayNonUniformIndexingEXT = 5311,
CapabilityStorageTexelBufferArrayNonUniformIndexing = 5312,
CapabilityStorageTexelBufferArrayNonUniformIndexingEXT = 5312,
+ CapabilityRayTracingPositionFetchKHR = 5336,
CapabilityRayTracingNV = 5340,
CapabilityRayTracingMotionBlurNV = 5341,
CapabilityVulkanMemoryModel = 5345,
@@ -1042,7 +1089,10 @@ enum Capability {
CapabilityFragmentShaderPixelInterlockEXT = 5378,
CapabilityDemoteToHelperInvocation = 5379,
CapabilityDemoteToHelperInvocationEXT = 5379,
+ CapabilityRayTracingOpacityMicromapEXT = 5381,
+ CapabilityShaderInvocationReorderNV = 5383,
CapabilityBindlessTextureNV = 5390,
+ CapabilityRayQueryPositionFetchKHR = 5391,
CapabilitySubgroupShuffleINTEL = 5568,
CapabilitySubgroupBufferBlockIOINTEL = 5569,
CapabilitySubgroupImageBlockIOINTEL = 5570,
@@ -1075,9 +1125,13 @@ enum Capability {
CapabilityFPGAMemoryAccessesINTEL = 5898,
CapabilityFPGAClusterAttributesINTEL = 5904,
CapabilityLoopFuseINTEL = 5906,
+ CapabilityFPGADSPControlINTEL = 5908,
+ CapabilityMemoryAccessAliasingINTEL = 5910,
+ CapabilityFPGAInvocationPipeliningAttributesINTEL = 5916,
CapabilityFPGABufferLocationINTEL = 5920,
CapabilityArbitraryPrecisionFixedPointINTEL = 5922,
CapabilityUSMStorageClassesINTEL = 5935,
+ CapabilityRuntimeAlignedAttributeINTEL = 5939,
CapabilityIOPipesINTEL = 5943,
CapabilityBlockingPipesINTEL = 5945,
CapabilityFPGARegINTEL = 5948,
@@ -1091,12 +1145,16 @@ enum Capability {
CapabilityDotProductKHR = 6019,
CapabilityRayCullMaskKHR = 6020,
CapabilityBitInstructions = 6025,
+ CapabilityGroupNonUniformRotateKHR = 6026,
CapabilityAtomicFloat32AddEXT = 6033,
CapabilityAtomicFloat64AddEXT = 6034,
CapabilityLongConstantCompositeINTEL = 6089,
CapabilityOptNoneINTEL = 6094,
CapabilityAtomicFloat16AddEXT = 6095,
CapabilityDebugInfoModuleINTEL = 6114,
+ CapabilitySplitBarrierINTEL = 6141,
+ CapabilityFPGAArgumentInterfacesINTEL = 6174,
+ CapabilityGroupUniformArithmeticKHR = 6400,
CapabilityMax = 0x7fffffff,
};
@@ -1111,6 +1169,7 @@ enum RayFlagsShift {
RayFlagsCullNoOpaqueKHRShift = 7,
RayFlagsSkipTrianglesKHRShift = 8,
RayFlagsSkipAABBsKHRShift = 9,
+ RayFlagsForceOpacityMicromap2StateEXTShift = 10,
RayFlagsMax = 0x7fffffff,
};
@@ -1126,6 +1185,7 @@ enum RayFlagsMask {
RayFlagsCullNoOpaqueKHRMask = 0x00000080,
RayFlagsSkipTrianglesKHRMask = 0x00000100,
RayFlagsSkipAABBsKHRMask = 0x00000200,
+ RayFlagsForceOpacityMicromap2StateEXTMask = 0x00000400,
};
enum RayQueryIntersection {
@@ -1546,12 +1606,16 @@ enum Op {
OpPtrEqual = 401,
OpPtrNotEqual = 402,
OpPtrDiff = 403,
+ OpColorAttachmentReadEXT = 4160,
+ OpDepthAttachmentReadEXT = 4161,
+ OpStencilAttachmentReadEXT = 4162,
OpTerminateInvocation = 4416,
OpSubgroupBallotKHR = 4421,
OpSubgroupFirstInvocationKHR = 4422,
OpSubgroupAllKHR = 4428,
OpSubgroupAnyKHR = 4429,
OpSubgroupAllEqualKHR = 4430,
+ OpGroupNonUniformRotateKHR = 4431,
OpSubgroupReadInvocationKHR = 4432,
OpTraceRayKHR = 4445,
OpExecuteCallableKHR = 4446,
@@ -1588,6 +1652,39 @@ enum Op {
OpFragmentMaskFetchAMD = 5011,
OpFragmentFetchAMD = 5012,
OpReadClockKHR = 5056,
+ OpHitObjectRecordHitMotionNV = 5249,
+ OpHitObjectRecordHitWithIndexMotionNV = 5250,
+ OpHitObjectRecordMissMotionNV = 5251,
+ OpHitObjectGetWorldToObjectNV = 5252,
+ OpHitObjectGetObjectToWorldNV = 5253,
+ OpHitObjectGetObjectRayDirectionNV = 5254,
+ OpHitObjectGetObjectRayOriginNV = 5255,
+ OpHitObjectTraceRayMotionNV = 5256,
+ OpHitObjectGetShaderRecordBufferHandleNV = 5257,
+ OpHitObjectGetShaderBindingTableRecordIndexNV = 5258,
+ OpHitObjectRecordEmptyNV = 5259,
+ OpHitObjectTraceRayNV = 5260,
+ OpHitObjectRecordHitNV = 5261,
+ OpHitObjectRecordHitWithIndexNV = 5262,
+ OpHitObjectRecordMissNV = 5263,
+ OpHitObjectExecuteShaderNV = 5264,
+ OpHitObjectGetCurrentTimeNV = 5265,
+ OpHitObjectGetAttributesNV = 5266,
+ OpHitObjectGetHitKindNV = 5267,
+ OpHitObjectGetPrimitiveIndexNV = 5268,
+ OpHitObjectGetGeometryIndexNV = 5269,
+ OpHitObjectGetInstanceIdNV = 5270,
+ OpHitObjectGetInstanceCustomIndexNV = 5271,
+ OpHitObjectGetWorldRayDirectionNV = 5272,
+ OpHitObjectGetWorldRayOriginNV = 5273,
+ OpHitObjectGetRayTMaxNV = 5274,
+ OpHitObjectGetRayTMinNV = 5275,
+ OpHitObjectIsEmptyNV = 5276,
+ OpHitObjectIsHitNV = 5277,
+ OpHitObjectIsMissNV = 5278,
+ OpReorderThreadWithHitObjectNV = 5279,
+ OpReorderThreadWithHintNV = 5280,
+ OpTypeHitObjectNV = 5281,
OpImageSampleFootprintNV = 5283,
OpEmitMeshTasksEXT = 5294,
OpSetMeshOutputsEXT = 5295,
@@ -1600,6 +1697,7 @@ enum Op {
OpTraceNV = 5337,
OpTraceMotionNV = 5338,
OpTraceRayMotionNV = 5339,
+ OpRayQueryGetIntersectionTriangleVertexPositionsKHR = 5340,
OpTypeAccelerationStructureKHR = 5341,
OpTypeAccelerationStructureNV = 5341,
OpExecuteCallableNV = 5344,
@@ -1820,6 +1918,9 @@ enum Op {
OpArbitraryFloatPowRINTEL = 5881,
OpArbitraryFloatPowNINTEL = 5882,
OpLoopControlINTEL = 5887,
+ OpAliasDomainDeclINTEL = 5911,
+ OpAliasScopeDeclINTEL = 5912,
+ OpAliasScopeListDeclINTEL = 5913,
OpFixedSqrtINTEL = 5923,
OpFixedRecipINTEL = 5924,
OpFixedRsqrtINTEL = 5925,
@@ -1858,10 +1959,23 @@ enum Op {
OpTypeStructContinuedINTEL = 6090,
OpConstantCompositeContinuedINTEL = 6091,
OpSpecConstantCompositeContinuedINTEL = 6092,
+ OpControlBarrierArriveINTEL = 6142,
+ OpControlBarrierWaitINTEL = 6143,
+ OpGroupIMulKHR = 6401,
+ OpGroupFMulKHR = 6402,
+ OpGroupBitwiseAndKHR = 6403,
+ OpGroupBitwiseOrKHR = 6404,
+ OpGroupBitwiseXorKHR = 6405,
+ OpGroupLogicalAndKHR = 6406,
+ OpGroupLogicalOrKHR = 6407,
+ OpGroupLogicalXorKHR = 6408,
OpMax = 0x7fffffff,
};
#ifdef SPV_ENABLE_UTILITY_CODE
+#ifndef __cplusplus
+#include <stdbool.h>
+#endif
inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
*hasResult = *hasResultType = false;
switch (opcode) {
@@ -2210,12 +2324,16 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
case OpPtrEqual: *hasResult = true; *hasResultType = true; break;
case OpPtrNotEqual: *hasResult = true; *hasResultType = true; break;
case OpPtrDiff: *hasResult = true; *hasResultType = true; break;
+ case OpColorAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
+ case OpDepthAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
+ case OpStencilAttachmentReadEXT: *hasResult = true; *hasResultType = true; break;
case OpTerminateInvocation: *hasResult = false; *hasResultType = false; break;
case OpSubgroupBallotKHR: *hasResult = true; *hasResultType = true; break;
case OpSubgroupFirstInvocationKHR: *hasResult = true; *hasResultType = true; break;
case OpSubgroupAllKHR: *hasResult = true; *hasResultType = true; break;
case OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break;
case OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break;
+ case OpGroupNonUniformRotateKHR: *hasResult = true; *hasResultType = true; break;
case OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break;
case OpTraceRayKHR: *hasResult = false; *hasResultType = false; break;
case OpExecuteCallableKHR: *hasResult = false; *hasResultType = false; break;
@@ -2246,10 +2364,43 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
case OpFragmentMaskFetchAMD: *hasResult = true; *hasResultType = true; break;
case OpFragmentFetchAMD: *hasResult = true; *hasResultType = true; break;
case OpReadClockKHR: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectRecordHitMotionNV: *hasResult = false; *hasResultType = false; break;
+ case OpHitObjectRecordHitWithIndexMotionNV: *hasResult = false; *hasResultType = false; break;
+ case OpHitObjectRecordMissMotionNV: *hasResult = false; *hasResultType = false; break;
+ case OpHitObjectGetWorldToObjectNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectGetObjectToWorldNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectGetObjectRayDirectionNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectGetObjectRayOriginNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectTraceRayMotionNV: *hasResult = false; *hasResultType = false; break;
+ case OpHitObjectGetShaderRecordBufferHandleNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectGetShaderBindingTableRecordIndexNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectRecordEmptyNV: *hasResult = false; *hasResultType = false; break;
+ case OpHitObjectTraceRayNV: *hasResult = false; *hasResultType = false; break;
+ case OpHitObjectRecordHitNV: *hasResult = false; *hasResultType = false; break;
+ case OpHitObjectRecordHitWithIndexNV: *hasResult = false; *hasResultType = false; break;
+ case OpHitObjectRecordMissNV: *hasResult = false; *hasResultType = false; break;
+ case OpHitObjectExecuteShaderNV: *hasResult = false; *hasResultType = false; break;
+ case OpHitObjectGetCurrentTimeNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectGetAttributesNV: *hasResult = false; *hasResultType = false; break;
+ case OpHitObjectGetHitKindNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectGetPrimitiveIndexNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectGetGeometryIndexNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectGetInstanceIdNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectGetInstanceCustomIndexNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectGetWorldRayDirectionNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectGetWorldRayOriginNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectGetRayTMaxNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectGetRayTMinNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectIsEmptyNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectIsHitNV: *hasResult = true; *hasResultType = true; break;
+ case OpHitObjectIsMissNV: *hasResult = true; *hasResultType = true; break;
+ case OpReorderThreadWithHitObjectNV: *hasResult = false; *hasResultType = false; break;
+ case OpReorderThreadWithHintNV: *hasResult = false; *hasResultType = false; break;
+ case OpTypeHitObjectNV: *hasResult = true; *hasResultType = false; break;
case OpImageSampleFootprintNV: *hasResult = true; *hasResultType = true; break;
- case OpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break;
case OpEmitMeshTasksEXT: *hasResult = false; *hasResultType = false; break;
case OpSetMeshOutputsEXT: *hasResult = false; *hasResultType = false; break;
+ case OpGroupNonUniformPartitionNV: *hasResult = true; *hasResultType = true; break;
case OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break;
case OpReportIntersectionNV: *hasResult = true; *hasResultType = true; break;
case OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break;
@@ -2257,6 +2408,7 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
case OpTraceNV: *hasResult = false; *hasResultType = false; break;
case OpTraceMotionNV: *hasResult = false; *hasResultType = false; break;
case OpTraceRayMotionNV: *hasResult = false; *hasResultType = false; break;
+ case OpRayQueryGetIntersectionTriangleVertexPositionsKHR: *hasResult = true; *hasResultType = true; break;
case OpTypeAccelerationStructureNV: *hasResult = true; *hasResultType = false; break;
case OpExecuteCallableNV: *hasResult = false; *hasResultType = false; break;
case OpTypeCooperativeMatrixNV: *hasResult = true; *hasResultType = false; break;
@@ -2473,6 +2625,9 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
case OpArbitraryFloatPowRINTEL: *hasResult = true; *hasResultType = true; break;
case OpArbitraryFloatPowNINTEL: *hasResult = true; *hasResultType = true; break;
case OpLoopControlINTEL: *hasResult = false; *hasResultType = false; break;
+ case OpAliasDomainDeclINTEL: *hasResult = true; *hasResultType = false; break;
+ case OpAliasScopeDeclINTEL: *hasResult = true; *hasResultType = false; break;
+ case OpAliasScopeListDeclINTEL: *hasResult = true; *hasResultType = false; break;
case OpFixedSqrtINTEL: *hasResult = true; *hasResultType = true; break;
case OpFixedRecipINTEL: *hasResult = true; *hasResultType = true; break;
case OpFixedRsqrtINTEL: *hasResult = true; *hasResultType = true; break;
@@ -2511,23 +2666,64 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
case OpTypeStructContinuedINTEL: *hasResult = false; *hasResultType = false; break;
case OpConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
case OpSpecConstantCompositeContinuedINTEL: *hasResult = false; *hasResultType = false; break;
+ case OpControlBarrierArriveINTEL: *hasResult = false; *hasResultType = false; break;
+ case OpControlBarrierWaitINTEL: *hasResult = false; *hasResultType = false; break;
+ case OpGroupIMulKHR: *hasResult = true; *hasResultType = true; break;
+ case OpGroupFMulKHR: *hasResult = true; *hasResultType = true; break;
+ case OpGroupBitwiseAndKHR: *hasResult = true; *hasResultType = true; break;
+ case OpGroupBitwiseOrKHR: *hasResult = true; *hasResultType = true; break;
+ case OpGroupBitwiseXorKHR: *hasResult = true; *hasResultType = true; break;
+ case OpGroupLogicalAndKHR: *hasResult = true; *hasResultType = true; break;
+ case OpGroupLogicalOrKHR: *hasResult = true; *hasResultType = true; break;
+ case OpGroupLogicalXorKHR: *hasResult = true; *hasResultType = true; break;
}
}
#endif /* SPV_ENABLE_UTILITY_CODE */
-// Overload operator| for mask bit combining
+// Overload bitwise operators for mask bit combining
inline ImageOperandsMask operator|(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) | unsigned(b)); }
+inline ImageOperandsMask operator&(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) & unsigned(b)); }
+inline ImageOperandsMask operator^(ImageOperandsMask a, ImageOperandsMask b) { return ImageOperandsMask(unsigned(a) ^ unsigned(b)); }
+inline ImageOperandsMask operator~(ImageOperandsMask a) { return ImageOperandsMask(~unsigned(a)); }
inline FPFastMathModeMask operator|(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) | unsigned(b)); }
+inline FPFastMathModeMask operator&(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) & unsigned(b)); }
+inline FPFastMathModeMask operator^(FPFastMathModeMask a, FPFastMathModeMask b) { return FPFastMathModeMask(unsigned(a) ^ unsigned(b)); }
+inline FPFastMathModeMask operator~(FPFastMathModeMask a) { return FPFastMathModeMask(~unsigned(a)); }
inline SelectionControlMask operator|(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) | unsigned(b)); }
+inline SelectionControlMask operator&(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) & unsigned(b)); }
+inline SelectionControlMask operator^(SelectionControlMask a, SelectionControlMask b) { return SelectionControlMask(unsigned(a) ^ unsigned(b)); }
+inline SelectionControlMask operator~(SelectionControlMask a) { return SelectionControlMask(~unsigned(a)); }
inline LoopControlMask operator|(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) | unsigned(b)); }
+inline LoopControlMask operator&(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) & unsigned(b)); }
+inline LoopControlMask operator^(LoopControlMask a, LoopControlMask b) { return LoopControlMask(unsigned(a) ^ unsigned(b)); }
+inline LoopControlMask operator~(LoopControlMask a) { return LoopControlMask(~unsigned(a)); }
inline FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) | unsigned(b)); }
+inline FunctionControlMask operator&(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) & unsigned(b)); }
+inline FunctionControlMask operator^(FunctionControlMask a, FunctionControlMask b) { return FunctionControlMask(unsigned(a) ^ unsigned(b)); }
+inline FunctionControlMask operator~(FunctionControlMask a) { return FunctionControlMask(~unsigned(a)); }
inline MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); }
+inline MemorySemanticsMask operator&(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) & unsigned(b)); }
+inline MemorySemanticsMask operator^(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) ^ unsigned(b)); }
+inline MemorySemanticsMask operator~(MemorySemanticsMask a) { return MemorySemanticsMask(~unsigned(a)); }
inline MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); }
+inline MemoryAccessMask operator&(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) & unsigned(b)); }
+inline MemoryAccessMask operator^(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) ^ unsigned(b)); }
+inline MemoryAccessMask operator~(MemoryAccessMask a) { return MemoryAccessMask(~unsigned(a)); }
inline KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); }
+inline KernelProfilingInfoMask operator&(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) & unsigned(b)); }
+inline KernelProfilingInfoMask operator^(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) ^ unsigned(b)); }
+inline KernelProfilingInfoMask operator~(KernelProfilingInfoMask a) { return KernelProfilingInfoMask(~unsigned(a)); }
inline RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) | unsigned(b)); }
+inline RayFlagsMask operator&(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) & unsigned(b)); }
+inline RayFlagsMask operator^(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) ^ unsigned(b)); }
+inline RayFlagsMask operator~(RayFlagsMask a) { return RayFlagsMask(~unsigned(a)); }
inline FragmentShadingRateMask operator|(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) | unsigned(b)); }
+inline FragmentShadingRateMask operator&(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) & unsigned(b)); }
+inline FragmentShadingRateMask operator^(FragmentShadingRateMask a, FragmentShadingRateMask b) { return FragmentShadingRateMask(unsigned(a) ^ unsigned(b)); }
+inline FragmentShadingRateMask operator~(FragmentShadingRateMask a) { return FragmentShadingRateMask(~unsigned(a)); }
} // end namespace spv
#endif // #ifndef spirv_HPP
+