Updated glslang.

3rdparty/glslang/SPIRV/GLSL.ext.KHR.h

@@ -63,5 +63,7 @@ static const char* const E_SPV_KHR_subgroup_rotate              = "SPV_KHR_subgr
 static const char* const E_SPV_KHR_expect_assume                = "SPV_KHR_expect_assume";
 static const char* const E_SPV_EXT_replicated_composites        = "SPV_EXT_replicated_composites";
 static const char* const E_SPV_KHR_relaxed_extended_instruction = "SPV_KHR_relaxed_extended_instruction";
+static const char* const E_SPV_KHR_integer_dot_product          = "SPV_KHR_integer_dot_product";
+static const char* const E_SPV_NV_cooperative_vector            = "SPV_NV_cooperative_vector";
 
 #endif  // #ifndef GLSLextKHR_H

3rdparty/glslang/SPIRV/GLSL.ext.NV.h

@@ -96,4 +96,9 @@ const char* const E_SPV_NV_tensor_addressing = "SPV_NV_tensor_addressing";
 //SPV_NV_cooperative_matrix2
 const char* const E_SPV_NV_cooperative_matrix2 = "SPV_NV_cooperative_matrix2";
 
+//SPV_NV_cluster_acceleration_structure
+const char* const E_SPV_NV_cluster_acceleration_structure = "SPV_NV_cluster_acceleration_structure";
+
+//SPV_NV_linear_swept_spheres
+const char* const E_SPV_NV_linear_swept_spheres = "SPV_NV_linear_swept_spheres";
 #endif  // #ifndef GLSLextNV_H

3rdparty/glslang/SPIRV/GlslangToSpv.cpp

@@ -569,6 +569,9 @@ spv::MemoryAccessMask TGlslangToSpvTraverser::TranslateMemoryAccess(
     if (coherentFlags.volatil) {
         mask = mask | spv::MemoryAccessVolatileMask;
     }
+    if (coherentFlags.nontemporal) {
+        mask = mask | spv::MemoryAccessNontemporalMask;
+    }
     if (mask != spv::MemoryAccessMaskNone) {
         builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
     }
@@ -595,6 +598,9 @@ spv::ImageOperandsMask TGlslangToSpvTraverser::TranslateImageOperands(
     if (coherentFlags.volatil) {
         mask = mask | spv::ImageOperandsVolatileTexelKHRMask;
     }
+    if (coherentFlags.nontemporal && builder.getSpvVersion() >= spv::Spv_1_6) {
+        mask = mask | spv::ImageOperandsNontemporalMask;
+    }
     if (mask != spv::ImageOperandsMaskNone) {
         builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
     }
@@ -614,6 +620,7 @@ spv::Builder::AccessChain::CoherentFlags TGlslangToSpvTraverser::TranslateCohere
     flags.subgroupcoherent = type.getQualifier().subgroupcoherent;
     flags.shadercallcoherent = type.getQualifier().shadercallcoherent;
     flags.volatil = type.getQualifier().volatil;
+    flags.nontemporal = type.getQualifier().nontemporal;
     // *coherent variables are implicitly nonprivate in GLSL
     flags.nonprivate = type.getQualifier().nonprivate ||
                        flags.anyCoherent() ||
@@ -1022,6 +1029,34 @@ spv::BuiltIn TGlslangToSpvTraverser::TranslateBuiltInDecoration(glslang::TBuiltI
         builder.addCapability(spv::CapabilityRayTracingDisplacementMicromapNV);
         builder.addExtension("SPV_NV_displacement_micromap");
         return spv::BuiltInHitKindBackFacingMicroTriangleNV;
+    case glslang::EbvClusterIDNV:
+        builder.addCapability(spv::CapabilityRayTracingClusterAccelerationStructureNV);
+        builder.addExtension("SPV_NV_cluster_acceleration_structure");
+        return spv::BuiltInClusterIDNV;
+    case glslang::EbvHitIsSphereNV:
+        builder.addCapability(spv::CapabilityRayTracingSpheresGeometryNV);
+        builder.addExtension("SPV_NV_linear_swept_spheres");
+        return spv::BuiltInHitIsSphereNV;
+    case glslang::EbvHitIsLSSNV:
+        builder.addCapability(spv::CapabilityRayTracingLinearSweptSpheresGeometryNV);
+        builder.addExtension("SPV_NV_linear_swept_spheres");
+        return spv::BuiltInHitIsLSSNV;
+    case glslang::EbvHitSpherePositionNV:
+        builder.addCapability(spv::CapabilityRayTracingSpheresGeometryNV);
+        builder.addExtension("SPV_NV_linear_swept_spheres");
+        return spv::BuiltInHitSpherePositionNV;
+    case glslang::EbvHitSphereRadiusNV:
+        builder.addCapability(spv::CapabilityRayTracingSpheresGeometryNV);
+        builder.addExtension("SPV_NV_linear_swept_spheres");
+        return spv::BuiltInHitSphereRadiusNV;
+    case glslang::EbvHitLSSPositionsNV:
+        builder.addCapability(spv::CapabilityRayTracingLinearSweptSpheresGeometryNV);
+        builder.addExtension("SPV_NV_linear_swept_spheres");
+        return spv::BuiltInHitLSSPositionsNV;
+    case glslang::EbvHitLSSRadiiNV:
+        builder.addCapability(spv::CapabilityRayTracingLinearSweptSpheresGeometryNV);
+        builder.addExtension("SPV_NV_linear_swept_spheres");
+        return spv::BuiltInHitLSSRadiiNV;
 
     // barycentrics
     case glslang::EbvBaryCoordNV:
@@ -1498,6 +1533,8 @@ void InheritQualifiers(glslang::TQualifier& child, const glslang::TQualifier& pa
         child.nonprivate = true;
     if (parent.volatil)
         child.volatil = true;
+    if (parent.nontemporal)
+        child.nontemporal = true;
     if (parent.restrict)
         child.restrict = true;
     if (parent.readonly)
@@ -2572,6 +2609,9 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI
                 spec_constant_op_mode_setter.turnOnSpecConstantOpMode();
                 length = builder.createCooperativeMatrixLengthNV(typeId);
             }
+        } else if (node->getOperand()->getType().isCoopVecNV()) {
+            spv::Id typeId = convertGlslangToSpvType(node->getOperand()->getType());
+            length = builder.getCooperativeVectorNumComponents(typeId);
         } else {
             glslang::TIntermTyped* block = node->getOperand()->getAsBinaryNode()->getLeft();
             block->traverse(this);
@@ -2651,6 +2691,11 @@ bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TI
             case glslang::EOpHitObjectRecordEmptyNV:
             case glslang::EOpHitObjectGetShaderBindingTableRecordIndexNV:
             case glslang::EOpHitObjectGetShaderRecordBufferHandleNV:
+            case glslang::EOpHitObjectGetClusterIdNV:
+            case glslang::EOpHitObjectGetSpherePositionNV:
+            case glslang::EOpHitObjectGetSphereRadiusNV:
+            case glslang::EOpHitObjectIsSphereHitNV:
+            case glslang::EOpHitObjectIsLSSHitNV:
                 return true;
             default:
                 return false;
@@ -3142,6 +3187,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
     case glslang::EOpConstructReference:
     case glslang::EOpConstructCooperativeMatrixNV:
     case glslang::EOpConstructCooperativeMatrixKHR:
+    case glslang::EOpConstructCooperativeVectorNV:
     {
         builder.setDebugSourceLocation(node->getLoc().line, node->getLoc().getFilename());
         std::vector<spv::Id> arguments;
@@ -3162,10 +3208,17 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
             builder.addCapability(spv::CapabilityCooperativeMatrixConversionsNV);
             builder.addExtension(spv::E_SPV_NV_cooperative_matrix2);
             constructed = builder.createCooperativeMatrixConversion(resultType(), arguments[0]);
+        } else if (node->getOp() == glslang::EOpConstructCooperativeVectorNV &&
+                   arguments.size() == 1 &&
+                   builder.getTypeId(arguments[0]) == resultType()) {
+            constructed = arguments[0];
         } else if (node->getOp() == glslang::EOpConstructStruct ||
                  node->getOp() == glslang::EOpConstructCooperativeMatrixNV ||
                  node->getOp() == glslang::EOpConstructCooperativeMatrixKHR ||
-                 node->getType().isArray()) {
+                 node->getType().isArray() ||
+                 // Handle constructing coopvec from one component here, to avoid the component
+                 // getting smeared
+                 (node->getOp() == glslang::EOpConstructCooperativeVectorNV && arguments.size() == 1 && builder.isScalar(arguments[0]))) {
             std::vector<spv::Id> constituents;
             for (int c = 0; c < (int)arguments.size(); ++c)
                 constituents.push_back(arguments[c]);
@@ -3351,6 +3404,12 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
     case glslang::EOpCooperativeMatrixReduceNV:
     case glslang::EOpCooperativeMatrixPerElementOpNV:
     case glslang::EOpCooperativeMatrixTransposeNV:
+    case glslang::EOpCooperativeVectorMatMulNV:
+    case glslang::EOpCooperativeVectorMatMulAddNV:
+    case glslang::EOpCooperativeVectorLoadNV:
+    case glslang::EOpCooperativeVectorStoreNV:
+    case glslang::EOpCooperativeVectorOuterProductAccumulateNV:
+    case glslang::EOpCooperativeVectorReduceSumAccumulateNV:
         noReturnValue = true;
         break;
     case glslang::EOpBeginInvocationInterlock:
@@ -3395,6 +3454,53 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
         builder.addExtension(spv::E_SPV_NV_shader_invocation_reorder);
         builder.addCapability(spv::CapabilityShaderInvocationReorderNV);
         break;
+
+    case glslang::EOpHitObjectGetLSSPositionsNV:
+    case glslang::EOpHitObjectGetLSSRadiiNV:
+        builder.addExtension(spv::E_SPV_NV_linear_swept_spheres);
+        builder.addCapability(spv::CapabilityShaderInvocationReorderNV);
+        builder.addCapability(spv::CapabilityRayTracingLinearSweptSpheresGeometryNV);
+        noReturnValue = true;
+        break;
+
+    case glslang::EOpHitObjectGetSpherePositionNV:
+    case glslang::EOpHitObjectGetSphereRadiusNV:
+    case glslang::EOpHitObjectIsSphereHitNV:
+        builder.addExtension(spv::E_SPV_NV_linear_swept_spheres);
+        builder.addCapability(spv::CapabilityShaderInvocationReorderNV);
+        builder.addCapability(spv::CapabilityRayTracingSpheresGeometryNV);
+        break;
+
+    case glslang::EOpHitObjectIsLSSHitNV:
+        builder.addExtension(spv::E_SPV_NV_linear_swept_spheres);
+        builder.addCapability(spv::CapabilityShaderInvocationReorderNV);
+        builder.addCapability(spv::CapabilityRayTracingLinearSweptSpheresGeometryNV);
+        break;
+
+    case glslang::EOpRayQueryGetIntersectionLSSPositionsNV:
+    case glslang::EOpRayQueryGetIntersectionLSSRadiiNV:
+        builder.addExtension(spv::E_SPV_NV_linear_swept_spheres);
+        builder.addCapability(spv::CapabilityRayQueryKHR);
+        builder.addCapability(spv::CapabilityRayTracingLinearSweptSpheresGeometryNV);
+        noReturnValue = true;
+        break;
+
+    case glslang::EOpRayQueryGetIntersectionSpherePositionNV:
+    case glslang::EOpRayQueryGetIntersectionSphereRadiusNV:
+    case glslang::EOpRayQueryIsSphereHitNV:
+        builder.addExtension(spv::E_SPV_NV_linear_swept_spheres);
+        builder.addCapability(spv::CapabilityRayQueryKHR);
+        builder.addCapability(spv::CapabilityRayTracingSpheresGeometryNV);
+        builder.addCapability(spv::CapabilityRayTracingLinearSweptSpheresGeometryNV);
+        break;
+
+    case glslang::EOpRayQueryGetIntersectionLSSHitValueNV:
+    case glslang::EOpRayQueryIsLSSHitNV:
+        builder.addExtension(spv::E_SPV_NV_linear_swept_spheres);
+        builder.addCapability(spv::CapabilityRayQueryKHR);
+        builder.addCapability(spv::CapabilityRayTracingLinearSweptSpheresGeometryNV);
+        break;
+
     case glslang::EOpRayQueryGetIntersectionTriangleVertexPositionsEXT:
         builder.addExtension(spv::E_SPV_KHR_ray_tracing_position_fetch);
         builder.addCapability(spv::CapabilityRayQueryPositionFetchKHR);
@@ -3437,6 +3543,12 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
         builder.addCapability(spv::CapabilityDisplacementMicromapNV);
         break;
 
+    case glslang::EOpRayQueryGetIntersectionClusterIdNV:
+        builder.addExtension(spv::E_SPV_NV_cluster_acceleration_structure);
+        builder.addCapability(spv::CapabilityRayQueryKHR);
+        builder.addCapability(spv::CapabilityRayTracingClusterAccelerationStructureNV);
+        break;
+
     case glslang::EOpDebugPrintf:
         noReturnValue = true;
         break;
@@ -3504,10 +3616,16 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
         case glslang::EOpHitObjectRecordMissNV:
         case glslang::EOpHitObjectRecordMissMotionNV:
         case glslang::EOpHitObjectGetAttributesNV:
+        case glslang::EOpHitObjectGetClusterIdNV:
             if (arg == 0)
                 lvalue = true;
             break;
 
+        case glslang::EOpHitObjectGetLSSPositionsNV:
+        case glslang::EOpHitObjectGetLSSRadiiNV:
+            lvalue = true;
+            break;
+
         case glslang::EOpRayQueryInitialize:
         case glslang::EOpRayQueryTerminate:
         case glslang::EOpRayQueryConfirmIntersection:
@@ -3526,6 +3644,12 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
         case glslang::EOpRayQueryGetIntersectionObjectRayOrigin:
         case glslang::EOpRayQueryGetIntersectionObjectToWorld:
         case glslang::EOpRayQueryGetIntersectionWorldToObject:
+        case glslang::EOpRayQueryGetIntersectionClusterIdNV:
+        case glslang::EOpRayQueryGetIntersectionSpherePositionNV:
+        case glslang::EOpRayQueryGetIntersectionSphereRadiusNV:
+        case glslang::EOpRayQueryGetIntersectionLSSHitValueNV:
+        case glslang::EOpRayQueryIsSphereHitNV:
+        case glslang::EOpRayQueryIsLSSHitNV:
             if (arg == 0)
                 lvalue = true;
             break;
@@ -3598,12 +3722,30 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
         case glslang::EOpCooperativeMatrixLoad:
         case glslang::EOpCooperativeMatrixLoadNV:
         case glslang::EOpCooperativeMatrixLoadTensorNV:
+        case glslang::EOpCooperativeVectorLoadNV:
             if (arg == 0 || arg == 1)
                 lvalue = true;
             break;
         case glslang::EOpCooperativeMatrixStore:
         case glslang::EOpCooperativeMatrixStoreNV:
         case glslang::EOpCooperativeMatrixStoreTensorNV:
+        case glslang::EOpCooperativeVectorStoreNV:
+            if (arg == 1)
+                lvalue = true;
+            break;
+        case glslang::EOpCooperativeVectorMatMulNV:
+            if (arg == 0 || arg == 3)
+                lvalue = true;
+            break;
+        case glslang::EOpCooperativeVectorMatMulAddNV:
+            if (arg == 0 || arg == 3 || arg == 6)
+                lvalue = true;
+            break;
+        case glslang::EOpCooperativeVectorOuterProductAccumulateNV:
+            if (arg == 2)
+                lvalue = true;
+            break;
+        case glslang::EOpCooperativeVectorReduceSumAccumulateNV:
             if (arg == 1)
                 lvalue = true;
             break;
@@ -3623,6 +3765,8 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
                 lvalue = true;
             break;
         case glslang::EOpRayQueryGetIntersectionTriangleVertexPositionsEXT:
+        case glslang::EOpRayQueryGetIntersectionLSSPositionsNV:
+        case glslang::EOpRayQueryGetIntersectionLSSRadiiNV:
             if (arg == 0 || arg == 2)
                 lvalue = true;
             break;
@@ -3635,39 +3779,51 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
         else
             glslangOperands[arg]->traverse(this);
 
-        if (node->getOp() == glslang::EOpCooperativeMatrixLoad ||
-            node->getOp() == glslang::EOpCooperativeMatrixStore ||
-            node->getOp() == glslang::EOpCooperativeMatrixLoadNV ||
-            node->getOp() == glslang::EOpCooperativeMatrixStoreNV ||
-            node->getOp() == glslang::EOpCooperativeMatrixLoadTensorNV ||
-            node->getOp() == glslang::EOpCooperativeMatrixStoreTensorNV) {
+        bool isCoopMat = node->getOp() == glslang::EOpCooperativeMatrixLoad ||
+                         node->getOp() == glslang::EOpCooperativeMatrixStore ||
+                         node->getOp() == glslang::EOpCooperativeMatrixLoadNV ||
+                         node->getOp() == glslang::EOpCooperativeMatrixStoreNV ||
+                         node->getOp() == glslang::EOpCooperativeMatrixLoadTensorNV ||
+                         node->getOp() == glslang::EOpCooperativeMatrixStoreTensorNV;
+        bool isCoopVec = node->getOp() == glslang::EOpCooperativeVectorLoadNV ||
+                         node->getOp() == glslang::EOpCooperativeVectorStoreNV;
+        if (isCoopMat || isCoopVec) {
 
             if (arg == 1) {
-                // fold "element" parameter into the access chain
-                spv::Builder::AccessChain save = builder.getAccessChain();
-                builder.clearAccessChain();
-                glslangOperands[2]->traverse(this);
-
-                spv::Id elementId = accessChainLoad(glslangOperands[2]->getAsTyped()->getType());
+                spv::Builder::AccessChain::CoherentFlags coherentFlags {};
+                unsigned int alignment {};
+                if (isCoopMat) {
+                    // fold "element" parameter into the access chain
+                    spv::Builder::AccessChain save = builder.getAccessChain();
+                    builder.clearAccessChain();
+                    glslangOperands[2]->traverse(this);
 
-                builder.setAccessChain(save);
+                    spv::Id elementId = accessChainLoad(glslangOperands[2]->getAsTyped()->getType());
 
-                // Point to the first element of the array.
-                builder.accessChainPush(elementId,
-                    TranslateCoherent(glslangOperands[arg]->getAsTyped()->getType()),
-                                      glslangOperands[arg]->getAsTyped()->getType().getBufferReferenceAlignment());
+                    builder.setAccessChain(save);
 
-                spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags;
-                unsigned int alignment = builder.getAccessChain().alignment;
+                    // Point to the first element of the array.
+                    builder.accessChainPush(elementId,
+                        TranslateCoherent(glslangOperands[arg]->getAsTyped()->getType()),
+                                          glslangOperands[arg]->getAsTyped()->getType().getBufferReferenceAlignment());
+                    coherentFlags = builder.getAccessChain().coherentFlags;
+                    alignment = builder.getAccessChain().alignment;
+                } else {
+                    coherentFlags = builder.getAccessChain().coherentFlags;
+                    coherentFlags |= TranslateCoherent(glslangOperands[arg]->getAsTyped()->getType());
+                    alignment = 16;
+                }
 
                 int memoryAccess = TranslateMemoryAccess(coherentFlags);
                 if (node->getOp() == glslang::EOpCooperativeMatrixLoad ||
                     node->getOp() == glslang::EOpCooperativeMatrixLoadNV ||
-                    node->getOp() == glslang::EOpCooperativeMatrixLoadTensorNV)
+                    node->getOp() == glslang::EOpCooperativeMatrixLoadTensorNV ||
+                    node->getOp() == glslang::EOpCooperativeVectorLoadNV)
                     memoryAccess &= ~spv::MemoryAccessMakePointerAvailableKHRMask;
                 if (node->getOp() == glslang::EOpCooperativeMatrixStore ||
                     node->getOp() == glslang::EOpCooperativeMatrixStoreNV ||
-                    node->getOp() == glslang::EOpCooperativeMatrixStoreTensorNV)
+                    node->getOp() == glslang::EOpCooperativeMatrixStoreTensorNV ||
+                    node->getOp() == glslang::EOpCooperativeVectorStoreNV)
                     memoryAccess &= ~spv::MemoryAccessMakePointerVisibleKHRMask;
                 if (builder.getStorageClass(builder.getAccessChain().base) ==
                     spv::StorageClassPhysicalStorageBufferEXT) {
@@ -3685,7 +3841,7 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
                     memoryAccessOperands.push_back(spv::IdImmediate(true,
                         builder.makeUintConstant(TranslateMemoryScope(coherentFlags))));
                 }
-            } else if (arg == 2) {
+            } else if (isCoopMat && arg == 2) {
                 continue;
             }
         }
@@ -3724,7 +3880,15 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
                  glslangOp == glslang::EOpRayQueryGetIntersectionObjectRayOrigin ||
                  glslangOp == glslang::EOpRayQueryGetIntersectionObjectToWorld ||
                  glslangOp == glslang::EOpRayQueryGetIntersectionWorldToObject ||
-                 glslangOp == glslang::EOpRayQueryGetIntersectionTriangleVertexPositionsEXT
+                 glslangOp == glslang::EOpRayQueryGetIntersectionTriangleVertexPositionsEXT ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionClusterIdNV ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionSpherePositionNV ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionSphereRadiusNV ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionLSSHitValueNV ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionLSSPositionsNV ||
+                 glslangOp == glslang::EOpRayQueryGetIntersectionLSSRadiiNV ||
+                 glslangOp == glslang::EOpRayQueryIsLSSHitNV ||
+                 glslangOp == glslang::EOpRayQueryIsSphereHitNV
                     )) {
                 bool cond = glslangOperands[arg]->getAsConstantUnion()->getConstArray()[0].getBConst();
                 operands.push_back(builder.makeIntConstant(cond ? 1 : 0));
@@ -3895,6 +4059,65 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
         // store the result to the pointer (out param 'm')
         builder.createStore(result, operands[2]);
         result = 0;
+    } else if (node->getOp() == glslang::EOpRayQueryGetIntersectionLSSPositionsNV) {
+        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(2), 0);
+        // do the op
+
+        spv::Op spvOp = spv::OpRayQueryGetIntersectionLSSPositionsNV;
+
+        spv::Id result = builder.createOp(spvOp, typeId, idImmOps);
+        // store the result to the pointer (out param 'm')
+        builder.createStore(result, operands[2]);
+        result = 0;
+    } else if (node->getOp() == glslang::EOpRayQueryGetIntersectionLSSRadiiNV) {
+        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.makeFloatType(32),
+                                               builder.makeUintConstant(2), 0);
+        // do the op
+
+        spv::Op spvOp = spv::OpRayQueryGetIntersectionLSSRadiiNV;
+
+        spv::Id result = builder.createOp(spvOp, typeId, idImmOps);
+        // store the result to the pointer (out param 'm')
+        builder.createStore(result, operands[2]);
+        result = 0;
+    } else if (node->getOp() == glslang::EOpHitObjectGetLSSPositionsNV) {
+        std::vector<spv::IdImmediate> idImmOps;
+
+        idImmOps.push_back(spv::IdImmediate(true, operands[0])); // hitObject
+
+        spv::Op spvOp = spv::OpHitObjectGetLSSPositionsNV;
+        spv::Id typeId = builder.makeArrayType(builder.makeVectorType(builder.makeFloatType(32), 3),
+                                               builder.makeUintConstant(2), 0);
+
+        spv::Id result = builder.createOp(spvOp, typeId, idImmOps);
+        // store the result to the pointer (out param 'm')
+        builder.createStore(result, operands[1]);
+        result = 0;
+    } else if (node->getOp() == glslang::EOpHitObjectGetLSSRadiiNV) {
+        std::vector<spv::IdImmediate> idImmOps;
+
+        idImmOps.push_back(spv::IdImmediate(true, operands[0])); // hitObject
+
+        spv::Op spvOp = spv::OpHitObjectGetLSSRadiiNV;
+        spv::Id typeId = builder.makeArrayType(builder.makeFloatType(32),
+                                               builder.makeUintConstant(2), 0);
+
+        spv::Id result = builder.createOp(spvOp, typeId, idImmOps);
+        // store the result to the pointer (out param 'm')
+        builder.createStore(result, operands[1]);
+        result = 0;
+
     } else if (node->getOp() == glslang::EOpCooperativeMatrixMulAdd) {
         uint32_t matrixOperands = 0;
 
@@ -3958,6 +4181,96 @@ bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TInt
         // store the result to the pointer
         builder.createStore(result, operands[0]);
         result = 0;
+    } else if (node->getOp() == glslang::EOpCooperativeVectorMatMulNV ||
+               node->getOp() == glslang::EOpCooperativeVectorMatMulAddNV) {
+        uint32_t matrixOperands = 0;
+
+        bool isMulAdd = node->getOp() == glslang::EOpCooperativeVectorMatMulAddNV;
+
+        // Determine Cooperative Matrix Operands bits from the signedness of the types.
+
+        if (isTypeSignedInt(glslangOperands[1]->getAsTyped()->getBasicType()))
+            matrixOperands |= spv::CooperativeMatrixOperandsMatrixBSignedComponentsKHRMask;
+        if (isTypeSignedInt(glslangOperands[0]->getAsTyped()->getBasicType()))
+            matrixOperands |= spv::CooperativeMatrixOperandsMatrixResultSignedComponentsKHRMask;
+
+        uint32_t opIdx = 1;
+        std::vector<spv::IdImmediate> idImmOps;
+        idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // Input
+        idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // InputInterpretation
+        idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // Matrix
+        idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // MatrixOffset
+        idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // MatrixInterpretation
+        if (isMulAdd) {
+            idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // Bias
+            idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // BiasOffset
+            idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // BiasInterpretation
+        }
+        idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // M
+        idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // K
+        idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // MemoryLayout
+        idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // Transpose
+        idImmOps.push_back(spv::IdImmediate(true, operands[opIdx++])); // MatrixStride
+        if (matrixOperands != 0)
+            idImmOps.push_back(spv::IdImmediate(false, matrixOperands));  // Cooperative Matrix Operands
+
+        // get the pointee type
+        spv::Id typeId = builder.getContainedTypeId(builder.getTypeId(operands[0]));
+        assert(builder.isCooperativeVectorType(typeId));
+        // do the op
+        spv::Id result = builder.createOp(isMulAdd ? spv::OpCooperativeVectorMatrixMulAddNV : spv::OpCooperativeVectorMatrixMulNV, typeId, idImmOps);
+        // store the result to the pointer (out param 'res')
+        builder.createStore(result, operands[0]);
+        result = 0;
+    } else if (node->getOp() == glslang::EOpCooperativeVectorLoadNV) {
+        std::vector<spv::IdImmediate> idImmOps;
+
+        idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf
+        idImmOps.push_back(spv::IdImmediate(true, operands[2])); // offset
+        idImmOps.insert(idImmOps.end(), memoryAccessOperands.begin(), memoryAccessOperands.end());
+        // get the pointee type
+        spv::Id typeId = builder.getContainedTypeId(builder.getTypeId(operands[0]));
+        assert(builder.isCooperativeVectorType(typeId));
+        // do the op
+        spv::Id result = builder.createOp(spv::OpCooperativeVectorLoadNV, typeId, idImmOps);
+        // store the result to the pointer (out param 'v')
+        builder.createStore(result, operands[0]);
+        result = 0;
+    } else if (node->getOp() == glslang::EOpCooperativeVectorStoreNV) {
+        std::vector<spv::IdImmediate> idImmOps;
+
+        idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf
+        idImmOps.push_back(spv::IdImmediate(true, operands[2])); // offset
+        idImmOps.push_back(spv::IdImmediate(true, operands[0])); // object
+        idImmOps.insert(idImmOps.end(), memoryAccessOperands.begin(), memoryAccessOperands.end());
+        builder.createNoResultOp(spv::OpCooperativeVectorStoreNV, idImmOps);
+        result = 0;
+    } else if (node->getOp() == glslang::EOpCooperativeVectorOuterProductAccumulateNV) {
+        builder.addCapability(spv::CapabilityCooperativeVectorTrainingNV);
+        builder.addExtension(spv::E_SPV_NV_cooperative_vector);
+
+        std::vector<spv::IdImmediate> idImmOps;
+
+        idImmOps.push_back(spv::IdImmediate(true, operands[2])); // Matrix
+        idImmOps.push_back(spv::IdImmediate(true, operands[3])); // Offset
+        idImmOps.push_back(spv::IdImmediate(true, operands[0])); // A
+        idImmOps.push_back(spv::IdImmediate(true, operands[1])); // B
+        idImmOps.push_back(spv::IdImmediate(true, operands[5])); // MemoryLayout
+        idImmOps.push_back(spv::IdImmediate(true, operands[6])); // MatrixInterpretation
+        idImmOps.push_back(spv::IdImmediate(true, operands[4])); // Stride
+        builder.createNoResultOp(spv::OpCooperativeVectorOuterProductAccumulateNV, idImmOps);
+        result = 0;
+    } else if (node->getOp() == glslang::EOpCooperativeVectorReduceSumAccumulateNV) {
+        builder.addCapability(spv::CapabilityCooperativeVectorTrainingNV);
+        builder.addExtension(spv::E_SPV_NV_cooperative_vector);
+
+        std::vector<spv::IdImmediate> idImmOps;
+
+        idImmOps.push_back(spv::IdImmediate(true, operands[1])); // Buf
+        idImmOps.push_back(spv::IdImmediate(true, operands[2])); // Offset
+        idImmOps.push_back(spv::IdImmediate(true, operands[0])); // A
+        builder.createNoResultOp(spv::OpCooperativeVectorReduceSumAccumulateNV, idImmOps);
+        result = 0;
     } else if (atomic) {
         // Handle all atomics
         glslang::TBasicType typeProxy = (node->getOp() == glslang::EOpAtomicStore)
@@ -4914,6 +5227,21 @@ spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& ty
         spvType = builder.makeCooperativeMatrixTypeKHR(spvType, scope, rows, cols, use);
     }
 
+    if (type.isCoopVecNV()) {
+        builder.addCapability(spv::CapabilityCooperativeVectorNV);
+        builder.addExtension(spv::E_SPV_NV_cooperative_vector);
+
+        if (type.getBasicType() == glslang::EbtFloat16)
+            builder.addCapability(spv::CapabilityFloat16);
+        if (type.getBasicType() == glslang::EbtUint8 || type.getBasicType() == glslang::EbtInt8) {
+            builder.addCapability(spv::CapabilityInt8);
+        }
+
+        spv::Id components = makeArraySizeId(*type.getTypeParameters()->arraySizes, 0);
+
+        spvType = builder.makeCooperativeVectorTypeNV(spvType, components);
+    }
+
     if (type.isArray()) {
         int stride = 0;  // keep this 0 unless doing an explicit layout; 0 will mean no decoration, no stride
 
@@ -5994,6 +6322,8 @@ void TGlslangToSpvTraverser::translateArguments(const glslang::TIntermAggregate&
                 lvalue = true;
             break;
         case glslang::EOpRayQueryGetIntersectionTriangleVertexPositionsEXT:
+        case glslang::EOpRayQueryGetIntersectionLSSPositionsNV:
+        case glslang::EOpRayQueryGetIntersectionLSSRadiiNV:
             if (i == 2)
                 lvalue = true;
             break;
@@ -6598,6 +6928,10 @@ spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermO
         params.volatil = true;
     }
 
+    if (imageType.getQualifier().nontemporal) {
+        params.nontemporal = true;
+    }
+
     std::vector<spv::Id> result( 1,
         builder.createTextureCall(precision, resultType(), sparse, cracked.fetch, cracked.proj, cracked.gather,
                                   noImplicitLod, params, signExtensionMask())
@@ -6754,16 +7088,24 @@ spv::Id TGlslangToSpvTraverser::createBinaryOperation(glslang::TOperator op, OpD
         break;
     case glslang::EOpVectorTimesScalar:
     case glslang::EOpVectorTimesScalarAssign:
-        if (isFloat && (builder.isVector(left) || builder.isVector(right))) {
-            if (builder.isVector(right))
+        if (isFloat && (builder.isVector(left) || builder.isVector(right) || builder.isCooperativeVector(left) || builder.isCooperativeVector(right))) {
+            if (builder.isVector(right) || builder.isCooperativeVector(right))
                 std::swap(left, right);
             assert(builder.isScalar(right));
             needMatchingVectors = false;
             binOp = spv::OpVectorTimesScalar;
-        } else if (isFloat)
+        } else if (isFloat) {
             binOp = spv::OpFMul;
-          else
+        } else if (builder.isCooperativeVector(left) || builder.isCooperativeVector(right)) {
+            if (builder.isCooperativeVector(right))
+                std::swap(left, right);
+            assert(builder.isScalar(right));
+            // Construct a cooperative vector from the scalar
+            right = builder.createCompositeConstruct(builder.getTypeId(left), { right });
+            binOp = spv::OpIMul;
+        } else {
             binOp = spv::OpIMul;
+        }
         break;
     case glslang::EOpVectorTimesMatrix:
     case glslang::EOpVectorTimesMatrixAssign:
@@ -7580,6 +7922,29 @@ spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, OpDe
         unaryOp = spv::OpHitObjectGetShaderRecordBufferHandleNV;
         break;
 
+    case glslang::EOpHitObjectGetClusterIdNV:
+        unaryOp = spv::OpHitObjectGetClusterIdNV;
+        builder.addExtension(spv::E_SPV_NV_cluster_acceleration_structure);
+        builder.addCapability(spv::CapabilityShaderInvocationReorderNV);
+        builder.addCapability(spv::CapabilityRayTracingClusterAccelerationStructureNV);
+        break;
+
+    case glslang::EOpHitObjectGetSpherePositionNV:
+        unaryOp = spv::OpHitObjectGetSpherePositionNV;
+        break;
+
+    case glslang::EOpHitObjectGetSphereRadiusNV:
+        unaryOp = spv::OpHitObjectGetSphereRadiusNV;
+        break;
+
+    case glslang::EOpHitObjectIsSphereHitNV:
+        unaryOp = spv::OpHitObjectIsSphereHitNV;
+        break;
+
+    case glslang::EOpHitObjectIsLSSHitNV:
+        unaryOp = spv::OpHitObjectIsLSSHitNV;
+        break;
+
     case glslang::EOpFetchMicroTriangleVertexPositionNV:
         unaryOp = spv::OpFetchMicroTriangleVertexPositionNV;
         break;
@@ -7681,7 +8046,9 @@ spv::Id TGlslangToSpvTraverser::createIntWidthConversion(spv::Id operand, int ve
         type = builder.makeUintType(width);
     }
 
-    if (vectorSize > 0)
+    if (builder.getOpCode(destType) == spv::OpTypeCooperativeVectorNV) {
+        type = builder.makeCooperativeVectorTypeNV(type, builder.getCooperativeVectorNumComponents(destType));
+    } else if (vectorSize > 0)
         type = builder.makeVectorType(type, vectorSize);
     else if (builder.getOpCode(destType) == spv::OpTypeCooperativeMatrixKHR ||
              builder.getOpCode(destType) == spv::OpTypeCooperativeMatrixNV) {
@@ -8760,7 +9127,49 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::
         libCall = spv::GLSLstd450Pow;
         break;
     case glslang::EOpDot:
-        opCode = spv::OpDot;
+    case glslang::EOpDotPackedEXT:
+    case glslang::EOpDotAccSatEXT:
+    case glslang::EOpDotPackedAccSatEXT:
+        {
+            if (builder.isFloatType(builder.getScalarTypeId(typeId0)) ||
+                // HLSL supports dot(int,int) which is just a multiply
+                glslangIntermediate->getSource() == glslang::EShSourceHlsl) {
+                opCode = spv::OpDot;
+            } else {
+                builder.addExtension(spv::E_SPV_KHR_integer_dot_product);
+                builder.addCapability(spv::CapabilityDotProductKHR);
+                const unsigned int vectorSize = builder.getNumComponents(operands[0]);
+                if (op == glslang::EOpDotPackedEXT || op == glslang::EOpDotPackedAccSatEXT) {
+                    builder.addCapability(spv::CapabilityDotProductInput4x8BitPackedKHR);
+                } else if (vectorSize == 4 && builder.getScalarTypeWidth(typeId0) == 8) {
+                    builder.addCapability(spv::CapabilityDotProductInput4x8BitKHR);
+                } else {
+                    builder.addCapability(spv::CapabilityDotProductInputAllKHR);
+                }
+                const bool type0isSigned = builder.isIntType(builder.getScalarTypeId(typeId0));
+                const bool type1isSigned = builder.isIntType(builder.getScalarTypeId(typeId1));
+                const bool accSat = (op == glslang::EOpDotAccSatEXT || op == glslang::EOpDotPackedAccSatEXT);
+                if (!type0isSigned && !type1isSigned) {
+                    opCode = accSat ? spv::OpUDotAccSatKHR : spv::OpUDotKHR;
+                } else if (type0isSigned && type1isSigned) {
+                    opCode = accSat ? spv::OpSDotAccSatKHR : spv::OpSDotKHR;
+                } else {
+                    opCode = accSat ? spv::OpSUDotAccSatKHR : spv::OpSUDotKHR;
+                    // the spir-v opcode assumes the operands to be "signed, unsigned" in that order, so swap if needed
+                    if (type1isSigned) {
+                        std::swap(operands[0], operands[1]);
+                    }
+                }
+                std::vector<spv::IdImmediate> operands2;
+                for (auto &o : operands) {
+                    operands2.push_back({true, o});
+                }
+                if (op == glslang::EOpDotPackedEXT || op == glslang::EOpDotPackedAccSatEXT) {
+                    operands2.push_back({false, 0});
+                }
+                return builder.createOp(opCode, typeId, operands2);
+            }
+        }
         break;
     case glslang::EOpAtan:
         libCall = spv::GLSLstd450Atan2;
@@ -9122,10 +9531,34 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::
         typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
         opCode = spv::OpRayQueryGetIntersectionObjectToWorldKHR;
         break;
+    case glslang::EOpRayQueryGetIntersectionClusterIdNV:
+        typeId = builder.makeIntegerType(32, 1);
+        opCode = spv::OpRayQueryGetIntersectionClusterIdNV;
+        break;
     case glslang::EOpRayQueryGetIntersectionWorldToObject:
         typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
         opCode = spv::OpRayQueryGetIntersectionWorldToObjectKHR;
         break;
+    case glslang::EOpRayQueryGetIntersectionSpherePositionNV:
+        typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
+        opCode = spv::OpRayQueryGetIntersectionSpherePositionNV;
+        break;
+    case glslang::EOpRayQueryGetIntersectionSphereRadiusNV:
+        typeId = builder.makeFloatType(32);
+        opCode = spv::OpRayQueryGetIntersectionSphereRadiusNV;
+        break;
+    case glslang::EOpRayQueryGetIntersectionLSSHitValueNV:
+        typeId = builder.makeFloatType(32);
+        opCode = spv::OpRayQueryGetIntersectionLSSHitValueNV;
+        break;
+    case glslang::EOpRayQueryIsSphereHitNV:
+        typeId = builder.makeBoolType();
+        opCode = spv::OpRayQueryIsSphereHitNV;
+        break;
+    case glslang::EOpRayQueryIsLSSHitNV:
+        typeId = builder.makeBoolType();
+        opCode = spv::OpRayQueryIsLSSHitNV;
+        break;
     case glslang::EOpWritePackedPrimitiveIndices4x8NV:
         builder.createNoResultOp(spv::OpWritePackedPrimitiveIndices4x8NV, operands);
         return 0;
@@ -9180,6 +9613,14 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::
         typeId = builder.makeBoolType();
         opCode = spv::OpHitObjectIsHitNV;
         break;
+    case glslang::EOpHitObjectIsSphereHitNV:
+        typeId = builder.makeBoolType();
+        opCode = spv::OpHitObjectIsSphereHitNV;
+        break;
+    case glslang::EOpHitObjectIsLSSHitNV:
+        typeId = builder.makeBoolType();
+        opCode = spv::OpHitObjectIsLSSHitNV;
+        break;
     case glslang::EOpHitObjectGetRayTMinNV:
         typeId = builder.makeFloatType(32);
         opCode = spv::OpHitObjectGetRayTMinNV;
@@ -9247,6 +9688,10 @@ spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::
         typeId = builder.makeVectorType(builder.makeUintType(32), 2);
         opCode = spv::OpHitObjectGetShaderRecordBufferHandleNV;
         break;
+    case glslang::EOpHitObjectGetClusterIdNV:
+        typeId = builder.makeIntegerType(32, 1);
+        opCode = spv::OpHitObjectGetClusterIdNV;
+        break;
     case glslang::EOpReorderThreadNV: {
         if (operands.size() == 2) {
             builder.createNoResultOp(spv::OpReorderThreadWithHintNV, operands);
@@ -10028,8 +10473,9 @@ spv::Id TGlslangToSpvTraverser::createSpvConstantFromConstUnionArray(const glsla
         glslang::TVector<glslang::TTypeLoc>::const_iterator iter;
         for (iter = glslangType.getStruct()->begin(); iter != glslangType.getStruct()->end(); ++iter)
             spvConsts.push_back(createSpvConstantFromConstUnionArray(*iter->type, consts, nextConst, false));
-    } else if (glslangType.getVectorSize() > 1) {
-        for (unsigned int i = 0; i < (unsigned int)glslangType.getVectorSize(); ++i) {
+    } else if (glslangType.getVectorSize() > 1 || glslangType.isCoopVecNV()) {
+        unsigned int numComponents = glslangType.isCoopVecNV() ? glslangType.getTypeParameters()->arraySizes->getDimSize(0) : glslangType.getVectorSize();
+        for (unsigned int i = 0; i < numComponents; ++i) {
             bool zero = nextConst >= consts.size();
             switch (glslangType.getBasicType()) {
             case glslang::EbtInt:

3rdparty/glslang/SPIRV/SPVRemapper.cpp

@@ -1384,13 +1384,15 @@ namespace spv {
                 return hash;
             }
 
-        case spv::OpTypeEvent:           return 300000;
-        case spv::OpTypeDeviceEvent:     return 300001;
-        case spv::OpTypeReserveId:       return 300002;
-        case spv::OpTypeQueue:           return 300003;
-        case spv::OpTypePipe:            return 300004;
-        case spv::OpConstantTrue:        return 300007;
-        case spv::OpConstantFalse:       return 300008;
+        case spv::OpTypeEvent:                      return 300000;
+        case spv::OpTypeDeviceEvent:                return 300001;
+        case spv::OpTypeReserveId:                  return 300002;
+        case spv::OpTypeQueue:                      return 300003;
+        case spv::OpTypePipe:                       return 300004;
+        case spv::OpConstantTrue:                   return 300007;
+        case spv::OpConstantFalse:                  return 300008;
+        case spv::OpTypeRayQueryKHR:                return 300009;
+        case spv::OpTypeAccelerationStructureKHR:   return 300010;
         case spv::OpConstantComposite:
             {
                 std::uint32_t hash = 300011 + hashType(idPos(spv[typeStart+1]));

3rdparty/glslang/SPIRV/SpvBuilder.cpp

@@ -515,6 +515,28 @@ Id Builder::makeCooperativeMatrixTypeWithSameShape(Id component, Id otherType)
     }
 }
 
+Id Builder::makeCooperativeVectorTypeNV(Id componentType, Id components)
+{
+    // try to find it
+    Instruction* type;
+    for (int t = 0; t < (int)groupedTypes[OpTypeCooperativeVectorNV].size(); ++t) {
+        type = groupedTypes[OpTypeCooperativeVectorNV][t];
+        if (type->getIdOperand(0) == componentType &&
+            type->getIdOperand(1) == components)
+            return type->getResultId();
+    }
+
+    // not found, make it
+    type = new Instruction(getUniqueId(), NoType, OpTypeCooperativeVectorNV);
+    type->addIdOperand(componentType);
+    type->addIdOperand(components);
+    groupedTypes[OpTypeCooperativeVectorNV].push_back(type);
+    constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
+    module.mapInstruction(type);
+
+    return type->getResultId();
+}
+
 Id Builder::makeGenericType(spv::Op opcode, std::vector<spv::IdImmediate>& operands)
 {
     // try to find it
@@ -1363,6 +1385,7 @@ unsigned int Builder::getNumTypeConstituents(Id typeId) const
     case OpTypeVector:
     case OpTypeMatrix:
         return instr->getImmediateOperand(1);
+    case OpTypeCooperativeVectorNV:
     case OpTypeArray:
     {
         Id lengthId = instr->getIdOperand(1);
@@ -1401,6 +1424,7 @@ Id Builder::getScalarTypeId(Id typeId) const
     case OpTypeArray:
     case OpTypeRuntimeArray:
     case OpTypePointer:
+    case OpTypeCooperativeVectorNV:
         return getScalarTypeId(getContainedTypeId(typeId));
     default:
         assert(0);
@@ -1422,6 +1446,7 @@ Id Builder::getContainedTypeId(Id typeId, int member) const
     case OpTypeRuntimeArray:
     case OpTypeCooperativeMatrixKHR:
     case OpTypeCooperativeMatrixNV:
+    case OpTypeCooperativeVectorNV:
         return instr->getIdOperand(0);
     case OpTypePointer:
         return instr->getIdOperand(1);
@@ -1804,7 +1829,7 @@ Id Builder::importNonSemanticShaderDebugInfoInstructions()
     return nonSemanticShaderDebugInfo;
 }
 
-Id Builder::findCompositeConstant(Op typeClass, Id typeId, const std::vector<Id>& comps)
+Id Builder::findCompositeConstant(Op typeClass, Op opcode, Id typeId, const std::vector<Id>& comps, size_t numMembers)
 {
     Instruction* constant = nullptr;
     bool found = false;
@@ -1814,6 +1839,13 @@ Id Builder::findCompositeConstant(Op typeClass, Id typeId, const std::vector<Id>
         if (constant->getTypeId() != typeId)
             continue;
 
+        if (constant->getOpCode() != opcode) {
+            continue;
+        }
+
+        if (constant->getNumOperands() != (int)numMembers)
+            continue;
+
         // same contents?
         bool mismatch = false;
         for (int op = 0; op < constant->getNumOperands(); ++op) {
@@ -1863,7 +1895,7 @@ Id Builder::makeCompositeConstant(Id typeId, const std::vector<Id>& members, boo
 
     bool replicate = false;
     size_t numMembers = members.size();
-    if (useReplicatedComposites) {
+    if (useReplicatedComposites || typeClass == OpTypeCooperativeVectorNV) {
         // use replicate if all members are the same
         replicate = numMembers > 0 &&
             std::equal(members.begin() + 1, members.end(), members.begin());
@@ -1885,8 +1917,9 @@ Id Builder::makeCompositeConstant(Id typeId, const std::vector<Id>& members, boo
     case OpTypeMatrix:
     case OpTypeCooperativeMatrixKHR:
     case OpTypeCooperativeMatrixNV:
+    case OpTypeCooperativeVectorNV:
         if (! specConstant) {
-            Id existing = findCompositeConstant(typeClass, typeId, members);
+            Id existing = findCompositeConstant(typeClass, opcode, typeId, members, numMembers);
             if (existing)
                 return existing;
         }
@@ -3021,7 +3054,7 @@ Id Builder::smearScalar(Decoration precision, Id scalar, Id vectorType)
     assert(getTypeId(scalar) == getScalarTypeId(vectorType));
 
     int numComponents = getNumTypeComponents(vectorType);
-    if (numComponents == 1)
+    if (numComponents == 1 && !isCooperativeVectorType(vectorType))
         return scalar;
 
     Instruction* smear = nullptr;
@@ -3038,7 +3071,7 @@ Id Builder::smearScalar(Decoration precision, Id scalar, Id vectorType)
         auto result_id = makeCompositeConstant(vectorType, members, isSpecConstant(scalar));
         smear = module.getInstruction(result_id);
     } else {
-        bool replicate = useReplicatedComposites && (numComponents > 0);
+        bool replicate = (useReplicatedComposites || isCooperativeVectorType(vectorType)) && (numComponents > 0);
 
         if (replicate) {
             numComponents = 1;
@@ -3152,6 +3185,9 @@ Id Builder::createTextureCall(Decoration precision, Id resultType, bool sparse,
     if (parameters.volatil) {
         mask = mask | ImageOperandsVolatileTexelKHRMask;
     }
+    if (parameters.nontemporal) {
+        mask = mask | ImageOperandsNontemporalMask;
+    }
     mask = mask | signExtensionMask;
     // insert the operand for the mask, if any bits were set.
     if (mask != ImageOperandsMaskNone)
@@ -3425,7 +3461,8 @@ Id Builder::createCompositeCompare(Decoration precision, Id value1, Id value2, b
 Id Builder::createCompositeConstruct(Id typeId, const std::vector<Id>& constituents)
 {
     assert(isAggregateType(typeId) || (getNumTypeConstituents(typeId) > 1 &&
-           getNumTypeConstituents(typeId) == constituents.size()));
+           getNumTypeConstituents(typeId) == constituents.size()) ||
+           (isCooperativeVectorType(typeId) && constituents.size() == 1));
 
     if (generatingOpCodeForSpecConst) {
         // Sometime, even in spec-constant-op mode, the constant composite to be
@@ -3444,7 +3481,7 @@ Id Builder::createCompositeConstruct(Id typeId, const std::vector<Id>& constitue
     bool replicate = false;
     size_t numConstituents = constituents.size();
 
-    if (useReplicatedComposites) {
+    if (useReplicatedComposites || isCooperativeVectorType(typeId)) {
         replicate = numConstituents > 0 &&
             std::equal(constituents.begin() + 1, constituents.end(), constituents.begin());
     }
@@ -3510,7 +3547,7 @@ Id Builder::createConstructor(Decoration precision, const std::vector<Id>& sourc
 
     // Special case: when calling a vector constructor with a single scalar
     // argument, smear the scalar
-    if (sources.size() == 1 && isScalar(sources[0]) && numTargetComponents > 1)
+    if (sources.size() == 1 && isScalar(sources[0]) && (numTargetComponents > 1 || isCooperativeVectorType(resultTypeId)))
         return smearScalar(precision, sources[0], resultTypeId);
 
     // Special case: 2 vectors of equal size
@@ -3574,7 +3611,7 @@ Id Builder::createConstructor(Decoration precision, const std::vector<Id>& sourc
 
         if (isScalar(sources[i]) || isPointer(sources[i]))
             latchResult(sources[i]);
-        else if (isVector(sources[i]))
+        else if (isVector(sources[i]) || isCooperativeVector(sources[i]))
             accumulateVectorConstituents(sources[i]);
         else if (isMatrix(sources[i]))
             accumulateMatrixConstituents(sources[i]);
@@ -4021,6 +4058,9 @@ Id Builder::accessChainLoad(Decoration precision, Decoration l_nonUniform,
             if (constant) {
                 id = createCompositeExtract(accessChain.base, swizzleBase, indexes);
                 setPrecision(id, precision);
+            } else if (isCooperativeVector(accessChain.base)) {
+                assert(accessChain.indexChain.size() == 1);
+                id = createVectorExtractDynamic(accessChain.base, resultType, accessChain.indexChain[0]);
             } else {
                 Id lValue = NoResult;
                 if (spvVersion >= Spv_1_4 && isValidInitializer(accessChain.base)) {

3rdparty/glslang/SPIRV/SpvBuilder.h

@@ -75,6 +75,7 @@ typedef enum {
     Spv_1_3 = (1 << 16) | (3 << 8),
     Spv_1_4 = (1 << 16) | (4 << 8),
     Spv_1_5 = (1 << 16) | (5 << 8),
+    Spv_1_6 = (1 << 16) | (6 << 8),
 } SpvVersion;
 
 class Builder {
@@ -216,6 +217,7 @@ public:
     Id makeCooperativeMatrixTypeKHR(Id component, Id scope, Id rows, Id cols, Id use);
     Id makeCooperativeMatrixTypeNV(Id component, Id scope, Id rows, Id cols);
     Id makeCooperativeMatrixTypeWithSameShape(Id component, Id otherType);
+    Id makeCooperativeVectorTypeNV(Id componentType, Id components);
     Id makeGenericType(spv::Op opcode, std::vector<spv::IdImmediate>& operands);
 
     // SPIR-V NonSemantic Shader DebugInfo Instructions
@@ -280,12 +282,14 @@ public:
         { return (ImageFormat)module.getInstruction(typeId)->getImmediateOperand(6); }
     Id getResultingAccessChainType() const;
     Id getIdOperand(Id resultId, int idx) { return module.getInstruction(resultId)->getIdOperand(idx); }
+    Id getCooperativeVectorNumComponents(Id typeId) const { return module.getInstruction(typeId)->getIdOperand(1); }
 
     bool isPointer(Id resultId)      const { return isPointerType(getTypeId(resultId)); }
     bool isScalar(Id resultId)       const { return isScalarType(getTypeId(resultId)); }
     bool isVector(Id resultId)       const { return isVectorType(getTypeId(resultId)); }
     bool isMatrix(Id resultId)       const { return isMatrixType(getTypeId(resultId)); }
     bool isCooperativeMatrix(Id resultId)const { return isCooperativeMatrixType(getTypeId(resultId)); }
+    bool isCooperativeVector(Id resultId)const { return isCooperativeVectorType(getTypeId(resultId)); }
     bool isAggregate(Id resultId)    const { return isAggregateType(getTypeId(resultId)); }
     bool isSampledImage(Id resultId) const { return isSampledImageType(getTypeId(resultId)); }
     bool isTensorView(Id resultId)const { return isTensorViewType(getTypeId(resultId)); }
@@ -310,6 +314,7 @@ public:
         return getTypeClass(typeId) == OpTypeCooperativeMatrixKHR || getTypeClass(typeId) == OpTypeCooperativeMatrixNV;
     }
     bool isTensorViewType(Id typeId)   const { return getTypeClass(typeId) == OpTypeTensorViewNV; }
+    bool isCooperativeVectorType(Id typeId)const { return getTypeClass(typeId) == OpTypeCooperativeVectorNV; }
     bool isAggregateType(Id typeId)    const
         { return isArrayType(typeId) || isStructType(typeId) || isCooperativeMatrixType(typeId); }
     bool isImageType(Id typeId)        const { return getTypeClass(typeId) == OpTypeImage; }
@@ -586,6 +591,7 @@ public:
         Id coarse;
         bool nonprivate;
         bool volatil;
+        bool nontemporal;
     };
 
     // Select the correct texture operation based on all inputs, and emit the correct instruction
@@ -754,6 +760,7 @@ public:
             unsigned shadercallcoherent : 1;
             unsigned nonprivate : 1;
             unsigned volatil : 1;
+            unsigned nontemporal : 1;
             unsigned isImage : 1;
             unsigned nonUniform : 1;
 
@@ -766,6 +773,7 @@ public:
                 shadercallcoherent = 0;
                 nonprivate = 0;
                 volatil = 0;
+                nontemporal = 0;
                 isImage = 0;
                 nonUniform = 0;
             }
@@ -779,6 +787,7 @@ public:
                 shadercallcoherent |= other.shadercallcoherent;
                 nonprivate |= other.nonprivate;
                 volatil |= other.volatil;
+                nontemporal = other.nontemporal;
                 isImage |= other.isImage;
                 nonUniform |= other.nonUniform;
                 return *this;
@@ -898,7 +907,7 @@ public:
  protected:
     Id findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned value);
     Id findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned v1, unsigned v2);
-    Id findCompositeConstant(Op typeClass, Id typeId, const std::vector<Id>& comps);
+    Id findCompositeConstant(Op typeClass, Op opcode, Id typeId, const std::vector<Id>& comps, size_t numMembers);
     Id findStructConstant(Id typeId, const std::vector<Id>& comps);
     Id collapseAccessChain();
     void remapDynamicSwizzle();

3rdparty/glslang/SPIRV/SpvTools.cpp

@@ -165,6 +165,7 @@ void SpirvToolsValidate(const glslang::TIntermediate& intermediate, std::vector<
     spvValidatorOptionsSetBeforeHlslLegalization(options, prelegalization);
     spvValidatorOptionsSetScalarBlockLayout(options, intermediate.usingScalarBlockLayout());
     spvValidatorOptionsSetWorkgroupScalarBlockLayout(options, intermediate.usingScalarBlockLayout());
+    spvValidatorOptionsSetAllowOffsetTextureOperand(options, intermediate.usingTextureOffsetNonConst());
     spvValidateWithOptions(context, options, &binary, &diagnostic);
 
     // report

3rdparty/glslang/SPIRV/doc.cpp

@@ -424,6 +424,12 @@ const char* BuiltInString(int builtIn)
     case BuiltInHitMicroTriangleVertexBarycentricsNV: return "HitMicroTriangleVertexBarycentricsNV";
     case BuiltInHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV";
     case BuiltInHitKindBackFacingMicroTriangleNV: return "HitKindBackFacingMicroTriangleNV";
+    case BuiltInHitIsSphereNV:               return "HitIsSphereNV";
+    case BuiltInHitIsLSSNV:                  return "HitIsLSSNV";
+    case BuiltInHitSpherePositionNV:         return "HitSpherePositionNV";
+    case BuiltInHitSphereRadiusNV:           return "HitSphereRadiusNV";
+    case BuiltInHitLSSPositionsNV:           return "HitLSSPositionsNV";
+    case BuiltInHitLSSRadiiNV:               return "HitLLSSRadiiNV";
     case BuiltInInstanceCustomIndexKHR:      return "InstanceCustomIndexKHR";
     case BuiltInRayGeometryIndexKHR:         return "RayGeometryIndexKHR";
     case BuiltInObjectToWorldKHR:            return "ObjectToWorldKHR";
@@ -440,6 +446,7 @@ const char* BuiltInString(int builtIn)
 //    case BuiltInInvocationsPerPixelNV:      return "InvocationsPerPixelNV"; // superseded by BuiltInFragInvocationCountEXT
     case BuiltInBaryCoordKHR:                return "BaryCoordKHR";
     case BuiltInBaryCoordNoPerspKHR:         return "BaryCoordNoPerspKHR";
+    case BuiltInClusterIDNV:                 return "ClusterIDNV";
 
     case BuiltInFragSizeEXT:                 return "FragSizeEXT";
     case BuiltInFragInvocationCountEXT:      return "FragInvocationCountEXT";
@@ -630,7 +637,7 @@ const char* ImageChannelDataTypeString(int type)
     }
 }
 
-const int ImageOperandsCeiling = 14;
+const int ImageOperandsCeiling = 15;
 
 const char* ImageOperandsString(int format)
 {
@@ -649,6 +656,7 @@ const char* ImageOperandsString(int format)
     case ImageOperandsVolatileTexelKHRShift:        return "VolatileTexelKHR";
     case ImageOperandsSignExtendShift:              return "SignExtend";
     case ImageOperandsZeroExtendShift:              return "ZeroExtend";
+    case ImageOperandsNontemporalShift:             return "Nontemporal";
 
     case ImageOperandsCeiling:
     default:
@@ -1046,6 +1054,9 @@ const char* CapabilityString(int info)
 
     case CapabilityShaderSMBuiltinsNV:      return "ShaderSMBuiltinsNV";
 
+    case CapabilityCooperativeVectorNV:                     return "CooperativeVectorNV";
+    case CapabilityCooperativeVectorTrainingNV:             return "CooperativeVectorTrainingNV";
+
     case CapabilityFragmentShaderSampleInterlockEXT:        return "CapabilityFragmentShaderSampleInterlockEXT";
     case CapabilityFragmentShaderPixelInterlockEXT:         return "CapabilityFragmentShaderPixelInterlockEXT";
     case CapabilityFragmentShaderShadingRateInterlockEXT:   return "CapabilityFragmentShaderShadingRateInterlockEXT";
@@ -1089,6 +1100,15 @@ const char* CapabilityString(int info)
 
     case CapabilityReplicatedCompositesEXT:             return "CapabilityReplicatedCompositesEXT";
 
+    case CapabilityDotProductKHR:                       return "DotProductKHR";
+    case CapabilityDotProductInputAllKHR:               return "DotProductInputAllKHR";
+    case CapabilityDotProductInput4x8BitKHR:            return "DotProductInput4x8BitKHR";
+    case CapabilityDotProductInput4x8BitPackedKHR:      return "DotProductInput4x8BitPackedKHR";
+
+    case CapabilityRayTracingClusterAccelerationStructureNV:   return "RayTracingClusterAccelerationStructureNV";
+
+    case CapabilityRayTracingSpheresGeometryNV:             return "RayTracingSpheresGeometryNV";
+    case CapabilityRayTracingLinearSweptSpheresGeometryNV:  return "RayTracingLinearSweptSpheresGeometryNV";
     default: return "Bad";
     }
 }
@@ -1541,6 +1561,15 @@ const char* OpcodeString(int op)
     case OpRayQueryGetIntersectionObjectToWorldKHR:                           return "OpRayQueryGetIntersectionObjectToWorldKHR";
     case OpRayQueryGetIntersectionWorldToObjectKHR:                           return "OpRayQueryGetIntersectionWorldToObjectKHR";
     case OpRayQueryGetIntersectionTriangleVertexPositionsKHR:                 return "OpRayQueryGetIntersectionTriangleVertexPositionsKHR";
+    case OpRayQueryGetIntersectionClusterIdNV:                                return "OpRayQueryGetIntersectionClusterIdNV";
+
+    case OpRayQueryGetIntersectionSpherePositionNV:                           return "OpRayQueryGetIntersectionSpherePositionNV";
+    case OpRayQueryGetIntersectionSphereRadiusNV:                             return "OpRayQueryGetIntersectionSphereRadiusNV";
+    case OpRayQueryGetIntersectionLSSHitValueNV:                              return "OpRayQueryGetIntersectionLSSHitValueNV";
+    case OpRayQueryGetIntersectionLSSPositionsNV:                             return "OpRayQueryGetIntersectionLSSPositionsNV";
+    case OpRayQueryGetIntersectionLSSRadiiNV:                                 return "OpRayQueryGetIntersectionLSSRadiiNV";
+    case OpRayQueryIsSphereHitNV:                                             return "OpRayQueryIsSphereHitNV";
+    case OpRayQueryIsLSSHitNV:                                                return "OpRayQueryIsLSSHitNV";
 
     case OpTypeCooperativeMatrixNV:         return "OpTypeCooperativeMatrixNV";
     case OpCooperativeMatrixLoadNV:         return "OpCooperativeMatrixLoadNV";
@@ -1574,6 +1603,14 @@ const char* OpcodeString(int op)
     case OpTensorViewSetStrideNV:           return "OpTensorViewSetStrideNV";
     case OpTensorViewSetClipNV:             return "OpTensorViewSetClipNV";
 
+    case OpTypeCooperativeVectorNV:         return "OpTypeCooperativeVectorNV";
+    case OpCooperativeVectorMatrixMulNV:    return "OpCooperativeVectorMatrixMulNV";
+    case OpCooperativeVectorMatrixMulAddNV: return "OpCooperativeVectorMatrixMulAddNV";
+    case OpCooperativeVectorLoadNV:         return "OpCooperativeVectorLoadNV";
+    case OpCooperativeVectorStoreNV:        return "OpCooperativeVectorStoreNV";
+    case OpCooperativeVectorOuterProductAccumulateNV:   return "OpCooperativeVectorOuterProductAccumulateNV";
+    case OpCooperativeVectorReduceSumAccumulateNV:      return "OpCooperativeVectorReduceSumAccumulateNV";
+
     case OpBeginInvocationInterlockEXT:     return "OpBeginInvocationInterlockEXT";
     case OpEndInvocationInterlockEXT:       return "OpEndInvocationInterlockEXT";
 
@@ -1610,6 +1647,13 @@ const char* OpcodeString(int op)
     case OpHitObjectIsMissNV:                   return "OpHitObjectIsMissNV";
     case OpHitObjectGetShaderBindingTableRecordIndexNV: return "OpHitObjectGetShaderBindingTableRecordIndexNV";
     case OpHitObjectGetShaderRecordBufferHandleNV:   return "OpHitObjectGetShaderRecordBufferHandleNV";
+    case OpHitObjectGetClusterIdNV:             return "OpHitObjectGetClusterIdNV";
+    case OpHitObjectGetSpherePositionNV:        return "OpHitObjectGetSpherePositionNV";
+    case OpHitObjectGetSphereRadiusNV:          return "OpHitObjectGetSphereRadiusNV";
+    case OpHitObjectGetLSSPositionsNV:          return "OpHitObjectGetLSSPositionsNV";
+    case OpHitObjectGetLSSRadiiNV:              return "OpHitObjectGetLSSRadiiNV";
+    case OpHitObjectIsSphereHitNV:              return "OpHitObjectIsSphereHitNV";
+    case OpHitObjectIsLSSHitNV:                 return "OpHitObjectIsLSSHitNV";
 
     case OpFetchMicroTriangleVertexBarycentricNV:       return "OpFetchMicroTriangleVertexBarycentricNV";
     case OpFetchMicroTriangleVertexPositionNV:    return "OpFetchMicroTriangleVertexPositionNV";
@@ -1631,6 +1675,13 @@ const char* OpcodeString(int op)
     case OpSpecConstantCompositeReplicateEXT: return "OpSpecConstantCompositeReplicateEXT";
     case OpCompositeConstructReplicateEXT: return "OpCompositeConstructReplicateEXT";
 
+    case OpSDotKHR: return "OpSDotKHR";
+    case OpUDotKHR: return "OpUDotKHR";
+    case OpSUDotKHR: return "OpSUDotKHR";
+    case OpSDotAccSatKHR: return "OpSDotAccSatKHR";
+    case OpUDotAccSatKHR: return "OpUDotAccSatKHR";
+    case OpSUDotAccSatKHR: return "OpSUDotAccSatKHR";
+
     default:
         return "Bad";
     }
@@ -1754,6 +1805,11 @@ void Parameterize()
         InstructionDesc[OpTypeTensorLayoutNV].setResultAndType(true, false);
         InstructionDesc[OpTypeTensorViewNV].setResultAndType(true, false);
         InstructionDesc[OpCooperativeMatrixStoreTensorNV].setResultAndType(false, false);
+        InstructionDesc[OpTypeCooperativeVectorNV].setResultAndType(true, false);
+        InstructionDesc[OpCooperativeVectorStoreNV].setResultAndType(false, false);
+        InstructionDesc[OpCooperativeVectorOuterProductAccumulateNV].setResultAndType(false, false);
+        InstructionDesc[OpCooperativeVectorReduceSumAccumulateNV].setResultAndType(false, false);
+
         // Specific additional context-dependent operands
 
         ExecutionModeOperands[ExecutionModeInvocations].push(OperandLiteralNumber, "'Number of <<Invocation,invocations>>'");
@@ -3185,6 +3241,37 @@ void Parameterize()
         InstructionDesc[OpRayQueryGetIntersectionTriangleVertexPositionsKHR].operands.push(OperandId, "'Committed'");
         InstructionDesc[OpRayQueryGetIntersectionTriangleVertexPositionsKHR].setResultAndType(true, true);
 
+        InstructionDesc[OpRayQueryGetIntersectionClusterIdNV].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionClusterIdNV].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionClusterIdNV].setResultAndType(true, true);
+        InstructionDesc[OpRayQueryGetIntersectionSpherePositionNV].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionSpherePositionNV].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionSpherePositionNV].setResultAndType(true, true);
+
+        InstructionDesc[OpRayQueryGetIntersectionSphereRadiusNV].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionSphereRadiusNV].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionSphereRadiusNV].setResultAndType(true, true);
+
+        InstructionDesc[OpRayQueryGetIntersectionLSSHitValueNV].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionLSSHitValueNV].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionLSSHitValueNV].setResultAndType(true, true);
+
+        InstructionDesc[OpRayQueryGetIntersectionLSSPositionsNV].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionLSSPositionsNV].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionLSSPositionsNV].setResultAndType(true, true);
+
+        InstructionDesc[OpRayQueryGetIntersectionLSSRadiiNV].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryGetIntersectionLSSRadiiNV].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryGetIntersectionLSSRadiiNV].setResultAndType(true, true);
+
+        InstructionDesc[OpRayQueryIsSphereHitNV].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryIsSphereHitNV].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryIsSphereHitNV].setResultAndType(true, true);
+
+        InstructionDesc[OpRayQueryIsLSSHitNV].operands.push(OperandId, "'RayQuery'");
+        InstructionDesc[OpRayQueryIsLSSHitNV].operands.push(OperandId, "'Committed'");
+        InstructionDesc[OpRayQueryIsLSSHitNV].setResultAndType(true, true);
+
         InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Sampled Image'");
         InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coordinate'");
         InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Granularity'");
@@ -3260,6 +3347,61 @@ void Parameterize()
 
         InstructionDesc[OpCooperativeMatrixLengthKHR].operands.push(OperandId, "'Type'");
 
+        InstructionDesc[OpTypeCooperativeVectorNV].operands.push(OperandId, "'Component Type'");
+        InstructionDesc[OpTypeCooperativeVectorNV].operands.push(OperandId, "'Components'");
+
+        InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'Input'");
+        InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'InputInterpretation'");
+        InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'Matrix'");
+        InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'MatrixOffset'");
+        InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'MatrixInterpretation'");
+        InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'M'");
+        InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'K'");
+        InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'MemoryLayout'");
+        InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'Transpose'");
+        InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandId, "'MatrixStride'", true);
+        InstructionDesc[OpCooperativeVectorMatrixMulNV].operands.push(OperandCooperativeMatrixOperands, "'Cooperative Matrix Operands'", true);
+
+        InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'Input'");
+        InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'InputInterpretation'");
+        InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'Matrix'");
+        InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'MatrixOffset'");
+        InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'MatrixInterpretation'");
+        InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'Bias'");
+        InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'BiasOffset'");
+        InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'BiasInterpretation'");
+        InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'M'");
+        InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'K'");
+        InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'MemoryLayout'");
+        InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'Transpose'");
+        InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandId, "'MatrixStride'", true);
+        InstructionDesc[OpCooperativeVectorMatrixMulAddNV].operands.push(OperandCooperativeMatrixOperands, "'Cooperative Matrix Operands'", true);
+
+        InstructionDesc[OpCooperativeVectorLoadNV].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpCooperativeVectorLoadNV].operands.push(OperandId, "'Offset'");
+        InstructionDesc[OpCooperativeVectorLoadNV].operands.push(OperandMemoryAccess, "'Memory Access'");
+        InstructionDesc[OpCooperativeVectorLoadNV].operands.push(OperandLiteralNumber, "", true);
+        InstructionDesc[OpCooperativeVectorLoadNV].operands.push(OperandId, "", true);
+
+        InstructionDesc[OpCooperativeVectorStoreNV].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpCooperativeVectorStoreNV].operands.push(OperandId, "'Offset'");
+        InstructionDesc[OpCooperativeVectorStoreNV].operands.push(OperandId, "'Object'");
+        InstructionDesc[OpCooperativeVectorStoreNV].operands.push(OperandMemoryAccess, "'Memory Access'");
+        InstructionDesc[OpCooperativeVectorStoreNV].operands.push(OperandLiteralNumber, "", true);
+        InstructionDesc[OpCooperativeVectorStoreNV].operands.push(OperandId, "", true);
+
+        InstructionDesc[OpCooperativeVectorOuterProductAccumulateNV].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpCooperativeVectorOuterProductAccumulateNV].operands.push(OperandId, "'Offset'");
+        InstructionDesc[OpCooperativeVectorOuterProductAccumulateNV].operands.push(OperandId, "'A'");
+        InstructionDesc[OpCooperativeVectorOuterProductAccumulateNV].operands.push(OperandId, "'B'");
+        InstructionDesc[OpCooperativeVectorOuterProductAccumulateNV].operands.push(OperandId, "'MemoryLayout'");
+        InstructionDesc[OpCooperativeVectorOuterProductAccumulateNV].operands.push(OperandId, "'MatrixInterpretation'");
+        InstructionDesc[OpCooperativeVectorOuterProductAccumulateNV].operands.push(OperandId, "'MatrixStride'", true);
+
+        InstructionDesc[OpCooperativeVectorReduceSumAccumulateNV].operands.push(OperandId, "'Pointer'");
+        InstructionDesc[OpCooperativeVectorReduceSumAccumulateNV].operands.push(OperandId, "'Offset'");
+        InstructionDesc[OpCooperativeVectorReduceSumAccumulateNV].operands.push(OperandId, "'V'");
+
         InstructionDesc[OpDemoteToHelperInvocationEXT].setResultAndType(false, false);
 
         InstructionDesc[OpReadClockKHR].operands.push(OperandScope, "'Scope'");
@@ -3449,6 +3591,26 @@ void Parameterize()
         InstructionDesc[OpHitObjectTraceRayMotionNV].operands.push(OperandId, "'Payload'");
         InstructionDesc[OpHitObjectTraceRayMotionNV].setResultAndType(false, false);
 
+        InstructionDesc[OpHitObjectGetClusterIdNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetClusterIdNV].setResultAndType(true, true);
+        InstructionDesc[OpHitObjectGetSpherePositionNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetSpherePositionNV].setResultAndType(true, true);
+
+        InstructionDesc[OpHitObjectGetSphereRadiusNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetSphereRadiusNV].setResultAndType(true, true);
+
+        InstructionDesc[OpHitObjectGetLSSPositionsNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetLSSPositionsNV].setResultAndType(true, true);
+
+        InstructionDesc[OpHitObjectGetLSSRadiiNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectGetLSSRadiiNV].setResultAndType(true, true);
+
+        InstructionDesc[OpHitObjectIsSphereHitNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectIsSphereHitNV].setResultAndType(true, true);
+
+        InstructionDesc[OpHitObjectIsLSSHitNV].operands.push(OperandId, "'HitObject'");
+        InstructionDesc[OpHitObjectIsLSSHitNV].setResultAndType(true, true);
+
         InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Acceleration Structure'");
         InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Instance ID'");
         InstructionDesc[OpFetchMicroTriangleVertexBarycentricNV].operands.push(OperandId, "'Geometry Index'");
@@ -3592,6 +3754,33 @@ void Parameterize()
         InstructionDesc[OpTensorViewSetClipNV].operands.push(OperandId, "'ClipRowSpan'");
         InstructionDesc[OpTensorViewSetClipNV].operands.push(OperandId, "'ClipColOffset'");
         InstructionDesc[OpTensorViewSetClipNV].operands.push(OperandId, "'ClipColSpan'");
+
+        InstructionDesc[OpSDotKHR].operands.push(OperandId, "'Vector1'");
+        InstructionDesc[OpSDotKHR].operands.push(OperandId, "'Vector2'");
+        InstructionDesc[OpSDotKHR].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");
+
+        InstructionDesc[OpUDotKHR].operands.push(OperandId, "'Vector1'");
+        InstructionDesc[OpUDotKHR].operands.push(OperandId, "'Vector2'");
+        InstructionDesc[OpUDotKHR].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");
+
+        InstructionDesc[OpSUDotKHR].operands.push(OperandId, "'Vector1'");
+        InstructionDesc[OpSUDotKHR].operands.push(OperandId, "'Vector2'");
+        InstructionDesc[OpSUDotKHR].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");
+
+        InstructionDesc[OpSDotAccSatKHR].operands.push(OperandId, "'Vector1'");
+        InstructionDesc[OpSDotAccSatKHR].operands.push(OperandId, "'Vector2'");
+        InstructionDesc[OpSDotAccSatKHR].operands.push(OperandId, "'Accumulator'");
+        InstructionDesc[OpSDotAccSatKHR].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");
+
+        InstructionDesc[OpUDotAccSatKHR].operands.push(OperandId, "'Vector1'");
+        InstructionDesc[OpUDotAccSatKHR].operands.push(OperandId, "'Vector2'");
+        InstructionDesc[OpUDotAccSatKHR].operands.push(OperandId, "'Accumulator'");
+        InstructionDesc[OpUDotAccSatKHR].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");
+
+        InstructionDesc[OpSUDotAccSatKHR].operands.push(OperandId, "'Vector1'");
+        InstructionDesc[OpSUDotAccSatKHR].operands.push(OperandId, "'Vector2'");
+        InstructionDesc[OpSUDotAccSatKHR].operands.push(OperandId, "'Accumulator'");
+        InstructionDesc[OpSUDotAccSatKHR].operands.push(OperandLiteralNumber, "'PackedVectorFormat'");
     });
 }
 

3rdparty/glslang/SPIRV/spirv.hpp

@@ -780,12 +780,19 @@ enum BuiltIn {
     BuiltInIncomingRayFlagsKHR = 5351,
     BuiltInIncomingRayFlagsNV = 5351,
     BuiltInRayGeometryIndexKHR = 5352,
+    BuiltInHitIsSphereNV = 5359,
+    BuiltInHitIsLSSNV = 5360,
+    BuiltInHitSpherePositionNV = 5361,
     BuiltInWarpsPerSMNV = 5374,
     BuiltInSMCountNV = 5375,
     BuiltInWarpIDNV = 5376,
     BuiltInSMIDNV = 5377,
+    BuiltInHitLSSPositionsNV = 5396,
     BuiltInHitKindFrontFacingMicroTriangleNV = 5405,
     BuiltInHitKindBackFacingMicroTriangleNV = 5406,
+    BuiltInHitSphereRadiusNV = 5420,
+    BuiltInHitLSSRadiiNV = 5421,
+    BuiltInClusterIDNV = 5436,
     BuiltInCullMaskKHR = 6021,
     BuiltInMax = 0x7fffffff,
 };
@@ -1167,14 +1174,19 @@ enum Capability {
     CapabilityShaderInvocationReorderNV = 5383,
     CapabilityBindlessTextureNV = 5390,
     CapabilityRayQueryPositionFetchKHR = 5391,
+    CapabilityCooperativeVectorNV = 5394,
     CapabilityAtomicFloat16VectorNV = 5404,
     CapabilityRayTracingDisplacementMicromapNV = 5409,
     CapabilityRawAccessChainsNV = 5414,
+    CapabilityRayTracingSpheresGeometryNV = 5418,
+    CapabilityRayTracingLinearSweptSpheresGeometryNV = 5419,
     CapabilityCooperativeMatrixReductionsNV = 5430,
     CapabilityCooperativeMatrixConversionsNV = 5431,
     CapabilityCooperativeMatrixPerElementOperationsNV = 5432,
     CapabilityCooperativeMatrixTensorAddressingNV = 5433,
     CapabilityCooperativeMatrixBlockLoadsNV = 5434,
+    CapabilityCooperativeVectorTrainingNV = 5435,
+    CapabilityRayTracingClusterAccelerationStructureNV = 5437,
     CapabilityTensorAddressingNV = 5439,
     CapabilitySubgroupShuffleINTEL = 5568,
     CapabilitySubgroupBufferBlockIOINTEL = 5569,
@@ -1480,6 +1492,33 @@ enum FPEncoding {
     FPEncodingMax = 0x7fffffff,
 };
 
+enum CooperativeVectorMatrixLayout {
+    CooperativeVectorMatrixLayoutRowMajorNV = 0,
+    CooperativeVectorMatrixLayoutColumnMajorNV = 1,
+    CooperativeVectorMatrixLayoutInferencingOptimalNV = 2,
+    CooperativeVectorMatrixLayoutTrainingOptimalNV = 3,
+    CooperativeVectorMatrixLayoutMax = 0x7fffffff,
+};
+
+enum ComponentType {
+    ComponentTypeFloat16NV = 0,
+    ComponentTypeFloat32NV = 1,
+    ComponentTypeFloat64NV = 2,
+    ComponentTypeSignedInt8NV = 3,
+    ComponentTypeSignedInt16NV = 4,
+    ComponentTypeSignedInt32NV = 5,
+    ComponentTypeSignedInt64NV = 6,
+    ComponentTypeUnsignedInt8NV = 7,
+    ComponentTypeUnsignedInt16NV = 8,
+    ComponentTypeUnsignedInt32NV = 9,
+    ComponentTypeUnsignedInt64NV = 10,
+    ComponentTypeSignedInt8PackedNV = 1000491000,
+    ComponentTypeUnsignedInt8PackedNV = 1000491001,
+    ComponentTypeFloatE4M3NV = 1000491002,
+    ComponentTypeFloatE5M2NV = 1000491003,
+    ComponentTypeMax = 0x7fffffff,
+};
+
 enum Op {
     OpNop = 0,
     OpUndef = 1,
@@ -1940,6 +1979,11 @@ enum Op {
     OpReorderThreadWithHintNV = 5280,
     OpTypeHitObjectNV = 5281,
     OpImageSampleFootprintNV = 5283,
+    OpTypeCooperativeVectorNV = 5288,
+    OpCooperativeVectorMatrixMulNV = 5289,
+    OpCooperativeVectorOuterProductAccumulateNV = 5290,
+    OpCooperativeVectorReduceSumAccumulateNV = 5291,
+    OpCooperativeVectorMatrixMulAddNV = 5292,
     OpCooperativeMatrixConvertNV = 5293,
     OpEmitMeshTasksEXT = 5294,
     OpSetMeshOutputsEXT = 5295,
@@ -1947,6 +1991,8 @@ enum Op {
     OpWritePackedPrimitiveIndices4x8NV = 5299,
     OpFetchMicroTriangleVertexPositionNV = 5300,
     OpFetchMicroTriangleVertexBarycentricNV = 5301,
+    OpCooperativeVectorLoadNV = 5302,
+    OpCooperativeVectorStoreNV = 5303,
     OpReportIntersectionKHR = 5334,
     OpReportIntersectionNV = 5334,
     OpIgnoreIntersectionNV = 5335,
@@ -1958,6 +2004,8 @@ enum Op {
     OpTypeAccelerationStructureKHR = 5341,
     OpTypeAccelerationStructureNV = 5341,
     OpExecuteCallableNV = 5344,
+    OpRayQueryGetIntersectionClusterIdNV = 5345,
+    OpHitObjectGetClusterIdNV = 5346,
     OpTypeCooperativeMatrixNV = 5358,
     OpCooperativeMatrixLoadNV = 5359,
     OpCooperativeMatrixStoreNV = 5360,
@@ -1993,6 +2041,19 @@ enum Op {
     OpConvertSampledImageToUNV = 5396,
     OpSamplerImageAddressingModeNV = 5397,
     OpRawAccessChainNV = 5398,
+    OpRayQueryGetIntersectionSpherePositionNV = 5427,
+    OpRayQueryGetIntersectionSphereRadiusNV = 5428,
+    OpRayQueryGetIntersectionLSSPositionsNV = 5429,
+    OpRayQueryGetIntersectionLSSRadiiNV = 5430,
+    OpRayQueryGetIntersectionLSSHitValueNV = 5431,
+    OpHitObjectGetSpherePositionNV = 5432,
+    OpHitObjectGetSphereRadiusNV = 5433,
+    OpHitObjectGetLSSPositionsNV = 5434,
+    OpHitObjectGetLSSRadiiNV = 5435,
+    OpHitObjectIsSphereHitNV = 5436,
+    OpHitObjectIsLSSHitNV = 5437,
+    OpRayQueryIsSphereHitNV = 5438,
+    OpRayQueryIsLSSHitNV = 5439,
     OpSubgroupShuffleINTEL = 5571,
     OpSubgroupShuffleDownINTEL = 5572,
     OpSubgroupShuffleUpINTEL = 5573,
@@ -2711,10 +2772,16 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
     case OpHitObjectIsEmptyNV: *hasResult = true; *hasResultType = true; break;
     case OpHitObjectIsHitNV: *hasResult = true; *hasResultType = true; break;
     case OpHitObjectIsMissNV: *hasResult = true; *hasResultType = true; break;
+    case OpHitObjectGetClusterIdNV: *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 OpTypeCooperativeVectorNV: *hasResult = true; *hasResultType = false; break;
+    case OpCooperativeVectorMatrixMulNV: *hasResult = true; *hasResultType = true; break;
+    case OpCooperativeVectorOuterProductAccumulateNV: *hasResult = false; *hasResultType = false; break;
+    case OpCooperativeVectorReduceSumAccumulateNV: *hasResult = false; *hasResultType = false; break;
+    case OpCooperativeVectorMatrixMulAddNV: *hasResult = true; *hasResultType = true; break;
     case OpCooperativeMatrixConvertNV: *hasResult = true; *hasResultType = true; break;
     case OpEmitMeshTasksEXT: *hasResult = false; *hasResultType = false; break;
     case OpSetMeshOutputsEXT: *hasResult = false; *hasResultType = false; break;
@@ -2722,6 +2789,8 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
     case OpWritePackedPrimitiveIndices4x8NV: *hasResult = false; *hasResultType = false; break;
     case OpFetchMicroTriangleVertexPositionNV: *hasResult = true; *hasResultType = true; break;
     case OpFetchMicroTriangleVertexBarycentricNV: *hasResult = true; *hasResultType = true; break;
+    case OpCooperativeVectorLoadNV: *hasResult = true; *hasResultType = true; break;
+    case OpCooperativeVectorStoreNV: *hasResult = false; *hasResultType = false; break;
     case OpReportIntersectionKHR: *hasResult = true; *hasResultType = true; break;
     case OpIgnoreIntersectionNV: *hasResult = false; *hasResultType = false; break;
     case OpTerminateRayNV: *hasResult = false; *hasResultType = false; break;
@@ -2999,6 +3068,7 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
     case OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break;
     case OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break;
     case OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break;
+    case OpRayQueryGetIntersectionClusterIdNV: *hasResult = true; *hasResultType = true; break;
     case OpAtomicFAddEXT: *hasResult = true; *hasResultType = true; break;
     case OpTypeBufferSurfaceINTEL: *hasResult = true; *hasResultType = false; break;
     case OpTypeStructContinuedINTEL: *hasResult = false; *hasResultType = false; break;
@@ -3864,6 +3934,7 @@ inline const char* CapabilityToString(Capability value) {
     case CapabilityShaderInvocationReorderNV: return "ShaderInvocationReorderNV";
     case CapabilityBindlessTextureNV: return "BindlessTextureNV";
     case CapabilityRayQueryPositionFetchKHR: return "RayQueryPositionFetchKHR";
+    case CapabilityCooperativeVectorNV: return "CooperativeVectorNV";
     case CapabilityAtomicFloat16VectorNV: return "AtomicFloat16VectorNV";
     case CapabilityRayTracingDisplacementMicromapNV: return "RayTracingDisplacementMicromapNV";
     case CapabilityRawAccessChainsNV: return "RawAccessChainsNV";
@@ -3872,6 +3943,7 @@ inline const char* CapabilityToString(Capability value) {
     case CapabilityCooperativeMatrixPerElementOperationsNV: return "CooperativeMatrixPerElementOperationsNV";
     case CapabilityCooperativeMatrixTensorAddressingNV: return "CooperativeMatrixTensorAddressingNV";
     case CapabilityCooperativeMatrixBlockLoadsNV: return "CooperativeMatrixBlockLoadsNV";
+    case CapabilityCooperativeVectorTrainingNV: return "CooperativeVectorTrainingNV";
     case CapabilityTensorAddressingNV: return "TensorAddressingNV";
     case CapabilitySubgroupShuffleINTEL: return "SubgroupShuffleINTEL";
     case CapabilitySubgroupBufferBlockIOINTEL: return "SubgroupBufferBlockIOINTEL";
@@ -4104,6 +4176,37 @@ inline const char* FPEncodingToString(FPEncoding value) {
     }
 }
 
+inline const char* CooperativeVectorMatrixLayoutToString(CooperativeVectorMatrixLayout value) {
+    switch (value) {
+    case CooperativeVectorMatrixLayoutRowMajorNV: return "RowMajorNV";
+    case CooperativeVectorMatrixLayoutColumnMajorNV: return "ColumnMajorNV";
+    case CooperativeVectorMatrixLayoutInferencingOptimalNV: return "InferencingOptimalNV";
+    case CooperativeVectorMatrixLayoutTrainingOptimalNV: return "TrainingOptimalNV";
+    default: return "Unknown";
+    }
+}
+
+inline const char* ComponentTypeToString(ComponentType value) {
+    switch (value) {
+    case ComponentTypeFloat16NV: return "Float16NV";
+    case ComponentTypeFloat32NV: return "Float32NV";
+    case ComponentTypeFloat64NV: return "Float64NV";
+    case ComponentTypeSignedInt8NV: return "SignedInt8NV";
+    case ComponentTypeSignedInt16NV: return "SignedInt16NV";
+    case ComponentTypeSignedInt32NV: return "SignedInt32NV";
+    case ComponentTypeSignedInt64NV: return "SignedInt64NV";
+    case ComponentTypeUnsignedInt8NV: return "UnsignedInt8NV";
+    case ComponentTypeUnsignedInt16NV: return "UnsignedInt16NV";
+    case ComponentTypeUnsignedInt32NV: return "UnsignedInt32NV";
+    case ComponentTypeUnsignedInt64NV: return "UnsignedInt64NV";
+    case ComponentTypeSignedInt8PackedNV: return "SignedInt8PackedNV";
+    case ComponentTypeUnsignedInt8PackedNV: return "UnsignedInt8PackedNV";
+    case ComponentTypeFloatE4M3NV: return "FloatE4M3NV";
+    case ComponentTypeFloatE5M2NV: return "FloatE5M2NV";
+    default: return "Unknown";
+    }
+}
+
 inline const char* OpToString(Op value) {
     switch (value) {
     case OpNop: return "OpNop";
@@ -4559,6 +4662,11 @@ inline const char* OpToString(Op value) {
     case OpReorderThreadWithHintNV: return "OpReorderThreadWithHintNV";
     case OpTypeHitObjectNV: return "OpTypeHitObjectNV";
     case OpImageSampleFootprintNV: return "OpImageSampleFootprintNV";
+    case OpTypeCooperativeVectorNV: return "OpTypeCooperativeVectorNV";
+    case OpCooperativeVectorMatrixMulNV: return "OpCooperativeVectorMatrixMulNV";
+    case OpCooperativeVectorOuterProductAccumulateNV: return "OpCooperativeVectorOuterProductAccumulateNV";
+    case OpCooperativeVectorReduceSumAccumulateNV: return "OpCooperativeVectorReduceSumAccumulateNV";
+    case OpCooperativeVectorMatrixMulAddNV: return "OpCooperativeVectorMatrixMulAddNV";
     case OpCooperativeMatrixConvertNV: return "OpCooperativeMatrixConvertNV";
     case OpEmitMeshTasksEXT: return "OpEmitMeshTasksEXT";
     case OpSetMeshOutputsEXT: return "OpSetMeshOutputsEXT";
@@ -4566,6 +4674,8 @@ inline const char* OpToString(Op value) {
     case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV";
     case OpFetchMicroTriangleVertexPositionNV: return "OpFetchMicroTriangleVertexPositionNV";
     case OpFetchMicroTriangleVertexBarycentricNV: return "OpFetchMicroTriangleVertexBarycentricNV";
+    case OpCooperativeVectorLoadNV: return "OpCooperativeVectorLoadNV";
+    case OpCooperativeVectorStoreNV: return "OpCooperativeVectorStoreNV";
     case OpReportIntersectionKHR: return "OpReportIntersectionKHR";
     case OpIgnoreIntersectionNV: return "OpIgnoreIntersectionNV";
     case OpTerminateRayNV: return "OpTerminateRayNV";

3rdparty/glslang/StandAlone/StandAlone.cpp

@@ -60,6 +60,7 @@
 #include <memory>
 #include <set>
 #include <thread>
+#include <type_traits>
 
 #include "../glslang/OSDependent/osinclude.h"
 

3rdparty/glslang/glslang/Include/BaseTypes.h

@@ -70,6 +70,7 @@ enum TBasicType {
     EbtFunction,
     EbtTensorLayoutNV,
     EbtTensorViewNV,
+    EbtCoopvecNV,
     // SPIR-V type defined by spirv_type
     EbtSpirvType,
 
@@ -278,6 +279,7 @@ enum TBuiltInVariable {
     EbvWorldToObject3x4,
     EbvIncomingRayFlags,
     EbvCurrentRayTimeNV,
+    EbvClusterIDNV,
     // barycentrics
     EbvBaryCoordNV,
     EbvBaryCoordNoPerspNV,
@@ -298,6 +300,13 @@ enum TBuiltInVariable {
     EbvHitKindFrontFacingMicroTriangleNV,
     EbvHitKindBackFacingMicroTriangleNV,
 
+    EbvHitIsSphereNV,
+    EbvHitIsLSSNV,
+    EbvHitSpherePositionNV,
+    EbvHitSphereRadiusNV,
+    EbvHitLSSPositionsNV,
+    EbvHitLSSRadiiNV,
+
     //GL_EXT_mesh_shader
     EbvPrimitivePointIndicesEXT,
     EbvPrimitiveLineIndicesEXT,
@@ -502,6 +511,7 @@ __inline const char* GetBuiltInVariableString(TBuiltInVariable v)
     case EbvObjectToWorld:              return "ObjectToWorldNV";
     case EbvWorldToObject:              return "WorldToObjectNV";
     case EbvCurrentRayTimeNV:           return "CurrentRayTimeNV";
+    case EbvClusterIDNV:                return "ClusterIDNV";
 
     case EbvBaryCoordEXT:
     case EbvBaryCoordNV:                return "BaryCoordKHR";
@@ -533,6 +543,13 @@ __inline const char* GetBuiltInVariableString(TBuiltInVariable v)
     case EbvHitKindFrontFacingMicroTriangleNV: return "HitKindFrontFacingMicroTriangleNV";
     case EbvHitKindBackFacingMicroTriangleNV:  return "HitKindBackFacingMicroTriangleNV";
 
+    case EbvHitIsSphereNV:              return "HitIsSphereNV";
+    case EbvHitIsLSSNV:                 return "HitIsLSSNV";
+    case EbvHitSpherePositionNV:        return "HitSpherePositionNV";
+    case EbvHitSphereRadiusNV:          return "HitSphereRadiusNV";
+    case EbvHitLSSPositionsNV:          return "HitSpherePositionsNV";
+    case EbvHitLSSRadiiNV:              return "HitLSSRadiiNV";
+
     default:                      return "unknown built-in variable";
     }
 }

3rdparty/glslang/glslang/Include/Types.h

@@ -552,6 +552,7 @@ public:
         shadercallcoherent = false;
         nonprivate = false;
         volatil      = false;
+        nontemporal = false;
         restrict     = false;
         readonly     = false;
         writeonly    = false;
@@ -589,6 +590,7 @@ public:
     bool writeonly    : 1;
     bool coherent     : 1;
     bool volatil      : 1;
+    bool nontemporal  : 1;
     bool devicecoherent : 1;
     bool queuefamilycoherent : 1;
     bool workgroupcoherent : 1;
@@ -603,14 +605,15 @@ public:
     bool isRestrict() const { return restrict; }
     bool isCoherent() const { return coherent; }
     bool isVolatile() const { return volatil; }
+    bool isNonTemporal() const { return nontemporal; }
     bool isSample() const { return sample; }
     bool isMemory() const
     {
-        return shadercallcoherent || subgroupcoherent || workgroupcoherent || queuefamilycoherent || devicecoherent || coherent || volatil || restrict || readonly || writeonly || nonprivate;
+        return shadercallcoherent || subgroupcoherent || workgroupcoherent || queuefamilycoherent || devicecoherent || coherent || volatil || nontemporal || restrict || readonly || writeonly || nonprivate;
     }
     bool isMemoryQualifierImageAndSSBOOnly() const
     {
-        return shadercallcoherent || subgroupcoherent || workgroupcoherent || queuefamilycoherent || devicecoherent || coherent || volatil || restrict || readonly || writeonly;
+        return shadercallcoherent || subgroupcoherent || workgroupcoherent || queuefamilycoherent || devicecoherent || coherent || volatil || nontemporal || restrict || readonly || writeonly;
     }
     bool bufferReferenceNeedsVulkanMemoryModel() const
     {
@@ -1460,6 +1463,7 @@ public:
     uint32_t matrixRows  : 4;
     bool coopmatNV  : 1;
     bool coopmatKHR : 1;
+    bool coopvecNV  : 1;
     TArraySizes* arraySizes;
     const TType* userDef;
     TSourceLoc loc;
@@ -1470,6 +1474,8 @@ public:
     bool isCoopmat() const { return coopmatNV || coopmatKHR; }
     bool isCoopmatNV() const { return coopmatNV; }
     bool isCoopmatKHR() const { return coopmatKHR; }
+    bool isCoopvecNV() const { return coopvecNV; }
+    bool isCoopmatOrvec() const { return isCoopmat() || isCoopvecNV(); }
 
     bool isTensorLayoutNV() const { return basicType == EbtTensorLayoutNV; }
     bool isTensorViewNV() const { return basicType == EbtTensorViewNV; }
@@ -1486,6 +1492,7 @@ public:
         typeParameters = nullptr;
         coopmatNV = false;
         coopmatKHR = false;
+        coopvecNV = false;
         spirvType = nullptr;
     }
 
@@ -1545,7 +1552,7 @@ public:
     // for "empty" type (no args) or simple scalar/vector/matrix
     explicit TType(TBasicType t = EbtVoid, TStorageQualifier q = EvqTemporary, int vs = 1, int mc = 0, int mr = 0,
                    bool isVector = false) :
-                            basicType(t), vectorSize(static_cast<uint32_t>(vs) & 0b1111), matrixCols(static_cast<uint32_t>(mc) & 0b1111), matrixRows(static_cast<uint32_t>(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false),
+                            basicType(t), vectorSize(static_cast<uint32_t>(vs) & 0b1111), matrixCols(static_cast<uint32_t>(mc) & 0b1111), matrixRows(static_cast<uint32_t>(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false),
                             arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
@@ -1561,7 +1568,7 @@ public:
     // for explicit precision qualifier
     TType(TBasicType t, TStorageQualifier q, TPrecisionQualifier p, int vs = 1, int mc = 0, int mr = 0,
           bool isVector = false) :
-                            basicType(t), vectorSize(static_cast<uint32_t>(vs) & 0b1111), matrixCols(static_cast<uint32_t>(mc) & 0b1111), matrixRows(static_cast<uint32_t>(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false),
+                            basicType(t), vectorSize(static_cast<uint32_t>(vs) & 0b1111), matrixCols(static_cast<uint32_t>(mc) & 0b1111), matrixRows(static_cast<uint32_t>(mr) & 0b1111), vector1(isVector && vs == 1), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false),
                             arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
@@ -1579,7 +1586,7 @@ public:
     // for turning a TPublicType into a TType, using a shallow copy
     explicit TType(const TPublicType& p) :
                             basicType(p.basicType),
-                            vectorSize(p.vectorSize), matrixCols(p.matrixCols), matrixRows(p.matrixRows), vector1(false), coopmatNV(p.coopmatNV), coopmatKHR(p.coopmatKHR), coopmatKHRuse(0), coopmatKHRUseValid(false),
+                            vectorSize(p.vectorSize), matrixCols(p.matrixCols), matrixRows(p.matrixRows), vector1(false), coopmatNV(p.coopmatNV), coopmatKHR(p.coopmatKHR), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(p.coopvecNV),
                             arraySizes(p.arraySizes), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(p.typeParameters),
                             spirvType(p.spirvType)
                             {
@@ -1630,10 +1637,13 @@ public:
                                         coopmatKHRUseValid = true;
                                     }
                                 }
+                                if (p.isCoopvecNV() && p.typeParameters) {
+                                    basicType = p.typeParameters->basicType;
+                                }
                             }
     // for construction of sampler types
     TType(const TSampler& sampler, TStorageQualifier q = EvqUniform, TArraySizes* as = nullptr) :
-        basicType(EbtSampler), vectorSize(1u), matrixCols(0u), matrixRows(0u), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false),
+        basicType(EbtSampler), vectorSize(1u), matrixCols(0u), matrixRows(0u), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false),
         arraySizes(as), structure(nullptr), fieldName(nullptr), typeName(nullptr),
         sampler(sampler), typeParameters(nullptr), spirvType(nullptr)
     {
@@ -1676,18 +1686,19 @@ public:
                                         // dereference from vector to scalar
                                         vectorSize = 1;
                                         vector1 = false;
-                                    } else if (isCoopMat()) {
+                                    } else if (isCoopMat() || isCoopVecNV()) {
                                         coopmatNV = false;
                                         coopmatKHR = false;
                                         coopmatKHRuse = 0;
                                         coopmatKHRUseValid = false;
+                                        coopvecNV = false;
                                         typeParameters = nullptr;
                                     }
                                 }
                             }
     // for making structures, ...
     TType(TTypeList* userDef, const TString& n) :
-                            basicType(EbtStruct), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false),
+                            basicType(EbtStruct), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false),
                             arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
@@ -1697,7 +1708,7 @@ public:
                             }
     // For interface blocks
     TType(TTypeList* userDef, const TString& n, const TQualifier& q) :
-                            basicType(EbtBlock), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false),
+                            basicType(EbtBlock), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false), coopvecNV(false),
                             qualifier(q), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
@@ -1745,6 +1756,7 @@ public:
         coopmatKHR = copyOf.isCoopMatKHR();
         coopmatKHRuse = copyOf.coopmatKHRuse;
         coopmatKHRUseValid = copyOf.coopmatKHRUseValid;
+        coopvecNV = copyOf.isCoopVecNV();
     }
 
     // Make complete copy of the whole type graph rooted at 'copyOf'.
@@ -1828,7 +1840,7 @@ public:
     virtual const TTypeParameters* getTypeParameters() const { return typeParameters; }
     virtual       TTypeParameters* getTypeParameters()       { return typeParameters; }
 
-    virtual bool isScalar() const { return ! isVector() && ! isMatrix() && ! isStruct() && ! isArray(); }
+    virtual bool isScalar() const { return ! isVector() && ! isMatrix() && ! isStruct() && ! isArray() && ! isCoopVecNV(); }
     virtual bool isScalarOrVec1() const { return isScalar() || vector1; }
     virtual bool isScalarOrVector() const { return !isMatrix() && !isStruct() && !isArray(); }
     virtual bool isVector() const { return vectorSize > 1u || vector1; }
@@ -1879,6 +1891,8 @@ public:
     bool isCoopMat() const { return coopmatNV || coopmatKHR; }
     bool isCoopMatNV() const { return coopmatNV; }
     bool isCoopMatKHR() const { return coopmatKHR; }
+    bool isCoopVecNV() const { return coopvecNV; }
+    bool isCoopMatOrVec() const { return isCoopMat() || isCoopVecNV(); }
     bool isReference() const { return getBasicType() == EbtReference; }
     bool isSpirvType() const { return getBasicType() == EbtSpirvType; }
     int getCoopMatKHRuse() const { return static_cast<int>(coopmatKHRuse); }
@@ -1994,6 +2008,10 @@ public:
     {
         return contains([](const TType* t) { return t->coopmatNV || t->coopmatKHR; } );
     }
+    bool containsCoopVec() const
+    {
+        return contains([](const TType* t) { return t->coopvecNV; } );
+    }
     bool containsReference() const
     {
         return containsBasicType(EbtReference);
@@ -2113,6 +2131,7 @@ public:
         case EbtCoopmat:           return "coopmat";
         case EbtTensorLayoutNV:    return "tensorLayoutNV";
         case EbtTensorViewNV:      return "tensorViewNV";
+        case EbtCoopvecNV:         return "coopvecNV";
         default:                   return "unknown type";
         }
     }
@@ -2281,6 +2300,8 @@ public:
             appendStr(" nonprivate");
           if (qualifier.volatil)
             appendStr(" volatile");
+          if (qualifier.nontemporal)
+            appendStr(" nontemporal");
           if (qualifier.restrict)
             appendStr(" restrict");
           if (qualifier.readonly)
@@ -2431,6 +2452,10 @@ public:
                 appendStr(" ");
                 appendStr("tensorViewNV");
               }
+              if (isCoopVecNV()) {
+                appendStr(" ");
+                appendStr("coopvecNV");
+              }
 
               appendStr("<");
               for (int i = 0; i < (int)typeParameters->arraySizes->getNumDims(); ++i) {
@@ -2512,7 +2537,9 @@ public:
     {
         uint32_t components = 0;
 
-        if (getBasicType() == EbtStruct || getBasicType() == EbtBlock) {
+        if (isCoopVecNV()) {
+            components = typeParameters->arraySizes->getDimSize(0);
+        } else if (getBasicType() == EbtStruct || getBasicType() == EbtBlock) {
             for (TTypeList::const_iterator tl = getStruct()->begin(); tl != getStruct()->end(); tl++)
                 components += ((*tl).type)->computeNumComponents();
         } else if (matrixCols)
@@ -2716,6 +2743,7 @@ public:
                   vector1 == right.vector1    &&
               isCoopMatNV() == right.isCoopMatNV() &&
               isCoopMatKHR() == right.isCoopMatKHR() &&
+              isCoopVecNV() == right.isCoopVecNV() &&
                sameStructType(right, lpidx, rpidx) &&
                sameReferenceType(right);
     }
@@ -2737,6 +2765,18 @@ public:
         return false;
     }
 
+    // See if a cooperative vector type parameter with unspecified parameters is
+    // an OK function parameter
+    bool coopVecParameterOK(const TType& right) const
+    {
+        if (isCoopVecNV() && right.isCoopVecNV()) {
+            return ((getBasicType() == right.getBasicType()) || (getBasicType() == EbtCoopvecNV) ||
+                    (right.getBasicType() == EbtCoopvecNV)) &&
+                   typeParameters == nullptr && right.typeParameters != nullptr;
+        }
+        return false;
+    }
+
     bool sameCoopMatBaseType(const TType &right) const {
         bool rv = false;
 
@@ -2774,6 +2814,22 @@ public:
         return false;
     }
 
+    bool sameCoopVecBaseType(const TType &right) const {
+        bool rv = false;
+
+        if (isCoopVecNV() && right.isCoopVecNV()) {
+            if (getBasicType() == EbtFloat || getBasicType() == EbtFloat16)
+                rv = right.getBasicType() == EbtFloat || right.getBasicType() == EbtFloat16 || right.getBasicType() == EbtCoopvecNV;
+            else if (getBasicType() == EbtUint || getBasicType() == EbtUint8 || getBasicType() == EbtUint16)
+                rv = right.getBasicType() == EbtUint || right.getBasicType() == EbtUint8 || right.getBasicType() == EbtUint16 || right.getBasicType() == EbtCoopvecNV;
+            else if (getBasicType() == EbtInt || getBasicType() == EbtInt8 || getBasicType() == EbtInt16)
+                rv = right.getBasicType() == EbtInt || right.getBasicType() == EbtInt8 || right.getBasicType() == EbtInt16 || right.getBasicType() == EbtCoopvecNV;
+            else
+                rv = false;
+        }
+        return rv;
+    }
+
     bool sameCoopMatUse(const TType &right) const {
         return coopmatKHRuse == right.coopmatKHRuse;
     }
@@ -2903,6 +2959,7 @@ protected:
     bool coopmatKHR      : 1;
     uint32_t coopmatKHRuse    : 3;  // Accepts one of three values: 0, 1, 2 (gl_MatrixUseA, gl_MatrixUseB, gl_MatrixUseAccumulator)
     bool coopmatKHRUseValid   : 1;  // True if coopmatKHRuse has been set
+    bool coopvecNV       : 1;
     TQualifier qualifier;
 
     TArraySizes* arraySizes;    // nullptr unless an array; can be shared across types

3rdparty/glslang/glslang/Include/glslang_c_interface.h

@@ -284,7 +284,7 @@ GLSLANG_EXPORT const char* glslang_program_SPIRV_get_messages(glslang_program_t*
 GLSLANG_EXPORT const char* glslang_program_get_info_log(glslang_program_t* program);
 GLSLANG_EXPORT const char* glslang_program_get_info_debug_log(glslang_program_t* program);
 
-GLSLANG_EXPORT glslang_mapper_t* glslang_glsl_mapper_create();
+GLSLANG_EXPORT glslang_mapper_t* glslang_glsl_mapper_create(void);
 GLSLANG_EXPORT void glslang_glsl_mapper_delete(glslang_mapper_t* mapper);
 
 GLSLANG_EXPORT glslang_resolver_t* glslang_glsl_resolver_create(glslang_program_t* program, glslang_stage_t stage);

3rdparty/glslang/glslang/Include/intermediate.h

@@ -387,6 +387,11 @@ enum TOperator {
     EOpSubgroupPartitionedExclusiveXor,
 
     EOpSubgroupGuardStop,
+    
+    // Integer dot product
+    EOpDotPackedEXT,
+    EOpDotAccSatEXT,
+    EOpDotPackedAccSatEXT,
 
     EOpMinInvocations,
     EOpMaxInvocations,
@@ -467,6 +472,13 @@ enum TOperator {
     EOpTensorViewSetStrideNV,
     EOpTensorViewSetClipNV,
 
+    EOpCooperativeVectorMatMulNV,
+    EOpCooperativeVectorMatMulAddNV,
+    EOpCooperativeVectorLoadNV,
+    EOpCooperativeVectorStoreNV,
+    EOpCooperativeVectorOuterProductAccumulateNV,
+    EOpCooperativeVectorReduceSumAccumulateNV,
+
     EOpBeginInvocationInterlock, // Fragment only
     EOpEndInvocationInterlock, // Fragment only
 
@@ -605,6 +617,7 @@ enum TOperator {
     EOpConstructReference,
     EOpConstructCooperativeMatrixNV,
     EOpConstructCooperativeMatrixKHR,
+    EOpConstructCooperativeVectorNV,
     EOpConstructAccStruct,
     EOpConstructGuardEnd,
 
@@ -954,6 +967,25 @@ enum TOperator {
     EOpImageBlockMatchWindowSADQCOM,
     EOpImageBlockMatchGatherSSDQCOM,
     EOpImageBlockMatchGatherSADQCOM,
+
+    // GL_NV_cluster_acceleration_structure
+    EOpRayQueryGetIntersectionClusterIdNV,
+    EOpHitObjectGetClusterIdNV,
+
+    // GL_NV_linear_swept_spheres
+    EOpRayQueryGetIntersectionSpherePositionNV,
+    EOpRayQueryGetIntersectionSphereRadiusNV,
+    EOpRayQueryGetIntersectionLSSHitValueNV,
+    EOpRayQueryGetIntersectionLSSPositionsNV,
+    EOpRayQueryGetIntersectionLSSRadiiNV,
+    EOpRayQueryIsSphereHitNV,
+    EOpRayQueryIsLSSHitNV,
+    EOpHitObjectGetSpherePositionNV,
+    EOpHitObjectGetSphereRadiusNV,
+    EOpHitObjectGetLSSPositionsNV,
+    EOpHitObjectGetLSSRadiiNV,
+    EOpHitObjectIsSphereHitNV,
+    EOpHitObjectIsLSSHitNV,
 };
 
 inline bool IsOpNumericConv(const TOperator op) {

3rdparty/glslang/glslang/MachineIndependent/Constant.cpp

@@ -1119,6 +1119,9 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode)
             break;
         }
         case EOpDot:
+            if (!children[0]->getAsTyped()->isFloatingDomain()) {
+                return aggrNode;
+            }
             newConstArray[0].setDConst(childConstUnions[0].dot(childConstUnions[1]));
             break;
         case EOpCross:

3rdparty/glslang/glslang/MachineIndependent/Intermediate.cpp

@@ -829,6 +829,11 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
         node->getType().isTensorViewNV())
         return nullptr;
 
+    // Reject implicit conversions to cooperative vector types
+    if (node->getType().isCoopVecNV() &&
+        op != EOpConstructCooperativeVectorNV)
+        return nullptr;
+
     // Note: callers are responsible for other aspects of shape,
     // like vector and matrix sizes.
 
@@ -896,6 +901,7 @@ TIntermTyped* TIntermediate::addConversion(TOperator op, const TType& type, TInt
     case EOpConstructStruct:
     case EOpConstructCooperativeMatrixNV:
     case EOpConstructCooperativeMatrixKHR:
+    case EOpConstructCooperativeVectorNV:
 
         if (type.isReference() || node->getType().isReference()) {
             // types must match to assign a reference
@@ -1772,6 +1778,9 @@ TOperator TIntermediate::mapTypeToConstructorOp(const TType& type) const
     if (type.isCoopMatKHR())
         return EOpConstructCooperativeMatrixKHR;
 
+    if (type.isCoopVecNV())
+        return EOpConstructCooperativeVectorNV;
+
     switch (type.getBasicType()) {
     case EbtStruct:
         op = EOpConstructStruct;
@@ -3301,6 +3310,43 @@ bool TIntermediate::promoteBinary(TIntermBinary& node)
         return false;
     }
 
+    if (left->getType().isCoopVecNV() || right->getType().isCoopVecNV()) {
+        // Operations on two cooperative vectors must have identical types
+        if (left->getType().isCoopVecNV() && right->getType().isCoopVecNV() &&
+            left->getType() != right->getType()) {
+            return false;
+        }
+        switch (op) {
+        case EOpMul:
+        case EOpMulAssign:
+            // Use VectorTimesScalar if either operand is not a vector. Otherwise use Mul.
+            if (!left->getType().isCoopVecNV() || !right->getType().isCoopVecNV()) {
+                node.setOp(op == EOpMulAssign ? EOpVectorTimesScalarAssign : EOpVectorTimesScalar);
+            }
+            // In case of scalar*vector, take the result type from the vector.
+            if (right->getType().isCoopVecNV()) {
+                node.setType(right->getType());
+            }
+            return true;
+        case EOpLeftShift:
+        case EOpLeftShiftAssign:
+        case EOpRightShift:
+        case EOpRightShiftAssign:
+        case EOpAdd:
+        case EOpSub:
+        case EOpDiv:
+        case EOpAssign:
+            // These require both to be cooperative vectors
+            if (!left->getType().isCoopVecNV() || !right->getType().isCoopVecNV()) {
+                return false;
+            }
+            return true;
+        default:
+            break;
+        }
+        return false;
+    }
+
     // Finish handling the case, for all ops, where both operands are scalars.
     if (left->isScalar() && right->isScalar())
         return true;

3rdparty/glslang/glslang/MachineIndependent/ParseContextBase.cpp

@@ -305,6 +305,11 @@ void TParseContextBase::checkIndex(const TSourceLoc& loc, const TType& type, int
             error(loc, "", "[", "matrix index out of range '%d'", index);
             index = type.getMatrixCols() - 1;
         }
+    } else if (type.isCoopVecNV()) {
+        if (index >= type.computeNumComponents()) {
+            error(loc, "", "[", "cooperative vector index out of range '%d'", index);
+            index = type.computeNumComponents() - 1;
+        }
     }
 }
 

3rdparty/glslang/glslang/MachineIndependent/ParseHelper.cpp

@@ -44,6 +44,7 @@
 
 #include <algorithm>
 
+#include "Versions.h"
 #include "preprocessor/PpContext.h"
 
 extern int yyparse(glslang::TParseContext*);
@@ -549,7 +550,7 @@ TIntermTyped* TParseContext::handleBracketDereference(const TSourceLoc& loc, TIn
     variableCheck(base);
 
     if (! base->isArray() && ! base->isMatrix() && ! base->isVector() && ! base->getType().isCoopMat() &&
-        ! base->isReference()) {
+        ! base->isReference() && ! base->getType().isCoopVecNV()) {
         if (base->getAsSymbolNode())
             error(loc, " left of '[' is not of type array, matrix, or vector ", base->getAsSymbolNode()->getName().c_str(), "");
         else
@@ -970,7 +971,7 @@ TIntermTyped* TParseContext::handleDotDereference(const TSourceLoc& loc, TInterm
             const char* feature = ".length() on vectors and matrices";
             requireProfile(loc, ~EEsProfile, feature);
             profileRequires(loc, ~EEsProfile, 420, E_GL_ARB_shading_language_420pack, feature);
-        } else if (!base->getType().isCoopMat()) {
+        } else if (!base->getType().isCoopMat() && !base->getType().isCoopVecNV()) {
             bool enhanced = intermediate.getEnhancedMsgs();
             error(loc, "does not operate on this type:", field.c_str(), base->getType().getCompleteString(enhanced).c_str());
             return base;
@@ -1182,19 +1183,23 @@ TFunction* TParseContext::handleFunctionDeclarator(const TSourceLoc& loc, TFunct
     if (prevDec) {
         if (prevDec->isPrototyped() && prototype)
             profileRequires(loc, EEsProfile, 300, nullptr, "multiple prototypes for same function");
-        if (prevDec->getType() != function.getType())
-            error(loc, "overloaded functions must have the same return type", function.getName().c_str(), "");
         if (prevDec->getSpirvInstruction() != function.getSpirvInstruction()) {
             error(loc, "overloaded functions must have the same qualifiers", function.getName().c_str(),
                   "spirv_instruction");
         }
+        bool parameterTypesDiffer = false;
         for (int i = 0; i < prevDec->getParamCount(); ++i) {
             if ((*prevDec)[i].type->getQualifier().storage != function[i].type->getQualifier().storage)
                 error(loc, "overloaded functions must have the same parameter storage qualifiers for argument", function[i].type->getStorageQualifierString(), "%d", i+1);
 
             if ((*prevDec)[i].type->getQualifier().precision != function[i].type->getQualifier().precision)
                 error(loc, "overloaded functions must have the same parameter precision qualifiers for argument", function[i].type->getPrecisionQualifierString(), "%d", i+1);
+
+            if (*(*prevDec)[i].type != *function[i].type)
+                parameterTypesDiffer = true;
         }
+        if (!parameterTypesDiffer && prevDec->getType() != function.getType())
+            error(loc, "overloaded functions must have the same return type", function.getName().c_str(), "");
     }
 
     arrayObjectCheck(loc, function.getType(), "array in function return type");
@@ -1427,6 +1432,8 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction
                             error(arguments->getLoc(), message, "readonly", "");
                         if (argQualifier.writeonly && ! formalQualifier.writeonly)
                             error(arguments->getLoc(), message, "writeonly", "");
+                        if (argQualifier.nontemporal && ! formalQualifier.nontemporal)
+                            error(arguments->getLoc(), message, "nontemporal", "");
                         // Don't check 'restrict', it is different than the rest:
                         // "...but only restrict can be taken away from a calling argument, by a formal parameter that
                         // lacks the restrict qualifier..."
@@ -1445,6 +1452,11 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction
                     if (builtIn && arg->getAsTyped()->getType().contains8BitInt())
                         requireInt8Arithmetic(arguments->getLoc(), "built-in function", "(u)int8 types can only be in uniform block or buffer storage");
 
+                    // Check that coopVecOuterProductAccumulateNV vector component types match
+                    if (builtIn && fnCandidate->getBuiltInOp() == EOpCooperativeVectorOuterProductAccumulateNV &&
+                        i == 1 && arg->getAsTyped()->getType().getBasicType() != aggregate->getSequence()[0]->getAsTyped()->getType().getBasicType())
+                        error(arguments->getLoc(), "cooperative vector basic types must match", fnCandidate->getName().c_str(), "");
+
                     // TODO 4.5 functionality:  A shader will fail to compile
                     // if the value passed to the memargument of an atomic memory function does not correspond to a buffer or
                     // shared variable. It is acceptable to pass an element of an array or a single component of a vector to the
@@ -1500,6 +1512,14 @@ TIntermTyped* TParseContext::handleFunctionCall(const TSourceLoc& loc, TFunction
             }
 
             handleCoopMat2FunctionCall(loc, fnCandidate, result, arguments);
+
+            if (result->getAsTyped()->getType().isCoopVecNV() &&
+               !result->getAsTyped()->getType().isParameterized()) {
+                if (auto unaryNode = result->getAsUnaryNode())
+                    result->setType(unaryNode->getOperand()->getAsTyped()->getType());
+                else 
+                    result->setType(result->getAsAggregate()->getSequence()[0]->getAsTyped()->getType());
+            }
         }
     }
 
@@ -2021,7 +2041,7 @@ TIntermTyped* TParseContext::handleLengthMethod(const TSourceLoc& loc, TFunction
             length = type.getMatrixCols();
         else if (type.isVector())
             length = type.getVectorSize();
-        else if (type.isCoopMat())
+        else if (type.isCoopMat() || type.isCoopVecNV())
             return intermediate.addBuiltInFunctionCall(loc, EOpArrayLength, true, intermNode, TType(EbtInt));
         else {
             // we should not get here, because earlier semantic checking should have prevented this path
@@ -2540,18 +2560,34 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
     case EOpTextureProjLodOffset:
     case EOpTextureGradOffset:
     case EOpTextureProjGradOffset:
+    case EOpSparseTextureOffset:
+    case EOpSparseTextureFetchOffset:
+    case EOpSparseTextureLodOffset:
+    case EOpSparseTextureGradOffset:
     {
         // Handle texture-offset limits checking
         // Pick which argument has to hold constant offsets
         int arg = -1;
         switch (callNode.getOp()) {
-        case EOpTextureOffset:          arg = 2;  break;
-        case EOpTextureFetchOffset:     arg = (arg0->getType().getSampler().isRect()) ? 2 : 3; break;
-        case EOpTextureProjOffset:      arg = 2;  break;
-        case EOpTextureLodOffset:       arg = 3;  break;
-        case EOpTextureProjLodOffset:   arg = 3;  break;
-        case EOpTextureGradOffset:      arg = 4;  break;
-        case EOpTextureProjGradOffset:  arg = 4;  break;
+        case EOpSparseTextureOffset:
+        case EOpTextureOffset:
+        case EOpTextureProjOffset:
+            arg = 2;
+            break;
+        case EOpSparseTextureLodOffset:
+        case EOpTextureLodOffset:
+        case EOpTextureProjLodOffset:
+            arg = 3;
+            break;
+        case EOpSparseTextureGradOffset:
+        case EOpTextureGradOffset:
+        case EOpTextureProjGradOffset:
+            arg = 4;
+            break;
+        case EOpSparseTextureFetchOffset:
+        case EOpTextureFetchOffset:
+            arg = (arg0->getType().getSampler().isRect()) ? 2 : 3;
+            break;
         default:
             assert(0);
             break;
@@ -2563,8 +2599,10 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
                                     arg0->getType().getSampler().shadow;
             if (f16ShadowCompare)
                 ++arg;
-            if (! (*argp)[arg]->getAsTyped()->getQualifier().isConstant())
-                error(loc, "argument must be compile-time constant", "texel offset", "");
+            if (! (*argp)[arg]->getAsTyped()->getQualifier().isConstant()) {
+                if (!extensionTurnedOn(E_GL_EXT_texture_offset_non_const))
+                    error(loc, "argument must be compile-time constant", "texel offset", "");
+            }
             else if ((*argp)[arg]->getAsConstantUnion()) {
                 const TType& type = (*argp)[arg]->getAsTyped()->getType();
                 for (int c = 0; c < type.getVectorSize(); ++c) {
@@ -2575,6 +2613,8 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
                 }
             }
 
+            // This check does not apply to sparse because
+            // GL_ARB_sparse_texture2 always includes this function.
             if (callNode.getOp() == EOpTextureOffset) {
                 TSampler s = arg0->getType().getSampler();
                 if (s.is2D() && s.isArrayed() && s.isShadow()) {
@@ -2595,6 +2635,9 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
                 }
             }
 
+            // This check does not apply to sparse because
+            // GL_ARB_sparse_texture2 does not define sparseTextureLodOffsetARB
+            // with a sampler2DArrayShadow.
             if (callNode.getOp() == EOpTextureLodOffset) {
                 TSampler s = arg0->getType().getSampler();
                 if (s.is2D() && s.isArrayed() && s.isShadow() &&
@@ -2731,6 +2774,12 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
     case EOpRayQueryGetIntersectionObjectToWorld:
     case EOpRayQueryGetIntersectionWorldToObject:
     case EOpRayQueryGetIntersectionTriangleVertexPositionsEXT:
+    case EOpRayQueryGetIntersectionClusterIdNV:
+    case EOpRayQueryGetIntersectionSpherePositionNV:
+    case EOpRayQueryGetIntersectionSphereRadiusNV:
+    case EOpRayQueryGetIntersectionLSSHitValueNV:
+    case EOpRayQueryGetIntersectionLSSPositionsNV:
+    case EOpRayQueryGetIntersectionLSSRadiiNV:
         if (!(*argp)[1]->getAsConstantUnion())
             error(loc, "argument must be compile-time constant", "committed", "");
         break;
@@ -3003,7 +3052,41 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
         }
 
         break;
-
+    case EOpCooperativeVectorMatMulNV:
+    case EOpCooperativeVectorMatMulAddNV:
+        {
+            int inputInterpIdx = 2;
+            int matrixInterpIdx = 5;
+            int biasInterpIdx = 8;
+            int MIdx = callNode.getOp() == EOpCooperativeVectorMatMulAddNV ? 9 : 6;
+            int KIdx = callNode.getOp() == EOpCooperativeVectorMatMulAddNV ? 10 : 7;
+            int matrixLayoutIdx = callNode.getOp() == EOpCooperativeVectorMatMulAddNV ? 11 : 8;
+            int transposeIdx = callNode.getOp() == EOpCooperativeVectorMatMulAddNV ? 12 : 9;
+
+            if (!(*argp)[inputInterpIdx]->getAsTyped()->getType().getQualifier().isConstant())
+                error(loc, "argument must be compile-time constant", "inputInterpretation", "");
+            if (!(*argp)[matrixInterpIdx]->getAsTyped()->getType().getQualifier().isConstant())
+                error(loc, "argument must be compile-time constant", "matrixInterpretation", "");
+            if (callNode.getOp() == EOpCooperativeVectorMatMulAddNV) {
+                if (!(*argp)[biasInterpIdx]->getAsTyped()->getType().getQualifier().isConstant())
+                    error(loc, "argument must be compile-time constant", "biasInterpretation", "");
+            }
+            if (!(*argp)[MIdx]->getAsTyped()->getType().getQualifier().isConstant())
+                error(loc, "argument must be compile-time constant", "M", "");
+            if (!(*argp)[KIdx]->getAsTyped()->getType().getQualifier().isConstant())
+                error(loc, "argument must be compile-time constant", "K", "");
+            if (!(*argp)[matrixLayoutIdx]->getAsTyped()->getType().getQualifier().isConstant())
+                error(loc, "argument must be compile-time constant", "matrixLayout", "");
+            if (!(*argp)[transposeIdx]->getAsTyped()->getType().getQualifier().isConstant())
+                error(loc, "argument must be compile-time constant", "transpose", "");
+        }
+        break;
+    case EOpCooperativeVectorOuterProductAccumulateNV:
+        if (!(*argp)[5]->getAsTyped()->getType().getQualifier().isConstant())
+            error(loc, "argument must be compile-time constant", "matrixLayout", "");
+        if (!(*argp)[6]->getAsTyped()->getType().getQualifier().isConstant())
+            error(loc, "argument must be compile-time constant", "matrixInterpretation", "");
+        break;
     default:
         break;
     }
@@ -3157,8 +3240,10 @@ void TParseContext::nonOpBuiltInCheck(const TSourceLoc& loc, const TFunction& fn
                     arg = 4;
 
                 if (arg > 0) {
-                    if (! callNode.getSequence()[arg]->getAsConstantUnion())
-                        error(loc, "argument must be compile-time constant", "texel offset", "");
+                    if (! callNode.getSequence()[arg]->getAsConstantUnion()) {
+                        if (!extensionTurnedOn(E_GL_EXT_texture_offset_non_const))
+                            error(loc, "argument must be compile-time constant", "texel offset", "");
+                    }
                     else {
                         const TType& type = callNode.getSequence()[arg]->getAsTyped()->getType();
                         for (int c = 0; c < type.getVectorSize(); ++c) {
@@ -4534,6 +4619,7 @@ void TParseContext::mergeQualifiers(const TSourceLoc& loc, TQualifier& dst, cons
     MERGE_SINGLETON(shadercallcoherent);
     MERGE_SINGLETON(nonprivate);
     MERGE_SINGLETON(volatil);
+    MERGE_SINGLETON(nontemporal);
     MERGE_SINGLETON(restrict);
     MERGE_SINGLETON(readonly);
     MERGE_SINGLETON(writeonly);
@@ -4634,7 +4720,7 @@ TPrecisionQualifier TParseContext::getDefaultPrecision(TPublicType& publicType)
         return defaultPrecision[publicType.basicType];
 }
 
-void TParseContext::precisionQualifierCheck(const TSourceLoc& loc, TBasicType baseType, TQualifier& qualifier, bool isCoopMat)
+void TParseContext::precisionQualifierCheck(const TSourceLoc& loc, TBasicType baseType, TQualifier& qualifier, bool isCoopMatOrVec)
 {
     // Built-in symbols are allowed some ambiguous precisions, to be pinned down
     // later by context.
@@ -4644,7 +4730,7 @@ void TParseContext::precisionQualifierCheck(const TSourceLoc& loc, TBasicType ba
     if (baseType == EbtAtomicUint && qualifier.precision != EpqNone && qualifier.precision != EpqHigh)
         error(loc, "atomic counters can only be highp", "atomic_uint", "");
 
-    if (isCoopMat)
+    if (isCoopMatOrVec)
         return;
 
     if (baseType == EbtFloat || baseType == EbtUint || baseType == EbtInt || baseType == EbtSampler || baseType == EbtAtomicUint) {
@@ -5528,6 +5614,7 @@ void TParseContext::paramCheckFix(const TSourceLoc& loc, const TQualifier& quali
 {
     if (qualifier.isMemory()) {
         type.getQualifier().volatil   = qualifier.volatil;
+        type.getQualifier().nontemporal   = qualifier.nontemporal;
         type.getQualifier().coherent  = qualifier.coherent;
         type.getQualifier().devicecoherent  = qualifier.devicecoherent ;
         type.getQualifier().queuefamilycoherent  = qualifier.queuefamilycoherent;
@@ -7460,6 +7547,8 @@ const TFunction* TParseContext::findFunction400(const TSourceLoc& loc, const TFu
             return true;
         if (from.getBasicType() == EbtFunction && to.getBasicType() == EbtFunction)
             return true;
+        if (from.coopVecParameterOK(to))
+            return true;
         // Allow a sized array to be passed through an unsized array parameter, for coopMatLoad/Store functions
         if (builtIn && from.isArray() && to.isUnsizedArray()) {
             TType fromElementType(from, 0);
@@ -7477,6 +7566,8 @@ const TFunction* TParseContext::findFunction400(const TSourceLoc& loc, const TFu
             return false;
         if (from.isCoopMat() && to.isCoopMat())
             return from.sameCoopMatBaseType(to);
+        if (from.isCoopVecNV() && to.isCoopVecNV())
+            return from.sameCoopVecBaseType(to);
         return intermediate.canImplicitlyPromote(from.getBasicType(), to.getBasicType());
     };
 
@@ -7546,6 +7637,8 @@ const TFunction* TParseContext::findFunctionExplicitTypes(const TSourceLoc& loc,
             return true;
         if (from.getBasicType() == EbtFunction && to.getBasicType() == EbtFunction)
             return true;
+        if (from.coopVecParameterOK(to))
+            return true;
         // Allow a sized array to be passed through an unsized array parameter, for coopMatLoad/Store functions
         if (builtIn && from.isArray() && to.isUnsizedArray()) {
             TType fromElementType(from, 0);
@@ -7563,6 +7656,8 @@ const TFunction* TParseContext::findFunctionExplicitTypes(const TSourceLoc& loc,
             return false;
         if (from.isCoopMat() && to.isCoopMat())
             return from.sameCoopMatBaseType(to);
+        if (from.isCoopVecNV() && to.isCoopVecNV())
+            return from.sameCoopVecBaseType(to);
         return intermediate.canImplicitlyPromote(from.getBasicType(), to.getBasicType());
     };
 
@@ -7698,7 +7793,7 @@ void TParseContext::declareTypeDefaults(const TSourceLoc& loc, const TPublicType
         warn(loc, "useless application of layout qualifier", "layout", "");
 }
 
-void TParseContext::coopMatTypeParametersCheck(const TSourceLoc& loc, const TPublicType& publicType)
+void TParseContext::typeParametersCheck(const TSourceLoc& loc, const TPublicType& publicType)
 {
     if (parsingBuiltins)
         return;
@@ -8155,10 +8250,9 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden
         intermediate.setUseVulkanMemoryModel();
         intermediate.setUseStorageBuffer();
 
-        if (!publicType.typeParameters || publicType.typeParameters->arraySizes->getNumDims() != 4) {
+        if (!publicType.typeParameters || !publicType.typeParameters->arraySizes || publicType.typeParameters->arraySizes->getNumDims() != 4) {
             error(loc, "expected four type parameters", identifier.c_str(), "");
-        }
-        if (publicType.typeParameters) {
+        } else {
             if (isTypeFloat(publicType.basicType) &&
                 publicType.typeParameters->arraySizes->getDimSize(0) != 16 &&
                 publicType.typeParameters->arraySizes->getDimSize(0) != 32 &&
@@ -8180,6 +8274,15 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden
         if (!publicType.typeParameters || publicType.typeParameters->arraySizes->getNumDims() > 7) {
             error(loc, "expected 1-7 type parameters", identifier.c_str(), "");
         }
+    } else if (type.isCoopVecNV()) {
+        intermediate.setUseVulkanMemoryModel();
+        intermediate.setUseStorageBuffer();
+
+        if (!publicType.typeParameters || !publicType.typeParameters->arraySizes || publicType.typeParameters->arraySizes->getNumDims() != 1) {
+            error(loc, "expected two type parameters", identifier.c_str(), "");
+        } else if (publicType.typeParameters->arraySizes->getDimSize(0) <= 0) {
+            error(loc, "expected positive number of components", identifier.c_str(), "");
+        }
     } else {
         if (publicType.typeParameters && publicType.typeParameters->arraySizes->getNumDims() != 0) {
             error(loc, "unexpected type parameters", identifier.c_str(), "");
@@ -9023,6 +9126,27 @@ TIntermTyped* TParseContext::constructBuiltIn(const TType& type, TOperator op, T
             return nullptr;
         }
 
+    case EOpConstructCooperativeVectorNV:
+        if (!node->getType().isCoopVecNV()) {
+            if (type.getBasicType() != node->getType().getBasicType()) {
+                node = intermediate.addConversion(type.getBasicType(), node);
+                if (node == nullptr)
+                    return nullptr;
+            }
+        }
+        if (type.getBasicType() != node->getType().getBasicType()) {
+            intermediate.buildConvertOp(type.getBasicType(), node->getType().getBasicType(), op);
+            node = intermediate.addUnaryNode(op, node, node->getLoc(), type);
+            return node;
+        }
+        if (subset) {
+            return node;
+        }
+
+        node = intermediate.setAggregateOperator(node, op, type, node->getLoc());
+
+        return node;
+
     case EOpConstructCooperativeMatrixNV:
     case EOpConstructCooperativeMatrixKHR:
         if (node->getType() == type) {
@@ -9116,6 +9240,8 @@ void TParseContext::inheritMemoryQualifiers(const TQualifier& from, TQualifier&
         to.coherent = from.coherent;
     if (from.volatil)
         to.volatil = from.volatil;
+    if (from.nontemporal)
+        to.nontemporal = from.nontemporal;
     if (from.restrict)
         to.restrict = from.restrict;
 }
@@ -9204,6 +9330,9 @@ void TParseContext::declareBlock(const TSourceLoc& loc, TTypeList& typeList, con
 
         if (memberType.containsCoopMat())
             error(memberLoc, "member of block cannot be or contain a cooperative matrix type", typeList[member].type->getFieldName().c_str(), "");
+
+        if (memberType.containsCoopVec())
+            error(memberLoc, "member of block cannot be or contain a cooperative vector type", typeList[member].type->getFieldName().c_str(), "");
     }
 
     // This might be a redeclaration of a built-in block.  If so, redeclareBuiltinBlock() will

3rdparty/glslang/glslang/MachineIndependent/ParseHelper.h

@@ -407,7 +407,7 @@ public:
     void setDefaultPrecision(const TSourceLoc&, TPublicType&, TPrecisionQualifier);
     int computeSamplerTypeIndex(TSampler&);
     TPrecisionQualifier getDefaultPrecision(TPublicType&);
-    void precisionQualifierCheck(const TSourceLoc&, TBasicType, TQualifier&, bool isCoopMat);
+    void precisionQualifierCheck(const TSourceLoc&, TBasicType, TQualifier&, bool isCoopMatOrVec);
     void parameterTypeCheck(const TSourceLoc&, TStorageQualifier qualifier, const TType& type);
     bool containsFieldWithBasicType(const TType& type ,TBasicType basicType);
     TSymbol* redeclareBuiltinVariable(const TSourceLoc&, const TString&, const TQualifier&, const TShaderQualifiers&);
@@ -425,7 +425,7 @@ public:
     void inductiveLoopCheck(const TSourceLoc&, TIntermNode* init, TIntermLoop* loop);
     void arrayLimitCheck(const TSourceLoc&, const TString&, int size);
     void limitCheck(const TSourceLoc&, int value, const char* limit, const char* feature);
-    void coopMatTypeParametersCheck(const TSourceLoc&, const TPublicType&);
+    void typeParametersCheck(const TSourceLoc&, const TPublicType&);
 
     void inductiveLoopBodyCheck(TIntermNode*, long long loopIndexId, TSymbolTable&);
     void constantIndexExpressionCheck(TIntermNode*);

3rdparty/glslang/glslang/MachineIndependent/Scan.cpp

@@ -408,6 +408,7 @@ const std::unordered_map<const char*, int, str_hash, str_eq> KeywordMap {
     {"writeonly",WRITEONLY},
     {"atomic_uint",ATOMIC_UINT},
     {"volatile",VOLATILE},
+    {"nontemporal",NONTEMPORAL},
     {"patch",PATCH},
     {"sample",SAMPLE},
     {"subroutine",SUBROUTINE},
@@ -756,6 +757,8 @@ const std::unordered_map<const char*, int, str_hash, str_eq> KeywordMap {
     {"__function",FUNCTION},
     {"tensorLayoutNV",TENSORLAYOUTNV},
     {"tensorViewNV",TENSORVIEWNV},
+
+    {"coopvecNV",COOPVECNV},
 };
 const std::unordered_set<const char*, str_hash, str_eq> ReservedSet {
     "common",
@@ -1104,6 +1107,11 @@ int TScanContext::tokenizeIdentifier()
             (parseContext.version < 420 && ! parseContext.extensionTurnedOn(E_GL_ARB_shader_image_load_store))))
             reservedWord();
         return keyword;
+    case NONTEMPORAL:
+        if (parseContext.symbolTable.atBuiltInLevel() ||
+            (parseContext.extensionTurnedOn(E_GL_EXT_nontemporal_keyword)))
+            return keyword;
+        return identifierOrType();
     case PATCH:
         if (parseContext.symbolTable.atBuiltInLevel() ||
             (parseContext.isEsProfile() &&
@@ -1776,6 +1784,13 @@ int TScanContext::tokenizeIdentifier()
             return keyword;
         return identifierOrType();
 
+    case COOPVECNV:
+        afterType = true;
+        if (parseContext.symbolTable.atBuiltInLevel() ||
+            parseContext.extensionTurnedOn(E_GL_NV_cooperative_vector))
+            return keyword;
+        return identifierOrType();
+
     case DEMOTE:
         if (parseContext.extensionTurnedOn(E_GL_EXT_demote_to_helper_invocation))
             return keyword;

3rdparty/glslang/glslang/MachineIndependent/SymbolTable.cpp

@@ -60,6 +60,9 @@ void TType::buildMangledName(TString& mangledName) const
     else if (isVector())
         mangledName += 'v';
 
+    if (isCoopVecNV())
+        mangledName += "coopvec";
+
     switch (basicType) {
     case EbtFloat:              mangledName += 'f';      break;
     case EbtInt:                mangledName += 'i';      break;
@@ -163,6 +166,23 @@ void TType::buildMangledName(TString& mangledName) const
         mangledName += static_cast<char>('0' + getMatrixRows());
     }
 
+    if (typeParameters) {
+        const int maxSize = 11;
+        char buf[maxSize];
+        for (int i = 0; i < typeParameters->arraySizes->getNumDims(); ++i) {
+            if (typeParameters->arraySizes->getDimNode(i)) {
+                if (typeParameters->arraySizes->getDimNode(i)->getAsSymbolNode())
+                    snprintf(buf, maxSize, "s%lld", typeParameters->arraySizes->getDimNode(i)->getAsSymbolNode()->getId());
+                else
+                    snprintf(buf, maxSize, "s%p", typeParameters->arraySizes->getDimNode(i));
+            } else
+                snprintf(buf, maxSize, "%d", typeParameters->arraySizes->getDimSize(i));
+            mangledName += '<';
+            mangledName += buf;
+            mangledName += '>';
+        }
+    }
+
     if (arraySizes) {
         const int maxSize = 11;
         char buf[maxSize];

3rdparty/glslang/glslang/MachineIndependent/Versions.cpp

@@ -269,6 +269,7 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_EXT_spec_constant_composites]                = EBhDisable;
 
     extensionBehavior[E_GL_KHR_cooperative_matrix]                      = EBhDisable;
+    extensionBehavior[E_GL_NV_cooperative_vector]                       = EBhDisable;
 
     // #line and #include
     extensionBehavior[E_GL_GOOGLE_cpp_style_line_directive]          = EBhDisable;
@@ -312,6 +313,8 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_NV_displacement_micromap]                 = EBhDisable;
     extensionBehavior[E_GL_NV_shader_atomic_fp16_vector]             = EBhDisable;
     extensionBehavior[E_GL_NV_cooperative_matrix2]                   = EBhDisable;
+    extensionBehavior[E_GL_NV_cluster_acceleration_structure]        = EBhDisable;
+    extensionBehavior[E_GL_NV_linear_swept_spheres]                  = EBhDisable;
 
     // ARM
     extensionBehavior[E_GL_ARM_shader_core_builtins]                 = EBhDisable;
@@ -373,6 +376,8 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_EXT_texture_shadow_lod]          = EBhDisable;
     extensionBehavior[E_GL_EXT_draw_instanced]              = EBhDisable;
     extensionBehavior[E_GL_EXT_texture_array]               = EBhDisable;
+    extensionBehavior[E_GL_EXT_texture_offset_non_const]    = EBhDisable;
+    extensionBehavior[E_GL_EXT_nontemporal_keyword]         = EBhDisable;
 
     // OVR extensions
     extensionBehavior[E_GL_OVR_multiview]                = EBhDisable;
@@ -396,6 +401,8 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_EXT_shader_atomic_float]                    = EBhDisable;
     extensionBehavior[E_GL_EXT_shader_atomic_float2]                   = EBhDisable;
 
+    extensionBehavior[E_GL_EXT_integer_dot_product]                    = EBhDisable;
+
     // Record extensions not for spv.
     spvUnsupportedExt.push_back(E_GL_ARB_bindless_texture);
 }
@@ -603,6 +610,8 @@ void TParseVersions::getPreamble(std::string& preamble)
             "#define GL_EXT_texture_array 1\n"
 
             "#define GL_EXT_control_flow_attributes2 1\n"
+
+            "#define GL_EXT_integer_dot_product 1\n"
             ;
 
         if (spvVersion.spv == 0) {
@@ -635,6 +644,11 @@ void TParseVersions::getPreamble(std::string& preamble)
             ;
     }
 
+    if ((!isEsProfile() && version >= 130) ||
+        (isEsProfile() && version >= 300)) {
+        preamble += "#define GL_EXT_texture_offset_non_const 1\n";
+    }
+
     if (version >= 300 /* both ES and non-ES */) {
         preamble +=
             "#define GL_OVR_multiview 1\n"
@@ -1394,6 +1408,14 @@ void TParseVersions::tensorLayoutViewCheck(const TSourceLoc& loc, const char* op
     }
 }
 
+void TParseVersions::coopvecCheck(const TSourceLoc& loc, const char* op, bool builtIn)
+{
+    if (!builtIn) {
+        const char* const extensions[] = {E_GL_NV_cooperative_vector};
+        requireExtensions(loc, sizeof(extensions)/sizeof(extensions[0]), extensions, op);
+    }
+}
+
 // Call for any operation removed because SPIR-V is in use.
 void TParseVersions::spvRemoved(const TSourceLoc& loc, const char* op)
 {

3rdparty/glslang/glslang/MachineIndependent/Versions.h

@@ -4,6 +4,7 @@
 // Copyright (C) 2017, 2022-2024 Arm Limited.
 // Copyright (C) 2015-2018 Google, Inc.
 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
+// Modifications Copyright (C) 2024 Valve Corporation.
 //
 // All rights reserved.
 //
@@ -223,6 +224,8 @@ const char* const E_GL_EXT_maximal_reconvergence            = "GL_EXT_maximal_re
 const char* const E_GL_EXT_expect_assume                    = "GL_EXT_expect_assume";
 const char* const E_GL_EXT_control_flow_attributes2         = "GL_EXT_control_flow_attributes2";
 const char* const E_GL_EXT_spec_constant_composites         = "GL_EXT_spec_constant_composites";
+const char* const E_GL_EXT_texture_offset_non_const         = "GL_EXT_texture_offset_non_const";
+const char* const E_GL_EXT_nontemporal_keyword              = "GL_EXT_nontemporal_keyword";
 
 // Arrays of extensions for the above viewportEXTs duplications
 
@@ -283,6 +286,9 @@ const char* const E_GL_EXT_ray_tracing_position_fetch           = "GL_EXT_ray_tr
 const char* const E_GL_NV_displacement_micromap                 = "GL_NV_displacement_micromap";
 const char* const E_GL_NV_shader_atomic_fp16_vector             = "GL_NV_shader_atomic_fp16_vector";
 const char* const E_GL_NV_cooperative_matrix2                   = "GL_NV_cooperative_matrix2";
+const char* const E_GL_NV_cooperative_vector                    = "GL_NV_cooperative_vector";
+const char* const E_GL_NV_cluster_acceleration_structure        = "GL_NV_cluster_acceleration_structure";
+const char* const E_GL_NV_linear_swept_spheres                  = "GL_NV_linear_swept_spheres";
 
 // ARM
 const char* const E_GL_ARM_shader_core_builtins                 = "GL_ARM_shader_core_builtins";
@@ -348,6 +354,8 @@ const char* const E_GL_EXT_shader_tile_image = "GL_EXT_shader_tile_image";
 
 const char* const E_GL_EXT_texture_shadow_lod = "GL_EXT_texture_shadow_lod";
 
+const char* const E_GL_EXT_integer_dot_product                    = "GL_EXT_integer_dot_product";
+
 // Arrays of extensions for the above AEP duplications
 
 const char* const AEP_geometry_shader[] = { E_GL_EXT_geometry_shader, E_GL_OES_geometry_shader };

3rdparty/glslang/glslang/MachineIndependent/glslang.y

@@ -178,6 +178,7 @@ extern int yylex(YYSTYPE*, TParseContext&);
 %token <lex> RAYQUERYEXT
 %token <lex> FCOOPMATNV ICOOPMATNV UCOOPMATNV
 %token <lex> COOPMAT
+%token <lex> COOPVECNV
 %token <lex> HITOBJECTNV HITOBJECTATTRNV
 %token <lex> TENSORLAYOUTNV TENSORVIEWNV
 
@@ -280,7 +281,7 @@ extern int yylex(YYSTYPE*, TParseContext&);
 %token <lex> PAYLOADNV PAYLOADINNV HITATTRNV CALLDATANV CALLDATAINNV 
 %token <lex> PAYLOADEXT PAYLOADINEXT HITATTREXT CALLDATAEXT CALLDATAINEXT
 %token <lex> PATCH SAMPLE NONUNIFORM
-%token <lex> COHERENT VOLATILE RESTRICT READONLY WRITEONLY DEVICECOHERENT QUEUEFAMILYCOHERENT WORKGROUPCOHERENT
+%token <lex> COHERENT VOLATILE RESTRICT READONLY WRITEONLY NONTEMPORAL DEVICECOHERENT QUEUEFAMILYCOHERENT WORKGROUPCOHERENT
 %token <lex> SUBGROUPCOHERENT NONPRIVATE SHADERCALLCOHERENT
 %token <lex> NOPERSPECTIVE EXPLICITINTERPAMD PERVERTEXEXT PERVERTEXNV PERPRIMITIVENV PERVIEWNV PERTASKNV PERPRIMITIVEEXT TASKPAYLOADWORKGROUPEXT
 %token <lex> PRECISE
@@ -1105,7 +1106,7 @@ parameter_declaration
         $$ = $2;
         if ($1.qualifier.precision != EpqNone)
             $$.param.type->getQualifier().precision = $1.qualifier.precision;
-        parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMat());
+        parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMatOrVec());
 
         parseContext.checkNoShaderLayouts($1.loc, $1.shaderQualifiers);
         parseContext.parameterTypeCheck($2.loc, $1.qualifier.storage, *$$.param.type);
@@ -1117,7 +1118,7 @@ parameter_declaration
 
         parseContext.parameterTypeCheck($1.loc, EvqIn, *$1.param.type);
         parseContext.paramCheckFixStorage($1.loc, EvqTemporary, *$$.param.type);
-        parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMat());
+        parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMatOrVec());
     }
     //
     // Without name
@@ -1126,7 +1127,7 @@ parameter_declaration
         $$ = $2;
         if ($1.qualifier.precision != EpqNone)
             $$.param.type->getQualifier().precision = $1.qualifier.precision;
-        parseContext.precisionQualifierCheck($1.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMat());
+        parseContext.precisionQualifierCheck($1.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMatOrVec());
 
         parseContext.checkNoShaderLayouts($1.loc, $1.shaderQualifiers);
         parseContext.parameterTypeCheck($2.loc, $1.qualifier.storage, *$$.param.type);
@@ -1137,7 +1138,7 @@ parameter_declaration
 
         parseContext.parameterTypeCheck($1.loc, EvqIn, *$1.param.type);
         parseContext.paramCheckFixStorage($1.loc, EvqTemporary, *$$.param.type);
-        parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMat());
+        parseContext.precisionQualifierCheck($$.loc, $$.param.type->getBasicType(), $$.param.type->getQualifier(), $$.param.type->isCoopMatOrVec());
     }
     ;
 
@@ -1212,7 +1213,7 @@ fully_specified_type
             parseContext.profileRequires($1.loc, ENoProfile, 120, E_GL_3DL_array_objects, "arrayed type");
             parseContext.profileRequires($1.loc, EEsProfile, 300, 0, "arrayed type");
         }
-        parseContext.precisionQualifierCheck($$.loc, $$.basicType, $$.qualifier, $$.isCoopmat());
+        parseContext.precisionQualifierCheck($$.loc, $$.basicType, $$.qualifier, $$.isCoopmatOrvec());
     }
     | type_qualifier type_specifier  {
         parseContext.globalQualifierFixCheck($1.loc, $1.qualifier, false, &$2);
@@ -1229,7 +1230,7 @@ fully_specified_type
         parseContext.checkNoShaderLayouts($2.loc, $1.shaderQualifiers);
         $2.shaderQualifiers.merge($1.shaderQualifiers);
         parseContext.mergeQualifiers($2.loc, $2.qualifier, $1.qualifier, true);
-        parseContext.precisionQualifierCheck($2.loc, $2.basicType, $2.qualifier, $2.isCoopmat());
+        parseContext.precisionQualifierCheck($2.loc, $2.basicType, $2.qualifier, $2.isCoopmatOrvec());
 
         $$ = $2;
 
@@ -1657,6 +1658,10 @@ storage_qualifier
         $$.init($1.loc);
         $$.qualifier.writeonly = true;
     }
+    | NONTEMPORAL {
+        $$.init($1.loc);
+        $$.qualifier.nontemporal  = true;
+    }
     | SUBROUTINE {
         parseContext.spvRemoved($1.loc, "subroutine");
         parseContext.globalCheck($1.loc, "subroutine");
@@ -1701,7 +1706,7 @@ type_specifier
         $$ = $1;
         $$.qualifier.precision = parseContext.getDefaultPrecision($$);
         $$.typeParameters = $2;
-        parseContext.coopMatTypeParametersCheck($1.loc, $$);
+        parseContext.typeParametersCheck($1.loc, $$);
 
     }
     | type_specifier_nonarray type_parameter_specifier_opt array_specifier {
@@ -1710,7 +1715,7 @@ type_specifier
         $$.qualifier.precision = parseContext.getDefaultPrecision($$);
         $$.typeParameters = $2;
         $$.arraySizes = $3.arraySizes;
-        parseContext.coopMatTypeParametersCheck($1.loc, $$);
+        parseContext.typeParametersCheck($1.loc, $$);
     }
     ;
 
@@ -3550,6 +3555,12 @@ type_specifier_nonarray
         $$.init($1.loc);
         $$.basicType = EbtFunction;
     }
+    | COOPVECNV {
+        parseContext.coopvecCheck($1.loc, "coopvecNV", parseContext.symbolTable.atBuiltInLevel());
+        $$.init($1.loc, parseContext.symbolTable.atGlobalLevel());
+        $$.basicType = EbtCoopvecNV;
+        $$.coopvecNV = true;
+    }
     | spirv_type_specifier {
         parseContext.requireExtensions($1.loc, 1, &E_GL_EXT_spirv_intrinsics, "SPIR-V type specifier");
         $$ = $1;
@@ -3651,7 +3662,7 @@ struct_declaration
         $$ = $2;
 
         parseContext.voidErrorCheck($1.loc, (*$2)[0].type->getFieldName(), $1.basicType);
-        parseContext.precisionQualifierCheck($1.loc, $1.basicType, $1.qualifier, $1.isCoopmat());
+        parseContext.precisionQualifierCheck($1.loc, $1.basicType, $1.qualifier, $1.isCoopmatOrvec());
 
         for (unsigned int i = 0; i < $$->size(); ++i) {
             TType type($1);
@@ -3675,7 +3686,7 @@ struct_declaration
         parseContext.memberQualifierCheck($1);
         parseContext.voidErrorCheck($2.loc, (*$3)[0].type->getFieldName(), $2.basicType);
         parseContext.mergeQualifiers($2.loc, $2.qualifier, $1.qualifier, true);
-        parseContext.precisionQualifierCheck($2.loc, $2.basicType, $2.qualifier, $2.isCoopmat());
+        parseContext.precisionQualifierCheck($2.loc, $2.basicType, $2.qualifier, $2.isCoopmatOrvec());
 
         for (unsigned int i = 0; i < $$->size(); ++i) {
             TType type($2);

3rdparty/glslang/glslang/MachineIndependent/glslang_tab.cpp.h

@@ -218,307 +218,309 @@ extern int yydebug;
     ICOOPMATNV = 419,              /* ICOOPMATNV  */
     UCOOPMATNV = 420,              /* UCOOPMATNV  */
     COOPMAT = 421,                 /* COOPMAT  */
-    HITOBJECTNV = 422,             /* HITOBJECTNV  */
-    HITOBJECTATTRNV = 423,         /* HITOBJECTATTRNV  */
-    TENSORLAYOUTNV = 424,          /* TENSORLAYOUTNV  */
-    TENSORVIEWNV = 425,            /* TENSORVIEWNV  */
-    SAMPLERCUBEARRAY = 426,        /* SAMPLERCUBEARRAY  */
-    SAMPLERCUBEARRAYSHADOW = 427,  /* SAMPLERCUBEARRAYSHADOW  */
-    ISAMPLERCUBEARRAY = 428,       /* ISAMPLERCUBEARRAY  */
-    USAMPLERCUBEARRAY = 429,       /* USAMPLERCUBEARRAY  */
-    SAMPLER1D = 430,               /* SAMPLER1D  */
-    SAMPLER1DARRAY = 431,          /* SAMPLER1DARRAY  */
-    SAMPLER1DARRAYSHADOW = 432,    /* SAMPLER1DARRAYSHADOW  */
-    ISAMPLER1D = 433,              /* ISAMPLER1D  */
-    SAMPLER1DSHADOW = 434,         /* SAMPLER1DSHADOW  */
-    SAMPLER2DRECT = 435,           /* SAMPLER2DRECT  */
-    SAMPLER2DRECTSHADOW = 436,     /* SAMPLER2DRECTSHADOW  */
-    ISAMPLER2DRECT = 437,          /* ISAMPLER2DRECT  */
-    USAMPLER2DRECT = 438,          /* USAMPLER2DRECT  */
-    SAMPLERBUFFER = 439,           /* SAMPLERBUFFER  */
-    ISAMPLERBUFFER = 440,          /* ISAMPLERBUFFER  */
-    USAMPLERBUFFER = 441,          /* USAMPLERBUFFER  */
-    SAMPLER2DMS = 442,             /* SAMPLER2DMS  */
-    ISAMPLER2DMS = 443,            /* ISAMPLER2DMS  */
-    USAMPLER2DMS = 444,            /* USAMPLER2DMS  */
-    SAMPLER2DMSARRAY = 445,        /* SAMPLER2DMSARRAY  */
-    ISAMPLER2DMSARRAY = 446,       /* ISAMPLER2DMSARRAY  */
-    USAMPLER2DMSARRAY = 447,       /* USAMPLER2DMSARRAY  */
-    SAMPLEREXTERNALOES = 448,      /* SAMPLEREXTERNALOES  */
-    SAMPLEREXTERNAL2DY2YEXT = 449, /* SAMPLEREXTERNAL2DY2YEXT  */
-    ISAMPLER1DARRAY = 450,         /* ISAMPLER1DARRAY  */
-    USAMPLER1D = 451,              /* USAMPLER1D  */
-    USAMPLER1DARRAY = 452,         /* USAMPLER1DARRAY  */
-    F16SAMPLER1D = 453,            /* F16SAMPLER1D  */
-    F16SAMPLER2D = 454,            /* F16SAMPLER2D  */
-    F16SAMPLER3D = 455,            /* F16SAMPLER3D  */
-    F16SAMPLER2DRECT = 456,        /* F16SAMPLER2DRECT  */
-    F16SAMPLERCUBE = 457,          /* F16SAMPLERCUBE  */
-    F16SAMPLER1DARRAY = 458,       /* F16SAMPLER1DARRAY  */
-    F16SAMPLER2DARRAY = 459,       /* F16SAMPLER2DARRAY  */
-    F16SAMPLERCUBEARRAY = 460,     /* F16SAMPLERCUBEARRAY  */
-    F16SAMPLERBUFFER = 461,        /* F16SAMPLERBUFFER  */
-    F16SAMPLER2DMS = 462,          /* F16SAMPLER2DMS  */
-    F16SAMPLER2DMSARRAY = 463,     /* F16SAMPLER2DMSARRAY  */
-    F16SAMPLER1DSHADOW = 464,      /* F16SAMPLER1DSHADOW  */
-    F16SAMPLER2DSHADOW = 465,      /* F16SAMPLER2DSHADOW  */
-    F16SAMPLER1DARRAYSHADOW = 466, /* F16SAMPLER1DARRAYSHADOW  */
-    F16SAMPLER2DARRAYSHADOW = 467, /* F16SAMPLER2DARRAYSHADOW  */
-    F16SAMPLER2DRECTSHADOW = 468,  /* F16SAMPLER2DRECTSHADOW  */
-    F16SAMPLERCUBESHADOW = 469,    /* F16SAMPLERCUBESHADOW  */
-    F16SAMPLERCUBEARRAYSHADOW = 470, /* F16SAMPLERCUBEARRAYSHADOW  */
-    IMAGE1D = 471,                 /* IMAGE1D  */
-    IIMAGE1D = 472,                /* IIMAGE1D  */
-    UIMAGE1D = 473,                /* UIMAGE1D  */
-    IMAGE2D = 474,                 /* IMAGE2D  */
-    IIMAGE2D = 475,                /* IIMAGE2D  */
-    UIMAGE2D = 476,                /* UIMAGE2D  */
-    IMAGE3D = 477,                 /* IMAGE3D  */
-    IIMAGE3D = 478,                /* IIMAGE3D  */
-    UIMAGE3D = 479,                /* UIMAGE3D  */
-    IMAGE2DRECT = 480,             /* IMAGE2DRECT  */
-    IIMAGE2DRECT = 481,            /* IIMAGE2DRECT  */
-    UIMAGE2DRECT = 482,            /* UIMAGE2DRECT  */
-    IMAGECUBE = 483,               /* IMAGECUBE  */
-    IIMAGECUBE = 484,              /* IIMAGECUBE  */
-    UIMAGECUBE = 485,              /* UIMAGECUBE  */
-    IMAGEBUFFER = 486,             /* IMAGEBUFFER  */
-    IIMAGEBUFFER = 487,            /* IIMAGEBUFFER  */
-    UIMAGEBUFFER = 488,            /* UIMAGEBUFFER  */
-    IMAGE1DARRAY = 489,            /* IMAGE1DARRAY  */
-    IIMAGE1DARRAY = 490,           /* IIMAGE1DARRAY  */
-    UIMAGE1DARRAY = 491,           /* UIMAGE1DARRAY  */
-    IMAGE2DARRAY = 492,            /* IMAGE2DARRAY  */
-    IIMAGE2DARRAY = 493,           /* IIMAGE2DARRAY  */
-    UIMAGE2DARRAY = 494,           /* UIMAGE2DARRAY  */
-    IMAGECUBEARRAY = 495,          /* IMAGECUBEARRAY  */
-    IIMAGECUBEARRAY = 496,         /* IIMAGECUBEARRAY  */
-    UIMAGECUBEARRAY = 497,         /* UIMAGECUBEARRAY  */
-    IMAGE2DMS = 498,               /* IMAGE2DMS  */
-    IIMAGE2DMS = 499,              /* IIMAGE2DMS  */
-    UIMAGE2DMS = 500,              /* UIMAGE2DMS  */
-    IMAGE2DMSARRAY = 501,          /* IMAGE2DMSARRAY  */
-    IIMAGE2DMSARRAY = 502,         /* IIMAGE2DMSARRAY  */
-    UIMAGE2DMSARRAY = 503,         /* UIMAGE2DMSARRAY  */
-    F16IMAGE1D = 504,              /* F16IMAGE1D  */
-    F16IMAGE2D = 505,              /* F16IMAGE2D  */
-    F16IMAGE3D = 506,              /* F16IMAGE3D  */
-    F16IMAGE2DRECT = 507,          /* F16IMAGE2DRECT  */
-    F16IMAGECUBE = 508,            /* F16IMAGECUBE  */
-    F16IMAGE1DARRAY = 509,         /* F16IMAGE1DARRAY  */
-    F16IMAGE2DARRAY = 510,         /* F16IMAGE2DARRAY  */
-    F16IMAGECUBEARRAY = 511,       /* F16IMAGECUBEARRAY  */
-    F16IMAGEBUFFER = 512,          /* F16IMAGEBUFFER  */
-    F16IMAGE2DMS = 513,            /* F16IMAGE2DMS  */
-    F16IMAGE2DMSARRAY = 514,       /* F16IMAGE2DMSARRAY  */
-    I64IMAGE1D = 515,              /* I64IMAGE1D  */
-    U64IMAGE1D = 516,              /* U64IMAGE1D  */
-    I64IMAGE2D = 517,              /* I64IMAGE2D  */
-    U64IMAGE2D = 518,              /* U64IMAGE2D  */
-    I64IMAGE3D = 519,              /* I64IMAGE3D  */
-    U64IMAGE3D = 520,              /* U64IMAGE3D  */
-    I64IMAGE2DRECT = 521,          /* I64IMAGE2DRECT  */
-    U64IMAGE2DRECT = 522,          /* U64IMAGE2DRECT  */
-    I64IMAGECUBE = 523,            /* I64IMAGECUBE  */
-    U64IMAGECUBE = 524,            /* U64IMAGECUBE  */
-    I64IMAGEBUFFER = 525,          /* I64IMAGEBUFFER  */
-    U64IMAGEBUFFER = 526,          /* U64IMAGEBUFFER  */
-    I64IMAGE1DARRAY = 527,         /* I64IMAGE1DARRAY  */
-    U64IMAGE1DARRAY = 528,         /* U64IMAGE1DARRAY  */
-    I64IMAGE2DARRAY = 529,         /* I64IMAGE2DARRAY  */
-    U64IMAGE2DARRAY = 530,         /* U64IMAGE2DARRAY  */
-    I64IMAGECUBEARRAY = 531,       /* I64IMAGECUBEARRAY  */
-    U64IMAGECUBEARRAY = 532,       /* U64IMAGECUBEARRAY  */
-    I64IMAGE2DMS = 533,            /* I64IMAGE2DMS  */
-    U64IMAGE2DMS = 534,            /* U64IMAGE2DMS  */
-    I64IMAGE2DMSARRAY = 535,       /* I64IMAGE2DMSARRAY  */
-    U64IMAGE2DMSARRAY = 536,       /* U64IMAGE2DMSARRAY  */
-    TEXTURECUBEARRAY = 537,        /* TEXTURECUBEARRAY  */
-    ITEXTURECUBEARRAY = 538,       /* ITEXTURECUBEARRAY  */
-    UTEXTURECUBEARRAY = 539,       /* UTEXTURECUBEARRAY  */
-    TEXTURE1D = 540,               /* TEXTURE1D  */
-    ITEXTURE1D = 541,              /* ITEXTURE1D  */
-    UTEXTURE1D = 542,              /* UTEXTURE1D  */
-    TEXTURE1DARRAY = 543,          /* TEXTURE1DARRAY  */
-    ITEXTURE1DARRAY = 544,         /* ITEXTURE1DARRAY  */
-    UTEXTURE1DARRAY = 545,         /* UTEXTURE1DARRAY  */
-    TEXTURE2DRECT = 546,           /* TEXTURE2DRECT  */
-    ITEXTURE2DRECT = 547,          /* ITEXTURE2DRECT  */
-    UTEXTURE2DRECT = 548,          /* UTEXTURE2DRECT  */
-    TEXTUREBUFFER = 549,           /* TEXTUREBUFFER  */
-    ITEXTUREBUFFER = 550,          /* ITEXTUREBUFFER  */
-    UTEXTUREBUFFER = 551,          /* UTEXTUREBUFFER  */
-    TEXTURE2DMS = 552,             /* TEXTURE2DMS  */
-    ITEXTURE2DMS = 553,            /* ITEXTURE2DMS  */
-    UTEXTURE2DMS = 554,            /* UTEXTURE2DMS  */
-    TEXTURE2DMSARRAY = 555,        /* TEXTURE2DMSARRAY  */
-    ITEXTURE2DMSARRAY = 556,       /* ITEXTURE2DMSARRAY  */
-    UTEXTURE2DMSARRAY = 557,       /* UTEXTURE2DMSARRAY  */
-    F16TEXTURE1D = 558,            /* F16TEXTURE1D  */
-    F16TEXTURE2D = 559,            /* F16TEXTURE2D  */
-    F16TEXTURE3D = 560,            /* F16TEXTURE3D  */
-    F16TEXTURE2DRECT = 561,        /* F16TEXTURE2DRECT  */
-    F16TEXTURECUBE = 562,          /* F16TEXTURECUBE  */
-    F16TEXTURE1DARRAY = 563,       /* F16TEXTURE1DARRAY  */
-    F16TEXTURE2DARRAY = 564,       /* F16TEXTURE2DARRAY  */
-    F16TEXTURECUBEARRAY = 565,     /* F16TEXTURECUBEARRAY  */
-    F16TEXTUREBUFFER = 566,        /* F16TEXTUREBUFFER  */
-    F16TEXTURE2DMS = 567,          /* F16TEXTURE2DMS  */
-    F16TEXTURE2DMSARRAY = 568,     /* F16TEXTURE2DMSARRAY  */
-    SUBPASSINPUT = 569,            /* SUBPASSINPUT  */
-    SUBPASSINPUTMS = 570,          /* SUBPASSINPUTMS  */
-    ISUBPASSINPUT = 571,           /* ISUBPASSINPUT  */
-    ISUBPASSINPUTMS = 572,         /* ISUBPASSINPUTMS  */
-    USUBPASSINPUT = 573,           /* USUBPASSINPUT  */
-    USUBPASSINPUTMS = 574,         /* USUBPASSINPUTMS  */
-    F16SUBPASSINPUT = 575,         /* F16SUBPASSINPUT  */
-    F16SUBPASSINPUTMS = 576,       /* F16SUBPASSINPUTMS  */
-    SPIRV_INSTRUCTION = 577,       /* SPIRV_INSTRUCTION  */
-    SPIRV_EXECUTION_MODE = 578,    /* SPIRV_EXECUTION_MODE  */
-    SPIRV_EXECUTION_MODE_ID = 579, /* SPIRV_EXECUTION_MODE_ID  */
-    SPIRV_DECORATE = 580,          /* SPIRV_DECORATE  */
-    SPIRV_DECORATE_ID = 581,       /* SPIRV_DECORATE_ID  */
-    SPIRV_DECORATE_STRING = 582,   /* SPIRV_DECORATE_STRING  */
-    SPIRV_TYPE = 583,              /* SPIRV_TYPE  */
-    SPIRV_STORAGE_CLASS = 584,     /* SPIRV_STORAGE_CLASS  */
-    SPIRV_BY_REFERENCE = 585,      /* SPIRV_BY_REFERENCE  */
-    SPIRV_LITERAL = 586,           /* SPIRV_LITERAL  */
-    ATTACHMENTEXT = 587,           /* ATTACHMENTEXT  */
-    IATTACHMENTEXT = 588,          /* IATTACHMENTEXT  */
-    UATTACHMENTEXT = 589,          /* UATTACHMENTEXT  */
-    LEFT_OP = 590,                 /* LEFT_OP  */
-    RIGHT_OP = 591,                /* RIGHT_OP  */
-    INC_OP = 592,                  /* INC_OP  */
-    DEC_OP = 593,                  /* DEC_OP  */
-    LE_OP = 594,                   /* LE_OP  */
-    GE_OP = 595,                   /* GE_OP  */
-    EQ_OP = 596,                   /* EQ_OP  */
-    NE_OP = 597,                   /* NE_OP  */
-    AND_OP = 598,                  /* AND_OP  */
-    OR_OP = 599,                   /* OR_OP  */
-    XOR_OP = 600,                  /* XOR_OP  */
-    MUL_ASSIGN = 601,              /* MUL_ASSIGN  */
-    DIV_ASSIGN = 602,              /* DIV_ASSIGN  */
-    ADD_ASSIGN = 603,              /* ADD_ASSIGN  */
-    MOD_ASSIGN = 604,              /* MOD_ASSIGN  */
-    LEFT_ASSIGN = 605,             /* LEFT_ASSIGN  */
-    RIGHT_ASSIGN = 606,            /* RIGHT_ASSIGN  */
-    AND_ASSIGN = 607,              /* AND_ASSIGN  */
-    XOR_ASSIGN = 608,              /* XOR_ASSIGN  */
-    OR_ASSIGN = 609,               /* OR_ASSIGN  */
-    SUB_ASSIGN = 610,              /* SUB_ASSIGN  */
-    STRING_LITERAL = 611,          /* STRING_LITERAL  */
-    LEFT_PAREN = 612,              /* LEFT_PAREN  */
-    RIGHT_PAREN = 613,             /* RIGHT_PAREN  */
-    LEFT_BRACKET = 614,            /* LEFT_BRACKET  */
-    RIGHT_BRACKET = 615,           /* RIGHT_BRACKET  */
-    LEFT_BRACE = 616,              /* LEFT_BRACE  */
-    RIGHT_BRACE = 617,             /* RIGHT_BRACE  */
-    DOT = 618,                     /* DOT  */
-    COMMA = 619,                   /* COMMA  */
-    COLON = 620,                   /* COLON  */
-    EQUAL = 621,                   /* EQUAL  */
-    SEMICOLON = 622,               /* SEMICOLON  */
-    BANG = 623,                    /* BANG  */
-    DASH = 624,                    /* DASH  */
-    TILDE = 625,                   /* TILDE  */
-    PLUS = 626,                    /* PLUS  */
-    STAR = 627,                    /* STAR  */
-    SLASH = 628,                   /* SLASH  */
-    PERCENT = 629,                 /* PERCENT  */
-    LEFT_ANGLE = 630,              /* LEFT_ANGLE  */
-    RIGHT_ANGLE = 631,             /* RIGHT_ANGLE  */
-    VERTICAL_BAR = 632,            /* VERTICAL_BAR  */
-    CARET = 633,                   /* CARET  */
-    AMPERSAND = 634,               /* AMPERSAND  */
-    QUESTION = 635,                /* QUESTION  */
-    INVARIANT = 636,               /* INVARIANT  */
-    HIGH_PRECISION = 637,          /* HIGH_PRECISION  */
-    MEDIUM_PRECISION = 638,        /* MEDIUM_PRECISION  */
-    LOW_PRECISION = 639,           /* LOW_PRECISION  */
-    PRECISION = 640,               /* PRECISION  */
-    PACKED = 641,                  /* PACKED  */
-    RESOURCE = 642,                /* RESOURCE  */
-    SUPERP = 643,                  /* SUPERP  */
-    FLOATCONSTANT = 644,           /* FLOATCONSTANT  */
-    INTCONSTANT = 645,             /* INTCONSTANT  */
-    UINTCONSTANT = 646,            /* UINTCONSTANT  */
-    BOOLCONSTANT = 647,            /* BOOLCONSTANT  */
-    IDENTIFIER = 648,              /* IDENTIFIER  */
-    TYPE_NAME = 649,               /* TYPE_NAME  */
-    CENTROID = 650,                /* CENTROID  */
-    IN = 651,                      /* IN  */
-    OUT = 652,                     /* OUT  */
-    INOUT = 653,                   /* INOUT  */
-    STRUCT = 654,                  /* STRUCT  */
-    VOID = 655,                    /* VOID  */
-    WHILE = 656,                   /* WHILE  */
-    BREAK = 657,                   /* BREAK  */
-    CONTINUE = 658,                /* CONTINUE  */
-    DO = 659,                      /* DO  */
-    ELSE = 660,                    /* ELSE  */
-    FOR = 661,                     /* FOR  */
-    IF = 662,                      /* IF  */
-    DISCARD = 663,                 /* DISCARD  */
-    RETURN = 664,                  /* RETURN  */
-    SWITCH = 665,                  /* SWITCH  */
-    CASE = 666,                    /* CASE  */
-    DEFAULT = 667,                 /* DEFAULT  */
-    TERMINATE_INVOCATION = 668,    /* TERMINATE_INVOCATION  */
-    TERMINATE_RAY = 669,           /* TERMINATE_RAY  */
-    IGNORE_INTERSECTION = 670,     /* IGNORE_INTERSECTION  */
-    UNIFORM = 671,                 /* UNIFORM  */
-    SHARED = 672,                  /* SHARED  */
-    BUFFER = 673,                  /* BUFFER  */
-    TILEIMAGEEXT = 674,            /* TILEIMAGEEXT  */
-    FLAT = 675,                    /* FLAT  */
-    SMOOTH = 676,                  /* SMOOTH  */
-    LAYOUT = 677,                  /* LAYOUT  */
-    DOUBLECONSTANT = 678,          /* DOUBLECONSTANT  */
-    INT16CONSTANT = 679,           /* INT16CONSTANT  */
-    UINT16CONSTANT = 680,          /* UINT16CONSTANT  */
-    FLOAT16CONSTANT = 681,         /* FLOAT16CONSTANT  */
-    INT32CONSTANT = 682,           /* INT32CONSTANT  */
-    UINT32CONSTANT = 683,          /* UINT32CONSTANT  */
-    INT64CONSTANT = 684,           /* INT64CONSTANT  */
-    UINT64CONSTANT = 685,          /* UINT64CONSTANT  */
-    SUBROUTINE = 686,              /* SUBROUTINE  */
-    DEMOTE = 687,                  /* DEMOTE  */
-    FUNCTION = 688,                /* FUNCTION  */
-    PAYLOADNV = 689,               /* PAYLOADNV  */
-    PAYLOADINNV = 690,             /* PAYLOADINNV  */
-    HITATTRNV = 691,               /* HITATTRNV  */
-    CALLDATANV = 692,              /* CALLDATANV  */
-    CALLDATAINNV = 693,            /* CALLDATAINNV  */
-    PAYLOADEXT = 694,              /* PAYLOADEXT  */
-    PAYLOADINEXT = 695,            /* PAYLOADINEXT  */
-    HITATTREXT = 696,              /* HITATTREXT  */
-    CALLDATAEXT = 697,             /* CALLDATAEXT  */
-    CALLDATAINEXT = 698,           /* CALLDATAINEXT  */
-    PATCH = 699,                   /* PATCH  */
-    SAMPLE = 700,                  /* SAMPLE  */
-    NONUNIFORM = 701,              /* NONUNIFORM  */
-    COHERENT = 702,                /* COHERENT  */
-    VOLATILE = 703,                /* VOLATILE  */
-    RESTRICT = 704,                /* RESTRICT  */
-    READONLY = 705,                /* READONLY  */
-    WRITEONLY = 706,               /* WRITEONLY  */
-    DEVICECOHERENT = 707,          /* DEVICECOHERENT  */
-    QUEUEFAMILYCOHERENT = 708,     /* QUEUEFAMILYCOHERENT  */
-    WORKGROUPCOHERENT = 709,       /* WORKGROUPCOHERENT  */
-    SUBGROUPCOHERENT = 710,        /* SUBGROUPCOHERENT  */
-    NONPRIVATE = 711,              /* NONPRIVATE  */
-    SHADERCALLCOHERENT = 712,      /* SHADERCALLCOHERENT  */
-    NOPERSPECTIVE = 713,           /* NOPERSPECTIVE  */
-    EXPLICITINTERPAMD = 714,       /* EXPLICITINTERPAMD  */
-    PERVERTEXEXT = 715,            /* PERVERTEXEXT  */
-    PERVERTEXNV = 716,             /* PERVERTEXNV  */
-    PERPRIMITIVENV = 717,          /* PERPRIMITIVENV  */
-    PERVIEWNV = 718,               /* PERVIEWNV  */
-    PERTASKNV = 719,               /* PERTASKNV  */
-    PERPRIMITIVEEXT = 720,         /* PERPRIMITIVEEXT  */
-    TASKPAYLOADWORKGROUPEXT = 721, /* TASKPAYLOADWORKGROUPEXT  */
-    PRECISE = 722                  /* PRECISE  */
+    COOPVECNV = 422,               /* COOPVECNV  */
+    HITOBJECTNV = 423,             /* HITOBJECTNV  */
+    HITOBJECTATTRNV = 424,         /* HITOBJECTATTRNV  */
+    TENSORLAYOUTNV = 425,          /* TENSORLAYOUTNV  */
+    TENSORVIEWNV = 426,            /* TENSORVIEWNV  */
+    SAMPLERCUBEARRAY = 427,        /* SAMPLERCUBEARRAY  */
+    SAMPLERCUBEARRAYSHADOW = 428,  /* SAMPLERCUBEARRAYSHADOW  */
+    ISAMPLERCUBEARRAY = 429,       /* ISAMPLERCUBEARRAY  */
+    USAMPLERCUBEARRAY = 430,       /* USAMPLERCUBEARRAY  */
+    SAMPLER1D = 431,               /* SAMPLER1D  */
+    SAMPLER1DARRAY = 432,          /* SAMPLER1DARRAY  */
+    SAMPLER1DARRAYSHADOW = 433,    /* SAMPLER1DARRAYSHADOW  */
+    ISAMPLER1D = 434,              /* ISAMPLER1D  */
+    SAMPLER1DSHADOW = 435,         /* SAMPLER1DSHADOW  */
+    SAMPLER2DRECT = 436,           /* SAMPLER2DRECT  */
+    SAMPLER2DRECTSHADOW = 437,     /* SAMPLER2DRECTSHADOW  */
+    ISAMPLER2DRECT = 438,          /* ISAMPLER2DRECT  */
+    USAMPLER2DRECT = 439,          /* USAMPLER2DRECT  */
+    SAMPLERBUFFER = 440,           /* SAMPLERBUFFER  */
+    ISAMPLERBUFFER = 441,          /* ISAMPLERBUFFER  */
+    USAMPLERBUFFER = 442,          /* USAMPLERBUFFER  */
+    SAMPLER2DMS = 443,             /* SAMPLER2DMS  */
+    ISAMPLER2DMS = 444,            /* ISAMPLER2DMS  */
+    USAMPLER2DMS = 445,            /* USAMPLER2DMS  */
+    SAMPLER2DMSARRAY = 446,        /* SAMPLER2DMSARRAY  */
+    ISAMPLER2DMSARRAY = 447,       /* ISAMPLER2DMSARRAY  */
+    USAMPLER2DMSARRAY = 448,       /* USAMPLER2DMSARRAY  */
+    SAMPLEREXTERNALOES = 449,      /* SAMPLEREXTERNALOES  */
+    SAMPLEREXTERNAL2DY2YEXT = 450, /* SAMPLEREXTERNAL2DY2YEXT  */
+    ISAMPLER1DARRAY = 451,         /* ISAMPLER1DARRAY  */
+    USAMPLER1D = 452,              /* USAMPLER1D  */
+    USAMPLER1DARRAY = 453,         /* USAMPLER1DARRAY  */
+    F16SAMPLER1D = 454,            /* F16SAMPLER1D  */
+    F16SAMPLER2D = 455,            /* F16SAMPLER2D  */
+    F16SAMPLER3D = 456,            /* F16SAMPLER3D  */
+    F16SAMPLER2DRECT = 457,        /* F16SAMPLER2DRECT  */
+    F16SAMPLERCUBE = 458,          /* F16SAMPLERCUBE  */
+    F16SAMPLER1DARRAY = 459,       /* F16SAMPLER1DARRAY  */
+    F16SAMPLER2DARRAY = 460,       /* F16SAMPLER2DARRAY  */
+    F16SAMPLERCUBEARRAY = 461,     /* F16SAMPLERCUBEARRAY  */
+    F16SAMPLERBUFFER = 462,        /* F16SAMPLERBUFFER  */
+    F16SAMPLER2DMS = 463,          /* F16SAMPLER2DMS  */
+    F16SAMPLER2DMSARRAY = 464,     /* F16SAMPLER2DMSARRAY  */
+    F16SAMPLER1DSHADOW = 465,      /* F16SAMPLER1DSHADOW  */
+    F16SAMPLER2DSHADOW = 466,      /* F16SAMPLER2DSHADOW  */
+    F16SAMPLER1DARRAYSHADOW = 467, /* F16SAMPLER1DARRAYSHADOW  */
+    F16SAMPLER2DARRAYSHADOW = 468, /* F16SAMPLER2DARRAYSHADOW  */
+    F16SAMPLER2DRECTSHADOW = 469,  /* F16SAMPLER2DRECTSHADOW  */
+    F16SAMPLERCUBESHADOW = 470,    /* F16SAMPLERCUBESHADOW  */
+    F16SAMPLERCUBEARRAYSHADOW = 471, /* F16SAMPLERCUBEARRAYSHADOW  */
+    IMAGE1D = 472,                 /* IMAGE1D  */
+    IIMAGE1D = 473,                /* IIMAGE1D  */
+    UIMAGE1D = 474,                /* UIMAGE1D  */
+    IMAGE2D = 475,                 /* IMAGE2D  */
+    IIMAGE2D = 476,                /* IIMAGE2D  */
+    UIMAGE2D = 477,                /* UIMAGE2D  */
+    IMAGE3D = 478,                 /* IMAGE3D  */
+    IIMAGE3D = 479,                /* IIMAGE3D  */
+    UIMAGE3D = 480,                /* UIMAGE3D  */
+    IMAGE2DRECT = 481,             /* IMAGE2DRECT  */
+    IIMAGE2DRECT = 482,            /* IIMAGE2DRECT  */
+    UIMAGE2DRECT = 483,            /* UIMAGE2DRECT  */
+    IMAGECUBE = 484,               /* IMAGECUBE  */
+    IIMAGECUBE = 485,              /* IIMAGECUBE  */
+    UIMAGECUBE = 486,              /* UIMAGECUBE  */
+    IMAGEBUFFER = 487,             /* IMAGEBUFFER  */
+    IIMAGEBUFFER = 488,            /* IIMAGEBUFFER  */
+    UIMAGEBUFFER = 489,            /* UIMAGEBUFFER  */
+    IMAGE1DARRAY = 490,            /* IMAGE1DARRAY  */
+    IIMAGE1DARRAY = 491,           /* IIMAGE1DARRAY  */
+    UIMAGE1DARRAY = 492,           /* UIMAGE1DARRAY  */
+    IMAGE2DARRAY = 493,            /* IMAGE2DARRAY  */
+    IIMAGE2DARRAY = 494,           /* IIMAGE2DARRAY  */
+    UIMAGE2DARRAY = 495,           /* UIMAGE2DARRAY  */
+    IMAGECUBEARRAY = 496,          /* IMAGECUBEARRAY  */
+    IIMAGECUBEARRAY = 497,         /* IIMAGECUBEARRAY  */
+    UIMAGECUBEARRAY = 498,         /* UIMAGECUBEARRAY  */
+    IMAGE2DMS = 499,               /* IMAGE2DMS  */
+    IIMAGE2DMS = 500,              /* IIMAGE2DMS  */
+    UIMAGE2DMS = 501,              /* UIMAGE2DMS  */
+    IMAGE2DMSARRAY = 502,          /* IMAGE2DMSARRAY  */
+    IIMAGE2DMSARRAY = 503,         /* IIMAGE2DMSARRAY  */
+    UIMAGE2DMSARRAY = 504,         /* UIMAGE2DMSARRAY  */
+    F16IMAGE1D = 505,              /* F16IMAGE1D  */
+    F16IMAGE2D = 506,              /* F16IMAGE2D  */
+    F16IMAGE3D = 507,              /* F16IMAGE3D  */
+    F16IMAGE2DRECT = 508,          /* F16IMAGE2DRECT  */
+    F16IMAGECUBE = 509,            /* F16IMAGECUBE  */
+    F16IMAGE1DARRAY = 510,         /* F16IMAGE1DARRAY  */
+    F16IMAGE2DARRAY = 511,         /* F16IMAGE2DARRAY  */
+    F16IMAGECUBEARRAY = 512,       /* F16IMAGECUBEARRAY  */
+    F16IMAGEBUFFER = 513,          /* F16IMAGEBUFFER  */
+    F16IMAGE2DMS = 514,            /* F16IMAGE2DMS  */
+    F16IMAGE2DMSARRAY = 515,       /* F16IMAGE2DMSARRAY  */
+    I64IMAGE1D = 516,              /* I64IMAGE1D  */
+    U64IMAGE1D = 517,              /* U64IMAGE1D  */
+    I64IMAGE2D = 518,              /* I64IMAGE2D  */
+    U64IMAGE2D = 519,              /* U64IMAGE2D  */
+    I64IMAGE3D = 520,              /* I64IMAGE3D  */
+    U64IMAGE3D = 521,              /* U64IMAGE3D  */
+    I64IMAGE2DRECT = 522,          /* I64IMAGE2DRECT  */
+    U64IMAGE2DRECT = 523,          /* U64IMAGE2DRECT  */
+    I64IMAGECUBE = 524,            /* I64IMAGECUBE  */
+    U64IMAGECUBE = 525,            /* U64IMAGECUBE  */
+    I64IMAGEBUFFER = 526,          /* I64IMAGEBUFFER  */
+    U64IMAGEBUFFER = 527,          /* U64IMAGEBUFFER  */
+    I64IMAGE1DARRAY = 528,         /* I64IMAGE1DARRAY  */
+    U64IMAGE1DARRAY = 529,         /* U64IMAGE1DARRAY  */
+    I64IMAGE2DARRAY = 530,         /* I64IMAGE2DARRAY  */
+    U64IMAGE2DARRAY = 531,         /* U64IMAGE2DARRAY  */
+    I64IMAGECUBEARRAY = 532,       /* I64IMAGECUBEARRAY  */
+    U64IMAGECUBEARRAY = 533,       /* U64IMAGECUBEARRAY  */
+    I64IMAGE2DMS = 534,            /* I64IMAGE2DMS  */
+    U64IMAGE2DMS = 535,            /* U64IMAGE2DMS  */
+    I64IMAGE2DMSARRAY = 536,       /* I64IMAGE2DMSARRAY  */
+    U64IMAGE2DMSARRAY = 537,       /* U64IMAGE2DMSARRAY  */
+    TEXTURECUBEARRAY = 538,        /* TEXTURECUBEARRAY  */
+    ITEXTURECUBEARRAY = 539,       /* ITEXTURECUBEARRAY  */
+    UTEXTURECUBEARRAY = 540,       /* UTEXTURECUBEARRAY  */
+    TEXTURE1D = 541,               /* TEXTURE1D  */
+    ITEXTURE1D = 542,              /* ITEXTURE1D  */
+    UTEXTURE1D = 543,              /* UTEXTURE1D  */
+    TEXTURE1DARRAY = 544,          /* TEXTURE1DARRAY  */
+    ITEXTURE1DARRAY = 545,         /* ITEXTURE1DARRAY  */
+    UTEXTURE1DARRAY = 546,         /* UTEXTURE1DARRAY  */
+    TEXTURE2DRECT = 547,           /* TEXTURE2DRECT  */
+    ITEXTURE2DRECT = 548,          /* ITEXTURE2DRECT  */
+    UTEXTURE2DRECT = 549,          /* UTEXTURE2DRECT  */
+    TEXTUREBUFFER = 550,           /* TEXTUREBUFFER  */
+    ITEXTUREBUFFER = 551,          /* ITEXTUREBUFFER  */
+    UTEXTUREBUFFER = 552,          /* UTEXTUREBUFFER  */
+    TEXTURE2DMS = 553,             /* TEXTURE2DMS  */
+    ITEXTURE2DMS = 554,            /* ITEXTURE2DMS  */
+    UTEXTURE2DMS = 555,            /* UTEXTURE2DMS  */
+    TEXTURE2DMSARRAY = 556,        /* TEXTURE2DMSARRAY  */
+    ITEXTURE2DMSARRAY = 557,       /* ITEXTURE2DMSARRAY  */
+    UTEXTURE2DMSARRAY = 558,       /* UTEXTURE2DMSARRAY  */
+    F16TEXTURE1D = 559,            /* F16TEXTURE1D  */
+    F16TEXTURE2D = 560,            /* F16TEXTURE2D  */
+    F16TEXTURE3D = 561,            /* F16TEXTURE3D  */
+    F16TEXTURE2DRECT = 562,        /* F16TEXTURE2DRECT  */
+    F16TEXTURECUBE = 563,          /* F16TEXTURECUBE  */
+    F16TEXTURE1DARRAY = 564,       /* F16TEXTURE1DARRAY  */
+    F16TEXTURE2DARRAY = 565,       /* F16TEXTURE2DARRAY  */
+    F16TEXTURECUBEARRAY = 566,     /* F16TEXTURECUBEARRAY  */
+    F16TEXTUREBUFFER = 567,        /* F16TEXTUREBUFFER  */
+    F16TEXTURE2DMS = 568,          /* F16TEXTURE2DMS  */
+    F16TEXTURE2DMSARRAY = 569,     /* F16TEXTURE2DMSARRAY  */
+    SUBPASSINPUT = 570,            /* SUBPASSINPUT  */
+    SUBPASSINPUTMS = 571,          /* SUBPASSINPUTMS  */
+    ISUBPASSINPUT = 572,           /* ISUBPASSINPUT  */
+    ISUBPASSINPUTMS = 573,         /* ISUBPASSINPUTMS  */
+    USUBPASSINPUT = 574,           /* USUBPASSINPUT  */
+    USUBPASSINPUTMS = 575,         /* USUBPASSINPUTMS  */
+    F16SUBPASSINPUT = 576,         /* F16SUBPASSINPUT  */
+    F16SUBPASSINPUTMS = 577,       /* F16SUBPASSINPUTMS  */
+    SPIRV_INSTRUCTION = 578,       /* SPIRV_INSTRUCTION  */
+    SPIRV_EXECUTION_MODE = 579,    /* SPIRV_EXECUTION_MODE  */
+    SPIRV_EXECUTION_MODE_ID = 580, /* SPIRV_EXECUTION_MODE_ID  */
+    SPIRV_DECORATE = 581,          /* SPIRV_DECORATE  */
+    SPIRV_DECORATE_ID = 582,       /* SPIRV_DECORATE_ID  */
+    SPIRV_DECORATE_STRING = 583,   /* SPIRV_DECORATE_STRING  */
+    SPIRV_TYPE = 584,              /* SPIRV_TYPE  */
+    SPIRV_STORAGE_CLASS = 585,     /* SPIRV_STORAGE_CLASS  */
+    SPIRV_BY_REFERENCE = 586,      /* SPIRV_BY_REFERENCE  */
+    SPIRV_LITERAL = 587,           /* SPIRV_LITERAL  */
+    ATTACHMENTEXT = 588,           /* ATTACHMENTEXT  */
+    IATTACHMENTEXT = 589,          /* IATTACHMENTEXT  */
+    UATTACHMENTEXT = 590,          /* UATTACHMENTEXT  */
+    LEFT_OP = 591,                 /* LEFT_OP  */
+    RIGHT_OP = 592,                /* RIGHT_OP  */
+    INC_OP = 593,                  /* INC_OP  */
+    DEC_OP = 594,                  /* DEC_OP  */
+    LE_OP = 595,                   /* LE_OP  */
+    GE_OP = 596,                   /* GE_OP  */
+    EQ_OP = 597,                   /* EQ_OP  */
+    NE_OP = 598,                   /* NE_OP  */
+    AND_OP = 599,                  /* AND_OP  */
+    OR_OP = 600,                   /* OR_OP  */
+    XOR_OP = 601,                  /* XOR_OP  */
+    MUL_ASSIGN = 602,              /* MUL_ASSIGN  */
+    DIV_ASSIGN = 603,              /* DIV_ASSIGN  */
+    ADD_ASSIGN = 604,              /* ADD_ASSIGN  */
+    MOD_ASSIGN = 605,              /* MOD_ASSIGN  */
+    LEFT_ASSIGN = 606,             /* LEFT_ASSIGN  */
+    RIGHT_ASSIGN = 607,            /* RIGHT_ASSIGN  */
+    AND_ASSIGN = 608,              /* AND_ASSIGN  */
+    XOR_ASSIGN = 609,              /* XOR_ASSIGN  */
+    OR_ASSIGN = 610,               /* OR_ASSIGN  */
+    SUB_ASSIGN = 611,              /* SUB_ASSIGN  */
+    STRING_LITERAL = 612,          /* STRING_LITERAL  */
+    LEFT_PAREN = 613,              /* LEFT_PAREN  */
+    RIGHT_PAREN = 614,             /* RIGHT_PAREN  */
+    LEFT_BRACKET = 615,            /* LEFT_BRACKET  */
+    RIGHT_BRACKET = 616,           /* RIGHT_BRACKET  */
+    LEFT_BRACE = 617,              /* LEFT_BRACE  */
+    RIGHT_BRACE = 618,             /* RIGHT_BRACE  */
+    DOT = 619,                     /* DOT  */
+    COMMA = 620,                   /* COMMA  */
+    COLON = 621,                   /* COLON  */
+    EQUAL = 622,                   /* EQUAL  */
+    SEMICOLON = 623,               /* SEMICOLON  */
+    BANG = 624,                    /* BANG  */
+    DASH = 625,                    /* DASH  */
+    TILDE = 626,                   /* TILDE  */
+    PLUS = 627,                    /* PLUS  */
+    STAR = 628,                    /* STAR  */
+    SLASH = 629,                   /* SLASH  */
+    PERCENT = 630,                 /* PERCENT  */
+    LEFT_ANGLE = 631,              /* LEFT_ANGLE  */
+    RIGHT_ANGLE = 632,             /* RIGHT_ANGLE  */
+    VERTICAL_BAR = 633,            /* VERTICAL_BAR  */
+    CARET = 634,                   /* CARET  */
+    AMPERSAND = 635,               /* AMPERSAND  */
+    QUESTION = 636,                /* QUESTION  */
+    INVARIANT = 637,               /* INVARIANT  */
+    HIGH_PRECISION = 638,          /* HIGH_PRECISION  */
+    MEDIUM_PRECISION = 639,        /* MEDIUM_PRECISION  */
+    LOW_PRECISION = 640,           /* LOW_PRECISION  */
+    PRECISION = 641,               /* PRECISION  */
+    PACKED = 642,                  /* PACKED  */
+    RESOURCE = 643,                /* RESOURCE  */
+    SUPERP = 644,                  /* SUPERP  */
+    FLOATCONSTANT = 645,           /* FLOATCONSTANT  */
+    INTCONSTANT = 646,             /* INTCONSTANT  */
+    UINTCONSTANT = 647,            /* UINTCONSTANT  */
+    BOOLCONSTANT = 648,            /* BOOLCONSTANT  */
+    IDENTIFIER = 649,              /* IDENTIFIER  */
+    TYPE_NAME = 650,               /* TYPE_NAME  */
+    CENTROID = 651,                /* CENTROID  */
+    IN = 652,                      /* IN  */
+    OUT = 653,                     /* OUT  */
+    INOUT = 654,                   /* INOUT  */
+    STRUCT = 655,                  /* STRUCT  */
+    VOID = 656,                    /* VOID  */
+    WHILE = 657,                   /* WHILE  */
+    BREAK = 658,                   /* BREAK  */
+    CONTINUE = 659,                /* CONTINUE  */
+    DO = 660,                      /* DO  */
+    ELSE = 661,                    /* ELSE  */
+    FOR = 662,                     /* FOR  */
+    IF = 663,                      /* IF  */
+    DISCARD = 664,                 /* DISCARD  */
+    RETURN = 665,                  /* RETURN  */
+    SWITCH = 666,                  /* SWITCH  */
+    CASE = 667,                    /* CASE  */
+    DEFAULT = 668,                 /* DEFAULT  */
+    TERMINATE_INVOCATION = 669,    /* TERMINATE_INVOCATION  */
+    TERMINATE_RAY = 670,           /* TERMINATE_RAY  */
+    IGNORE_INTERSECTION = 671,     /* IGNORE_INTERSECTION  */
+    UNIFORM = 672,                 /* UNIFORM  */
+    SHARED = 673,                  /* SHARED  */
+    BUFFER = 674,                  /* BUFFER  */
+    TILEIMAGEEXT = 675,            /* TILEIMAGEEXT  */
+    FLAT = 676,                    /* FLAT  */
+    SMOOTH = 677,                  /* SMOOTH  */
+    LAYOUT = 678,                  /* LAYOUT  */
+    DOUBLECONSTANT = 679,          /* DOUBLECONSTANT  */
+    INT16CONSTANT = 680,           /* INT16CONSTANT  */
+    UINT16CONSTANT = 681,          /* UINT16CONSTANT  */
+    FLOAT16CONSTANT = 682,         /* FLOAT16CONSTANT  */
+    INT32CONSTANT = 683,           /* INT32CONSTANT  */
+    UINT32CONSTANT = 684,          /* UINT32CONSTANT  */
+    INT64CONSTANT = 685,           /* INT64CONSTANT  */
+    UINT64CONSTANT = 686,          /* UINT64CONSTANT  */
+    SUBROUTINE = 687,              /* SUBROUTINE  */
+    DEMOTE = 688,                  /* DEMOTE  */
+    FUNCTION = 689,                /* FUNCTION  */
+    PAYLOADNV = 690,               /* PAYLOADNV  */
+    PAYLOADINNV = 691,             /* PAYLOADINNV  */
+    HITATTRNV = 692,               /* HITATTRNV  */
+    CALLDATANV = 693,              /* CALLDATANV  */
+    CALLDATAINNV = 694,            /* CALLDATAINNV  */
+    PAYLOADEXT = 695,              /* PAYLOADEXT  */
+    PAYLOADINEXT = 696,            /* PAYLOADINEXT  */
+    HITATTREXT = 697,              /* HITATTREXT  */
+    CALLDATAEXT = 698,             /* CALLDATAEXT  */
+    CALLDATAINEXT = 699,           /* CALLDATAINEXT  */
+    PATCH = 700,                   /* PATCH  */
+    SAMPLE = 701,                  /* SAMPLE  */
+    NONUNIFORM = 702,              /* NONUNIFORM  */
+    COHERENT = 703,                /* COHERENT  */
+    VOLATILE = 704,                /* VOLATILE  */
+    RESTRICT = 705,                /* RESTRICT  */
+    READONLY = 706,                /* READONLY  */
+    WRITEONLY = 707,               /* WRITEONLY  */
+    NONTEMPORAL = 708,             /* NONTEMPORAL  */
+    DEVICECOHERENT = 709,          /* DEVICECOHERENT  */
+    QUEUEFAMILYCOHERENT = 710,     /* QUEUEFAMILYCOHERENT  */
+    WORKGROUPCOHERENT = 711,       /* WORKGROUPCOHERENT  */
+    SUBGROUPCOHERENT = 712,        /* SUBGROUPCOHERENT  */
+    NONPRIVATE = 713,              /* NONPRIVATE  */
+    SHADERCALLCOHERENT = 714,      /* SHADERCALLCOHERENT  */
+    NOPERSPECTIVE = 715,           /* NOPERSPECTIVE  */
+    EXPLICITINTERPAMD = 716,       /* EXPLICITINTERPAMD  */
+    PERVERTEXEXT = 717,            /* PERVERTEXEXT  */
+    PERVERTEXNV = 718,             /* PERVERTEXNV  */
+    PERPRIMITIVENV = 719,          /* PERPRIMITIVENV  */
+    PERVIEWNV = 720,               /* PERVIEWNV  */
+    PERTASKNV = 721,               /* PERTASKNV  */
+    PERPRIMITIVEEXT = 722,         /* PERPRIMITIVEEXT  */
+    TASKPAYLOADWORKGROUPEXT = 723, /* TASKPAYLOADWORKGROUPEXT  */
+    PRECISE = 724                  /* PRECISE  */
   };
   typedef enum yytokentype yytoken_kind_t;
 #endif
@@ -566,7 +568,7 @@ union YYSTYPE
         glslang::TTypeParameters* typeParameters;
     } interm;
 
-#line 570 "MachineIndependent/glslang_tab.cpp.h"
+#line 572 "MachineIndependent/glslang_tab.cpp.h"
 
 };
 typedef union YYSTYPE YYSTYPE;

3rdparty/glslang/glslang/MachineIndependent/intermOut.cpp

@@ -643,6 +643,7 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
     case EOpConstructReference:  out.debug << "Construct reference";  break;
     case EOpConstructCooperativeMatrixNV:  out.debug << "Construct cooperative matrix NV";  break;
     case EOpConstructCooperativeMatrixKHR:  out.debug << "Construct cooperative matrix KHR";  break;
+    case EOpConstructCooperativeVectorNV:  out.debug << "Construct cooperative vector NV";  break;
     case EOpConstructAccStruct: out.debug << "Construct acceleration structure"; break;
 
     case EOpLessThan:         out.debug << "Compare Less Than";             break;
@@ -667,6 +668,9 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
 
     case EOpDistance:      out.debug << "distance";                break;
     case EOpDot:           out.debug << "dot-product";             break;
+    case EOpDotPackedEXT:  out.debug << "dot-product-packed";break;
+    case EOpDotAccSatEXT:  out.debug << "dot-product-accumulate-saturate";break;
+    case EOpDotPackedAccSatEXT:  out.debug << "dot-product-packed-accumulate-saturate";break;
     case EOpCross:         out.debug << "cross-product";           break;
     case EOpFaceForward:   out.debug << "face-forward";            break;
     case EOpReflect:       out.debug << "reflect";                 break;
@@ -939,6 +943,14 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
     case EOpRayQueryGetIntersectionObjectToWorld:                          out.debug << "rayQueryGetIntersectionObjectToWorldEXT"; break;
     case EOpRayQueryGetIntersectionWorldToObject:                          out.debug << "rayQueryGetIntersectionWorldToObjectEXT"; break;
     case EOpRayQueryGetIntersectionTriangleVertexPositionsEXT:             out.debug << "rayQueryGetIntersectionTriangleVertexPositionsEXT"; break;
+    case EOpRayQueryGetIntersectionClusterIdNV:                            out.debug << "rayQueryGetIntersectionClusterIdNV"; break;
+    case EOpRayQueryGetIntersectionSpherePositionNV:                       out.debug << "rayQueryGetIntersectionSpherePositionNV"; break;
+    case EOpRayQueryGetIntersectionSphereRadiusNV:                         out.debug << "rayQueryGetIntersectionSphereRadiusNV"; break;
+    case EOpRayQueryGetIntersectionLSSHitValueNV:                          out.debug << "rayQueryGetIntersectionLSSHitValueNV"; break;
+    case EOpRayQueryGetIntersectionLSSPositionsNV:                         out.debug << "rayQueryGetIntersectionLSSPositionsNV"; break;
+    case EOpRayQueryGetIntersectionLSSRadiiNV:                             out.debug << "rayQueryGetIntersectionLSSRadiiNV"; break;
+    case EOpRayQueryIsSphereHitNV:                                         out.debug << "rayQueryIsSphereHitNV"; break;
+    case EOpRayQueryIsLSSHitNV:                                            out.debug << "rayQueryIsLSSHitNV"; break;
 
     case EOpCooperativeMatrixLoad:  out.debug << "Load cooperative matrix KHR"; break;
     case EOpCooperativeMatrixStore:  out.debug << "Store cooperative matrix KHR"; break;
@@ -952,6 +964,13 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
     case EOpCooperativeMatrixPerElementOpNV: out.debug << "cooperative matrix per element op"; break;
     case EOpCooperativeMatrixTransposeNV: out.debug << "Transpose cooperative matrix"; break;
 
+    case EOpCooperativeVectorMatMulNV: out.debug << "Cooperative vector matrix multiply NV"; break;
+    case EOpCooperativeVectorMatMulAddNV: out.debug << "Cooperative vector matrix multiply add NV"; break;
+    case EOpCooperativeVectorLoadNV:  out.debug << "Load cooperative vector NV"; break;
+    case EOpCooperativeVectorStoreNV:  out.debug << "Store cooperative vector NV"; break;
+    case EOpCooperativeVectorOuterProductAccumulateNV: out.debug << "Cooperative vector outer product accumulate NV"; break;
+    case EOpCooperativeVectorReduceSumAccumulateNV: out.debug << "Cooperative vector reduce sum accumulate NV"; break;
+
     case EOpIsHelperInvocation: out.debug << "IsHelperInvocation"; break;
     case EOpDebugPrintf:  out.debug << "Debug printf";  break;
 
@@ -985,9 +1004,16 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
     case EOpHitObjectGetCurrentTimeNV: out.debug << "HitObjectGetCurrentTimeNV"; break;
     case EOpHitObjectGetShaderBindingTableRecordIndexNV: out.debug << "HitObjectGetShaderBindingTableRecordIndexNV"; break;
     case EOpHitObjectGetShaderRecordBufferHandleNV: out.debug << "HitObjectReadShaderRecordBufferHandleNV"; break;
+    case EOpHitObjectGetClusterIdNV: out.debug << "HitObjectGetClusterIdNV"; break;
     case EOpReorderThreadNV: out.debug << "ReorderThreadNV"; break;
     case EOpFetchMicroTriangleVertexPositionNV: out.debug << "MicroTriangleVertexPositionNV"; break;
     case EOpFetchMicroTriangleVertexBarycentricNV: out.debug << "MicroTriangleVertexBarycentricNV"; break;
+    case EOpHitObjectGetSpherePositionNV: out.debug << "HitObjectGetSpherePositionNV"; break;
+    case EOpHitObjectGetSphereRadiusNV:   out.debug << "HitObjectGetSphereRadiusNV"; break;
+    case EOpHitObjectGetLSSPositionsNV:   out.debug << "HitObjectGetLSSPositionsNV"; break;
+    case EOpHitObjectGetLSSRadiiNV:       out.debug << "HitObjectGetLSSRadiiNV"; break;
+    case EOpHitObjectIsSphereHitNV:       out.debug << "HitObjectIsSphereHitNV"; break;
+    case EOpHitObjectIsLSSHitNV:          out.debug << "HitObjectIsLSSHitNV"; break;
 
     case EOpSpirvInst: out.debug << "spirv_instruction"; break;
     case EOpStencilAttachmentReadEXT: out.debug << "stencilAttachmentReadEXT"; break;

3rdparty/glslang/glslang/MachineIndependent/linkValidate.cpp

@@ -167,32 +167,7 @@ void TIntermediate::checkStageIO(TInfoSink& infoSink, TIntermediate& unit) {
     // do matching and error checking
     mergeLinkerObjects(infoSink, linkerObjects, unitLinkerObjects, unit.getStage());
 
-    // Check that all of our inputs have matching outputs from the previous stage.
-    // Only do this for Vulkan, since GL_ARB_separate_shader_objects allows for
-    // the in/out to not match
-    if (spvVersion.vulkan > 0) {
-        for (auto& nextStageInterm : unitLinkerObjects) {
-            auto* nextStageSymbol = nextStageInterm->getAsSymbolNode();
-            bool found = false;
-            for (auto& curStageInterm : linkerObjects) {
-                if (isSameSymbol(curStageInterm->getAsSymbolNode(), nextStageSymbol)) {
-                    found = true;
-                    break;
-                }
-            }
-            if (!found) {
-                TString errmsg;
-                errmsg.append("Input '");
-                if (nextStageSymbol->getType().getBasicType() == EbtBlock)
-                    errmsg.append(nextStageSymbol->getType().getTypeName());
-                else
-                    errmsg.append(nextStageSymbol->getName());
-                errmsg.append("' in ").append(StageName(unit.getStage()));
-                errmsg.append(" shader has no corresponding output in ").append(StageName(getStage())).append(" shader.");
-                error(infoSink, errmsg.c_str(), unit.getStage());
-            }
-        }
-    }
+    // TODO: final check; make sure that any statically used `in` have matching `out` written to
 }
 
 void TIntermediate::optimizeStageIO(TInfoSink&, TIntermediate& unit)
@@ -852,15 +827,10 @@ void TIntermediate::mergeLinkerObjects(TInfoSink& infoSink, TIntermSequence& lin
     // Error check and merge the linker objects (duplicates should not be created)
     std::size_t initialNumLinkerObjects = linkerObjects.size();
     for (unsigned int unitLinkObj = 0; unitLinkObj < unitLinkerObjects.size(); ++unitLinkObj) {
-        TIntermSymbol* unitSymbol = unitLinkerObjects[unitLinkObj]->getAsSymbolNode();
         bool merge = true;
-
-        // Don't merge inputs backwards into previous stages
-        if (getStage() != unitStage && unitSymbol->getQualifier().storage == EvqVaryingIn)
-            merge = false;
-
         for (std::size_t linkObj = 0; linkObj < initialNumLinkerObjects; ++linkObj) {
             TIntermSymbol* symbol = linkerObjects[linkObj]->getAsSymbolNode();
+            TIntermSymbol* unitSymbol = unitLinkerObjects[unitLinkObj]->getAsSymbolNode();
             assert(symbol && unitSymbol);
 
             if (isSameSymbol(symbol, unitSymbol)) {
@@ -1224,6 +1194,10 @@ void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& sy
         error(infoSink, "Memory volatil qualifier must match:", unitStage);
         memoryQualifierError = true;
     }
+    if (symbol.getQualifier().nontemporal != unitSymbol.getQualifier().nontemporal) {
+        error(infoSink, "Memory nontemporal qualifier must match:", unitStage);
+        memoryQualifierError = true;
+    }
     if (symbol.getQualifier().restrict != unitSymbol.getQualifier().restrict) {
         error(infoSink, "Memory restrict qualifier must match:", unitStage);
         memoryQualifierError = true;

3rdparty/glslang/glslang/MachineIndependent/localintermediate.h

@@ -1035,11 +1035,11 @@ public:
 #endif
 
     bool usingScalarBlockLayout() const {
-        for (auto extIt = requestedExtensions.begin(); extIt != requestedExtensions.end(); ++extIt) {
-            if (*extIt == E_GL_EXT_scalar_block_layout)
-                return true;
-        }
-        return false;
+        return IsRequestedExtension(E_GL_EXT_scalar_block_layout);
+    }
+
+    bool usingTextureOffsetNonConst() const {
+        return IsRequestedExtension(E_GL_EXT_texture_offset_non_const);
     }
 
     bool IsRequestedExtension(const char* extension) const

3rdparty/glslang/glslang/MachineIndependent/parseVersions.h

@@ -122,6 +122,7 @@ public:
     virtual void intcoopmatCheckNV(const TSourceLoc&, const char *op, bool builtIn = false);
     virtual void coopmatCheck(const TSourceLoc&, const char* op, bool builtIn = false);
     virtual void tensorLayoutViewCheck(const TSourceLoc&, const char* op, bool builtIn = false);
+    virtual void coopvecCheck(const TSourceLoc&, const char* op, bool builtIn = false);
     bool relaxedErrors()    const { return (messages & EShMsgRelaxedErrors) != 0; }
     bool suppressWarnings() const { return (messages & EShMsgSuppressWarnings) != 0; }
     bool isForwardCompatible() const { return forwardCompatible; }

3rdparty/glslang/glslang/MachineIndependent/propagateNoContraction.cpp

@@ -174,6 +174,9 @@ bool isArithmeticOperation(glslang::TOperator op)
     case glslang::EOpMatrixTimesMatrix:
 
     case glslang::EOpDot:
+    case glslang::EOpDotPackedEXT:
+    case glslang::EOpDotAccSatEXT:
+    case glslang::EOpDotPackedAccSatEXT:
 
     case glslang::EOpPostIncrement:
     case glslang::EOpPostDecrement: