[Misc] (3rdparty): Update glslang to 15.4.0

.gitattributes

@@ -0,0 +1,2 @@
+*.a filter=lfs diff=lfs merge=lfs -text
+*.so filter=lfs diff=lfs merge=lfs -text

MobileGL/Includes.h

@@ -89,4 +89,4 @@
 
 #include "MG_Util/Pipelines/Pipeline.hpp"
 
-#include "MG_Util/Pipelines/Pipelines/Shader/GLSLtoSPIRVPipeline.h"
+#include "MG_Util/Pipelines/Shader/GLSLtoSPIRVPipeline.h"

include/glslang/Include/BaseTypes.h

@@ -49,6 +49,9 @@ enum TBasicType {
     EbtFloat,
     EbtDouble,
     EbtFloat16,
+    EbtBFloat16,
+    EbtFloatE5M2,
+    EbtFloatE4M3,
     EbtInt8,
     EbtUint8,
     EbtInt16,
@@ -70,6 +73,8 @@ enum TBasicType {
     EbtFunction,
     EbtTensorLayoutNV,
     EbtTensorViewNV,
+    EbtCoopvecNV,
+    EbtTensorARM,
     // SPIR-V type defined by spirv_type
     EbtSpirvType,
 
@@ -278,6 +283,7 @@ enum TBuiltInVariable {
     EbvWorldToObject3x4,
     EbvIncomingRayFlags,
     EbvCurrentRayTimeNV,
+    EbvClusterIDNV,
     // barycentrics
     EbvBaryCoordNV,
     EbvBaryCoordNoPerspNV,
@@ -298,6 +304,13 @@ enum TBuiltInVariable {
     EbvHitKindFrontFacingMicroTriangleNV,
     EbvHitKindBackFacingMicroTriangleNV,
 
+    EbvHitIsSphereNV,
+    EbvHitIsLSSNV,
+    EbvHitSpherePositionNV,
+    EbvHitSphereRadiusNV,
+    EbvHitLSSPositionsNV,
+    EbvHitLSSRadiiNV,
+
     //GL_EXT_mesh_shader
     EbvPrimitivePointIndicesEXT,
     EbvPrimitiveLineIndicesEXT,
@@ -334,6 +347,11 @@ enum TBuiltInVariable {
 
     EbvPositionFetch,
 
+    // SPV_QCOM_tile_shading
+    EbvTileOffsetQCOM,
+    EbvTileDimensionQCOM,
+    EbvTileApronSizeQCOM,
+
     EbvLast
 };
 
@@ -502,6 +520,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 +552,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";
     }
 }
@@ -585,6 +611,9 @@ __inline bool isTypeFloat(TBasicType type)
     case EbtFloat:
     case EbtDouble:
     case EbtFloat16:
+    case EbtBFloat16:
+    case EbtFloatE5M2:
+    case EbtFloatE4M3:
         return true;
     default:
         return false;
@@ -596,7 +625,10 @@ __inline uint32_t GetNumBits(TBasicType type)
     switch (type) {
     case EbtInt8:
     case EbtUint8:
+    case EbtFloatE5M2:
+    case EbtFloatE4M3:
         return 8;
+    case EbtBFloat16:
     case EbtFloat16:
     case EbtInt16:
     case EbtUint16:

include/glslang/Include/ConstantUnion.h

@@ -899,6 +899,17 @@ public:
         unionArray = new TConstUnionVector(size, val);
     }
 
+    TConstUnionArray* clone() const
+    {
+        TConstUnionArray *copy = new TConstUnionArray(size());
+        if (unionArray) {
+            for (const auto i : *unionArray) {
+                copy->unionArray->push_back(i);
+            }
+        }
+        return copy;
+    }
+
     int size() const { return unionArray ? (int)unionArray->size() : 0; }
     TConstUnion& operator[](size_t index) { return (*unionArray)[index]; }
     const TConstUnion& operator[](size_t index) const { return (*unionArray)[index]; }

include/glslang/Include/PoolAlloc.h

@@ -61,6 +61,8 @@
 // class as the allocator (second) template argument.
 //
 
+#include "visibility.h"
+
 #include <cstddef>
 #include <cstring>
 #include <vector>
@@ -179,6 +181,7 @@ public:
     // Call allocate() to actually acquire memory.  Returns nullptr if no memory
     // available, otherwise a properly aligned pointer to 'numBytes' of memory.
     //
+    GLSLANG_EXPORT_FOR_TESTS
     void* allocate(size_t numBytes);
 
     //
@@ -255,6 +258,7 @@ private:
 // different times.  But a simple use is to have a global pop
 // with everyone using the same global allocator.
 //
+GLSLANG_EXPORT_FOR_TESTS
 extern TPoolAllocator& GetThreadPoolAllocator();
 void SetThreadPoolAllocator(TPoolAllocator* poolAllocator);
 
@@ -289,6 +293,7 @@ public:
     template<class Other>
         pool_allocator(const pool_allocator<Other>& p) : allocator(p.getAllocator()) { }
 
+    GLSLANG_EXPORT_FOR_TESTS
     pointer allocate(size_type n) {
         return reinterpret_cast<pointer>(getAllocator().allocate(n * sizeof(T))); }
     pointer allocate(size_type n, const void*) {

include/glslang/Include/Types.h

@@ -85,6 +85,7 @@ struct TSampler {   // misnomer now; includes images, textures without sampler,
     bool      image : 1;  // image, combined should be false
     bool   combined : 1;  // true means texture is combined with a sampler, false means texture with no sampler
     bool    sampler : 1;  // true means a pure sampler, other fields should be clear()
+    bool   tileQCOM : 1;  // is tile shading attachment 
 
     unsigned int vectorSize : 3;  // vector return type size.
     // Some languages support structures as sample results.  Storing the whole structure in the
@@ -127,6 +128,8 @@ struct TSampler {   // misnomer now; includes images, textures without sampler,
     bool isShadow()      const { return shadow; }
     bool isArrayed()     const { return arrayed; }
 
+    bool isTileAttachmentQCOM() const { return tileQCOM; }
+
     void clear()
     {
         type = EbtVoid;
@@ -139,6 +142,7 @@ struct TSampler {   // misnomer now; includes images, textures without sampler,
         sampler = false;
         external = false;
         yuv = false;
+        tileQCOM = false;
 
 #ifdef ENABLE_HLSL
         clearReturnStruct();
@@ -220,7 +224,8 @@ struct TSampler {   // misnomer now; includes images, textures without sampler,
             isCombined() == right.isCombined() &&
          isPureSampler() == right.isPureSampler() &&
             isExternal() == right.isExternal() &&
-                 isYuv() == right.isYuv()
+                 isYuv() == right.isYuv() &&
+  isTileAttachmentQCOM() == right.isTileAttachmentQCOM()
 #ifdef ENABLE_HLSL
       && getVectorSize() == right.getVectorSize() &&
   getStructReturnIndex() == right.getStructReturnIndex()
@@ -246,6 +251,9 @@ struct TSampler {   // misnomer now; includes images, textures without sampler,
         case EbtInt:    s.append("i");   break;
         case EbtUint:   s.append("u");   break;
         case EbtFloat16: s.append("f16"); break;
+        case EbtBFloat16: s.append("bf16"); break;
+        case EbtFloatE5M2: s.append("fe5m2"); break;
+        case EbtFloatE4M3: s.append("fe4m3"); break;
         case EbtInt8:   s.append("i8");  break;
         case EbtUint16: s.append("u8");  break;
         case EbtInt16:  s.append("i16"); break;
@@ -259,6 +267,8 @@ struct TSampler {   // misnomer now; includes images, textures without sampler,
                 s.append("attachmentEXT");
             else if (isSubpass())
                 s.append("subpass");
+            else if (isTileAttachmentQCOM())
+                s.append("attachmentQCOM");
             else
                 s.append("image");
         } else if (isCombined()) {
@@ -552,6 +562,7 @@ public:
         shadercallcoherent = false;
         nonprivate = false;
         volatil      = false;
+        nontemporal = false;
         restrict     = false;
         readonly     = false;
         writeonly    = false;
@@ -589,6 +600,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 +615,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
     {
@@ -846,6 +859,8 @@ public:
         layoutBufferReferenceAlign = layoutBufferReferenceAlignEnd;
         layoutFormat = ElfNone;
 
+        layoutTileAttachmentQCOM = false;
+
         clearInterstageLayout();
 
         layoutSpecConstantId = layoutSpecConstantIdEnd;
@@ -947,6 +962,8 @@ public:
     bool layoutBindlessSampler;
     bool layoutBindlessImage;
 
+    bool layoutTileAttachmentQCOM;
+
     bool hasUniformLayout() const
     {
         return hasMatrix() ||
@@ -1065,6 +1082,10 @@ public:
     {
         return layoutBindlessImage;
     }
+    bool isTileAttachmentQCOM() const
+    {
+        return layoutTileAttachmentQCOM;
+    }
 
     // GL_EXT_spirv_intrinsics
     bool hasSpirvDecorate() const { return spirvDecorate != nullptr; }
@@ -1278,7 +1299,7 @@ public:
     }
 };
 
-// Qualifiers that don't need to be keep per object.  They have shader scope, not object scope.
+// Qualifiers that don't need to be kept per object.  They have shader scope, not object scope.
 // So, they will not be part of TType, TQualifier, etc.
 struct TShaderQualifiers {
     TLayoutGeometry geometry; // geometry/tessellation shader in/out primitives
@@ -1308,6 +1329,9 @@ struct TShaderQualifiers {
     bool layoutDerivativeGroupLinear;   // true if layout derivative_group_linearNV set
     int primitives;                     // mesh shader "max_primitives"DerivativeGroupLinear;   // true if layout derivative_group_linearNV set
     bool layoutPrimitiveCulling;        // true if layout primitive_culling set
+    bool layoutNonCoherentTileAttachmentReadQCOM; // fragment shaders -- per object
+    int  layoutTileShadingRateQCOM[3];  // compute shader
+    bool layoutTileShadingRateQCOMNotDefault[3];  // compute shader
     TLayoutDepth getDepth() const { return layoutDepth; }
     TLayoutStencil getStencil() const { return layoutStencil; }
 
@@ -1344,6 +1368,13 @@ struct TShaderQualifiers {
         layoutDerivativeGroupQuads  = false;
         layoutDerivativeGroupLinear = false;
         layoutPrimitiveCulling      = false;
+        layoutNonCoherentTileAttachmentReadQCOM = false;
+        layoutTileShadingRateQCOM[0] = 0;
+        layoutTileShadingRateQCOM[1] = 0;
+        layoutTileShadingRateQCOM[2] = 0;
+        layoutTileShadingRateQCOMNotDefault[0] = false;
+        layoutTileShadingRateQCOMNotDefault[1] = false;
+        layoutTileShadingRateQCOMNotDefault[2] = false;
         primitives                  = TQualifier::layoutNotSet;
         interlockOrdering = EioNone;
     }
@@ -1413,6 +1444,15 @@ struct TShaderQualifiers {
             interlockOrdering = src.interlockOrdering;
         if (src.layoutPrimitiveCulling)
             layoutPrimitiveCulling = src.layoutPrimitiveCulling;
+        if (src.layoutNonCoherentTileAttachmentReadQCOM)
+            layoutNonCoherentTileAttachmentReadQCOM = src.layoutNonCoherentTileAttachmentReadQCOM;
+        for (int i = 0; i < 3; ++i) {
+            if (src.layoutTileShadingRateQCOM[i] > 1)
+                layoutTileShadingRateQCOM[i] = src.layoutTileShadingRateQCOM[i];
+        }
+        for (int i = 0; i < 3; ++i) {
+            layoutTileShadingRateQCOMNotDefault[i] = src.layoutTileShadingRateQCOMNotDefault[i] || layoutTileShadingRateQCOMNotDefault[i];
+        }
     }
 };
 
@@ -1460,6 +1500,9 @@ public:
     uint32_t matrixRows  : 4;
     bool coopmatNV  : 1;
     bool coopmatKHR : 1;
+    bool coopvecNV  : 1;
+    bool tileAttachmentQCOM: 1;
+    uint32_t tensorRankARM : 4;
     TArraySizes* arraySizes;
     const TType* userDef;
     TSourceLoc loc;
@@ -1470,6 +1513,9 @@ public:
     bool isCoopmat() const { return coopmatNV || coopmatKHR; }
     bool isCoopmatNV() const { return coopmatNV; }
     bool isCoopmatKHR() const { return coopmatKHR; }
+    bool isCoopvecNV() const { return coopvecNV; }
+    bool isTensorARM() const { return tensorRankARM; }
+    bool hasTypeParameter() const { return isCoopmat() || isCoopvecNV() || isTensorARM(); }
 
     bool isTensorLayoutNV() const { return basicType == EbtTensorLayoutNV; }
     bool isTensorViewNV() const { return basicType == EbtTensorViewNV; }
@@ -1486,6 +1532,9 @@ public:
         typeParameters = nullptr;
         coopmatNV = false;
         coopmatKHR = false;
+        coopvecNV = false;
+        tileAttachmentQCOM = false;
+        tensorRankARM = 0;
         spirvType = nullptr;
     }
 
@@ -1545,8 +1594,8 @@ 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),
+                            tileAttachmentQCOM(false), tensorRankARM(0), arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
                                 assert(vs >= 0);
@@ -1561,8 +1610,8 @@ 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),
+                            tileAttachmentQCOM(false), tensorRankARM(0), arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
                                 assert(vs >= 0);
@@ -1579,8 +1628,8 @@ 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),
+                            tileAttachmentQCOM(p.tileAttachmentQCOM), tensorRankARM(p.tensorRankARM), arraySizes(p.arraySizes), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(p.typeParameters),
                             spirvType(p.spirvType)
                             {
                                 if (basicType == EbtSampler)
@@ -1630,11 +1679,20 @@ public:
                                         coopmatKHRUseValid = true;
                                     }
                                 }
+                                if (p.isCoopvecNV() && p.typeParameters) {
+                                    basicType = p.typeParameters->basicType;
+                                }
+                                if (p.isTensorARM() && p.typeParameters) {
+                                    basicType = p.typeParameters->basicType;
+                                    if (p.typeParameters->arraySizes->getNumDims() > 0) {
+                                        tensorRankARM = static_cast<uint32_t>(p.typeParameters->arraySizes->getDimSize(0)) & 0b1111;
+                                    }
+                                }
                             }
     // 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),
+        tileAttachmentQCOM(false), tensorRankARM(0), arraySizes(as), structure(nullptr), fieldName(nullptr), typeName(nullptr),
         sampler(sampler), typeParameters(nullptr), spirvType(nullptr)
     {
         qualifier.clear();
@@ -1676,19 +1734,23 @@ 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;
+                                    } else if (isTileAttachmentQCOM()) {
+                                        tileAttachmentQCOM = 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),
+                            tileAttachmentQCOM(false), tensorRankARM(0), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
                                 sampler.clear();
@@ -1697,8 +1759,8 @@ 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),
+                            tileAttachmentQCOM(false), tensorRankARM(0), qualifier(q), arraySizes(nullptr), structure(userDef), fieldName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
                                 sampler.clear();
@@ -1707,7 +1769,7 @@ public:
     // for block reference (first parameter must be EbtReference)
     explicit TType(TBasicType t, const TType &p, const TString& n) :
                             basicType(t), vectorSize(1), matrixCols(0), matrixRows(0), vector1(false), coopmatNV(false), coopmatKHR(false), coopmatKHRuse(0), coopmatKHRUseValid(false),
-                            arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr),
+                            tileAttachmentQCOM(false), tensorRankARM(0), arraySizes(nullptr), structure(nullptr), fieldName(nullptr), typeName(nullptr), typeParameters(nullptr),
                             spirvType(nullptr)
                             {
                                 assert(t == EbtReference);
@@ -1745,6 +1807,9 @@ public:
         coopmatKHR = copyOf.isCoopMatKHR();
         coopmatKHRuse = copyOf.coopmatKHRuse;
         coopmatKHRUseValid = copyOf.coopmatKHRUseValid;
+        coopvecNV = copyOf.isCoopVecNV();
+        tileAttachmentQCOM = copyOf.tileAttachmentQCOM;
+        tensorRankARM = copyOf.tensorRankARM;
     }
 
     // Make complete copy of the whole type graph rooted at 'copyOf'.
@@ -1828,7 +1893,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; }
@@ -1842,7 +1907,8 @@ public:
     virtual void updateImplicitArraySize(int size) { assert(isArray()); arraySizes->updateImplicitSize(size); }
     virtual void setImplicitlySized(bool isImplicitSized) { arraySizes->setImplicitlySized(isImplicitSized); }
     virtual bool isStruct() const { return basicType == EbtStruct || basicType == EbtBlock; }
-    virtual bool isFloatingDomain() const { return basicType == EbtFloat || basicType == EbtDouble || basicType == EbtFloat16; }
+    virtual bool isFloatingDomain() const { return basicType == EbtFloat || basicType == EbtDouble || basicType == EbtFloat16 ||
+                                                   basicType == EbtBFloat16 || basicType == EbtFloatE5M2 || basicType == EbtFloatE4M3; }
     virtual bool isIntegerDomain() const
     {
         switch (basicType) {
@@ -1863,7 +1929,9 @@ public:
     }
     virtual bool isOpaque() const { return basicType == EbtSampler
             || basicType == EbtAtomicUint || basicType == EbtAccStruct || basicType == EbtRayQuery
-            || basicType == EbtHitObjectNV; }
+            || basicType == EbtHitObjectNV || isTileAttachmentQCOM()
+            || isTensorARM();
+    }
     virtual bool isBuiltIn() const { return getQualifier().builtIn != EbvNone; }
 
     virtual bool isAttachmentEXT() const { return basicType == EbtSampler && getSampler().isAttachmentEXT(); }
@@ -1879,6 +1947,11 @@ public:
     bool isCoopMat() const { return coopmatNV || coopmatKHR; }
     bool isCoopMatNV() const { return coopmatNV; }
     bool isCoopMatKHR() const { return coopmatKHR; }
+    bool isCoopVecNV() const { return coopvecNV; }
+    bool isTileAttachmentQCOM() const { return tileAttachmentQCOM; }
+    bool isTensorARM() const { return tensorRankARM; }
+    bool hasTypeParameter() const { return isCoopMat() || isCoopVecNV() || isTensorARM(); }
+    int getTensorRankARM() const { return static_cast<int>(tensorRankARM); }
     bool isReference() const { return getBasicType() == EbtReference; }
     bool isSpirvType() const { return getBasicType() == EbtSpirvType; }
     int getCoopMatKHRuse() const { return static_cast<int>(coopmatKHRuse); }
@@ -1940,12 +2013,20 @@ public:
 
     virtual bool containsNonOpaque() const
     {
+        if (isTensorARM()) {
+            // Tensors have a numerical basicType even though it is Opaque
+            return false;
+        }
+
         const auto nonOpaque = [](const TType* t) {
             switch (t->basicType) {
             case EbtVoid:
             case EbtFloat:
             case EbtDouble:
             case EbtFloat16:
+            case EbtBFloat16:
+            case EbtFloatE5M2:
+            case EbtFloatE4M3:
             case EbtInt8:
             case EbtUint8:
             case EbtInt16:
@@ -1978,6 +2059,10 @@ public:
     {
         return containsBasicType(EbtFloat16);
     }
+    bool containsBFloat16() const
+    {
+        return containsBasicType(EbtBFloat16);
+    }
     bool contains64BitInt() const
     {
         return containsBasicType(EbtInt64) || containsBasicType(EbtUint64);
@@ -1994,6 +2079,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);
@@ -2095,6 +2184,9 @@ public:
         case EbtVoid:              return "void";
         case EbtDouble:            return "double";
         case EbtFloat16:           return "float16_t";
+        case EbtBFloat16:          return "bfloat16_t";
+        case EbtFloatE5M2:         return "floate5m2_t";
+        case EbtFloatE4M3:         return "floate4m3_t";
         case EbtInt8:              return "int8_t";
         case EbtUint8:             return "uint8_t";
         case EbtInt16:             return "int16_t";
@@ -2113,6 +2205,8 @@ public:
         case EbtCoopmat:           return "coopmat";
         case EbtTensorLayoutNV:    return "tensorLayoutNV";
         case EbtTensorViewNV:      return "tensorViewNV";
+        case EbtCoopvecNV:         return "coopvecNV";
+        case EbtTensorARM:         return "tensorARM";
         default:                   return "unknown type";
         }
     }
@@ -2281,6 +2375,8 @@ public:
             appendStr(" nonprivate");
           if (qualifier.volatil)
             appendStr(" volatile");
+          if (qualifier.nontemporal)
+            appendStr(" nontemporal");
           if (qualifier.restrict)
             appendStr(" restrict");
           if (qualifier.readonly)
@@ -2431,6 +2527,10 @@ public:
                 appendStr(" ");
                 appendStr("tensorViewNV");
               }
+              if (isCoopVecNV()) {
+                appendStr(" ");
+                appendStr("coopvecNV");
+              }
 
               appendStr("<");
               for (int i = 0; i < (int)typeParameters->arraySizes->getNumDims(); ++i) {
@@ -2512,7 +2612,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 +2818,8 @@ public:
                   vector1 == right.vector1    &&
               isCoopMatNV() == right.isCoopMatNV() &&
               isCoopMatKHR() == right.isCoopMatKHR() &&
+              isCoopVecNV() == right.isCoopVecNV() &&
+               isTensorARM() == right.isTensorARM() &&
                sameStructType(right, lpidx, rpidx) &&
                sameReferenceType(right);
     }
@@ -2737,6 +2841,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;
 
@@ -2751,8 +2867,8 @@ public:
             else
                 rv = false;
         } else if (isCoopMatKHR() && right.isCoopMatKHR()) {
-            if (getBasicType() == EbtFloat || getBasicType() == EbtFloat16)
+            if (isFloatingDomain())
-                rv = right.getBasicType() == EbtFloat || right.getBasicType() == EbtFloat16 || right.getBasicType() == EbtCoopmat;
+                rv = right.isFloatingDomain() || right.getBasicType() == EbtCoopmat;
             else if (getBasicType() == EbtUint || getBasicType() == EbtUint8 || getBasicType() == EbtUint16)
                 rv = right.getBasicType() == EbtUint || right.getBasicType() == EbtUint8 || right.getBasicType() == EbtUint16 || right.getBasicType() == EbtCoopmat;
             else if (getBasicType() == EbtInt || getBasicType() == EbtInt8 || getBasicType() == EbtInt16)
@@ -2771,9 +2887,34 @@ public:
         if (isTensorViewNV()) {
             return right.isTensorViewNV() && right.typeParameters == nullptr && typeParameters != nullptr;
         }
+        if (isTensorARM()) {
+            return right.isTensorARM() && right.typeParameters == nullptr && typeParameters != nullptr;
+        }
+
         return false;
     }
 
+    bool sameTensorBaseTypeARM(const TType &right) const {
+        return (typeParameters == nullptr || right.typeParameters == nullptr ||
+                (tensorRankARM == right.tensorRankARM && getBasicType() == right.getBasicType()));
+    }
+
+    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 +3044,9 @@ 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;
+    bool tileAttachmentQCOM : 1;
+    uint32_t tensorRankARM       : 4;  // 0 means not a tensor; non-zero indicates the tensor rank.
     TQualifier qualifier;
 
     TArraySizes* arraySizes;    // nullptr unless an array; can be shared across types

include/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);

include/glslang/Include/glslang_c_shader_types.h

@@ -118,8 +118,9 @@ typedef enum {
     GLSLANG_TARGET_VULKAN_1_1 = (1 << 22) | (1 << 12),
     GLSLANG_TARGET_VULKAN_1_2 = (1 << 22) | (2 << 12),
     GLSLANG_TARGET_VULKAN_1_3 = (1 << 22) | (3 << 12),
+    GLSLANG_TARGET_VULKAN_1_4 = (1 << 22) | (4 << 12),
     GLSLANG_TARGET_OPENGL_450 = 450,
-    LAST_ELEMENT_MARKER(GLSLANG_TARGET_CLIENT_VERSION_COUNT = 5),
+    LAST_ELEMENT_MARKER(GLSLANG_TARGET_CLIENT_VERSION_COUNT = 6),
 } glslang_target_client_version_t;
 
 /* SH_TARGET_LanguageVersion counterpart */
@@ -177,6 +178,7 @@ typedef enum {
     GLSLANG_MSG_ABSOLUTE_PATH               = (1 << 16),
     GLSLANG_MSG_DISPLAY_ERROR_COLUMN        = (1 << 17),
     GLSLANG_MSG_LINK_TIME_OPTIMIZATION_BIT  = (1 << 18),
+    GLSLANG_MSG_VALIDATE_CROSS_STAGE_IO_BIT = (1 << 19),
     LAST_ELEMENT_MARKER(GLSLANG_MSG_COUNT),
 } glslang_messages_t;
 

include/glslang/Include/intermediate.h

@@ -388,6 +388,11 @@ enum TOperator {
 
     EOpSubgroupGuardStop,
     
+    // Integer dot product
+    EOpDotPackedEXT,
+    EOpDotAccSatEXT,
+    EOpDotPackedAccSatEXT,
+
     EOpMinInvocations,
     EOpMaxInvocations,
     EOpAddInvocations,
@@ -467,6 +472,17 @@ enum TOperator {
     EOpTensorViewSetStrideNV,
     EOpTensorViewSetClipNV,
 
+    EOpCooperativeVectorMatMulNV,
+    EOpCooperativeVectorMatMulAddNV,
+    EOpCooperativeVectorLoadNV,
+    EOpCooperativeVectorStoreNV,
+    EOpCooperativeVectorOuterProductAccumulateNV,
+    EOpCooperativeVectorReduceSumAccumulateNV,
+
+    EOpTensorReadARM,
+    EOpTensorWriteARM,
+    EOpTensorSizeARM,
+
     EOpBeginInvocationInterlock, // Fragment only
     EOpEndInvocationInterlock, // Fragment only
 
@@ -599,13 +615,27 @@ enum TOperator {
     EOpConstructF16Mat4x2,
     EOpConstructF16Mat4x3,
     EOpConstructF16Mat4x4,
+    EOpConstructBFloat16,
+    EOpConstructBF16Vec2,
+    EOpConstructBF16Vec3,
+    EOpConstructBF16Vec4,
+    EOpConstructFloatE5M2,
+    EOpConstructFloatE5M2Vec2,
+    EOpConstructFloatE5M2Vec3,
+    EOpConstructFloatE5M2Vec4,
+    EOpConstructFloatE4M3,
+    EOpConstructFloatE4M3Vec2,
+    EOpConstructFloatE4M3Vec3,
+    EOpConstructFloatE4M3Vec4,
     EOpConstructStruct,
     EOpConstructTextureSampler,
     EOpConstructNonuniform,     // expected to be transformed away, not present in final AST
     EOpConstructReference,
     EOpConstructCooperativeMatrixNV,
     EOpConstructCooperativeMatrixKHR,
+    EOpConstructCooperativeVectorNV,
     EOpConstructAccStruct,
+    EOpConstructSaturated,
     EOpConstructGuardEnd,
 
     //
@@ -954,6 +984,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) {
@@ -1059,6 +1108,7 @@ public:
     virtual int getVectorSize() const { return type.getVectorSize(); }
     virtual int getMatrixCols() const { return type.getMatrixCols(); }
     virtual int getMatrixRows() const { return type.getMatrixRows(); }
+    virtual int getTensorRankARM() const { return type.getTensorRankARM(); }
     virtual bool isMatrix() const { return type.isMatrix(); }
     virtual bool isArray()  const { return type.isArray(); }
     virtual bool isVector() const { return type.isVector(); }

include/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 isCoopMatOrVec);
+    void precisionQualifierCheck(const TSourceLoc&, TBasicType, TQualifier&, bool hasTypeParameter);
     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&);
@@ -450,6 +450,9 @@ public:
     TIntermTyped* addConstructor(const TSourceLoc&, TIntermNode*, const TType&);
     TIntermTyped* constructAggregate(TIntermNode*, const TType&, int, const TSourceLoc&);
     TIntermTyped* constructBuiltIn(const TType&, TOperator, TIntermTyped*, const TSourceLoc&, bool subset);
+    void makeVariadic(TFunction *F, const TSourceLoc &loc);
+    TParameter getParamWithDefault(const TPublicType& ty, TString* identifier, TIntermTyped* initializer,
+                                   const TSourceLoc& loc);
     void inheritMemoryQualifiers(const TQualifier& from, TQualifier& to);
     void declareBlock(const TSourceLoc&, TTypeList& typeList, const TString* instanceName = nullptr, TArraySizes* arraySizes = nullptr);
     void blockStorageRemap(const TSourceLoc&, const TString*, TQualifier&);

include/glslang/MachineIndependent/SymbolTable.h

@@ -232,6 +232,13 @@ struct TParameter {
             name = nullptr;
         type = param.type->clone();
         defaultValue = param.defaultValue;
+        if (defaultValue) {
+            // The defaultValue of a builtin is created in a TPoolAllocator that no longer exists
+            // when parsing the user program, so make a deep copy.
+            if (const auto *constUnion = defaultValue->getAsConstantUnion()) {
+                defaultValue = new TIntermConstantUnion(*constUnion->getConstArray().clone(), constUnion->getType());
+            }
+        }
         return *this;
     }
     TBuiltInVariable getDeclaredBuiltIn() const { return type->getQualifier().declaredBuiltIn; }
@@ -245,12 +252,12 @@ public:
     explicit TFunction(TOperator o) :
         TSymbol(nullptr),
         op(o),
-        defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), defaultParamCount(0) { }
+        defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), variadic(false), defaultParamCount(0) { }
     TFunction(const TString *name, const TType& retType, TOperator tOp = EOpNull) :
         TSymbol(name),
         mangledName(*name + '('),
         op(tOp),
-        defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), defaultParamCount(0),
+        defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), variadic(false), defaultParamCount(0),
         linkType(ELinkNone)
     {
         returnType.shallowCopy(retType);
@@ -268,6 +275,7 @@ public:
     virtual void addParameter(TParameter& p)
     {
         assert(writable);
+        assert(!variadic && "cannot add more parameters if function is marked variadic");
         parameters.push_back(p);
         p.type->appendMangledName(mangledName);
 
@@ -310,6 +318,13 @@ public:
     virtual bool hasImplicitThis() const { return implicitThis; }
     virtual void setIllegalImplicitThis() { assert(writable); illegalImplicitThis = true; }
     virtual bool hasIllegalImplicitThis() const { return illegalImplicitThis; }
+    virtual void setVariadic() {
+        assert(writable);
+        assert(!variadic && "function was already marked variadic");
+        variadic = true;
+        mangledName += 'z';
+    }
+    virtual bool isVariadic() const { return variadic; }
 
     // Return total number of parameters
     virtual int getParamCount() const { return static_cast<int>(parameters.size()); }
@@ -352,6 +367,7 @@ protected:
                                // even if it finds member variables in the symbol table.
                                // This is important for a static member function that has member variables in scope,
                                // but is not allowed to use them, or see hidden symbols instead.
+    bool variadic;
     int  defaultParamCount;
 
     TSpirvInstruction spirvInst; // SPIR-V instruction qualifiers

include/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,9 +286,14 @@ 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";
+const char* const E_GL_NV_gpu_shader5                           = "GL_NV_gpu_shader5";
 
 // ARM
 const char* const E_GL_ARM_shader_core_builtins                 = "GL_ARM_shader_core_builtins";
+const char* const E_GL_ARM_tensors                              = "GL_ARM_tensors";
 
 // Arrays of extensions for the above viewportEXTs duplications
 
@@ -295,6 +303,7 @@ const int Num_viewportEXTs = sizeof(viewportEXTs) / sizeof(viewportEXTs[0]);
 
 const char* const E_GL_QCOM_image_processing                    = "GL_QCOM_image_processing";
 const char* const E_GL_QCOM_image_processing2                   = "GL_QCOM_image_processing2";
+const char* const E_GL_QCOM_tile_shading                        = "GL_QCOM_tile_shading";
 
 // AEP
 const char* const E_GL_ANDROID_extension_pack_es31a             = "GL_ANDROID_extension_pack_es31a";
@@ -348,6 +357,12 @@ 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";
+
+const char* const E_GL_EXT_bfloat16 = "GL_EXT_bfloat16";
+const char* const E_GL_EXT_float_e5m2 = "GL_EXT_float_e5m2";
+const char* const E_GL_EXT_float_e4m3 = "GL_EXT_float_e4m3";
+
 // Arrays of extensions for the above AEP duplications
 
 const char* const AEP_geometry_shader[] = { E_GL_EXT_geometry_shader, E_GL_OES_geometry_shader };
@@ -359,6 +374,9 @@ const int Num_AEP_geometry_point_size = sizeof(AEP_geometry_point_size)/sizeof(A
 const char* const AEP_gpu_shader5[] = { E_GL_EXT_gpu_shader5, E_GL_OES_gpu_shader5 };
 const int Num_AEP_gpu_shader5 = sizeof(AEP_gpu_shader5)/sizeof(AEP_gpu_shader5[0]);
 
+const char* const AEP_core_gpu_shader5[] = { E_GL_ARB_gpu_shader5, E_GL_NV_gpu_shader5};
+const int Num_AEP_core_gpu_shader5 = sizeof(AEP_core_gpu_shader5)/sizeof(AEP_core_gpu_shader5[0]);
+
 const char* const AEP_primitive_bounding_box[] = { E_GL_EXT_primitive_bounding_box, E_GL_OES_primitive_bounding_box };
 const int Num_AEP_primitive_bounding_box = sizeof(AEP_primitive_bounding_box)/sizeof(AEP_primitive_bounding_box[0]);
 

include/glslang/MachineIndependent/glslang_tab.cpp.h

@@ -114,417 +114,426 @@ extern int yydebug;
     UTEXTURE2DARRAY = 315,         /* UTEXTURE2DARRAY  */
     ATTRIBUTE = 316,               /* ATTRIBUTE  */
     VARYING = 317,                 /* VARYING  */
-    BFLOAT16_T = 318,              /* BFLOAT16_T  */
+    FLOATE5M2_T = 318,             /* FLOATE5M2_T  */
-    FLOAT16_T = 319,               /* FLOAT16_T  */
+    FLOATE4M3_T = 319,             /* FLOATE4M3_T  */
-    FLOAT32_T = 320,               /* FLOAT32_T  */
+    BFLOAT16_T = 320,              /* BFLOAT16_T  */
-    DOUBLE = 321,                  /* DOUBLE  */
+    FLOAT16_T = 321,               /* FLOAT16_T  */
-    FLOAT64_T = 322,               /* FLOAT64_T  */
+    FLOAT32_T = 322,               /* FLOAT32_T  */
-    INT64_T = 323,                 /* INT64_T  */
+    DOUBLE = 323,                  /* DOUBLE  */
-    UINT64_T = 324,                /* UINT64_T  */
+    FLOAT64_T = 324,               /* FLOAT64_T  */
-    INT32_T = 325,                 /* INT32_T  */
+    INT64_T = 325,                 /* INT64_T  */
-    UINT32_T = 326,                /* UINT32_T  */
+    UINT64_T = 326,                /* UINT64_T  */
-    INT16_T = 327,                 /* INT16_T  */
+    INT32_T = 327,                 /* INT32_T  */
-    UINT16_T = 328,                /* UINT16_T  */
+    UINT32_T = 328,                /* UINT32_T  */
-    INT8_T = 329,                  /* INT8_T  */
+    INT16_T = 329,                 /* INT16_T  */
-    UINT8_T = 330,                 /* UINT8_T  */
+    UINT16_T = 330,                /* UINT16_T  */
-    I64VEC2 = 331,                 /* I64VEC2  */
+    INT8_T = 331,                  /* INT8_T  */
-    I64VEC3 = 332,                 /* I64VEC3  */
+    UINT8_T = 332,                 /* UINT8_T  */
-    I64VEC4 = 333,                 /* I64VEC4  */
+    I64VEC2 = 333,                 /* I64VEC2  */
-    U64VEC2 = 334,                 /* U64VEC2  */
+    I64VEC3 = 334,                 /* I64VEC3  */
-    U64VEC3 = 335,                 /* U64VEC3  */
+    I64VEC4 = 335,                 /* I64VEC4  */
-    U64VEC4 = 336,                 /* U64VEC4  */
+    U64VEC2 = 336,                 /* U64VEC2  */
-    I32VEC2 = 337,                 /* I32VEC2  */
+    U64VEC3 = 337,                 /* U64VEC3  */
-    I32VEC3 = 338,                 /* I32VEC3  */
+    U64VEC4 = 338,                 /* U64VEC4  */
-    I32VEC4 = 339,                 /* I32VEC4  */
+    I32VEC2 = 339,                 /* I32VEC2  */
-    U32VEC2 = 340,                 /* U32VEC2  */
+    I32VEC3 = 340,                 /* I32VEC3  */
-    U32VEC3 = 341,                 /* U32VEC3  */
+    I32VEC4 = 341,                 /* I32VEC4  */
-    U32VEC4 = 342,                 /* U32VEC4  */
+    U32VEC2 = 342,                 /* U32VEC2  */
-    I16VEC2 = 343,                 /* I16VEC2  */
+    U32VEC3 = 343,                 /* U32VEC3  */
-    I16VEC3 = 344,                 /* I16VEC3  */
+    U32VEC4 = 344,                 /* U32VEC4  */
-    I16VEC4 = 345,                 /* I16VEC4  */
+    I16VEC2 = 345,                 /* I16VEC2  */
-    U16VEC2 = 346,                 /* U16VEC2  */
+    I16VEC3 = 346,                 /* I16VEC3  */
-    U16VEC3 = 347,                 /* U16VEC3  */
+    I16VEC4 = 347,                 /* I16VEC4  */
-    U16VEC4 = 348,                 /* U16VEC4  */
+    U16VEC2 = 348,                 /* U16VEC2  */
-    I8VEC2 = 349,                  /* I8VEC2  */
+    U16VEC3 = 349,                 /* U16VEC3  */
-    I8VEC3 = 350,                  /* I8VEC3  */
+    U16VEC4 = 350,                 /* U16VEC4  */
-    I8VEC4 = 351,                  /* I8VEC4  */
+    I8VEC2 = 351,                  /* I8VEC2  */
-    U8VEC2 = 352,                  /* U8VEC2  */
+    I8VEC3 = 352,                  /* I8VEC3  */
-    U8VEC3 = 353,                  /* U8VEC3  */
+    I8VEC4 = 353,                  /* I8VEC4  */
-    U8VEC4 = 354,                  /* U8VEC4  */
+    U8VEC2 = 354,                  /* U8VEC2  */
-    DVEC2 = 355,                   /* DVEC2  */
+    U8VEC3 = 355,                  /* U8VEC3  */
-    DVEC3 = 356,                   /* DVEC3  */
+    U8VEC4 = 356,                  /* U8VEC4  */
-    DVEC4 = 357,                   /* DVEC4  */
+    DVEC2 = 357,                   /* DVEC2  */
-    DMAT2 = 358,                   /* DMAT2  */
+    DVEC3 = 358,                   /* DVEC3  */
-    DMAT3 = 359,                   /* DMAT3  */
+    DVEC4 = 359,                   /* DVEC4  */
-    DMAT4 = 360,                   /* DMAT4  */
+    DMAT2 = 360,                   /* DMAT2  */
-    BF16VEC2 = 361,                /* BF16VEC2  */
+    DMAT3 = 361,                   /* DMAT3  */
-    BF16VEC3 = 362,                /* BF16VEC3  */
+    DMAT4 = 362,                   /* DMAT4  */
-    BF16VEC4 = 363,                /* BF16VEC4  */
+    BF16VEC2 = 363,                /* BF16VEC2  */
-    F16VEC2 = 364,                 /* F16VEC2  */
+    BF16VEC3 = 364,                /* BF16VEC3  */
-    F16VEC3 = 365,                 /* F16VEC3  */
+    BF16VEC4 = 365,                /* BF16VEC4  */
-    F16VEC4 = 366,                 /* F16VEC4  */
+    FE5M2VEC2 = 366,               /* FE5M2VEC2  */
-    F16MAT2 = 367,                 /* F16MAT2  */
+    FE5M2VEC3 = 367,               /* FE5M2VEC3  */
-    F16MAT3 = 368,                 /* F16MAT3  */
+    FE5M2VEC4 = 368,               /* FE5M2VEC4  */
-    F16MAT4 = 369,                 /* F16MAT4  */
+    FE4M3VEC2 = 369,               /* FE4M3VEC2  */
-    F32VEC2 = 370,                 /* F32VEC2  */
+    FE4M3VEC3 = 370,               /* FE4M3VEC3  */
-    F32VEC3 = 371,                 /* F32VEC3  */
+    FE4M3VEC4 = 371,               /* FE4M3VEC4  */
-    F32VEC4 = 372,                 /* F32VEC4  */
+    F16VEC2 = 372,                 /* F16VEC2  */
-    F32MAT2 = 373,                 /* F32MAT2  */
+    F16VEC3 = 373,                 /* F16VEC3  */
-    F32MAT3 = 374,                 /* F32MAT3  */
+    F16VEC4 = 374,                 /* F16VEC4  */
-    F32MAT4 = 375,                 /* F32MAT4  */
+    F16MAT2 = 375,                 /* F16MAT2  */
-    F64VEC2 = 376,                 /* F64VEC2  */
+    F16MAT3 = 376,                 /* F16MAT3  */
-    F64VEC3 = 377,                 /* F64VEC3  */
+    F16MAT4 = 377,                 /* F16MAT4  */
-    F64VEC4 = 378,                 /* F64VEC4  */
+    F32VEC2 = 378,                 /* F32VEC2  */
-    F64MAT2 = 379,                 /* F64MAT2  */
+    F32VEC3 = 379,                 /* F32VEC3  */
-    F64MAT3 = 380,                 /* F64MAT3  */
+    F32VEC4 = 380,                 /* F32VEC4  */
-    F64MAT4 = 381,                 /* F64MAT4  */
+    F32MAT2 = 381,                 /* F32MAT2  */
-    DMAT2X2 = 382,                 /* DMAT2X2  */
+    F32MAT3 = 382,                 /* F32MAT3  */
-    DMAT2X3 = 383,                 /* DMAT2X3  */
+    F32MAT4 = 383,                 /* F32MAT4  */
-    DMAT2X4 = 384,                 /* DMAT2X4  */
+    F64VEC2 = 384,                 /* F64VEC2  */
-    DMAT3X2 = 385,                 /* DMAT3X2  */
+    F64VEC3 = 385,                 /* F64VEC3  */
-    DMAT3X3 = 386,                 /* DMAT3X3  */
+    F64VEC4 = 386,                 /* F64VEC4  */
-    DMAT3X4 = 387,                 /* DMAT3X4  */
+    F64MAT2 = 387,                 /* F64MAT2  */
-    DMAT4X2 = 388,                 /* DMAT4X2  */
+    F64MAT3 = 388,                 /* F64MAT3  */
-    DMAT4X3 = 389,                 /* DMAT4X3  */
+    F64MAT4 = 389,                 /* F64MAT4  */
-    DMAT4X4 = 390,                 /* DMAT4X4  */
+    DMAT2X2 = 390,                 /* DMAT2X2  */
-    F16MAT2X2 = 391,               /* F16MAT2X2  */
+    DMAT2X3 = 391,                 /* DMAT2X3  */
-    F16MAT2X3 = 392,               /* F16MAT2X3  */
+    DMAT2X4 = 392,                 /* DMAT2X4  */
-    F16MAT2X4 = 393,               /* F16MAT2X4  */
+    DMAT3X2 = 393,                 /* DMAT3X2  */
-    F16MAT3X2 = 394,               /* F16MAT3X2  */
+    DMAT3X3 = 394,                 /* DMAT3X3  */
-    F16MAT3X3 = 395,               /* F16MAT3X3  */
+    DMAT3X4 = 395,                 /* DMAT3X4  */
-    F16MAT3X4 = 396,               /* F16MAT3X4  */
+    DMAT4X2 = 396,                 /* DMAT4X2  */
-    F16MAT4X2 = 397,               /* F16MAT4X2  */
+    DMAT4X3 = 397,                 /* DMAT4X3  */
-    F16MAT4X3 = 398,               /* F16MAT4X3  */
+    DMAT4X4 = 398,                 /* DMAT4X4  */
-    F16MAT4X4 = 399,               /* F16MAT4X4  */
+    F16MAT2X2 = 399,               /* F16MAT2X2  */
-    F32MAT2X2 = 400,               /* F32MAT2X2  */
+    F16MAT2X3 = 400,               /* F16MAT2X3  */
-    F32MAT2X3 = 401,               /* F32MAT2X3  */
+    F16MAT2X4 = 401,               /* F16MAT2X4  */
-    F32MAT2X4 = 402,               /* F32MAT2X4  */
+    F16MAT3X2 = 402,               /* F16MAT3X2  */
-    F32MAT3X2 = 403,               /* F32MAT3X2  */
+    F16MAT3X3 = 403,               /* F16MAT3X3  */
-    F32MAT3X3 = 404,               /* F32MAT3X3  */
+    F16MAT3X4 = 404,               /* F16MAT3X4  */
-    F32MAT3X4 = 405,               /* F32MAT3X4  */
+    F16MAT4X2 = 405,               /* F16MAT4X2  */
-    F32MAT4X2 = 406,               /* F32MAT4X2  */
+    F16MAT4X3 = 406,               /* F16MAT4X3  */
-    F32MAT4X3 = 407,               /* F32MAT4X3  */
+    F16MAT4X4 = 407,               /* F16MAT4X4  */
-    F32MAT4X4 = 408,               /* F32MAT4X4  */
+    F32MAT2X2 = 408,               /* F32MAT2X2  */
-    F64MAT2X2 = 409,               /* F64MAT2X2  */
+    F32MAT2X3 = 409,               /* F32MAT2X3  */
-    F64MAT2X3 = 410,               /* F64MAT2X3  */
+    F32MAT2X4 = 410,               /* F32MAT2X4  */
-    F64MAT2X4 = 411,               /* F64MAT2X4  */
+    F32MAT3X2 = 411,               /* F32MAT3X2  */
-    F64MAT3X2 = 412,               /* F64MAT3X2  */
+    F32MAT3X3 = 412,               /* F32MAT3X3  */
-    F64MAT3X3 = 413,               /* F64MAT3X3  */
+    F32MAT3X4 = 413,               /* F32MAT3X4  */
-    F64MAT3X4 = 414,               /* F64MAT3X4  */
+    F32MAT4X2 = 414,               /* F32MAT4X2  */
-    F64MAT4X2 = 415,               /* F64MAT4X2  */
+    F32MAT4X3 = 415,               /* F32MAT4X3  */
-    F64MAT4X3 = 416,               /* F64MAT4X3  */
+    F32MAT4X4 = 416,               /* F32MAT4X4  */
-    F64MAT4X4 = 417,               /* F64MAT4X4  */
+    F64MAT2X2 = 417,               /* F64MAT2X2  */
-    ATOMIC_UINT = 418,             /* ATOMIC_UINT  */
+    F64MAT2X3 = 418,               /* F64MAT2X3  */
-    ACCSTRUCTNV = 419,             /* ACCSTRUCTNV  */
+    F64MAT2X4 = 419,               /* F64MAT2X4  */
-    ACCSTRUCTEXT = 420,            /* ACCSTRUCTEXT  */
+    F64MAT3X2 = 420,               /* F64MAT3X2  */
-    RAYQUERYEXT = 421,             /* RAYQUERYEXT  */
+    F64MAT3X3 = 421,               /* F64MAT3X3  */
-    FCOOPMATNV = 422,              /* FCOOPMATNV  */
+    F64MAT3X4 = 422,               /* F64MAT3X4  */
-    ICOOPMATNV = 423,              /* ICOOPMATNV  */
+    F64MAT4X2 = 423,               /* F64MAT4X2  */
-    UCOOPMATNV = 424,              /* UCOOPMATNV  */
+    F64MAT4X3 = 424,               /* F64MAT4X3  */
-    COOPMAT = 425,                 /* COOPMAT  */
+    F64MAT4X4 = 425,               /* F64MAT4X4  */
-    COOPVECNV = 426,               /* COOPVECNV  */
+    ATOMIC_UINT = 426,             /* ATOMIC_UINT  */
-    HITOBJECTNV = 427,             /* HITOBJECTNV  */
+    ACCSTRUCTNV = 427,             /* ACCSTRUCTNV  */
-    HITOBJECTATTRNV = 428,         /* HITOBJECTATTRNV  */
+    ACCSTRUCTEXT = 428,            /* ACCSTRUCTEXT  */
-    TENSORLAYOUTNV = 429,          /* TENSORLAYOUTNV  */
+    RAYQUERYEXT = 429,             /* RAYQUERYEXT  */
-    TENSORVIEWNV = 430,            /* TENSORVIEWNV  */
+    FCOOPMATNV = 430,              /* FCOOPMATNV  */
-    SAMPLERCUBEARRAY = 431,        /* SAMPLERCUBEARRAY  */
+    ICOOPMATNV = 431,              /* ICOOPMATNV  */
-    SAMPLERCUBEARRAYSHADOW = 432,  /* SAMPLERCUBEARRAYSHADOW  */
+    UCOOPMATNV = 432,              /* UCOOPMATNV  */
-    ISAMPLERCUBEARRAY = 433,       /* ISAMPLERCUBEARRAY  */
+    COOPMAT = 433,                 /* COOPMAT  */
-    USAMPLERCUBEARRAY = 434,       /* USAMPLERCUBEARRAY  */
+    COOPVECNV = 434,               /* COOPVECNV  */
-    SAMPLER1D = 435,               /* SAMPLER1D  */
+    HITOBJECTNV = 435,             /* HITOBJECTNV  */
-    SAMPLER1DARRAY = 436,          /* SAMPLER1DARRAY  */
+    HITOBJECTATTRNV = 436,         /* HITOBJECTATTRNV  */
-    SAMPLER1DARRAYSHADOW = 437,    /* SAMPLER1DARRAYSHADOW  */
+    TENSORLAYOUTNV = 437,          /* TENSORLAYOUTNV  */
-    ISAMPLER1D = 438,              /* ISAMPLER1D  */
+    TENSORVIEWNV = 438,            /* TENSORVIEWNV  */
-    SAMPLER1DSHADOW = 439,         /* SAMPLER1DSHADOW  */
+    TENSORARM = 439,               /* TENSORARM  */
-    SAMPLER2DRECT = 440,           /* SAMPLER2DRECT  */
+    SAMPLERCUBEARRAY = 440,        /* SAMPLERCUBEARRAY  */
-    SAMPLER2DRECTSHADOW = 441,     /* SAMPLER2DRECTSHADOW  */
+    SAMPLERCUBEARRAYSHADOW = 441,  /* SAMPLERCUBEARRAYSHADOW  */
-    ISAMPLER2DRECT = 442,          /* ISAMPLER2DRECT  */
+    ISAMPLERCUBEARRAY = 442,       /* ISAMPLERCUBEARRAY  */
-    USAMPLER2DRECT = 443,          /* USAMPLER2DRECT  */
+    USAMPLERCUBEARRAY = 443,       /* USAMPLERCUBEARRAY  */
-    SAMPLERBUFFER = 444,           /* SAMPLERBUFFER  */
+    SAMPLER1D = 444,               /* SAMPLER1D  */
-    ISAMPLERBUFFER = 445,          /* ISAMPLERBUFFER  */
+    SAMPLER1DARRAY = 445,          /* SAMPLER1DARRAY  */
-    USAMPLERBUFFER = 446,          /* USAMPLERBUFFER  */
+    SAMPLER1DARRAYSHADOW = 446,    /* SAMPLER1DARRAYSHADOW  */
-    SAMPLER2DMS = 447,             /* SAMPLER2DMS  */
+    ISAMPLER1D = 447,              /* ISAMPLER1D  */
-    ISAMPLER2DMS = 448,            /* ISAMPLER2DMS  */
+    SAMPLER1DSHADOW = 448,         /* SAMPLER1DSHADOW  */
-    USAMPLER2DMS = 449,            /* USAMPLER2DMS  */
+    SAMPLER2DRECT = 449,           /* SAMPLER2DRECT  */
-    SAMPLER2DMSARRAY = 450,        /* SAMPLER2DMSARRAY  */
+    SAMPLER2DRECTSHADOW = 450,     /* SAMPLER2DRECTSHADOW  */
-    ISAMPLER2DMSARRAY = 451,       /* ISAMPLER2DMSARRAY  */
+    ISAMPLER2DRECT = 451,          /* ISAMPLER2DRECT  */
-    USAMPLER2DMSARRAY = 452,       /* USAMPLER2DMSARRAY  */
+    USAMPLER2DRECT = 452,          /* USAMPLER2DRECT  */
-    SAMPLEREXTERNALOES = 453,      /* SAMPLEREXTERNALOES  */
+    SAMPLERBUFFER = 453,           /* SAMPLERBUFFER  */
-    SAMPLEREXTERNAL2DY2YEXT = 454, /* SAMPLEREXTERNAL2DY2YEXT  */
+    ISAMPLERBUFFER = 454,          /* ISAMPLERBUFFER  */
-    ISAMPLER1DARRAY = 455,         /* ISAMPLER1DARRAY  */
+    USAMPLERBUFFER = 455,          /* USAMPLERBUFFER  */
-    USAMPLER1D = 456,              /* USAMPLER1D  */
+    SAMPLER2DMS = 456,             /* SAMPLER2DMS  */
-    USAMPLER1DARRAY = 457,         /* USAMPLER1DARRAY  */
+    ISAMPLER2DMS = 457,            /* ISAMPLER2DMS  */
-    F16SAMPLER1D = 458,            /* F16SAMPLER1D  */
+    USAMPLER2DMS = 458,            /* USAMPLER2DMS  */
-    F16SAMPLER2D = 459,            /* F16SAMPLER2D  */
+    SAMPLER2DMSARRAY = 459,        /* SAMPLER2DMSARRAY  */
-    F16SAMPLER3D = 460,            /* F16SAMPLER3D  */
+    ISAMPLER2DMSARRAY = 460,       /* ISAMPLER2DMSARRAY  */
-    F16SAMPLER2DRECT = 461,        /* F16SAMPLER2DRECT  */
+    USAMPLER2DMSARRAY = 461,       /* USAMPLER2DMSARRAY  */
-    F16SAMPLERCUBE = 462,          /* F16SAMPLERCUBE  */
+    SAMPLEREXTERNALOES = 462,      /* SAMPLEREXTERNALOES  */
-    F16SAMPLER1DARRAY = 463,       /* F16SAMPLER1DARRAY  */
+    SAMPLEREXTERNAL2DY2YEXT = 463, /* SAMPLEREXTERNAL2DY2YEXT  */
-    F16SAMPLER2DARRAY = 464,       /* F16SAMPLER2DARRAY  */
+    ISAMPLER1DARRAY = 464,         /* ISAMPLER1DARRAY  */
-    F16SAMPLERCUBEARRAY = 465,     /* F16SAMPLERCUBEARRAY  */
+    USAMPLER1D = 465,              /* USAMPLER1D  */
-    F16SAMPLERBUFFER = 466,        /* F16SAMPLERBUFFER  */
+    USAMPLER1DARRAY = 466,         /* USAMPLER1DARRAY  */
-    F16SAMPLER2DMS = 467,          /* F16SAMPLER2DMS  */
+    F16SAMPLER1D = 467,            /* F16SAMPLER1D  */
-    F16SAMPLER2DMSARRAY = 468,     /* F16SAMPLER2DMSARRAY  */
+    F16SAMPLER2D = 468,            /* F16SAMPLER2D  */
-    F16SAMPLER1DSHADOW = 469,      /* F16SAMPLER1DSHADOW  */
+    F16SAMPLER3D = 469,            /* F16SAMPLER3D  */
-    F16SAMPLER2DSHADOW = 470,      /* F16SAMPLER2DSHADOW  */
+    F16SAMPLER2DRECT = 470,        /* F16SAMPLER2DRECT  */
-    F16SAMPLER1DARRAYSHADOW = 471, /* F16SAMPLER1DARRAYSHADOW  */
+    F16SAMPLERCUBE = 471,          /* F16SAMPLERCUBE  */
-    F16SAMPLER2DARRAYSHADOW = 472, /* F16SAMPLER2DARRAYSHADOW  */
+    F16SAMPLER1DARRAY = 472,       /* F16SAMPLER1DARRAY  */
-    F16SAMPLER2DRECTSHADOW = 473,  /* F16SAMPLER2DRECTSHADOW  */
+    F16SAMPLER2DARRAY = 473,       /* F16SAMPLER2DARRAY  */
-    F16SAMPLERCUBESHADOW = 474,    /* F16SAMPLERCUBESHADOW  */
+    F16SAMPLERCUBEARRAY = 474,     /* F16SAMPLERCUBEARRAY  */
-    F16SAMPLERCUBEARRAYSHADOW = 475, /* F16SAMPLERCUBEARRAYSHADOW  */
+    F16SAMPLERBUFFER = 475,        /* F16SAMPLERBUFFER  */
-    IMAGE1D = 476,                 /* IMAGE1D  */
+    F16SAMPLER2DMS = 476,          /* F16SAMPLER2DMS  */
-    IIMAGE1D = 477,                /* IIMAGE1D  */
+    F16SAMPLER2DMSARRAY = 477,     /* F16SAMPLER2DMSARRAY  */
-    UIMAGE1D = 478,                /* UIMAGE1D  */
+    F16SAMPLER1DSHADOW = 478,      /* F16SAMPLER1DSHADOW  */
-    IMAGE2D = 479,                 /* IMAGE2D  */
+    F16SAMPLER2DSHADOW = 479,      /* F16SAMPLER2DSHADOW  */
-    IIMAGE2D = 480,                /* IIMAGE2D  */
+    F16SAMPLER1DARRAYSHADOW = 480, /* F16SAMPLER1DARRAYSHADOW  */
-    UIMAGE2D = 481,                /* UIMAGE2D  */
+    F16SAMPLER2DARRAYSHADOW = 481, /* F16SAMPLER2DARRAYSHADOW  */
-    IMAGE3D = 482,                 /* IMAGE3D  */
+    F16SAMPLER2DRECTSHADOW = 482,  /* F16SAMPLER2DRECTSHADOW  */
-    IIMAGE3D = 483,                /* IIMAGE3D  */
+    F16SAMPLERCUBESHADOW = 483,    /* F16SAMPLERCUBESHADOW  */
-    UIMAGE3D = 484,                /* UIMAGE3D  */
+    F16SAMPLERCUBEARRAYSHADOW = 484, /* F16SAMPLERCUBEARRAYSHADOW  */
-    IMAGE2DRECT = 485,             /* IMAGE2DRECT  */
+    IMAGE1D = 485,                 /* IMAGE1D  */
-    IIMAGE2DRECT = 486,            /* IIMAGE2DRECT  */
+    IIMAGE1D = 486,                /* IIMAGE1D  */
-    UIMAGE2DRECT = 487,            /* UIMAGE2DRECT  */
+    UIMAGE1D = 487,                /* UIMAGE1D  */
-    IMAGECUBE = 488,               /* IMAGECUBE  */
+    IMAGE2D = 488,                 /* IMAGE2D  */
-    IIMAGECUBE = 489,              /* IIMAGECUBE  */
+    IIMAGE2D = 489,                /* IIMAGE2D  */
-    UIMAGECUBE = 490,              /* UIMAGECUBE  */
+    UIMAGE2D = 490,                /* UIMAGE2D  */
-    IMAGEBUFFER = 491,             /* IMAGEBUFFER  */
+    IMAGE3D = 491,                 /* IMAGE3D  */
-    IIMAGEBUFFER = 492,            /* IIMAGEBUFFER  */
+    IIMAGE3D = 492,                /* IIMAGE3D  */
-    UIMAGEBUFFER = 493,            /* UIMAGEBUFFER  */
+    UIMAGE3D = 493,                /* UIMAGE3D  */
-    IMAGE1DARRAY = 494,            /* IMAGE1DARRAY  */
+    IMAGE2DRECT = 494,             /* IMAGE2DRECT  */
-    IIMAGE1DARRAY = 495,           /* IIMAGE1DARRAY  */
+    IIMAGE2DRECT = 495,            /* IIMAGE2DRECT  */
-    UIMAGE1DARRAY = 496,           /* UIMAGE1DARRAY  */
+    UIMAGE2DRECT = 496,            /* UIMAGE2DRECT  */
-    IMAGE2DARRAY = 497,            /* IMAGE2DARRAY  */
+    IMAGECUBE = 497,               /* IMAGECUBE  */
-    IIMAGE2DARRAY = 498,           /* IIMAGE2DARRAY  */
+    IIMAGECUBE = 498,              /* IIMAGECUBE  */
-    UIMAGE2DARRAY = 499,           /* UIMAGE2DARRAY  */
+    UIMAGECUBE = 499,              /* UIMAGECUBE  */
-    IMAGECUBEARRAY = 500,          /* IMAGECUBEARRAY  */
+    IMAGEBUFFER = 500,             /* IMAGEBUFFER  */
-    IIMAGECUBEARRAY = 501,         /* IIMAGECUBEARRAY  */
+    IIMAGEBUFFER = 501,            /* IIMAGEBUFFER  */
-    UIMAGECUBEARRAY = 502,         /* UIMAGECUBEARRAY  */
+    UIMAGEBUFFER = 502,            /* UIMAGEBUFFER  */
-    IMAGE2DMS = 503,               /* IMAGE2DMS  */
+    IMAGE1DARRAY = 503,            /* IMAGE1DARRAY  */
-    IIMAGE2DMS = 504,              /* IIMAGE2DMS  */
+    IIMAGE1DARRAY = 504,           /* IIMAGE1DARRAY  */
-    UIMAGE2DMS = 505,              /* UIMAGE2DMS  */
+    UIMAGE1DARRAY = 505,           /* UIMAGE1DARRAY  */
-    IMAGE2DMSARRAY = 506,          /* IMAGE2DMSARRAY  */
+    IMAGE2DARRAY = 506,            /* IMAGE2DARRAY  */
-    IIMAGE2DMSARRAY = 507,         /* IIMAGE2DMSARRAY  */
+    IIMAGE2DARRAY = 507,           /* IIMAGE2DARRAY  */
-    UIMAGE2DMSARRAY = 508,         /* UIMAGE2DMSARRAY  */
+    UIMAGE2DARRAY = 508,           /* UIMAGE2DARRAY  */
-    F16IMAGE1D = 509,              /* F16IMAGE1D  */
+    IMAGECUBEARRAY = 509,          /* IMAGECUBEARRAY  */
-    F16IMAGE2D = 510,              /* F16IMAGE2D  */
+    IIMAGECUBEARRAY = 510,         /* IIMAGECUBEARRAY  */
-    F16IMAGE3D = 511,              /* F16IMAGE3D  */
+    UIMAGECUBEARRAY = 511,         /* UIMAGECUBEARRAY  */
-    F16IMAGE2DRECT = 512,          /* F16IMAGE2DRECT  */
+    IMAGE2DMS = 512,               /* IMAGE2DMS  */
-    F16IMAGECUBE = 513,            /* F16IMAGECUBE  */
+    IIMAGE2DMS = 513,              /* IIMAGE2DMS  */
-    F16IMAGE1DARRAY = 514,         /* F16IMAGE1DARRAY  */
+    UIMAGE2DMS = 514,              /* UIMAGE2DMS  */
-    F16IMAGE2DARRAY = 515,         /* F16IMAGE2DARRAY  */
+    IMAGE2DMSARRAY = 515,          /* IMAGE2DMSARRAY  */
-    F16IMAGECUBEARRAY = 516,       /* F16IMAGECUBEARRAY  */
+    IIMAGE2DMSARRAY = 516,         /* IIMAGE2DMSARRAY  */
-    F16IMAGEBUFFER = 517,          /* F16IMAGEBUFFER  */
+    UIMAGE2DMSARRAY = 517,         /* UIMAGE2DMSARRAY  */
-    F16IMAGE2DMS = 518,            /* F16IMAGE2DMS  */
+    F16IMAGE1D = 518,              /* F16IMAGE1D  */
-    F16IMAGE2DMSARRAY = 519,       /* F16IMAGE2DMSARRAY  */
+    F16IMAGE2D = 519,              /* F16IMAGE2D  */
-    I64IMAGE1D = 520,              /* I64IMAGE1D  */
+    F16IMAGE3D = 520,              /* F16IMAGE3D  */
-    U64IMAGE1D = 521,              /* U64IMAGE1D  */
+    F16IMAGE2DRECT = 521,          /* F16IMAGE2DRECT  */
-    I64IMAGE2D = 522,              /* I64IMAGE2D  */
+    F16IMAGECUBE = 522,            /* F16IMAGECUBE  */
-    U64IMAGE2D = 523,              /* U64IMAGE2D  */
+    F16IMAGE1DARRAY = 523,         /* F16IMAGE1DARRAY  */
-    I64IMAGE3D = 524,              /* I64IMAGE3D  */
+    F16IMAGE2DARRAY = 524,         /* F16IMAGE2DARRAY  */
-    U64IMAGE3D = 525,              /* U64IMAGE3D  */
+    F16IMAGECUBEARRAY = 525,       /* F16IMAGECUBEARRAY  */
-    I64IMAGE2DRECT = 526,          /* I64IMAGE2DRECT  */
+    F16IMAGEBUFFER = 526,          /* F16IMAGEBUFFER  */
-    U64IMAGE2DRECT = 527,          /* U64IMAGE2DRECT  */
+    F16IMAGE2DMS = 527,            /* F16IMAGE2DMS  */
-    I64IMAGECUBE = 528,            /* I64IMAGECUBE  */
+    F16IMAGE2DMSARRAY = 528,       /* F16IMAGE2DMSARRAY  */
-    U64IMAGECUBE = 529,            /* U64IMAGECUBE  */
+    I64IMAGE1D = 529,              /* I64IMAGE1D  */
-    I64IMAGEBUFFER = 530,          /* I64IMAGEBUFFER  */
+    U64IMAGE1D = 530,              /* U64IMAGE1D  */
-    U64IMAGEBUFFER = 531,          /* U64IMAGEBUFFER  */
+    I64IMAGE2D = 531,              /* I64IMAGE2D  */
-    I64IMAGE1DARRAY = 532,         /* I64IMAGE1DARRAY  */
+    U64IMAGE2D = 532,              /* U64IMAGE2D  */
-    U64IMAGE1DARRAY = 533,         /* U64IMAGE1DARRAY  */
+    I64IMAGE3D = 533,              /* I64IMAGE3D  */
-    I64IMAGE2DARRAY = 534,         /* I64IMAGE2DARRAY  */
+    U64IMAGE3D = 534,              /* U64IMAGE3D  */
-    U64IMAGE2DARRAY = 535,         /* U64IMAGE2DARRAY  */
+    I64IMAGE2DRECT = 535,          /* I64IMAGE2DRECT  */
-    I64IMAGECUBEARRAY = 536,       /* I64IMAGECUBEARRAY  */
+    U64IMAGE2DRECT = 536,          /* U64IMAGE2DRECT  */
-    U64IMAGECUBEARRAY = 537,       /* U64IMAGECUBEARRAY  */
+    I64IMAGECUBE = 537,            /* I64IMAGECUBE  */
-    I64IMAGE2DMS = 538,            /* I64IMAGE2DMS  */
+    U64IMAGECUBE = 538,            /* U64IMAGECUBE  */
-    U64IMAGE2DMS = 539,            /* U64IMAGE2DMS  */
+    I64IMAGEBUFFER = 539,          /* I64IMAGEBUFFER  */
-    I64IMAGE2DMSARRAY = 540,       /* I64IMAGE2DMSARRAY  */
+    U64IMAGEBUFFER = 540,          /* U64IMAGEBUFFER  */
-    U64IMAGE2DMSARRAY = 541,       /* U64IMAGE2DMSARRAY  */
+    I64IMAGE1DARRAY = 541,         /* I64IMAGE1DARRAY  */
-    TEXTURECUBEARRAY = 542,        /* TEXTURECUBEARRAY  */
+    U64IMAGE1DARRAY = 542,         /* U64IMAGE1DARRAY  */
-    ITEXTURECUBEARRAY = 543,       /* ITEXTURECUBEARRAY  */
+    I64IMAGE2DARRAY = 543,         /* I64IMAGE2DARRAY  */
-    UTEXTURECUBEARRAY = 544,       /* UTEXTURECUBEARRAY  */
+    U64IMAGE2DARRAY = 544,         /* U64IMAGE2DARRAY  */
-    TEXTURE1D = 545,               /* TEXTURE1D  */
+    I64IMAGECUBEARRAY = 545,       /* I64IMAGECUBEARRAY  */
-    ITEXTURE1D = 546,              /* ITEXTURE1D  */
+    U64IMAGECUBEARRAY = 546,       /* U64IMAGECUBEARRAY  */
-    UTEXTURE1D = 547,              /* UTEXTURE1D  */
+    I64IMAGE2DMS = 547,            /* I64IMAGE2DMS  */
-    TEXTURE1DARRAY = 548,          /* TEXTURE1DARRAY  */
+    U64IMAGE2DMS = 548,            /* U64IMAGE2DMS  */
-    ITEXTURE1DARRAY = 549,         /* ITEXTURE1DARRAY  */
+    I64IMAGE2DMSARRAY = 549,       /* I64IMAGE2DMSARRAY  */
-    UTEXTURE1DARRAY = 550,         /* UTEXTURE1DARRAY  */
+    U64IMAGE2DMSARRAY = 550,       /* U64IMAGE2DMSARRAY  */
-    TEXTURE2DRECT = 551,           /* TEXTURE2DRECT  */
+    TEXTURECUBEARRAY = 551,        /* TEXTURECUBEARRAY  */
-    ITEXTURE2DRECT = 552,          /* ITEXTURE2DRECT  */
+    ITEXTURECUBEARRAY = 552,       /* ITEXTURECUBEARRAY  */
-    UTEXTURE2DRECT = 553,          /* UTEXTURE2DRECT  */
+    UTEXTURECUBEARRAY = 553,       /* UTEXTURECUBEARRAY  */
-    TEXTUREBUFFER = 554,           /* TEXTUREBUFFER  */
+    TEXTURE1D = 554,               /* TEXTURE1D  */
-    ITEXTUREBUFFER = 555,          /* ITEXTUREBUFFER  */
+    ITEXTURE1D = 555,              /* ITEXTURE1D  */
-    UTEXTUREBUFFER = 556,          /* UTEXTUREBUFFER  */
+    UTEXTURE1D = 556,              /* UTEXTURE1D  */
-    TEXTURE2DMS = 557,             /* TEXTURE2DMS  */
+    TEXTURE1DARRAY = 557,          /* TEXTURE1DARRAY  */
-    ITEXTURE2DMS = 558,            /* ITEXTURE2DMS  */
+    ITEXTURE1DARRAY = 558,         /* ITEXTURE1DARRAY  */
-    UTEXTURE2DMS = 559,            /* UTEXTURE2DMS  */
+    UTEXTURE1DARRAY = 559,         /* UTEXTURE1DARRAY  */
-    TEXTURE2DMSARRAY = 560,        /* TEXTURE2DMSARRAY  */
+    TEXTURE2DRECT = 560,           /* TEXTURE2DRECT  */
-    ITEXTURE2DMSARRAY = 561,       /* ITEXTURE2DMSARRAY  */
+    ITEXTURE2DRECT = 561,          /* ITEXTURE2DRECT  */
-    UTEXTURE2DMSARRAY = 562,       /* UTEXTURE2DMSARRAY  */
+    UTEXTURE2DRECT = 562,          /* UTEXTURE2DRECT  */
-    F16TEXTURE1D = 563,            /* F16TEXTURE1D  */
+    TEXTUREBUFFER = 563,           /* TEXTUREBUFFER  */
-    F16TEXTURE2D = 564,            /* F16TEXTURE2D  */
+    ITEXTUREBUFFER = 564,          /* ITEXTUREBUFFER  */
-    F16TEXTURE3D = 565,            /* F16TEXTURE3D  */
+    UTEXTUREBUFFER = 565,          /* UTEXTUREBUFFER  */
-    F16TEXTURE2DRECT = 566,        /* F16TEXTURE2DRECT  */
+    TEXTURE2DMS = 566,             /* TEXTURE2DMS  */
-    F16TEXTURECUBE = 567,          /* F16TEXTURECUBE  */
+    ITEXTURE2DMS = 567,            /* ITEXTURE2DMS  */
-    F16TEXTURE1DARRAY = 568,       /* F16TEXTURE1DARRAY  */
+    UTEXTURE2DMS = 568,            /* UTEXTURE2DMS  */
-    F16TEXTURE2DARRAY = 569,       /* F16TEXTURE2DARRAY  */
+    TEXTURE2DMSARRAY = 569,        /* TEXTURE2DMSARRAY  */
-    F16TEXTURECUBEARRAY = 570,     /* F16TEXTURECUBEARRAY  */
+    ITEXTURE2DMSARRAY = 570,       /* ITEXTURE2DMSARRAY  */
-    F16TEXTUREBUFFER = 571,        /* F16TEXTUREBUFFER  */
+    UTEXTURE2DMSARRAY = 571,       /* UTEXTURE2DMSARRAY  */
-    F16TEXTURE2DMS = 572,          /* F16TEXTURE2DMS  */
+    F16TEXTURE1D = 572,            /* F16TEXTURE1D  */
-    F16TEXTURE2DMSARRAY = 573,     /* F16TEXTURE2DMSARRAY  */
+    F16TEXTURE2D = 573,            /* F16TEXTURE2D  */
-    SUBPASSINPUT = 574,            /* SUBPASSINPUT  */
+    F16TEXTURE3D = 574,            /* F16TEXTURE3D  */
-    SUBPASSINPUTMS = 575,          /* SUBPASSINPUTMS  */
+    F16TEXTURE2DRECT = 575,        /* F16TEXTURE2DRECT  */
-    ISUBPASSINPUT = 576,           /* ISUBPASSINPUT  */
+    F16TEXTURECUBE = 576,          /* F16TEXTURECUBE  */
-    ISUBPASSINPUTMS = 577,         /* ISUBPASSINPUTMS  */
+    F16TEXTURE1DARRAY = 577,       /* F16TEXTURE1DARRAY  */
-    USUBPASSINPUT = 578,           /* USUBPASSINPUT  */
+    F16TEXTURE2DARRAY = 578,       /* F16TEXTURE2DARRAY  */
-    USUBPASSINPUTMS = 579,         /* USUBPASSINPUTMS  */
+    F16TEXTURECUBEARRAY = 579,     /* F16TEXTURECUBEARRAY  */
-    F16SUBPASSINPUT = 580,         /* F16SUBPASSINPUT  */
+    F16TEXTUREBUFFER = 580,        /* F16TEXTUREBUFFER  */
-    F16SUBPASSINPUTMS = 581,       /* F16SUBPASSINPUTMS  */
+    F16TEXTURE2DMS = 581,          /* F16TEXTURE2DMS  */
-    SPIRV_INSTRUCTION = 582,       /* SPIRV_INSTRUCTION  */
+    F16TEXTURE2DMSARRAY = 582,     /* F16TEXTURE2DMSARRAY  */
-    SPIRV_EXECUTION_MODE = 583,    /* SPIRV_EXECUTION_MODE  */
+    SUBPASSINPUT = 583,            /* SUBPASSINPUT  */
-    SPIRV_EXECUTION_MODE_ID = 584, /* SPIRV_EXECUTION_MODE_ID  */
+    SUBPASSINPUTMS = 584,          /* SUBPASSINPUTMS  */
-    SPIRV_DECORATE = 585,          /* SPIRV_DECORATE  */
+    ISUBPASSINPUT = 585,           /* ISUBPASSINPUT  */
-    SPIRV_DECORATE_ID = 586,       /* SPIRV_DECORATE_ID  */
+    ISUBPASSINPUTMS = 586,         /* ISUBPASSINPUTMS  */
-    SPIRV_DECORATE_STRING = 587,   /* SPIRV_DECORATE_STRING  */
+    USUBPASSINPUT = 587,           /* USUBPASSINPUT  */
-    SPIRV_TYPE = 588,              /* SPIRV_TYPE  */
+    USUBPASSINPUTMS = 588,         /* USUBPASSINPUTMS  */
-    SPIRV_STORAGE_CLASS = 589,     /* SPIRV_STORAGE_CLASS  */
+    F16SUBPASSINPUT = 589,         /* F16SUBPASSINPUT  */
-    SPIRV_BY_REFERENCE = 590,      /* SPIRV_BY_REFERENCE  */
+    F16SUBPASSINPUTMS = 590,       /* F16SUBPASSINPUTMS  */
-    SPIRV_LITERAL = 591,           /* SPIRV_LITERAL  */
+    SPIRV_INSTRUCTION = 591,       /* SPIRV_INSTRUCTION  */
-    ATTACHMENTEXT = 592,           /* ATTACHMENTEXT  */
+    SPIRV_EXECUTION_MODE = 592,    /* SPIRV_EXECUTION_MODE  */
-    IATTACHMENTEXT = 593,          /* IATTACHMENTEXT  */
+    SPIRV_EXECUTION_MODE_ID = 593, /* SPIRV_EXECUTION_MODE_ID  */
-    UATTACHMENTEXT = 594,          /* UATTACHMENTEXT  */
+    SPIRV_DECORATE = 594,          /* SPIRV_DECORATE  */
-    LEFT_OP = 595,                 /* LEFT_OP  */
+    SPIRV_DECORATE_ID = 595,       /* SPIRV_DECORATE_ID  */
-    RIGHT_OP = 596,                /* RIGHT_OP  */
+    SPIRV_DECORATE_STRING = 596,   /* SPIRV_DECORATE_STRING  */
-    INC_OP = 597,                  /* INC_OP  */
+    SPIRV_TYPE = 597,              /* SPIRV_TYPE  */
-    DEC_OP = 598,                  /* DEC_OP  */
+    SPIRV_STORAGE_CLASS = 598,     /* SPIRV_STORAGE_CLASS  */
-    LE_OP = 599,                   /* LE_OP  */
+    SPIRV_BY_REFERENCE = 599,      /* SPIRV_BY_REFERENCE  */
-    GE_OP = 600,                   /* GE_OP  */
+    SPIRV_LITERAL = 600,           /* SPIRV_LITERAL  */
-    EQ_OP = 601,                   /* EQ_OP  */
+    ATTACHMENTEXT = 601,           /* ATTACHMENTEXT  */
-    NE_OP = 602,                   /* NE_OP  */
+    IATTACHMENTEXT = 602,          /* IATTACHMENTEXT  */
-    AND_OP = 603,                  /* AND_OP  */
+    UATTACHMENTEXT = 603,          /* UATTACHMENTEXT  */
-    OR_OP = 604,                   /* OR_OP  */
+    LEFT_OP = 604,                 /* LEFT_OP  */
-    XOR_OP = 605,                  /* XOR_OP  */
+    RIGHT_OP = 605,                /* RIGHT_OP  */
-    MUL_ASSIGN = 606,              /* MUL_ASSIGN  */
+    INC_OP = 606,                  /* INC_OP  */
-    DIV_ASSIGN = 607,              /* DIV_ASSIGN  */
+    DEC_OP = 607,                  /* DEC_OP  */
-    ADD_ASSIGN = 608,              /* ADD_ASSIGN  */
+    LE_OP = 608,                   /* LE_OP  */
-    MOD_ASSIGN = 609,              /* MOD_ASSIGN  */
+    GE_OP = 609,                   /* GE_OP  */
-    LEFT_ASSIGN = 610,             /* LEFT_ASSIGN  */
+    EQ_OP = 610,                   /* EQ_OP  */
-    RIGHT_ASSIGN = 611,            /* RIGHT_ASSIGN  */
+    NE_OP = 611,                   /* NE_OP  */
-    AND_ASSIGN = 612,              /* AND_ASSIGN  */
+    AND_OP = 612,                  /* AND_OP  */
-    XOR_ASSIGN = 613,              /* XOR_ASSIGN  */
+    OR_OP = 613,                   /* OR_OP  */
-    OR_ASSIGN = 614,               /* OR_ASSIGN  */
+    XOR_OP = 614,                  /* XOR_OP  */
-    SUB_ASSIGN = 615,              /* SUB_ASSIGN  */
+    MUL_ASSIGN = 615,              /* MUL_ASSIGN  */
-    STRING_LITERAL = 616,          /* STRING_LITERAL  */
+    DIV_ASSIGN = 616,              /* DIV_ASSIGN  */
-    LEFT_PAREN = 617,              /* LEFT_PAREN  */
+    ADD_ASSIGN = 617,              /* ADD_ASSIGN  */
-    RIGHT_PAREN = 618,             /* RIGHT_PAREN  */
+    MOD_ASSIGN = 618,              /* MOD_ASSIGN  */
-    LEFT_BRACKET = 619,            /* LEFT_BRACKET  */
+    LEFT_ASSIGN = 619,             /* LEFT_ASSIGN  */
-    RIGHT_BRACKET = 620,           /* RIGHT_BRACKET  */
+    RIGHT_ASSIGN = 620,            /* RIGHT_ASSIGN  */
-    LEFT_BRACE = 621,              /* LEFT_BRACE  */
+    AND_ASSIGN = 621,              /* AND_ASSIGN  */
-    RIGHT_BRACE = 622,             /* RIGHT_BRACE  */
+    XOR_ASSIGN = 622,              /* XOR_ASSIGN  */
-    DOT = 623,                     /* DOT  */
+    OR_ASSIGN = 623,               /* OR_ASSIGN  */
-    COMMA = 624,                   /* COMMA  */
+    SUB_ASSIGN = 624,              /* SUB_ASSIGN  */
-    COLON = 625,                   /* COLON  */
+    STRING_LITERAL = 625,          /* STRING_LITERAL  */
-    EQUAL = 626,                   /* EQUAL  */
+    LEFT_PAREN = 626,              /* LEFT_PAREN  */
-    SEMICOLON = 627,               /* SEMICOLON  */
+    RIGHT_PAREN = 627,             /* RIGHT_PAREN  */
-    BANG = 628,                    /* BANG  */
+    LEFT_BRACKET = 628,            /* LEFT_BRACKET  */
-    DASH = 629,                    /* DASH  */
+    RIGHT_BRACKET = 629,           /* RIGHT_BRACKET  */
-    TILDE = 630,                   /* TILDE  */
+    LEFT_BRACE = 630,              /* LEFT_BRACE  */
-    PLUS = 631,                    /* PLUS  */
+    RIGHT_BRACE = 631,             /* RIGHT_BRACE  */
-    STAR = 632,                    /* STAR  */
+    DOT = 632,                     /* DOT  */
-    SLASH = 633,                   /* SLASH  */
+    COMMA = 633,                   /* COMMA  */
-    PERCENT = 634,                 /* PERCENT  */
+    COLON = 634,                   /* COLON  */
-    LEFT_ANGLE = 635,              /* LEFT_ANGLE  */
+    EQUAL = 635,                   /* EQUAL  */
-    RIGHT_ANGLE = 636,             /* RIGHT_ANGLE  */
+    SEMICOLON = 636,               /* SEMICOLON  */
-    VERTICAL_BAR = 637,            /* VERTICAL_BAR  */
+    BANG = 637,                    /* BANG  */
-    CARET = 638,                   /* CARET  */
+    DASH = 638,                    /* DASH  */
-    AMPERSAND = 639,               /* AMPERSAND  */
+    TILDE = 639,                   /* TILDE  */
-    QUESTION = 640,                /* QUESTION  */
+    PLUS = 640,                    /* PLUS  */
-    INVARIANT = 641,               /* INVARIANT  */
+    STAR = 641,                    /* STAR  */
-    HIGH_PRECISION = 642,          /* HIGH_PRECISION  */
+    SLASH = 642,                   /* SLASH  */
-    MEDIUM_PRECISION = 643,        /* MEDIUM_PRECISION  */
+    PERCENT = 643,                 /* PERCENT  */
-    LOW_PRECISION = 644,           /* LOW_PRECISION  */
+    LEFT_ANGLE = 644,              /* LEFT_ANGLE  */
-    PRECISION = 645,               /* PRECISION  */
+    RIGHT_ANGLE = 645,             /* RIGHT_ANGLE  */
-    PACKED = 646,                  /* PACKED  */
+    VERTICAL_BAR = 646,            /* VERTICAL_BAR  */
-    RESOURCE = 647,                /* RESOURCE  */
+    CARET = 647,                   /* CARET  */
-    SUPERP = 648,                  /* SUPERP  */
+    AMPERSAND = 648,               /* AMPERSAND  */
-    FLOATCONSTANT = 649,           /* FLOATCONSTANT  */
+    QUESTION = 649,                /* QUESTION  */
-    INTCONSTANT = 650,             /* INTCONSTANT  */
+    INVARIANT = 650,               /* INVARIANT  */
-    UINTCONSTANT = 651,            /* UINTCONSTANT  */
+    HIGH_PRECISION = 651,          /* HIGH_PRECISION  */
-    BOOLCONSTANT = 652,            /* BOOLCONSTANT  */
+    MEDIUM_PRECISION = 652,        /* MEDIUM_PRECISION  */
-    IDENTIFIER = 653,              /* IDENTIFIER  */
+    LOW_PRECISION = 653,           /* LOW_PRECISION  */
-    TYPE_NAME = 654,               /* TYPE_NAME  */
+    PRECISION = 654,               /* PRECISION  */
-    CENTROID = 655,                /* CENTROID  */
+    PACKED = 655,                  /* PACKED  */
-    IN = 656,                      /* IN  */
+    RESOURCE = 656,                /* RESOURCE  */
-    OUT = 657,                     /* OUT  */
+    SUPERP = 657,                  /* SUPERP  */
-    INOUT = 658,                   /* INOUT  */
+    FLOATCONSTANT = 658,           /* FLOATCONSTANT  */
-    STRUCT = 659,                  /* STRUCT  */
+    INTCONSTANT = 659,             /* INTCONSTANT  */
-    VOID = 660,                    /* VOID  */
+    UINTCONSTANT = 660,            /* UINTCONSTANT  */
-    WHILE = 661,                   /* WHILE  */
+    BOOLCONSTANT = 661,            /* BOOLCONSTANT  */
-    BREAK = 662,                   /* BREAK  */
+    IDENTIFIER = 662,              /* IDENTIFIER  */
-    CONTINUE = 663,                /* CONTINUE  */
+    TYPE_NAME = 663,               /* TYPE_NAME  */
-    DO = 664,                      /* DO  */
+    CENTROID = 664,                /* CENTROID  */
-    ELSE = 665,                    /* ELSE  */
+    IN = 665,                      /* IN  */
-    FOR = 666,                     /* FOR  */
+    OUT = 666,                     /* OUT  */
-    IF = 667,                      /* IF  */
+    INOUT = 667,                   /* INOUT  */
-    DISCARD = 668,                 /* DISCARD  */
+    STRUCT = 668,                  /* STRUCT  */
-    RETURN = 669,                  /* RETURN  */
+    VOID = 669,                    /* VOID  */
-    SWITCH = 670,                  /* SWITCH  */
+    WHILE = 670,                   /* WHILE  */
-    CASE = 671,                    /* CASE  */
+    BREAK = 671,                   /* BREAK  */
-    DEFAULT = 672,                 /* DEFAULT  */
+    CONTINUE = 672,                /* CONTINUE  */
-    TERMINATE_INVOCATION = 673,    /* TERMINATE_INVOCATION  */
+    DO = 673,                      /* DO  */
-    TERMINATE_RAY = 674,           /* TERMINATE_RAY  */
+    ELSE = 674,                    /* ELSE  */
-    IGNORE_INTERSECTION = 675,     /* IGNORE_INTERSECTION  */
+    FOR = 675,                     /* FOR  */
-    UNIFORM = 676,                 /* UNIFORM  */
+    IF = 676,                      /* IF  */
-    SHARED = 677,                  /* SHARED  */
+    DISCARD = 677,                 /* DISCARD  */
-    BUFFER = 678,                  /* BUFFER  */
+    RETURN = 678,                  /* RETURN  */
-    TILEIMAGEEXT = 679,            /* TILEIMAGEEXT  */
+    SWITCH = 679,                  /* SWITCH  */
-    FLAT = 680,                    /* FLAT  */
+    CASE = 680,                    /* CASE  */
-    SMOOTH = 681,                  /* SMOOTH  */
+    DEFAULT = 681,                 /* DEFAULT  */
-    LAYOUT = 682,                  /* LAYOUT  */
+    TERMINATE_INVOCATION = 682,    /* TERMINATE_INVOCATION  */
-    DOUBLECONSTANT = 683,          /* DOUBLECONSTANT  */
+    TERMINATE_RAY = 683,           /* TERMINATE_RAY  */
-    INT16CONSTANT = 684,           /* INT16CONSTANT  */
+    IGNORE_INTERSECTION = 684,     /* IGNORE_INTERSECTION  */
-    UINT16CONSTANT = 685,          /* UINT16CONSTANT  */
+    UNIFORM = 685,                 /* UNIFORM  */
-    FLOAT16CONSTANT = 686,         /* FLOAT16CONSTANT  */
+    SHARED = 686,                  /* SHARED  */
-    INT32CONSTANT = 687,           /* INT32CONSTANT  */
+    BUFFER = 687,                  /* BUFFER  */
-    UINT32CONSTANT = 688,          /* UINT32CONSTANT  */
+    TILEIMAGEEXT = 688,            /* TILEIMAGEEXT  */
-    INT64CONSTANT = 689,           /* INT64CONSTANT  */
+    FLAT = 689,                    /* FLAT  */
-    UINT64CONSTANT = 690,          /* UINT64CONSTANT  */
+    SMOOTH = 690,                  /* SMOOTH  */
-    SUBROUTINE = 691,              /* SUBROUTINE  */
+    LAYOUT = 691,                  /* LAYOUT  */
-    DEMOTE = 692,                  /* DEMOTE  */
+    DOUBLECONSTANT = 692,          /* DOUBLECONSTANT  */
-    FUNCTION = 693,                /* FUNCTION  */
+    INT16CONSTANT = 693,           /* INT16CONSTANT  */
-    PAYLOADNV = 694,               /* PAYLOADNV  */
+    UINT16CONSTANT = 694,          /* UINT16CONSTANT  */
-    PAYLOADINNV = 695,             /* PAYLOADINNV  */
+    FLOAT16CONSTANT = 695,         /* FLOAT16CONSTANT  */
-    HITATTRNV = 696,               /* HITATTRNV  */
+    INT32CONSTANT = 696,           /* INT32CONSTANT  */
-    CALLDATANV = 697,              /* CALLDATANV  */
+    UINT32CONSTANT = 697,          /* UINT32CONSTANT  */
-    CALLDATAINNV = 698,            /* CALLDATAINNV  */
+    INT64CONSTANT = 698,           /* INT64CONSTANT  */
-    PAYLOADEXT = 699,              /* PAYLOADEXT  */
+    UINT64CONSTANT = 699,          /* UINT64CONSTANT  */
-    PAYLOADINEXT = 700,            /* PAYLOADINEXT  */
+    SUBROUTINE = 700,              /* SUBROUTINE  */
-    HITATTREXT = 701,              /* HITATTREXT  */
+    DEMOTE = 701,                  /* DEMOTE  */
-    CALLDATAEXT = 702,             /* CALLDATAEXT  */
+    FUNCTION = 702,                /* FUNCTION  */
-    CALLDATAINEXT = 703,           /* CALLDATAINEXT  */
+    PAYLOADNV = 703,               /* PAYLOADNV  */
-    PATCH = 704,                   /* PATCH  */
+    PAYLOADINNV = 704,             /* PAYLOADINNV  */
-    SAMPLE = 705,                  /* SAMPLE  */
+    HITATTRNV = 705,               /* HITATTRNV  */
-    NONUNIFORM = 706,              /* NONUNIFORM  */
+    CALLDATANV = 706,              /* CALLDATANV  */
-    COHERENT = 707,                /* COHERENT  */
+    CALLDATAINNV = 707,            /* CALLDATAINNV  */
-    VOLATILE = 708,                /* VOLATILE  */
+    PAYLOADEXT = 708,              /* PAYLOADEXT  */
-    RESTRICT = 709,                /* RESTRICT  */
+    PAYLOADINEXT = 709,            /* PAYLOADINEXT  */
-    READONLY = 710,                /* READONLY  */
+    HITATTREXT = 710,              /* HITATTREXT  */
-    WRITEONLY = 711,               /* WRITEONLY  */
+    CALLDATAEXT = 711,             /* CALLDATAEXT  */
-    NONTEMPORAL = 712,             /* NONTEMPORAL  */
+    CALLDATAINEXT = 712,           /* CALLDATAINEXT  */
-    DEVICECOHERENT = 713,          /* DEVICECOHERENT  */
+    PATCH = 713,                   /* PATCH  */
-    QUEUEFAMILYCOHERENT = 714,     /* QUEUEFAMILYCOHERENT  */
+    SAMPLE = 714,                  /* SAMPLE  */
-    WORKGROUPCOHERENT = 715,       /* WORKGROUPCOHERENT  */
+    NONUNIFORM = 715,              /* NONUNIFORM  */
-    SUBGROUPCOHERENT = 716,        /* SUBGROUPCOHERENT  */
+    COHERENT = 716,                /* COHERENT  */
-    NONPRIVATE = 717,              /* NONPRIVATE  */
+    VOLATILE = 717,                /* VOLATILE  */
-    SHADERCALLCOHERENT = 718,      /* SHADERCALLCOHERENT  */
+    RESTRICT = 718,                /* RESTRICT  */
-    NOPERSPECTIVE = 719,           /* NOPERSPECTIVE  */
+    READONLY = 719,                /* READONLY  */
-    EXPLICITINTERPAMD = 720,       /* EXPLICITINTERPAMD  */
+    WRITEONLY = 720,               /* WRITEONLY  */
-    PERVERTEXEXT = 721,            /* PERVERTEXEXT  */
+    NONTEMPORAL = 721,             /* NONTEMPORAL  */
-    PERVERTEXNV = 722,             /* PERVERTEXNV  */
+    DEVICECOHERENT = 722,          /* DEVICECOHERENT  */
-    PERPRIMITIVENV = 723,          /* PERPRIMITIVENV  */
+    QUEUEFAMILYCOHERENT = 723,     /* QUEUEFAMILYCOHERENT  */
-    PERVIEWNV = 724,               /* PERVIEWNV  */
+    WORKGROUPCOHERENT = 724,       /* WORKGROUPCOHERENT  */
-    PERTASKNV = 725,               /* PERTASKNV  */
+    SUBGROUPCOHERENT = 725,        /* SUBGROUPCOHERENT  */
-    PERPRIMITIVEEXT = 726,         /* PERPRIMITIVEEXT  */
+    NONPRIVATE = 726,              /* NONPRIVATE  */
-    TASKPAYLOADWORKGROUPEXT = 727, /* TASKPAYLOADWORKGROUPEXT  */
+    SHADERCALLCOHERENT = 727,      /* SHADERCALLCOHERENT  */
-    PRECISE = 728                  /* PRECISE  */
+    NOPERSPECTIVE = 728,           /* NOPERSPECTIVE  */
+    EXPLICITINTERPAMD = 729,       /* EXPLICITINTERPAMD  */
+    PERVERTEXEXT = 730,            /* PERVERTEXEXT  */
+    PERVERTEXNV = 731,             /* PERVERTEXNV  */
+    PERPRIMITIVENV = 732,          /* PERPRIMITIVENV  */
+    PERVIEWNV = 733,               /* PERVIEWNV  */
+    PERTASKNV = 734,               /* PERTASKNV  */
+    PERPRIMITIVEEXT = 735,         /* PERPRIMITIVEEXT  */
+    TASKPAYLOADWORKGROUPEXT = 736, /* TASKPAYLOADWORKGROUPEXT  */
+    PRECISE = 737                  /* PRECISE  */
   };
   typedef enum yytokentype yytoken_kind_t;
 #endif
@@ -572,7 +581,7 @@ union YYSTYPE
         glslang::TTypeParameters* typeParameters;
     } interm;
 
-#line 576 "MachineIndependent/glslang_tab.cpp.h"
+#line 585 "MachineIndependent/glslang_tab.cpp.h"
 
 };
 typedef union YYSTYPE YYSTYPE;

include/glslang/MachineIndependent/localintermediate.h

@@ -268,6 +268,7 @@ public:
         gpu_shader_fp64                           = 1 << 9,
         gpu_shader_int16                          = 1 << 10,
         gpu_shader_half_float                     = 1 << 11,
+        nv_gpu_shader5_types                      = 1 << 12,
     } feature;
     void insert(feature f) { features |= f; }
     void erase(feature f) { features &= ~f; }
@@ -342,6 +343,7 @@ public:
         numTaskNVBlocks(0),
         layoutPrimitiveCulling(false),
         numTaskEXTPayloads(0),
+        nonCoherentTileAttachmentReadQCOM(false),
         autoMapBindings(false),
         autoMapLocations(false),
         flattenUniformArrays(false),
@@ -370,6 +372,12 @@ public:
         localSizeSpecId[1] = TQualifier::layoutNotSet;
         localSizeSpecId[2] = TQualifier::layoutNotSet;
         xfbBuffers.resize(TQualifier::layoutXfbBufferEnd);
+        tileShadingRateQCOM[0] = 0;
+        tileShadingRateQCOM[1] = 0;
+        tileShadingRateQCOM[2] = 0;
+        tileShadingRateQCOMNotDefault[0] = false;
+        tileShadingRateQCOMNotDefault[1] = false;
+        tileShadingRateQCOMNotDefault[2] = false;
         shiftBinding.fill(0);
     }
 
@@ -650,6 +658,21 @@ public:
 
     bool isEsProfile() const { return profile == EEsProfile; }
 
+    bool setTileShadingRateQCOM(int dim, int size)
+    {
+        if (tileShadingRateQCOMNotDefault[dim])
+            return size == tileShadingRateQCOM[dim];
+        tileShadingRateQCOMNotDefault[dim] = true;
+        tileShadingRateQCOM[dim] = size;
+        return true;
+    }
+    unsigned int getTileShadingRateQCOM(int dim) const { return tileShadingRateQCOM[dim]; }
+    bool isTileShadingRateQCOMSet() const
+    {
+        // Return true if any component has been set (i.e. any component is not default).
+        return tileShadingRateQCOMNotDefault[0] || tileShadingRateQCOMNotDefault[1] || tileShadingRateQCOMNotDefault[2];
+    }
+
     void setShiftBinding(TResourceType res, unsigned int shift)
     {
         shiftBinding[res] = shift;
@@ -895,6 +918,8 @@ public:
     bool getNonCoherentDepthAttachmentReadEXT() const { return nonCoherentDepthAttachmentReadEXT; }
     void setNonCoherentStencilAttachmentReadEXT() { nonCoherentStencilAttachmentReadEXT = true; }
     bool getNonCoherentStencilAttachmentReadEXT() const { return nonCoherentStencilAttachmentReadEXT; }
+    void setNonCoherentTileAttachmentReadQCOM() { nonCoherentTileAttachmentReadQCOM = true; }
+    bool getNonCoherentTileAttachmentReadQCOM() const { return nonCoherentTileAttachmentReadQCOM; }
     void setPostDepthCoverage() { postDepthCoverage = true; }
     bool getPostDepthCoverage() const { return postDepthCoverage; }
     void setEarlyFragmentTests() { earlyFragmentTests = true; }
@@ -1107,17 +1132,20 @@ public:
     // Certain explicit conversions are allowed conditionally
     bool getArithemeticInt8Enabled() const {
         return numericFeatures.contains(TNumericFeatures::shader_explicit_arithmetic_types) ||
+               numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types) ||
                numericFeatures.contains(TNumericFeatures::shader_explicit_arithmetic_types_int8);
     }
     bool getArithemeticInt16Enabled() const {
         return numericFeatures.contains(TNumericFeatures::shader_explicit_arithmetic_types) ||
                numericFeatures.contains(TNumericFeatures::gpu_shader_int16) ||
+               numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types) ||
                numericFeatures.contains(TNumericFeatures::shader_explicit_arithmetic_types_int16);
     }
 
     bool getArithemeticFloat16Enabled() const {
         return numericFeatures.contains(TNumericFeatures::shader_explicit_arithmetic_types) ||
                numericFeatures.contains(TNumericFeatures::gpu_shader_half_float) ||
+               numericFeatures.contains(TNumericFeatures::nv_gpu_shader5_types) ||
                numericFeatures.contains(TNumericFeatures::shader_explicit_arithmetic_types_float16);
     }
     void updateNumericFeature(TNumericFeatures::feature f, bool on)
@@ -1238,6 +1266,10 @@ protected:
     bool layoutPrimitiveCulling;
     int numTaskEXTPayloads;
 
+    bool nonCoherentTileAttachmentReadQCOM;
+    int  tileShadingRateQCOM[3];
+    bool tileShadingRateQCOMNotDefault[3];
+
     // Base shift values
     std::array<unsigned int, EResCount> shiftBinding;
 

include/glslang/MachineIndependent/parseVersions.h

@@ -104,6 +104,8 @@ public:
     virtual void float16Check(const TSourceLoc&, const char* op, bool builtIn = false);
     virtual void float16ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false);
     virtual void bfloat16ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false);
+    virtual void floate5m2ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false);
+    virtual void floate4m3ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false);
     virtual bool float16Arithmetic();
     virtual void requireFloat16Arithmetic(const TSourceLoc& loc, const char* op, const char* featureDesc);
     virtual void int16ScalarVectorCheck(const TSourceLoc&, const char* op, bool builtIn = false);
@@ -124,6 +126,8 @@ public:
     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);
+    virtual void intattachmentCheck(const TSourceLoc&, const char *op, bool builtIn = false);
+    virtual void tensorCheckARM(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; }

include/glslang/MachineIndependent/reflection.h

@@ -58,8 +58,10 @@ public:
     TReflection(EShReflectionOptions opts, EShLanguage first, EShLanguage last)
         : options(opts), firstStage(first), lastStage(last), badReflection(TObjectReflection::badReflection())
     { 
-        for (int dim=0; dim<3; ++dim)
+        for (int dim=0; dim<3; ++dim) {
             localSize[dim] = 0;
+            tileShadingRateQCOM[dim] = 0;
+        }
     }
 
     virtual ~TReflection() {}
@@ -168,6 +170,9 @@ public:
     // Thread local size
     unsigned getLocalSize(int dim) const { return dim <= 2 ? localSize[dim] : 0; }
 
+    // Tile shading rate QCOM
+    unsigned getTileShadingRateQCOM(int dim) const { return dim <= 2 ? tileShadingRateQCOM[dim] : 0; }
+
     void dump();
 
 protected:
@@ -213,6 +218,7 @@ protected:
     TIndices atomicCounterUniformIndices;
 
     unsigned int localSize[3];
+    unsigned int tileShadingRateQCOM[3];
 };
 
 } // end namespace glslang

include/glslang/Public/ShaderLang.h

@@ -156,8 +156,9 @@ typedef enum {
     EShTargetVulkan_1_1 = (1 << 22) | (1 << 12),      // Vulkan 1.1
     EShTargetVulkan_1_2 = (1 << 22) | (2 << 12),      // Vulkan 1.2
     EShTargetVulkan_1_3 = (1 << 22) | (3 << 12),      // Vulkan 1.3
+    EShTargetVulkan_1_4 = (1 << 22) | (4 << 12),      // Vulkan 1.4
     EShTargetOpenGL_450 = 450,                        // OpenGL
-    LAST_ELEMENT_MARKER(EShTargetClientVersionCount = 5),
+    LAST_ELEMENT_MARKER(EShTargetClientVersionCount = 6),
 } EShTargetClientVersion;
 
 typedef EShTargetClientVersion EshTargetClientVersion;
@@ -272,6 +273,7 @@ enum EShMessages : unsigned {
     EShMsgAbsolutePath         = (1 << 16), // Output Absolute path for messages
     EShMsgDisplayErrorColumn   = (1 << 17), // Display error message column aswell as line
     EShMsgLinkTimeOptimization = (1 << 18), // perform cross-stage optimizations during linking
+    EShMsgValidateCrossStageIO = (1 << 19), // validate shader inputs have matching outputs in previous stage
     LAST_ELEMENT_MARKER(EShMsgCount),
 };
 
@@ -893,6 +895,7 @@ public:
     // call first, to do liveness analysis, index mapping, etc.; returns false on failure
     GLSLANG_EXPORT bool buildReflection(int opts = EShReflectionDefault);
     GLSLANG_EXPORT unsigned getLocalSize(int dim) const;                  // return dim'th local size
+    GLSLANG_EXPORT unsigned getTileShadingRateQCOM(int dim) const;        // return dim'th tile shading rate QCOM
     GLSLANG_EXPORT int getReflectionIndex(const char *name) const;
     GLSLANG_EXPORT int getReflectionPipeIOIndex(const char* name, const bool inOrOut) const;
     GLSLANG_EXPORT int getNumUniformVariables() const;

include/glslang/SPIRV/SPVRemapper.h

@@ -91,7 +91,7 @@ public:
 #include <set>
 #include <cassert>
 
-#include "spirv.hpp"
+#include "spirv.hpp11"
 
 namespace spv {
 

include/glslang/build_info.h

@@ -35,7 +35,7 @@
 #define GLSLANG_BUILD_INFO
 
 #define GLSLANG_VERSION_MAJOR 15
-#define GLSLANG_VERSION_MINOR 0
+#define GLSLANG_VERSION_MINOR 4
 #define GLSLANG_VERSION_PATCH 0
 #define GLSLANG_VERSION_FLAVOR ""