Update glslang

2026-08-17 19:23:38 +02:00 · 2020-04-26 22:49:42 -03:00
parent 910ede47cc
commit e4b84224fc
49 changed files with 7435 additions and 5345 deletions
@@ -1,5 +1,6 @@
 /*
-** Copyright (c) 2014-2016 The Khronos Group Inc.
+** Copyright (c) 2014-2020 The Khronos Group Inc.
 ** Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 **
 ** Permission is hereby granted, free of charge, to any person obtaining a copy
 ** of this software and/or associated documentation files (the "Materials"),
@@ -44,5 +45,7 @@ static const char* const E_SPV_EXT_physical_storage_buffer      = "SPV_EXT_physi
 static const char* const E_SPV_KHR_physical_storage_buffer      = "SPV_KHR_physical_storage_buffer";
 static const char* const E_SPV_EXT_fragment_shader_interlock    = "SPV_EXT_fragment_shader_interlock";
 static const char* const E_SPV_KHR_shader_clock                 = "SPV_KHR_shader_clock";
-
+static const char* const E_SPV_KHR_non_semantic_info            = "SPV_KHR_non_semantic_info";
 static const char* const E_SPV_KHR_ray_tracing                  = "SPV_KHR_ray_tracing";
 static const char* const E_SPV_KHR_ray_query                    = "SPV_KHR_ray_query";
 #endif  // #ifndef GLSLextKHR_H
@@ -0,0 +1,50 @@
 // Copyright (c) 2020 The Khronos Group Inc.
 // 
 // Permission is hereby granted, free of charge, to any person obtaining a
 // copy of this software and/or associated documentation files (the
 // "Materials"), to deal in the Materials without restriction, including
 // without limitation the rights to use, copy, modify, merge, publish,
 // distribute, sublicense, and/or sell copies of the Materials, and to
 // permit persons to whom the Materials are furnished to do so, subject to
 // the following conditions:
 // 
 // The above copyright notice and this permission notice shall be included
 // in all copies or substantial portions of the Materials.
 // 
 // MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS
 // KHRONOS STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS
 // SPECIFICATIONS AND HEADER INFORMATION ARE LOCATED AT
 //    https://www.khronos.org/registry/
 // 
 // THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 // MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
 // 
 #ifndef SPIRV_UNIFIED1_NonSemanticDebugPrintf_H_
 #define SPIRV_UNIFIED1_NonSemanticDebugPrintf_H_
 #ifdef __cplusplus
 extern "C" {
 #endif
 enum {
    NonSemanticDebugPrintfRevision = 1,
    NonSemanticDebugPrintfRevision_BitWidthPadding = 0x7fffffff
 };
 enum NonSemanticDebugPrintfInstructions {
    NonSemanticDebugPrintfDebugPrintf = 1,
    NonSemanticDebugPrintfInstructionsMax = 0x7fffffff
 };
 #ifdef __cplusplus
 }
 #endif
 #endif // SPIRV_UNIFIED1_NonSemanticDebugPrintf_H_
@@ -1,6 +1,7 @@
 //
 // Copyright (C) 2014-2015 LunarG, Inc.
 // Copyright (C) 2015-2018 Google, Inc.
 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -496,7 +497,8 @@ Id Builder::makeFunctionType(Id returnType, const std::vector<Id>& paramTypes)
    return type->getResultId();
 }
-Id Builder::makeImageType(Id sampledType, Dim dim, bool depth, bool arrayed, bool ms, unsigned sampled, ImageFormat format)
+Id Builder::makeImageType(Id sampledType, Dim dim, bool depth, bool arrayed, bool ms, unsigned sampled,
    ImageFormat format)
 {
    assert(sampled == 1 || sampled == 2);
@@ -601,16 +603,31 @@ Id Builder::makeSampledImageType(Id imageType)
 }
 #ifndef GLSLANG_WEB
-Id Builder::makeAccelerationStructureNVType()
+Id Builder::makeAccelerationStructureType()
 {
    Instruction *type;
-    if (groupedTypes[OpTypeAccelerationStructureNV].size() == 0) {
+    if (groupedTypes[OpTypeAccelerationStructureKHR].size() == 0) {
-        type = new Instruction(getUniqueId(), NoType, OpTypeAccelerationStructureNV);
+        type = new Instruction(getUniqueId(), NoType, OpTypeAccelerationStructureKHR);
-        groupedTypes[OpTypeAccelerationStructureNV].push_back(type);
+        groupedTypes[OpTypeAccelerationStructureKHR].push_back(type);
        constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
        module.mapInstruction(type);
    } else {
-        type = groupedTypes[OpTypeAccelerationStructureNV].back();
+        type = groupedTypes[OpTypeAccelerationStructureKHR].back();
    }
    return type->getResultId();
 }
 Id Builder::makeRayQueryType()
 {
    Instruction *type;
    if (groupedTypes[OpTypeRayQueryProvisionalKHR].size() == 0) {
        type = new Instruction(getUniqueId(), NoType, OpTypeRayQueryProvisionalKHR);
        groupedTypes[OpTypeRayQueryProvisionalKHR].push_back(type);
        constantsTypesGlobals.push_back(std::unique_ptr<Instruction>(type));
        module.mapInstruction(type);
    } else {
        type = groupedTypes[OpTypeRayQueryProvisionalKHR].back();
    }
    return type->getResultId();
@@ -1270,7 +1287,8 @@ Function* Builder::makeEntryPoint(const char* entryPoint)
 // Comments in header
 Function* Builder::makeFunctionEntry(Decoration precision, Id returnType, const char* name,
-                                     const std::vector<Id>& paramTypes, const std::vector<std::vector<Decoration>>& decorations, Block **entry)
+                                     const std::vector<Id>& paramTypes,
                                     const std::vector<std::vector<Decoration>>& decorations, Block **entry)
 {
    // Make the function and initial instructions in it
    Id typeId = makeFunctionType(returnType, paramTypes);
@@ -1373,7 +1391,8 @@ Id Builder::createUndefined(Id type)
 }
 // av/vis/nonprivate are unnecessary and illegal for some storage classes.
-spv::MemoryAccessMask Builder::sanitizeMemoryAccessForStorageClass(spv::MemoryAccessMask memoryAccess, StorageClass sc) const
+spv::MemoryAccessMask Builder::sanitizeMemoryAccessForStorageClass(spv::MemoryAccessMask memoryAccess, StorageClass sc)
    const
 {
    switch (sc) {
    case spv::StorageClassUniform:
@@ -1392,7 +1411,8 @@ spv::MemoryAccessMask Builder::sanitizeMemoryAccessForStorageClass(spv::MemoryAc
 }
 // Comments in header
-void Builder::createStore(Id rValue, Id lValue, spv::MemoryAccessMask memoryAccess, spv::Scope scope, unsigned int alignment)
+void Builder::createStore(Id rValue, Id lValue, spv::MemoryAccessMask memoryAccess, spv::Scope scope,
    unsigned int alignment)
 {
    Instruction* store = new Instruction(OpStore);
    store->addIdOperand(lValue);
@@ -1495,7 +1515,8 @@ Id Builder::createCompositeExtract(Id composite, Id typeId, unsigned index)
    // Generate code for spec constants if in spec constant operation
    // generation mode.
    if (generatingOpCodeForSpecConst) {
-        return createSpecConstantOp(OpCompositeExtract, typeId, std::vector<Id>(1, composite), std::vector<Id>(1, index));
+        return createSpecConstantOp(OpCompositeExtract, typeId, std::vector<Id>(1, composite),
            std::vector<Id>(1, index));
    }
    Instruction* extract = new Instruction(getUniqueId(), typeId, OpCompositeExtract);
    extract->addIdOperand(composite);
@@ -1697,7 +1718,8 @@ Id Builder::createOp(Op opCode, Id typeId, const std::vector<IdImmediate>& opera
    return op->getResultId();
 }
-Id Builder::createSpecConstantOp(Op opCode, Id typeId, const std::vector<Id>& operands, const std::vector<unsigned>& literals)
+Id Builder::createSpecConstantOp(Op opCode, Id typeId, const std::vector<Id>& operands,
    const std::vector<unsigned>& literals)
 {
    Instruction* op = new Instruction(getUniqueId(), typeId, OpSpecConstantOp);
    op->addImmediateOperand((unsigned) opCode);
@@ -2187,7 +2209,8 @@ Id Builder::createCompositeCompare(Decoration precision, Id value1, Id value2, b
        if (constituent == 0)
            resultId = subResultId;
        else
-            resultId = setPrecision(createBinOp(equal ? OpLogicalAnd : OpLogicalOr, boolType, resultId, subResultId), precision);
+            resultId = setPrecision(createBinOp(equal ? OpLogicalAnd : OpLogicalOr, boolType, resultId, subResultId),
                                    precision);
    }
    return resultId;
@@ -2196,7 +2219,8 @@ Id Builder::createCompositeCompare(Decoration precision, Id value1, Id value2, b
 // OpCompositeConstruct
 Id Builder::createCompositeConstruct(Id typeId, const std::vector<Id>& constituents)
 {
-    assert(isAggregateType(typeId) || (getNumTypeConstituents(typeId) > 1 && getNumTypeConstituents(typeId) == (int)constituents.size()));
+    assert(isAggregateType(typeId) || (getNumTypeConstituents(typeId) > 1 &&
           getNumTypeConstituents(typeId) == (int)constituents.size()));
    if (generatingOpCodeForSpecConst) {
        // Sometime, even in spec-constant-op mode, the constant composite to be
@@ -2609,7 +2633,8 @@ void Builder::clearAccessChain()
 }
 // Comments in header
-void Builder::accessChainPushSwizzle(std::vector<unsigned>& swizzle, Id preSwizzleBaseType, AccessChain::CoherentFlags coherentFlags, unsigned int alignment)
+void Builder::accessChainPushSwizzle(std::vector<unsigned>& swizzle, Id preSwizzleBaseType,
    AccessChain::CoherentFlags coherentFlags, unsigned int alignment)
 {
    accessChain.coherentFlags |= coherentFlags;
    accessChain.alignment |= alignment;
@@ -2663,7 +2688,8 @@ void Builder::accessChainStore(Id rvalue, spv::MemoryAccessMask memoryAccess, sp
 }
 // Comments in header
-Id Builder::accessChainLoad(Decoration precision, Decoration nonUniform, Id resultType, spv::MemoryAccessMask memoryAccess, spv::Scope scope, unsigned int alignment)
+Id Builder::accessChainLoad(Decoration precision, Decoration nonUniform, Id resultType,
    spv::MemoryAccessMask memoryAccess, spv::Scope scope, unsigned int alignment)
 {
    Id id;
@@ -2721,7 +2747,13 @@ Id Builder::accessChainLoad(Decoration precision, Decoration nonUniform, Id resu
        }
        // load through the access chain
-        id = createLoad(collapseAccessChain(), memoryAccess, scope, alignment);
+        id = collapseAccessChain();
        // Apply nonuniform both to the access chain and the loaded value.
        // Buffer accesses need the access chain decorated, and this is where
        // loaded image types get decorated. TODO: This should maybe move to
        // createImageTextureFunctionCall.
        addDecoration(id, nonUniform);
        id = createLoad(id, memoryAccess, scope, alignment);
        setPrecision(id, precision);
        addDecoration(id, nonUniform);
    }
@@ -3075,7 +3107,8 @@ void Builder::dumpSourceInstructions(std::vector<unsigned int>& out) const
        dumpSourceInstructions(iItr->first, *iItr->second, out);
 }
-void Builder::dumpInstructions(std::vector<unsigned int>& out, const std::vector<std::unique_ptr<Instruction> >& instructions) const
+void Builder::dumpInstructions(std::vector<unsigned int>& out,
    const std::vector<std::unique_ptr<Instruction> >& instructions) const
 {
    for (int i = 0; i < (int)instructions.size(); ++i) {
        instructions[i]->dump(out);
@@ -1,7 +1,8 @@
 //
 // Copyright (C) 2014-2015 LunarG, Inc.
-// Copyright (C) 2015-2018 Google, Inc.
+// Copyright (C) 2015-2020 Google, Inc.
 // Copyright (C) 2017 ARM Limited.
 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -94,6 +95,7 @@ public:
        const char* file_c_str = str.c_str();
        fileString->addStringOperand(file_c_str);
        strings.push_back(std::unique_ptr<Instruction>(fileString));
        module.mapInstruction(fileString);
        stringIds[file_c_str] = strId;
        return strId;
    }
@@ -181,7 +183,9 @@ public:
    Id makeCooperativeMatrixType(Id component, Id scope, Id rows, Id cols);
    // accelerationStructureNV type
-    Id makeAccelerationStructureNVType();
+    Id makeAccelerationStructureType();
    // rayQueryEXT type
    Id makeRayQueryType();
    // For querying about types.
    Id getTypeId(Id resultId) const { return module.getTypeId(resultId); }
@@ -196,7 +200,8 @@ public:
    Id getContainedTypeId(Id typeId) const;
    Id getContainedTypeId(Id typeId, int) const;
    StorageClass getTypeStorageClass(Id typeId) const { return module.getStorageClass(typeId); }
-    ImageFormat getImageTypeFormat(Id typeId) const { return (ImageFormat)module.getInstruction(typeId)->getImmediateOperand(6); }
+    ImageFormat getImageTypeFormat(Id typeId) const
        { return (ImageFormat)module.getInstruction(typeId)->getImmediateOperand(6); }
    bool isPointer(Id resultId)      const { return isPointerType(getTypeId(resultId)); }
    bool isScalar(Id resultId)       const { return isScalarType(getTypeId(resultId)); }
@@ -206,12 +211,17 @@ public:
    bool isAggregate(Id resultId)    const { return isAggregateType(getTypeId(resultId)); }
    bool isSampledImage(Id resultId) const { return isSampledImageType(getTypeId(resultId)); }
-    bool isBoolType(Id typeId)               { return groupedTypes[OpTypeBool].size() > 0 && typeId == groupedTypes[OpTypeBool].back()->getResultId(); }
+    bool isBoolType(Id typeId)
-    bool isIntType(Id typeId)          const { return getTypeClass(typeId) == OpTypeInt && module.getInstruction(typeId)->getImmediateOperand(1) != 0; }
+        { return groupedTypes[OpTypeBool].size() > 0 && typeId == groupedTypes[OpTypeBool].back()->getResultId(); }
-    bool isUintType(Id typeId)         const { return getTypeClass(typeId) == OpTypeInt && module.getInstruction(typeId)->getImmediateOperand(1) == 0; }
+    bool isIntType(Id typeId)          const
        { return getTypeClass(typeId) == OpTypeInt && module.getInstruction(typeId)->getImmediateOperand(1) != 0; }
    bool isUintType(Id typeId)         const
        { return getTypeClass(typeId) == OpTypeInt && module.getInstruction(typeId)->getImmediateOperand(1) == 0; }
    bool isFloatType(Id typeId)        const { return getTypeClass(typeId) == OpTypeFloat; }
    bool isPointerType(Id typeId)      const { return getTypeClass(typeId) == OpTypePointer; }
-    bool isScalarType(Id typeId)       const { return getTypeClass(typeId) == OpTypeFloat  || getTypeClass(typeId) == OpTypeInt || getTypeClass(typeId) == OpTypeBool; }
+    bool isScalarType(Id typeId)       const
        { return getTypeClass(typeId) == OpTypeFloat || getTypeClass(typeId) == OpTypeInt ||
          getTypeClass(typeId) == OpTypeBool; }
    bool isVectorType(Id typeId)       const { return getTypeClass(typeId) == OpTypeVector; }
    bool isMatrixType(Id typeId)       const { return getTypeClass(typeId) == OpTypeMatrix; }
    bool isStructType(Id typeId)       const { return getTypeClass(typeId) == OpTypeStruct; }
@@ -221,7 +231,8 @@ public:
 #else
    bool isCooperativeMatrixType(Id typeId)const { return getTypeClass(typeId) == OpTypeCooperativeMatrixNV; }
 #endif
-    bool isAggregateType(Id typeId)    const { return isArrayType(typeId) || isStructType(typeId) || isCooperativeMatrixType(typeId); }
+    bool isAggregateType(Id typeId)    const
        { return isArrayType(typeId) || isStructType(typeId) || isCooperativeMatrixType(typeId); }
    bool isImageType(Id typeId)        const { return getTypeClass(typeId) == OpTypeImage; }
    bool isSamplerType(Id typeId)      const { return getTypeClass(typeId) == OpTypeSampler; }
    bool isSampledImageType(Id typeId) const { return getTypeClass(typeId) == OpTypeSampledImage; }
@@ -233,7 +244,8 @@ public:
    bool isConstant(Id resultId) const { return isConstantOpCode(getOpCode(resultId)); }
    bool isConstantScalar(Id resultId) const { return getOpCode(resultId) == OpConstant; }
    bool isSpecConstant(Id resultId) const { return isSpecConstantOpCode(getOpCode(resultId)); }
-    unsigned int getConstantScalar(Id resultId) const { return module.getInstruction(resultId)->getImmediateOperand(0); }
+    unsigned int getConstantScalar(Id resultId) const
        { return module.getInstruction(resultId)->getImmediateOperand(0); }
    StorageClass getStorageClass(Id resultId) const { return getTypeStorageClass(getTypeId(resultId)); }
    int getScalarTypeWidth(Id typeId) const
@@ -275,14 +287,22 @@ public:
    // For making new constants (will return old constant if the requested one was already made).
    Id makeBoolConstant(bool b, bool specConstant = false);
-    Id makeInt8Constant(int i, bool specConstant = false)        { return makeIntConstant(makeIntType(8),  (unsigned)i, specConstant); }
+    Id makeInt8Constant(int i, bool specConstant = false)
-    Id makeUint8Constant(unsigned u, bool specConstant = false)  { return makeIntConstant(makeUintType(8),           u, specConstant); }
+        { return makeIntConstant(makeIntType(8),  (unsigned)i, specConstant); }
-    Id makeInt16Constant(int i, bool specConstant = false)       { return makeIntConstant(makeIntType(16),  (unsigned)i, specConstant); }
+    Id makeUint8Constant(unsigned u, bool specConstant = false)
-    Id makeUint16Constant(unsigned u, bool specConstant = false) { return makeIntConstant(makeUintType(16),           u, specConstant); }
+        { return makeIntConstant(makeUintType(8),           u, specConstant); }
-    Id makeIntConstant(int i, bool specConstant = false)         { return makeIntConstant(makeIntType(32),  (unsigned)i, specConstant); }
+    Id makeInt16Constant(int i, bool specConstant = false)
-    Id makeUintConstant(unsigned u, bool specConstant = false)   { return makeIntConstant(makeUintType(32),           u, specConstant); }
+        { return makeIntConstant(makeIntType(16),  (unsigned)i, specConstant); }
-    Id makeInt64Constant(long long i, bool specConstant = false)            { return makeInt64Constant(makeIntType(64),  (unsigned long long)i, specConstant); }
+    Id makeUint16Constant(unsigned u, bool specConstant = false)
-    Id makeUint64Constant(unsigned long long u, bool specConstant = false)  { return makeInt64Constant(makeUintType(64),                     u, specConstant); }
+        { return makeIntConstant(makeUintType(16),           u, specConstant); }
    Id makeIntConstant(int i, bool specConstant = false)
        { return makeIntConstant(makeIntType(32),  (unsigned)i, specConstant); }
    Id makeUintConstant(unsigned u, bool specConstant = false)
        { return makeIntConstant(makeUintType(32),           u, specConstant); }
    Id makeInt64Constant(long long i, bool specConstant = false)
        { return makeInt64Constant(makeIntType(64),  (unsigned long long)i, specConstant); }
    Id makeUint64Constant(unsigned long long u, bool specConstant = false)
        { return makeInt64Constant(makeUintType(64),                     u, specConstant); }
    Id makeFloatConstant(float f, bool specConstant = false);
    Id makeDoubleConstant(double d, bool specConstant = false);
    Id makeFloat16Constant(float f16, bool specConstant = false);
@@ -313,8 +333,8 @@ public:
    // Make a shader-style function, and create its entry block if entry is non-zero.
    // Return the function, pass back the entry.
    // The returned pointer is only valid for the lifetime of this builder.
-    Function* makeFunctionEntry(Decoration precision, Id returnType, const char* name, const std::vector<Id>& paramTypes,
+    Function* makeFunctionEntry(Decoration precision, Id returnType, const char* name,
-                                const std::vector<std::vector<Decoration>>& precisions, Block **entry = 0);
+        const std::vector<Id>& paramTypes, const std::vector<std::vector<Decoration>>& precisions, Block **entry = 0);
    // Create a return. An 'implicit' return is one not appearing in the source
    // code.  In the case of an implicit return, no post-return block is inserted.
@@ -333,10 +353,12 @@ public:
    Id createUndefined(Id type);
    // Store into an Id and return the l-value
-    void createStore(Id rValue, Id lValue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0);
+    void createStore(Id rValue, Id lValue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone,
        spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0);
    // Load from an Id and return it
-    Id createLoad(Id lValue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0);
+    Id createLoad(Id lValue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone,
        spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0);
    // Create an OpAccessChain instruction
    Id createAccessChain(StorageClass, Id base, const std::vector<Id>& offsets);
@@ -495,7 +517,7 @@ public:
    // recursion stack can hold the memory for it.
    //
    void makeSwitch(Id condition, unsigned int control, int numSegments, const std::vector<int>& caseValues,
-                    const std::vector<int>& valueToSegment, int defaultSegment, std::vector<Block*>& segmentBB); // return argument
+                    const std::vector<int>& valueToSegment, int defaultSegment, std::vector<Block*>& segmentBB);
    // Add a branch to the innermost switch's merge block.
    void addSwitchBreak();
@@ -512,7 +534,7 @@ public:
        Block &head, &body, &merge, &continue_target;
    private:
        LoopBlocks();
-        LoopBlocks& operator=(const LoopBlocks&);
+        LoopBlocks& operator=(const LoopBlocks&) = delete;
    };
    // Start a new loop and prepare the builder to generate code for it.  Until
@@ -569,10 +591,13 @@ public:
        std::vector<Id> indexChain;
        Id instr;                      // cache the instruction that generates this access chain
        std::vector<unsigned> swizzle; // each std::vector element selects the next GLSL component number
-        Id component;                  // a dynamic component index, can coexist with a swizzle, done after the swizzle, NoResult if not present
+        Id component;                  // a dynamic component index, can coexist with a swizzle,
-        Id preSwizzleBaseType;         // dereferenced type, before swizzle or component is applied; NoType unless a swizzle or component is present
+                                       // done after the swizzle, NoResult if not present
        Id preSwizzleBaseType;         // dereferenced type, before swizzle or component is applied;
                                       // NoType unless a swizzle or component is present
        bool isRValue;                 // true if 'base' is an r-value, otherwise, base is an l-value
-        unsigned int alignment;        // bitwise OR of alignment values passed in. Accumulates worst alignment. Only tracks base and (optional) component selection alignment.
+        unsigned int alignment;        // bitwise OR of alignment values passed in. Accumulates worst alignment.
                                       // Only tracks base and (optional) component selection alignment.
        // Accumulate whether anything in the chain of structures has coherent decorations.
        struct CoherentFlags {
@@ -583,12 +608,17 @@ public:
            CoherentFlags operator |=(const CoherentFlags &other) { return *this; }
 #else
            bool isVolatile() const { return volatil; }
            bool anyCoherent() const {
                return coherent || devicecoherent || queuefamilycoherent || workgroupcoherent ||
                    subgroupcoherent || shadercallcoherent;
            }
            unsigned coherent : 1;
            unsigned devicecoherent : 1;
            unsigned queuefamilycoherent : 1;
            unsigned workgroupcoherent : 1;
            unsigned subgroupcoherent : 1;
            unsigned shadercallcoherent : 1;
            unsigned nonprivate : 1;
            unsigned volatil : 1;
            unsigned isImage : 1;
@@ -599,6 +629,7 @@ public:
                queuefamilycoherent = 0;
                workgroupcoherent = 0;
                subgroupcoherent = 0;
                shadercallcoherent = 0;
                nonprivate = 0;
                volatil = 0;
                isImage = 0;
@@ -610,6 +641,7 @@ public:
                queuefamilycoherent |= other.queuefamilycoherent;
                workgroupcoherent |= other.workgroupcoherent;
                subgroupcoherent |= other.subgroupcoherent;
                shadercallcoherent |= other.shadercallcoherent;
                nonprivate |= other.nonprivate;
                volatil |= other.volatil;
                isImage |= other.isImage;
@@ -655,11 +687,13 @@ public:
    }
    // push new swizzle onto the end of any existing swizzle, merging into a single swizzle
-    void accessChainPushSwizzle(std::vector<unsigned>& swizzle, Id preSwizzleBaseType, AccessChain::CoherentFlags coherentFlags, unsigned int alignment);
+    void accessChainPushSwizzle(std::vector<unsigned>& swizzle, Id preSwizzleBaseType,
        AccessChain::CoherentFlags coherentFlags, unsigned int alignment);
    // push a dynamic component selection onto the access chain, only applicable with a
    // non-trivial swizzle or no swizzle
-    void accessChainPushComponent(Id component, Id preSwizzleBaseType, AccessChain::CoherentFlags coherentFlags, unsigned int alignment)
+    void accessChainPushComponent(Id component, Id preSwizzleBaseType, AccessChain::CoherentFlags coherentFlags,
        unsigned int alignment)
    {
        if (accessChain.swizzle.size() != 1) {
            accessChain.component = component;
@@ -671,10 +705,18 @@ public:
    }
    // use accessChain and swizzle to store value
-    void accessChainStore(Id rvalue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0);
+    void accessChainStore(Id rvalue, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone,
        spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0);
    // use accessChain and swizzle to load an r-value
-    Id accessChainLoad(Decoration precision, Decoration nonUniform, Id ResultType, spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, spv::Scope scope = spv::ScopeMax, unsigned int alignment = 0);
+    Id accessChainLoad(Decoration precision, Decoration nonUniform, Id ResultType,
        spv::MemoryAccessMask memoryAccess = spv::MemoryAccessMaskNone, spv::Scope scope = spv::ScopeMax,
            unsigned int alignment = 0);
    // Return whether or not the access chain can be represented in SPIR-V
    // as an l-value.
    // E.g., a[3].yx cannot be, while a[3].y and a[3].y[x] can be.
    bool isSpvLvalue() const { return accessChain.swizzle.size() <= 1; }
    // get the direct pointer for an l-value
    Id accessChainGetLValue();
@@ -703,7 +745,8 @@ public:
    void createBranch(Block* block);
    void createConditionalBranch(Id condition, Block* thenBlock, Block* elseBlock);
-    void createLoopMerge(Block* mergeBlock, Block* continueBlock, unsigned int control, const std::vector<unsigned int>& operands);
+    void createLoopMerge(Block* mergeBlock, Block* continueBlock, unsigned int control,
        const std::vector<unsigned int>& operands);
    // Sets to generate opcode for specialization constants.
    void setToSpecConstCodeGenMode() { generatingOpCodeForSpecConst = true; }
@@ -729,7 +772,8 @@ public:
    void dumpSourceInstructions(const spv::Id fileId, const std::string& text, std::vector<unsigned int>&) const;
    void dumpInstructions(std::vector<unsigned int>&, const std::vector<std::unique_ptr<Instruction> >&) const;
    void dumpModuleProcesses(std::vector<unsigned int>&) const;
-    spv::MemoryAccessMask sanitizeMemoryAccessForStorageClass(spv::MemoryAccessMask memoryAccess, StorageClass sc) const;
+    spv::MemoryAccessMask sanitizeMemoryAccessForStorageClass(spv::MemoryAccessMask memoryAccess, StorageClass sc)
        const;
    unsigned int spvVersion;     // the version of SPIR-V to emit in the header
    SourceLanguage source;
@@ -765,9 +809,13 @@ public:
    std::vector<std::unique_ptr<Function> > functions;
    // not output, internally used for quick & dirty canonical (unique) creation
-    std::unordered_map<unsigned int, std::vector<Instruction*>> groupedConstants;       // map type opcodes to constant inst.
+
-    std::unordered_map<unsigned int, std::vector<Instruction*>> groupedStructConstants; // map struct-id to constant instructions
+    // map type opcodes to constant inst.
-    std::unordered_map<unsigned int, std::vector<Instruction*>> groupedTypes;           // map type opcodes to type instructions
+    std::unordered_map<unsigned int, std::vector<Instruction*>> groupedConstants;
    // map struct-id to constant instructions
    std::unordered_map<unsigned int, std::vector<Instruction*>> groupedStructConstants;
    // map type opcodes to type instructions
    std::unordered_map<unsigned int, std::vector<Instruction*>> groupedTypes;
    // stack of switches
    std::stack<Block*> switchMerges;
@@ -1,6 +1,6 @@
 //
 // Copyright (C) 2014-2016 LunarG, Inc.
-// Copyright (C) 2018 Google, Inc.
+// Copyright (C) 2018-2020 Google, Inc.
 //
 // All rights reserved.
 //
@@ -67,6 +67,8 @@ spv_target_env MapToSpirvToolsEnv(const SpvVersion& spvVersion, spv::SpvBuildLog
            logger->missingFunctionality("Target version for SPIRV-Tools validator");
            return spv_target_env::SPV_ENV_VULKAN_1_1;
        }
    case glslang::EShTargetVulkan_1_2:
        return spv_target_env::SPV_ENV_VULKAN_1_2;
    default:
        break;
    }
@@ -128,8 +130,8 @@ void SpirvToolsValidate(const glslang::TIntermediate& intermediate, std::vector<
 // Apply the SPIRV-Tools optimizer to generated SPIR-V, for the purpose of
 // legalizing HLSL SPIR-V.
-void SpirvToolsLegalize(const glslang::TIntermediate&, std::vector<unsigned int>& spirv,
+void SpirvToolsLegalize(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv,
-                        spv::SpvBuildLogger*, const SpvOptions* options)
+                        spv::SpvBuildLogger* logger, const SpvOptions* options)
 {
    spv_target_env target_env = SPV_ENV_UNIVERSAL_1_2;
@@ -205,7 +207,8 @@ void SpirvToolsLegalize(const glslang::TIntermediate&, std::vector<unsigned int>
    }
    spvtools::OptimizerOptions spvOptOptions;
-    spvOptOptions.set_run_validator(false); // The validator may run as a seperate step later on
+    optimizer.SetTargetEnv(MapToSpirvToolsEnv(intermediate.getSpv(), logger));
    spvOptOptions.set_run_validator(false); // The validator may run as a separate step later on
    optimizer.Run(spirv.data(), spirv.size(), &spirv, spvOptOptions);
 }
@@ -75,6 +75,7 @@ enum ExtInstSet {
    GLSLextAMDInst,
    GLSLextNVInst,
    OpenCLExtInst,
    NonSemanticDebugPrintfExtInst,
 };
 // Container class for a single instance of a SPIR-V stream, with methods for disassembly.
@@ -480,8 +481,12 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
            if (opCode == OpExtInst) {
                ExtInstSet extInstSet = GLSL450Inst;
                const char* name = idDescriptor[stream[word - 2]].c_str();
-                if (0 == memcmp("OpenCL", name, 6)) {
+                if (strcmp("OpenCL.std", name) == 0) {
                    extInstSet = OpenCLExtInst;
                } else if (strcmp("OpenCL.DebugInfo.100", name) == 0) {
                    extInstSet = OpenCLExtInst;
                } else if (strcmp("NonSemantic.DebugPrintf", name) == 0) {
                    extInstSet = NonSemanticDebugPrintfExtInst;
                } else if (strcmp(spv::E_SPV_AMD_shader_ballot, name) == 0 ||
                           strcmp(spv::E_SPV_AMD_shader_trinary_minmax, name) == 0 ||
                           strcmp(spv::E_SPV_AMD_shader_explicit_vertex_parameter, name) == 0 ||
@@ -505,6 +510,8 @@ void SpirvStream::disassembleInstruction(Id resultId, Id /*typeId*/, Op opCode,
                }
                else if (extInstSet == GLSLextNVInst) {
                    out << "(" << GLSLextNVGetDebugNames(name, entrypoint) << ")";
                } else if (extInstSet == NonSemanticDebugPrintfExtInst) {
                    out << "(DebugPrintf)";
                }
            }
            break;
@@ -1,5 +1,6 @@
 //
 // Copyright (C) 2014-2015 LunarG, Inc.
 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -99,12 +100,12 @@ const char* ExecutionModelString(int model)
    default: return "Bad";
-    case ExecutionModelRayGenerationNV: return "RayGenerationNV";
+    case ExecutionModelRayGenerationKHR: return "RayGenerationKHR";
-    case ExecutionModelIntersectionNV:  return "IntersectionNV";
+    case ExecutionModelIntersectionKHR:  return "IntersectionKHR";
-    case ExecutionModelAnyHitNV:        return "AnyHitNV";
+    case ExecutionModelAnyHitKHR:        return "AnyHitKHR";
-    case ExecutionModelClosestHitNV:    return "ClosestHitNV";
+    case ExecutionModelClosestHitKHR:    return "ClosestHitKHR";
-    case ExecutionModelMissNV:          return "MissNV";
+    case ExecutionModelMissKHR:          return "MissKHR";
-    case ExecutionModelCallableNV:      return "CallableNV";
+    case ExecutionModelCallableKHR:      return "CallableKHR";
    }
 }
@@ -209,12 +210,12 @@ const char* StorageClassString(int StorageClass)
    case 11: return "Image";
    case 12: return "StorageBuffer";
-    case StorageClassRayPayloadNV:            return "RayPayloadNV";
+    case StorageClassRayPayloadKHR:            return "RayPayloadKHR";
-    case StorageClassHitAttributeNV:          return "HitAttributeNV";
+    case StorageClassHitAttributeKHR:          return "HitAttributeKHR";
-    case StorageClassIncomingRayPayloadNV:    return "IncomingRayPayloadNV";
+    case StorageClassIncomingRayPayloadKHR:    return "IncomingRayPayloadKHR";
-    case StorageClassShaderRecordBufferNV:    return "ShaderRecordBufferNV";
+    case StorageClassShaderRecordBufferKHR:    return "ShaderRecordBufferKHR";
-    case StorageClassCallableDataNV:          return "CallableDataNV";
+    case StorageClassCallableDataKHR:          return "CallableDataKHR";
-    case StorageClassIncomingCallableDataNV:  return "IncomingCallableDataNV";
+    case StorageClassIncomingCallableDataKHR:  return "IncomingCallableDataKHR";
    case StorageClassPhysicalStorageBufferEXT: return "PhysicalStorageBufferEXT";
@@ -361,20 +362,21 @@ const char* BuiltInString(int builtIn)
    case 4996: return "BaryCoordSmoothCentroidAMD";
    case 4997: return "BaryCoordSmoothSampleAMD";
    case 4998: return "BaryCoordPullModelAMD";
-    case BuiltInLaunchIdNV:                 return "LaunchIdNV";
+    case BuiltInLaunchIdKHR:                 return "LaunchIdKHR";
-    case BuiltInLaunchSizeNV:               return "LaunchSizeNV";
+    case BuiltInLaunchSizeKHR:               return "LaunchSizeKHR";
-    case BuiltInWorldRayOriginNV:           return "WorldRayOriginNV";
+    case BuiltInWorldRayOriginKHR:           return "WorldRayOriginKHR";
-    case BuiltInWorldRayDirectionNV:        return "WorldRayDirectionNV";
+    case BuiltInWorldRayDirectionKHR:        return "WorldRayDirectionKHR";
-    case BuiltInObjectRayOriginNV:          return "ObjectRayOriginNV";
+    case BuiltInObjectRayOriginKHR:          return "ObjectRayOriginKHR";
-    case BuiltInObjectRayDirectionNV:       return "ObjectRayDirectionNV";
+    case BuiltInObjectRayDirectionKHR:       return "ObjectRayDirectionKHR";
-    case BuiltInRayTminNV:                  return "RayTminNV";
+    case BuiltInRayTminKHR:                  return "RayTminKHR";
-    case BuiltInRayTmaxNV:                  return "RayTmaxNV";
+    case BuiltInRayTmaxKHR:                  return "RayTmaxKHR";
-    case BuiltInInstanceCustomIndexNV:      return "InstanceCustomIndexNV";
+    case BuiltInInstanceCustomIndexKHR:      return "InstanceCustomIndexKHR";
-    case BuiltInObjectToWorldNV:            return "ObjectToWorldNV";
+    case BuiltInRayGeometryIndexKHR:         return "RayGeometryIndexKHR";
-    case BuiltInWorldToObjectNV:            return "WorldToObjectNV";
+    case BuiltInObjectToWorldKHR:            return "ObjectToWorldKHR";
-    case BuiltInHitTNV:                     return "HitTNV";
+    case BuiltInWorldToObjectKHR:            return "WorldToObjectKHR";
-    case BuiltInHitKindNV:                  return "HitKindNV";
+    case BuiltInHitTKHR:                     return "HitTKHR";
-    case BuiltInIncomingRayFlagsNV:         return "IncomingRayFlagsNV";
+    case BuiltInHitKindKHR:                  return "HitKindKHR";
    case BuiltInIncomingRayFlagsKHR:         return "IncomingRayFlagsKHR";
    case BuiltInViewportMaskNV:              return "ViewportMaskNV";
    case BuiltInSecondaryPositionNV:         return "SecondaryPositionNV";
    case BuiltInSecondaryViewportMaskNV:     return "SecondaryViewportMaskNV";
@@ -890,6 +892,9 @@ const char* CapabilityString(int info)
    case CapabilityPerViewAttributesNV:             return "PerViewAttributesNV";
    case CapabilityGroupNonUniformPartitionedNV:    return "GroupNonUniformPartitionedNV";
    case CapabilityRayTracingNV:                    return "RayTracingNV";
    case CapabilityRayTracingProvisionalKHR:        return "RayTracingProvisionalKHR";
    case CapabilityRayQueryProvisionalKHR:          return "RayQueryProvisionalKHR";
    case CapabilityRayTraversalPrimitiveCullingProvisionalKHR: return "RayTraversalPrimitiveCullingProvisionalKHR";
    case CapabilityComputeDerivativeGroupQuadsNV:   return "ComputeDerivativeGroupQuadsNV";
    case CapabilityComputeDerivativeGroupLinearNV:  return "ComputeDerivativeGroupLinearNV";
    case CapabilityFragmentBarycentricNV:           return "FragmentBarycentricNV";
@@ -1326,15 +1331,40 @@ const char* OpcodeString(int op)
    case OpMemberDecorateStringGOOGLE: return "OpMemberDecorateStringGOOGLE";
    case OpGroupNonUniformPartitionNV:       return "OpGroupNonUniformPartitionNV";
-    case OpReportIntersectionNV:             return "OpReportIntersectionNV";
+    case OpReportIntersectionKHR:            return "OpReportIntersectionKHR";
-    case OpIgnoreIntersectionNV:             return "OpIgnoreIntersectionNV";
+    case OpIgnoreIntersectionKHR:            return "OpIgnoreIntersectionKHR";
-    case OpTerminateRayNV:                   return "OpTerminateRayNV";
+    case OpTerminateRayKHR:                  return "OpTerminateRayKHR";
-    case OpTraceNV:                          return "OpTraceNV";
+    case OpTraceRayKHR:                      return "OpTraceRayKHR";
-    case OpTypeAccelerationStructureNV:      return "OpTypeAccelerationStructureNV";
+    case OpTypeAccelerationStructureKHR:     return "OpTypeAccelerationStructureKHR";
-    case OpExecuteCallableNV:                return "OpExecuteCallableNV";
+    case OpExecuteCallableKHR:               return "OpExecuteCallableKHR";
    case OpImageSampleFootprintNV:           return "OpImageSampleFootprintNV";
    case OpWritePackedPrimitiveIndices4x8NV: return "OpWritePackedPrimitiveIndices4x8NV";
    case OpTypeRayQueryProvisionalKHR:                                        return "OpTypeRayQueryProvisionalKHR";
    case OpRayQueryInitializeKHR:                                             return "OpRayQueryInitializeKHR";
    case OpRayQueryTerminateKHR:                                              return "OpRayQueryTerminateKHR";
    case OpRayQueryGenerateIntersectionKHR:                                   return "OpRayQueryGenerateIntersectionKHR";
    case OpRayQueryConfirmIntersectionKHR:                                    return "OpRayQueryConfirmIntersectionKHR";
    case OpRayQueryProceedKHR:                                                return "OpRayQueryProceedKHR";
    case OpRayQueryGetIntersectionTypeKHR:                                    return "OpRayQueryGetIntersectionTypeKHR";
    case OpRayQueryGetRayTMinKHR:                                             return "OpRayQueryGetRayTMinKHR";
    case OpRayQueryGetRayFlagsKHR:                                            return "OpRayQueryGetRayFlagsKHR";
    case OpRayQueryGetIntersectionTKHR:                                       return "OpRayQueryGetIntersectionTKHR";
    case OpRayQueryGetIntersectionInstanceCustomIndexKHR:                     return "OpRayQueryGetIntersectionInstanceCustomIndexKHR";
    case OpRayQueryGetIntersectionInstanceIdKHR:                              return "OpRayQueryGetIntersectionInstanceIdKHR";
    case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR:  return "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR";
    case OpRayQueryGetIntersectionGeometryIndexKHR:                           return "OpRayQueryGetIntersectionGeometryIndexKHR";
    case OpRayQueryGetIntersectionPrimitiveIndexKHR:                          return "OpRayQueryGetIntersectionPrimitiveIndexKHR";
    case OpRayQueryGetIntersectionBarycentricsKHR:                            return "OpRayQueryGetIntersectionBarycentricsKHR";
    case OpRayQueryGetIntersectionFrontFaceKHR:                               return "OpRayQueryGetIntersectionFrontFaceKHR";
    case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR:                     return "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR";
    case OpRayQueryGetIntersectionObjectRayDirectionKHR:                      return "OpRayQueryGetIntersectionObjectRayDirectionKHR";
    case OpRayQueryGetIntersectionObjectRayOriginKHR:                         return "OpRayQueryGetIntersectionObjectRayOriginKHR";
    case OpRayQueryGetWorldRayDirectionKHR:                                   return "OpRayQueryGetWorldRayDirectionKHR";
    case OpRayQueryGetWorldRayOriginKHR:                                      return "OpRayQueryGetWorldRayOriginKHR";
    case OpRayQueryGetIntersectionObjectToWorldKHR:                           return "OpRayQueryGetIntersectionObjectToWorldKHR";
    case OpRayQueryGetIntersectionWorldToObjectKHR:                           return "OpRayQueryGetIntersectionWorldToObjectKHR";
    case OpTypeCooperativeMatrixNV:         return "OpTypeCooperativeMatrixNV";
    case OpCooperativeMatrixLoadNV:         return "OpCooperativeMatrixLoadNV";
    case OpCooperativeMatrixStoreNV:        return "OpCooperativeMatrixStoreNV";
@@ -2694,31 +2724,125 @@ void Parameterize()
    InstructionDesc[OpGroupNonUniformPartitionNV].operands.push(OperandId, "X");
-    InstructionDesc[OpTypeAccelerationStructureNV].setResultAndType(true, false);
+    InstructionDesc[OpTypeAccelerationStructureKHR].setResultAndType(true, false);
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'NV Acceleration Structure'");
+    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'NV Acceleration Structure'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Flags'");
+    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Ray Flags'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Cull Mask'");
+    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Cull Mask'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'SBT Record Offset'");
+    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'SBT Record Offset'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'SBT Record Stride'");
+    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'SBT Record Stride'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Miss Index'");
+    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Miss Index'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Origin'");
+    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Ray Origin'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'TMin'");
+    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'TMin'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Ray Direction'");
+    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Ray Direction'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'TMax'");
+    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'TMax'");
-    InstructionDesc[OpTraceNV].operands.push(OperandId, "'Payload'");
+    InstructionDesc[OpTraceRayKHR].operands.push(OperandId, "'Payload'");
-    InstructionDesc[OpTraceNV].setResultAndType(false, false);
+    InstructionDesc[OpTraceRayKHR].setResultAndType(false, false);
-    InstructionDesc[OpReportIntersectionNV].operands.push(OperandId, "'Hit Parameter'");
+    InstructionDesc[OpReportIntersectionKHR].operands.push(OperandId, "'Hit Parameter'");
-    InstructionDesc[OpReportIntersectionNV].operands.push(OperandId, "'Hit Kind'");
+    InstructionDesc[OpReportIntersectionKHR].operands.push(OperandId, "'Hit Kind'");
-    InstructionDesc[OpIgnoreIntersectionNV].setResultAndType(false, false);
+    InstructionDesc[OpIgnoreIntersectionKHR].setResultAndType(false, false);
-    InstructionDesc[OpTerminateRayNV].setResultAndType(false, false);
+    InstructionDesc[OpTerminateRayKHR].setResultAndType(false, false);
-    InstructionDesc[OpExecuteCallableNV].operands.push(OperandId, "SBT Record Index");
+    InstructionDesc[OpExecuteCallableKHR].operands.push(OperandId, "SBT Record Index");
-    InstructionDesc[OpExecuteCallableNV].operands.push(OperandId, "CallableData ID");
+    InstructionDesc[OpExecuteCallableKHR].operands.push(OperandId, "CallableData ID");
-    InstructionDesc[OpExecuteCallableNV].setResultAndType(false, false);
+    InstructionDesc[OpExecuteCallableKHR].setResultAndType(false, false);
    // Ray Query
    InstructionDesc[OpTypeAccelerationStructureKHR].setResultAndType(true, false);
    InstructionDesc[OpTypeRayQueryProvisionalKHR].setResultAndType(true, false);
    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'AccelerationS'");
    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'RayFlags'");
    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'CullMask'");
    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Origin'");
    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Tmin'");
    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Direction'");
    InstructionDesc[OpRayQueryInitializeKHR].operands.push(OperandId, "'Tmax'");
    InstructionDesc[OpRayQueryInitializeKHR].setResultAndType(false, false);
    InstructionDesc[OpRayQueryTerminateKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryTerminateKHR].setResultAndType(false, false);
    InstructionDesc[OpRayQueryGenerateIntersectionKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGenerateIntersectionKHR].operands.push(OperandId, "'THit'");
    InstructionDesc[OpRayQueryGenerateIntersectionKHR].setResultAndType(false, false);
    InstructionDesc[OpRayQueryConfirmIntersectionKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryConfirmIntersectionKHR].setResultAndType(false, false);
    InstructionDesc[OpRayQueryProceedKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryProceedKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetIntersectionTypeKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetIntersectionTypeKHR].operands.push(OperandId, "'Committed'");
    InstructionDesc[OpRayQueryGetIntersectionTypeKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetRayTMinKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetRayTMinKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetRayFlagsKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetRayFlagsKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetIntersectionTKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetIntersectionTKHR].operands.push(OperandId, "'Committed'");
    InstructionDesc[OpRayQueryGetIntersectionTKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].operands.push(OperandId, "'Committed'");
    InstructionDesc[OpRayQueryGetIntersectionInstanceCustomIndexKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].operands.push(OperandId, "'Committed'");
    InstructionDesc[OpRayQueryGetIntersectionInstanceIdKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].operands.push(OperandId, "'Committed'");
    InstructionDesc[OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].operands.push(OperandId, "'Committed'");
    InstructionDesc[OpRayQueryGetIntersectionGeometryIndexKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].operands.push(OperandId, "'Committed'");
    InstructionDesc[OpRayQueryGetIntersectionPrimitiveIndexKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].operands.push(OperandId, "'Committed'");
    InstructionDesc[OpRayQueryGetIntersectionBarycentricsKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].operands.push(OperandId, "'Committed'");
    InstructionDesc[OpRayQueryGetIntersectionFrontFaceKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetIntersectionCandidateAABBOpaqueKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetIntersectionCandidateAABBOpaqueKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].operands.push(OperandId, "'Committed'");
    InstructionDesc[OpRayQueryGetIntersectionObjectRayDirectionKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].operands.push(OperandId, "'Committed'");
    InstructionDesc[OpRayQueryGetIntersectionObjectRayOriginKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetWorldRayDirectionKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetWorldRayDirectionKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetWorldRayOriginKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetWorldRayOriginKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].operands.push(OperandId, "'Committed'");
    InstructionDesc[OpRayQueryGetIntersectionObjectToWorldKHR].setResultAndType(true, true);
    InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].operands.push(OperandId, "'RayQuery'");
    InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].operands.push(OperandId, "'Committed'");
    InstructionDesc[OpRayQueryGetIntersectionWorldToObjectKHR].setResultAndType(true, true);
    InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Sampled Image'");
    InstructionDesc[OpImageSampleFootprintNV].operands.push(OperandId, "'Coordinate'");
@@ -784,7 +784,7 @@ inline std::istream& ParseNormalFloat(std::istream& is, bool negate_value,
  if (val.isInfinity()) {
    // Fail the parse.  Emulate standard behaviour by setting the value to
    // the closest normal value, and set the fail bit on the stream.
-    value.set_value((value.isNegative() | negate_value) ? T::lowest()
+    value.set_value((value.isNegative() || negate_value) ? T::lowest()
                                                         : T::max());
    is.setstate(std::ios_base::failbit);
  }
@@ -1,4 +1,4 @@
-// Copyright (c) 2014-2019 The Khronos Group Inc.
+// Copyright (c) 2014-2020 The Khronos Group Inc.
 // 
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and/or associated documentation files (the "Materials"),
@@ -49,11 +49,11 @@ namespace spv {
 typedef unsigned int Id;
-#define SPV_VERSION 0x10400
+#define SPV_VERSION 0x10500
 #define SPV_REVISION 1
 static const unsigned int MagicNumber = 0x07230203;
-static const unsigned int Version = 0x00010400;
+static const unsigned int Version = 0x00010500;
 static const unsigned int Revision = 1;
 static const unsigned int OpCodeMask = 0xffff;
 static const unsigned int WordCountShift = 16;
@@ -78,11 +78,17 @@ enum ExecutionModel {
    ExecutionModelKernel = 6,
    ExecutionModelTaskNV = 5267,
    ExecutionModelMeshNV = 5268,
    ExecutionModelRayGenerationKHR = 5313,
    ExecutionModelRayGenerationNV = 5313,
    ExecutionModelIntersectionKHR = 5314,
    ExecutionModelIntersectionNV = 5314,
    ExecutionModelAnyHitKHR = 5315,
    ExecutionModelAnyHitNV = 5315,
    ExecutionModelClosestHitKHR = 5316,
    ExecutionModelClosestHitNV = 5316,
    ExecutionModelMissKHR = 5317,
    ExecutionModelMissNV = 5317,
    ExecutionModelCallableKHR = 5318,
    ExecutionModelCallableNV = 5318,
    ExecutionModelMax = 0x7fffffff,
 };
@@ -179,11 +185,17 @@ enum StorageClass {
    StorageClassAtomicCounter = 10,
    StorageClassImage = 11,
    StorageClassStorageBuffer = 12,
    StorageClassCallableDataKHR = 5328,
    StorageClassCallableDataNV = 5328,
    StorageClassIncomingCallableDataKHR = 5329,
    StorageClassIncomingCallableDataNV = 5329,
    StorageClassRayPayloadKHR = 5338,
    StorageClassRayPayloadNV = 5338,
    StorageClassHitAttributeKHR = 5339,
    StorageClassHitAttributeNV = 5339,
    StorageClassIncomingRayPayloadKHR = 5342,
    StorageClassIncomingRayPayloadNV = 5342,
    StorageClassShaderRecordBufferKHR = 5343,
    StorageClassShaderRecordBufferNV = 5343,
    StorageClassPhysicalStorageBuffer = 5349,
    StorageClassPhysicalStorageBufferEXT = 5349,
@@ -558,20 +570,35 @@ enum BuiltIn {
    BuiltInFragmentSizeNV = 5292,
    BuiltInFragInvocationCountEXT = 5293,
    BuiltInInvocationsPerPixelNV = 5293,
    BuiltInLaunchIdKHR = 5319,
    BuiltInLaunchIdNV = 5319,
    BuiltInLaunchSizeKHR = 5320,
    BuiltInLaunchSizeNV = 5320,
    BuiltInWorldRayOriginKHR = 5321,
    BuiltInWorldRayOriginNV = 5321,
    BuiltInWorldRayDirectionKHR = 5322,
    BuiltInWorldRayDirectionNV = 5322,
    BuiltInObjectRayOriginKHR = 5323,
    BuiltInObjectRayOriginNV = 5323,
    BuiltInObjectRayDirectionKHR = 5324,
    BuiltInObjectRayDirectionNV = 5324,
    BuiltInRayTminKHR = 5325,
    BuiltInRayTminNV = 5325,
    BuiltInRayTmaxKHR = 5326,
    BuiltInRayTmaxNV = 5326,
    BuiltInInstanceCustomIndexKHR = 5327,
    BuiltInInstanceCustomIndexNV = 5327,
    BuiltInObjectToWorldKHR = 5330,
    BuiltInObjectToWorldNV = 5330,
    BuiltInWorldToObjectKHR = 5331,
    BuiltInWorldToObjectNV = 5331,
    BuiltInHitTKHR = 5332,
    BuiltInHitTNV = 5332,
    BuiltInHitKindKHR = 5333,
    BuiltInHitKindNV = 5333,
    BuiltInIncomingRayFlagsKHR = 5351,
    BuiltInIncomingRayFlagsNV = 5351,
    BuiltInRayGeometryIndexKHR = 5352,
    BuiltInWarpsPerSMNV = 5374,
    BuiltInSMCountNV = 5375,
    BuiltInWarpIDNV = 5376,
@@ -709,6 +736,7 @@ enum Scope {
    ScopeInvocation = 4,
    ScopeQueueFamily = 5,
    ScopeQueueFamilyKHR = 5,
    ScopeShaderCallKHR = 6,
    ScopeMax = 0x7fffffff,
 };
@@ -833,6 +861,8 @@ enum Capability {
    CapabilitySignedZeroInfNanPreserve = 4466,
    CapabilityRoundingModeRTE = 4467,
    CapabilityRoundingModeRTZ = 4468,
    CapabilityRayQueryProvisionalKHR = 4471,
    CapabilityRayTraversalPrimitiveCullingProvisionalKHR = 4478,
    CapabilityFloat16ImageAMD = 5008,
    CapabilityImageGatherBiasLodAMD = 5009,
    CapabilityFragmentMaskAMD = 5010,
@@ -886,6 +916,7 @@ enum Capability {
    CapabilityPhysicalStorageBufferAddresses = 5347,
    CapabilityPhysicalStorageBufferAddressesEXT = 5347,
    CapabilityComputeDerivativeGroupLinearNV = 5350,
    CapabilityRayTracingProvisionalKHR = 5353,
    CapabilityCooperativeMatrixNV = 5357,
    CapabilityFragmentShaderSampleInterlockEXT = 5363,
    CapabilityFragmentShaderShadingRateInterlockEXT = 5372,
@@ -903,6 +934,53 @@ enum Capability {
    CapabilityMax = 0x7fffffff,
 };
 enum RayFlagsShift {
    RayFlagsOpaqueKHRShift = 0,
    RayFlagsNoOpaqueKHRShift = 1,
    RayFlagsTerminateOnFirstHitKHRShift = 2,
    RayFlagsSkipClosestHitShaderKHRShift = 3,
    RayFlagsCullBackFacingTrianglesKHRShift = 4,
    RayFlagsCullFrontFacingTrianglesKHRShift = 5,
    RayFlagsCullOpaqueKHRShift = 6,
    RayFlagsCullNoOpaqueKHRShift = 7,
    RayFlagsSkipTrianglesKHRShift = 8,
    RayFlagsSkipAABBsKHRShift = 9,
    RayFlagsMax = 0x7fffffff,
 };
 enum RayFlagsMask {
    RayFlagsMaskNone = 0,
    RayFlagsOpaqueKHRMask = 0x00000001,
    RayFlagsNoOpaqueKHRMask = 0x00000002,
    RayFlagsTerminateOnFirstHitKHRMask = 0x00000004,
    RayFlagsSkipClosestHitShaderKHRMask = 0x00000008,
    RayFlagsCullBackFacingTrianglesKHRMask = 0x00000010,
    RayFlagsCullFrontFacingTrianglesKHRMask = 0x00000020,
    RayFlagsCullOpaqueKHRMask = 0x00000040,
    RayFlagsCullNoOpaqueKHRMask = 0x00000080,
    RayFlagsSkipTrianglesKHRMask = 0x00000100,
    RayFlagsSkipAABBsKHRMask = 0x00000200,
 };
 enum RayQueryIntersection {
    RayQueryIntersectionRayQueryCandidateIntersectionKHR = 0,
    RayQueryIntersectionRayQueryCommittedIntersectionKHR = 1,
    RayQueryIntersectionMax = 0x7fffffff,
 };
 enum RayQueryCommittedIntersectionType {
    RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionNoneKHR = 0,
    RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionTriangleKHR = 1,
    RayQueryCommittedIntersectionTypeRayQueryCommittedIntersectionGeneratedKHR = 2,
    RayQueryCommittedIntersectionTypeMax = 0x7fffffff,
 };
 enum RayQueryCandidateIntersectionType {
    RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionTriangleKHR = 0,
    RayQueryCandidateIntersectionTypeRayQueryCandidateIntersectionAABBKHR = 1,
    RayQueryCandidateIntersectionTypeMax = 0x7fffffff,
 };
 enum Op {
    OpNop = 0,
    OpUndef = 1,
@@ -1254,6 +1332,13 @@ enum Op {
    OpSubgroupAnyKHR = 4429,
    OpSubgroupAllEqualKHR = 4430,
    OpSubgroupReadInvocationKHR = 4432,
    OpTypeRayQueryProvisionalKHR = 4472,
    OpRayQueryInitializeKHR = 4473,
    OpRayQueryTerminateKHR = 4474,
    OpRayQueryGenerateIntersectionKHR = 4475,
    OpRayQueryConfirmIntersectionKHR = 4476,
    OpRayQueryProceedKHR = 4477,
    OpRayQueryGetIntersectionTypeKHR = 4479,
    OpGroupIAddNonUniformAMD = 5000,
    OpGroupFAddNonUniformAMD = 5001,
    OpGroupFMinNonUniformAMD = 5002,
@@ -1268,11 +1353,17 @@ enum Op {
    OpImageSampleFootprintNV = 5283,
    OpGroupNonUniformPartitionNV = 5296,
    OpWritePackedPrimitiveIndices4x8NV = 5299,
    OpReportIntersectionKHR = 5334,
    OpReportIntersectionNV = 5334,
    OpIgnoreIntersectionKHR = 5335,
    OpIgnoreIntersectionNV = 5335,
    OpTerminateRayKHR = 5336,
    OpTerminateRayNV = 5336,
    OpTraceNV = 5337,
    OpTraceRayKHR = 5337,
    OpTypeAccelerationStructureKHR = 5341,
    OpTypeAccelerationStructureNV = 5341,
    OpExecuteCallableKHR = 5344,
    OpExecuteCallableNV = 5344,
    OpTypeCooperativeMatrixNV = 5358,
    OpCooperativeMatrixLoadNV = 5359,
@@ -1429,6 +1520,23 @@ enum Op {
    OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL = 5814,
    OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL = 5815,
    OpSubgroupAvcSicGetInterRawSadsINTEL = 5816,
    OpRayQueryGetRayTMinKHR = 6016,
    OpRayQueryGetRayFlagsKHR = 6017,
    OpRayQueryGetIntersectionTKHR = 6018,
    OpRayQueryGetIntersectionInstanceCustomIndexKHR = 6019,
    OpRayQueryGetIntersectionInstanceIdKHR = 6020,
    OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR = 6021,
    OpRayQueryGetIntersectionGeometryIndexKHR = 6022,
    OpRayQueryGetIntersectionPrimitiveIndexKHR = 6023,
    OpRayQueryGetIntersectionBarycentricsKHR = 6024,
    OpRayQueryGetIntersectionFrontFaceKHR = 6025,
    OpRayQueryGetIntersectionCandidateAABBOpaqueKHR = 6026,
    OpRayQueryGetIntersectionObjectRayDirectionKHR = 6027,
    OpRayQueryGetIntersectionObjectRayOriginKHR = 6028,
    OpRayQueryGetWorldRayDirectionKHR = 6029,
    OpRayQueryGetWorldRayOriginKHR = 6030,
    OpRayQueryGetIntersectionObjectToWorldKHR = 6031,
    OpRayQueryGetIntersectionWorldToObjectKHR = 6032,
    OpMax = 0x7fffffff,
 };
@@ -1787,6 +1895,13 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
    case OpSubgroupAnyKHR: *hasResult = true; *hasResultType = true; break;
    case OpSubgroupAllEqualKHR: *hasResult = true; *hasResultType = true; break;
    case OpSubgroupReadInvocationKHR: *hasResult = true; *hasResultType = true; break;
    case OpTypeRayQueryProvisionalKHR: *hasResult = true; *hasResultType = false; break;
    case OpRayQueryInitializeKHR: *hasResult = false; *hasResultType = false; break;
    case OpRayQueryTerminateKHR: *hasResult = false; *hasResultType = false; break;
    case OpRayQueryGenerateIntersectionKHR: *hasResult = false; *hasResultType = false; break;
    case OpRayQueryConfirmIntersectionKHR: *hasResult = false; *hasResultType = false; break;
    case OpRayQueryProceedKHR: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetIntersectionTypeKHR: *hasResult = true; *hasResultType = true; break;
    case OpGroupIAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
    case OpGroupFAddNonUniformAMD: *hasResult = true; *hasResultType = true; break;
    case OpGroupFMinNonUniformAMD: *hasResult = true; *hasResultType = true; break;
@@ -1960,6 +2075,23 @@ inline void HasResultAndType(Op opcode, bool *hasResult, bool *hasResultType) {
    case OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL: *hasResult = true; *hasResultType = true; break;
    case OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL: *hasResult = true; *hasResultType = true; break;
    case OpSubgroupAvcSicGetInterRawSadsINTEL: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetRayTMinKHR: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetRayFlagsKHR: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetIntersectionTKHR: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetIntersectionInstanceCustomIndexKHR: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetIntersectionInstanceIdKHR: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetIntersectionGeometryIndexKHR: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetIntersectionPrimitiveIndexKHR: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetIntersectionBarycentricsKHR: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetIntersectionFrontFaceKHR: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetIntersectionCandidateAABBOpaqueKHR: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetIntersectionObjectRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetIntersectionObjectRayOriginKHR: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetWorldRayDirectionKHR: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetWorldRayOriginKHR: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetIntersectionObjectToWorldKHR: *hasResult = true; *hasResultType = true; break;
    case OpRayQueryGetIntersectionWorldToObjectKHR: *hasResult = true; *hasResultType = true; break;
    }
 }
 #endif /* SPV_ENABLE_UTILITY_CODE */
@@ -1974,6 +2106,7 @@ inline FunctionControlMask operator|(FunctionControlMask a, FunctionControlMask
 inline MemorySemanticsMask operator|(MemorySemanticsMask a, MemorySemanticsMask b) { return MemorySemanticsMask(unsigned(a) | unsigned(b)); }
 inline MemoryAccessMask operator|(MemoryAccessMask a, MemoryAccessMask b) { return MemoryAccessMask(unsigned(a) | unsigned(b)); }
 inline KernelProfilingInfoMask operator|(KernelProfilingInfoMask a, KernelProfilingInfoMask b) { return KernelProfilingInfoMask(unsigned(a) | unsigned(b)); }
 inline RayFlagsMask operator|(RayFlagsMask a, RayFlagsMask b) { return RayFlagsMask(unsigned(a) | unsigned(b)); }
 }  // end namespace spv
@@ -235,8 +235,7 @@ public:
        assert(instructions.size() > 0);
        instructions.resize(1);
        successors.clear();
-        Instruction* unreachable = new Instruction(OpUnreachable);
+        addInstruction(std::unique_ptr<Instruction>(new Instruction(OpUnreachable)));
        addInstruction(std::unique_ptr<Instruction>(unreachable));
    }
    // Change this block into a canonical dead continue target branching to the
    // given header ID.  Delete instructions as necessary.  A canonical dead continue
@@ -2,6 +2,7 @@
 // Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
 // Copyright (C) 2012-2013 LunarG, Inc.
 // Copyright (C) 2017 ARM Limited.
 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -61,8 +62,9 @@ enum TBasicType {
    EbtSampler,
    EbtStruct,
    EbtBlock,
-    EbtAccStructNV,
+    EbtAccStruct,
    EbtReference,
    EbtRayQuery,
    // HLSL types that live only temporarily.
    EbtString,
@@ -90,11 +92,11 @@ enum TStorageQualifier {
    EvqBuffer,        // read/write, shared with app
    EvqShared,        // compute shader's read/write 'shared' qualifier
-    EvqPayloadNV,
+    EvqPayload,
-    EvqPayloadInNV,
+    EvqPayloadIn,
-    EvqHitAttrNV,
+    EvqHitAttr,
-    EvqCallableDataNV,
+    EvqCallableData,
-    EvqCallableDataInNV,
+    EvqCallableDataIn,
    // parameters
    EvqIn,            // also, for 'in' in the grammar before we know if it's a pipeline input or an 'in' parameter
@@ -238,20 +240,23 @@ enum TBuiltInVariable {
    EbvFragmentSizeNV,
    EbvInvocationsPerPixelNV,
    // ray tracing
-    EbvLaunchIdNV,
+    EbvLaunchId,
-    EbvLaunchSizeNV,
+    EbvLaunchSize,
-    EbvInstanceCustomIndexNV,
+    EbvInstanceCustomIndex,
-    EbvWorldRayOriginNV,
+    EbvGeometryIndex,
-    EbvWorldRayDirectionNV,
+    EbvWorldRayOrigin,
-    EbvObjectRayOriginNV,
+    EbvWorldRayDirection,
-    EbvObjectRayDirectionNV,
+    EbvObjectRayOrigin,
-    EbvRayTminNV,
+    EbvObjectRayDirection,
-    EbvRayTmaxNV,
+    EbvRayTmin,
-    EbvHitTNV,
+    EbvRayTmax,
-    EbvHitKindNV,
+    EbvHitT,
-    EbvObjectToWorldNV,
+    EbvHitKind,
-    EbvWorldToObjectNV,
+    EbvObjectToWorld,
-    EbvIncomingRayFlagsNV,
+    EbvObjectToWorld3x4,
    EbvWorldToObject,
    EbvWorldToObject3x4,
    EbvIncomingRayFlags,
    // barycentrics
    EbvBaryCoordNV,
    EbvBaryCoordNoPerspNV,
@@ -328,11 +333,11 @@ __inline const char* GetStorageQualifierString(TStorageQualifier q)
    case EvqPointCoord:     return "gl_PointCoord";  break;
    case EvqFragColor:      return "fragColor";      break;
    case EvqFragDepth:      return "gl_FragDepth";   break;
-    case EvqPayloadNV:        return "rayPayloadNV";     break;
+    case EvqPayload:        return "rayPayloadNV";     break;
-    case EvqPayloadInNV:      return "rayPayloadInNV";   break;
+    case EvqPayloadIn:      return "rayPayloadInNV";   break;
-    case EvqHitAttrNV:        return "hitAttributeNV";   break;
+    case EvqHitAttr:        return "hitAttributeNV";   break;
-    case EvqCallableDataNV:   return "callableDataNV";   break;
+    case EvqCallableData:   return "callableDataNV";   break;
-    case EvqCallableDataInNV: return "callableDataInNV"; break;
+    case EvqCallableDataIn: return "callableDataInNV"; break;
    default:                return "unknown qualifier";
    }
 }
@@ -436,20 +441,21 @@ __inline const char* GetBuiltInVariableString(TBuiltInVariable v)
    case EbvFragFullyCoveredNV:         return "FragFullyCoveredNV";
    case EbvFragmentSizeNV:             return "FragmentSizeNV";
    case EbvInvocationsPerPixelNV:      return "InvocationsPerPixelNV";
-    case EbvLaunchIdNV:                 return "LaunchIdNV";
+    case EbvLaunchId:                   return "LaunchIdNV";
-    case EbvLaunchSizeNV:               return "LaunchSizeNV";
+    case EbvLaunchSize:                 return "LaunchSizeNV";
-    case EbvInstanceCustomIndexNV:      return "InstanceCustomIndexNV";
+    case EbvInstanceCustomIndex:        return "InstanceCustomIndexNV";
-    case EbvWorldRayOriginNV:           return "WorldRayOriginNV";
+    case EbvGeometryIndex:              return "GeometryIndexEXT";
-    case EbvWorldRayDirectionNV:        return "WorldRayDirectionNV";
+    case EbvWorldRayOrigin:             return "WorldRayOriginNV";
-    case EbvObjectRayOriginNV:          return "ObjectRayOriginNV";
+    case EbvWorldRayDirection:          return "WorldRayDirectionNV";
-    case EbvObjectRayDirectionNV:       return "ObjectRayDirectionNV";
+    case EbvObjectRayOrigin:            return "ObjectRayOriginNV";
-    case EbvRayTminNV:                  return "ObjectRayTminNV";
+    case EbvObjectRayDirection:         return "ObjectRayDirectionNV";
-    case EbvRayTmaxNV:                  return "ObjectRayTmaxNV";
+    case EbvRayTmin:                    return "ObjectRayTminNV";
-    case EbvHitTNV:                     return "HitTNV";
+    case EbvRayTmax:                    return "ObjectRayTmaxNV";
-    case EbvHitKindNV:                  return "HitKindNV";
+    case EbvHitT:                       return "HitTNV";
-    case EbvIncomingRayFlagsNV:         return "IncomingRayFlagsNV";
+    case EbvHitKind:                    return "HitKindNV";
-    case EbvObjectToWorldNV:            return "ObjectToWorldNV";
+    case EbvIncomingRayFlags:           return "IncomingRayFlagsNV";
-    case EbvWorldToObjectNV:            return "WorldToObjectNV";
+    case EbvObjectToWorld:              return "ObjectToWorldNV";
    case EbvWorldToObject:              return "WorldToObjectNV";
    case EbvBaryCoordNV:                return "BaryCoordNV";
    case EbvBaryCoordNoPerspNV:         return "BaryCoordNoPerspNV";
@@ -921,7 +921,7 @@ public:
        else
            unionArray =  new TConstUnionVector(size);
    }
-    TConstUnionArray(const TConstUnionArray& a) : unionArray(a.unionArray) { }
+    TConstUnionArray(const TConstUnionArray& a) = default;
    TConstUnionArray(const TConstUnionArray& a, int start, int size)
    {
        unionArray = new TConstUnionVector(size);
@@ -3,6 +3,7 @@
 // Copyright (C) 2012-2016 LunarG, Inc.
 // Copyright (C) 2015-2016 Google, Inc.
 // Copyright (C) 2017 ARM Limited.
 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -472,6 +473,18 @@ enum TInterlockOrdering {
    EioCount,
 };
 enum TShaderInterface
 {
    // Includes both uniform blocks and buffer blocks
    EsiUniform = 0,
    EsiInput,
    EsiOutput,
    EsiNone,
    EsiCount
 };
 class TQualifier {
 public:
    static const int layoutNotSet = -1;
@@ -532,6 +545,7 @@ public:
        queuefamilycoherent = false;
        workgroupcoherent = false;
        subgroupcoherent  = false;
        shadercallcoherent = false;
        nonprivate = false;
        volatil      = false;
        restrict     = false;
@@ -553,6 +567,7 @@ public:
    // having a constant_id is not sufficient: expressions have no id, but are still specConstant
    bool specConstant : 1;
    bool nonUniform   : 1;
    bool explicitOffset   : 1;
 #ifdef GLSLANG_WEB
    bool isWriteOnly() const { return false; }
@@ -590,6 +605,7 @@ public:
    bool queuefamilycoherent : 1;
    bool workgroupcoherent : 1;
    bool subgroupcoherent  : 1;
    bool shadercallcoherent : 1;
    bool nonprivate   : 1;
    bool isWriteOnly() const { return writeonly; }
    bool isReadOnly() const { return readonly; }
@@ -599,11 +615,11 @@ public:
    bool isSample() const { return sample; }
    bool isMemory() const
    {
-        return subgroupcoherent || workgroupcoherent || queuefamilycoherent || devicecoherent || coherent || volatil || restrict || readonly || writeonly || nonprivate;
+        return shadercallcoherent || subgroupcoherent || workgroupcoherent || queuefamilycoherent || devicecoherent || coherent || volatil || restrict || readonly || writeonly || nonprivate;
    }
    bool isMemoryQualifierImageAndSSBOOnly() const
    {
-        return subgroupcoherent || workgroupcoherent || queuefamilycoherent || devicecoherent || coherent || volatil || restrict || readonly || writeonly;
+        return shadercallcoherent || subgroupcoherent || workgroupcoherent || queuefamilycoherent || devicecoherent || coherent || volatil || restrict || readonly || writeonly;
    }
    bool bufferReferenceNeedsVulkanMemoryModel() const
    {
@@ -773,7 +789,7 @@ public:
        layoutViewportRelative = false;
        // -2048 as the default value indicating layoutSecondaryViewportRelative is not set
        layoutSecondaryViewportRelativeOffset = -2048;
-        layoutShaderRecordNV = false;
+        layoutShaderRecord = false;
        layoutBufferReferenceAlign = layoutBufferReferenceAlignEnd;
        layoutFormat = ElfNone;
 #endif
@@ -812,7 +828,7 @@ public:
               hasAnyLocation() ||
               hasStream() ||
               hasFormat() ||
-               isShaderRecordNV() ||
+               isShaderRecord() ||
               isPushConstant() ||
               hasBufferReference();
    }
@@ -871,7 +887,7 @@ public:
    bool layoutPassthrough;
    bool layoutViewportRelative;
    int layoutSecondaryViewportRelativeOffset;
-    bool layoutShaderRecordNV;
+    bool layoutShaderRecord;
 #endif
    bool hasUniformLayout() const
@@ -942,7 +958,7 @@ public:
    bool hasAttachment() const { return false; }
    TLayoutFormat getFormat() const { return ElfNone; }
    bool isPushConstant() const { return false; }
-    bool isShaderRecordNV() const { return false; }
+    bool isShaderRecord() const { return false; }
    bool hasBufferReference() const { return false; }
    bool hasBufferReferenceAlign() const { return false; }
    bool isNonUniform() const { return false; }
@@ -993,7 +1009,7 @@ public:
    }
    TLayoutFormat getFormat() const { return layoutFormat; }
    bool isPushConstant() const { return layoutPushConstant; }
-    bool isShaderRecordNV() const { return layoutShaderRecordNV; }
+    bool isShaderRecord() const { return layoutShaderRecord; }
    bool hasBufferReference() const { return layoutBufferReference; }
    bool hasBufferReferenceAlign() const
    {
@@ -1612,6 +1628,23 @@ public:
        assert(fieldName);
        return *fieldName;
    }
    TShaderInterface getShaderInterface() const
    {
        if (basicType != EbtBlock)
            return EsiNone;
        switch (qualifier.storage) {
        default:
            return EsiNone;
        case EvqVaryingIn:
            return EsiInput;
        case EvqVaryingOut:
            return EsiOutput;
        case EvqUniform:
        case EvqBuffer:
            return EsiUniform;
        }
    }
    virtual TBasicType getBasicType() const { return basicType; }
    virtual const TSampler& getSampler() const { return sampler; }
@@ -1670,7 +1703,7 @@ public:
    }
    virtual bool isOpaque() const { return basicType == EbtSampler
 #ifndef GLSLANG_WEB
-         || basicType == EbtAtomicUint || basicType == EbtAccStructNV
+         || basicType == EbtAtomicUint || basicType == EbtAccStruct || basicType == EbtRayQuery
 #endif
        ; }
    virtual bool isBuiltIn() const { return getQualifier().builtIn != EbvNone; }
@@ -1946,7 +1979,8 @@ public:
        case EbtAtomicUint:        return "atomic_uint";
        case EbtStruct:            return "structure";
        case EbtBlock:             return "block";
-        case EbtAccStructNV:       return "accelerationStructureNV";
+        case EbtAccStruct:         return "accelerationStructureNV";
        case EbtRayQuery:          return "rayQueryEXT";
        case EbtReference:         return "reference";
 #endif
        default:                   return "unknown type";
@@ -2056,7 +2090,7 @@ public:
                    appendStr(" layoutSecondaryViewportRelativeOffset=");
                    appendInt(qualifier.layoutSecondaryViewportRelativeOffset);
                }
-                if (qualifier.layoutShaderRecordNV)
+                if (qualifier.layoutShaderRecord)
                    appendStr(" shaderRecordNV");
                appendStr(")");
@@ -2099,6 +2133,8 @@ public:
            appendStr(" workgroupcoherent");
        if (qualifier.subgroupcoherent)
            appendStr(" subgroupcoherent");
        if (qualifier.shadercallcoherent)
            appendStr(" shadercallcoherent");
        if (qualifier.nonprivate)
            appendStr(" nonprivate");
        if (qualifier.volatil)
@@ -0,0 +1,232 @@
 /**
    This code is based on the glslang_c_interface implementation by Viktor Latypov
 **/
 /**
 BSD 2-Clause License
 Copyright (c) 2019, Viktor Latypov
 All rights reserved.
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
 1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 **/
 #ifndef GLSLANG_C_IFACE_H_INCLUDED
 #define GLSLANG_C_IFACE_H_INCLUDED
 #include <stdbool.h>
 #include <stdlib.h>
 #include "glslang_c_shader_types.h"
 typedef struct glslang_shader_s glslang_shader_t;
 typedef struct glslang_program_s glslang_program_t;
 /* TLimits counterpart */
 typedef struct glslang_limits_s {
    bool non_inductive_for_loops;
    bool while_loops;
    bool do_while_loops;
    bool general_uniform_indexing;
    bool general_attribute_matrix_vector_indexing;
    bool general_varying_indexing;
    bool general_sampler_indexing;
    bool general_variable_indexing;
    bool general_constant_matrix_vector_indexing;
 } glslang_limits_t;
 /* TBuiltInResource counterpart */
 typedef struct glslang_resource_s {
    int max_lights;
    int max_clip_planes;
    int max_texture_units;
    int max_texture_coords;
    int max_vertex_attribs;
    int max_vertex_uniform_components;
    int max_varying_floats;
    int max_vertex_texture_image_units;
    int max_combined_texture_image_units;
    int max_texture_image_units;
    int max_fragment_uniform_components;
    int max_draw_buffers;
    int max_vertex_uniform_vectors;
    int max_varying_vectors;
    int max_fragment_uniform_vectors;
    int max_vertex_output_vectors;
    int max_fragment_input_vectors;
    int min_program_texel_offset;
    int max_program_texel_offset;
    int max_clip_distances;
    int max_compute_work_group_count_x;
    int max_compute_work_group_count_y;
    int max_compute_work_group_count_z;
    int max_compute_work_group_size_x;
    int max_compute_work_group_size_y;
    int max_compute_work_group_size_z;
    int max_compute_uniform_components;
    int max_compute_texture_image_units;
    int max_compute_image_uniforms;
    int max_compute_atomic_counters;
    int max_compute_atomic_counter_buffers;
    int max_varying_components;
    int max_vertex_output_components;
    int max_geometry_input_components;
    int max_geometry_output_components;
    int max_fragment_input_components;
    int max_image_units;
    int max_combined_image_units_and_fragment_outputs;
    int max_combined_shader_output_resources;
    int max_image_samples;
    int max_vertex_image_uniforms;
    int max_tess_control_image_uniforms;
    int max_tess_evaluation_image_uniforms;
    int max_geometry_image_uniforms;
    int max_fragment_image_uniforms;
    int max_combined_image_uniforms;
    int max_geometry_texture_image_units;
    int max_geometry_output_vertices;
    int max_geometry_total_output_components;
    int max_geometry_uniform_components;
    int max_geometry_varying_components;
    int max_tess_control_input_components;
    int max_tess_control_output_components;
    int max_tess_control_texture_image_units;
    int max_tess_control_uniform_components;
    int max_tess_control_total_output_components;
    int max_tess_evaluation_input_components;
    int max_tess_evaluation_output_components;
    int max_tess_evaluation_texture_image_units;
    int max_tess_evaluation_uniform_components;
    int max_tess_patch_components;
    int max_patch_vertices;
    int max_tess_gen_level;
    int max_viewports;
    int max_vertex_atomic_counters;
    int max_tess_control_atomic_counters;
    int max_tess_evaluation_atomic_counters;
    int max_geometry_atomic_counters;
    int max_fragment_atomic_counters;
    int max_combined_atomic_counters;
    int max_atomic_counter_bindings;
    int max_vertex_atomic_counter_buffers;
    int max_tess_control_atomic_counter_buffers;
    int max_tess_evaluation_atomic_counter_buffers;
    int max_geometry_atomic_counter_buffers;
    int max_fragment_atomic_counter_buffers;
    int max_combined_atomic_counter_buffers;
    int max_atomic_counter_buffer_size;
    int max_transform_feedback_buffers;
    int max_transform_feedback_interleaved_components;
    int max_cull_distances;
    int max_combined_clip_and_cull_distances;
    int max_samples;
    int max_mesh_output_vertices_nv;
    int max_mesh_output_primitives_nv;
    int max_mesh_work_group_size_x_nv;
    int max_mesh_work_group_size_y_nv;
    int max_mesh_work_group_size_z_nv;
    int max_task_work_group_size_x_nv;
    int max_task_work_group_size_y_nv;
    int max_task_work_group_size_z_nv;
    int max_mesh_view_count_nv;
    glslang_limits_t limits;
 } glslang_resource_t;
 typedef struct glslang_input_s {
    glslang_source_t language;
    glslang_stage_t stage;
    glslang_client_t client;
    glslang_target_client_version_t client_version;
    glslang_target_language_t target_language;
    glslang_target_language_version_t target_language_version;
    /** Shader source code */
    const char* code;
    int default_version;
    glslang_profile_t default_profile;
    int force_default_version_and_profile;
    int forward_compatible;
    glslang_messages_t messages;
    const glslang_resource_t* resource;
 } glslang_input_t;
 /* Inclusion result structure allocated by C include_local/include_system callbacks */
 typedef struct glsl_include_result_s {
    /* Header file name or NULL if inclusion failed */
    const char* header_name;
    /* Header contents or NULL */
    const char* header_data;
    size_t header_length;
 } glsl_include_result_t;
 /* Callback for local file inclusion */
 typedef glsl_include_result_t* (*glsl_include_local_func)(void* ctx, const char* header_name, const char* includer_name,
                                                          size_t include_depth);
 /* Callback for system file inclusion */
 typedef glsl_include_result_t* (*glsl_include_system_func)(void* ctx, const char* header_name,
                                                           const char* includer_name, size_t include_depth);
 /* Callback for include result destruction */
 typedef int (*glsl_free_include_result_func)(void* ctx, glsl_include_result_t* result);
 /* Collection of callbacks for GLSL preprocessor */
 typedef struct glsl_include_callbacks_s {
    glsl_include_system_func include_system;
    glsl_include_local_func include_local;
    glsl_free_include_result_func free_include_result;
 } glsl_include_callbacks_t;
 #ifdef __cplusplus
 extern "C" {
 #endif
 int glslang_initialize_process();
 void glslang_finalize_process();
 glslang_shader_t* glslang_shader_create(const glslang_input_t* input);
 void glslang_shader_delete(glslang_shader_t* shader);
 int glslang_shader_preprocess(glslang_shader_t* shader, const glslang_input_t* input);
 int glslang_shader_parse(glslang_shader_t* shader, const glslang_input_t* input);
 const char* glslang_shader_get_preprocessed_code(glslang_shader_t* shader);
 const char* glslang_shader_get_info_log(glslang_shader_t* shader);
 const char* glslang_shader_get_info_debug_log(glslang_shader_t* shader);
 glslang_program_t* glslang_program_create();
 void glslang_program_delete(glslang_program_t* program);
 void glslang_program_add_shader(glslang_program_t* program, glslang_shader_t* shader);
 int glslang_program_link(glslang_program_t* program, int messages); // glslang_messages_t
 void glslang_program_SPIRV_generate(glslang_program_t* program, glslang_stage_t stage);
 size_t glslang_program_SPIRV_get_size(glslang_program_t* program);
 void glslang_program_SPIRV_get(glslang_program_t* program, unsigned int*);
 unsigned int* glslang_program_SPIRV_get_ptr(glslang_program_t* program);
 const char* glslang_program_SPIRV_get_messages(glslang_program_t* program);
 const char* glslang_program_get_info_log(glslang_program_t* program);
 const char* glslang_program_get_info_debug_log(glslang_program_t* program);
 #ifdef __cplusplus
 }
 #endif
 #endif /* #ifdef GLSLANG_C_IFACE_INCLUDED */
@@ -0,0 +1,182 @@
 /**
    This code is based on the glslang_c_interface implementation by Viktor Latypov
 **/
 /**
 BSD 2-Clause License
 Copyright (c) 2019, Viktor Latypov
 All rights reserved.
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
 1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 **/
 #ifndef C_SHADER_TYPES_H_INCLUDED
 #define C_SHADER_TYPES_H_INCLUDED
 #define LAST_ELEMENT_MARKER(x) x
 /* EShLanguage counterpart */
 typedef enum {
    GLSLANG_STAGE_VERTEX,
    GLSLANG_STAGE_TESSCONTROL,
    GLSLANG_STAGE_TESSEVALUATION,
    GLSLANG_STAGE_GEOMETRY,
    GLSLANG_STAGE_FRAGMENT,
    GLSLANG_STAGE_COMPUTE,
    GLSLANG_STAGE_RAYGEN_NV,
    GLSLANG_STAGE_INTERSECT_NV,
    GLSLANG_STAGE_ANYHIT_NV,
    GLSLANG_STAGE_CLOSESTHIT_NV,
    GLSLANG_STAGE_MISS_NV,
    GLSLANG_STAGE_CALLABLE_NV,
    GLSLANG_STAGE_TASK_NV,
    GLSLANG_STAGE_MESH_NV,
    LAST_ELEMENT_MARKER(GLSLANG_STAGE_COUNT),
 } glslang_stage_t; // would be better as stage, but this is ancient now
 /* EShLanguageMask counterpart */
 typedef enum {
    GLSLANG_STAGE_VERTEX_MASK = (1 << GLSLANG_STAGE_VERTEX),
    GLSLANG_STAGE_TESSCONTROL_MASK = (1 << GLSLANG_STAGE_TESSCONTROL),
    GLSLANG_STAGE_TESSEVALUATION_MASK = (1 << GLSLANG_STAGE_TESSEVALUATION),
    GLSLANG_STAGE_GEOMETRY_MASK = (1 << GLSLANG_STAGE_GEOMETRY),
    GLSLANG_STAGE_FRAGMENT_MASK = (1 << GLSLANG_STAGE_FRAGMENT),
    GLSLANG_STAGE_COMPUTE_MASK = (1 << GLSLANG_STAGE_COMPUTE),
    GLSLANG_STAGE_RAYGEN_NV_MASK = (1 << GLSLANG_STAGE_RAYGEN_NV),
    GLSLANG_STAGE_INTERSECT_NV_MASK = (1 << GLSLANG_STAGE_INTERSECT_NV),
    GLSLANG_STAGE_ANYHIT_NV_MASK = (1 << GLSLANG_STAGE_ANYHIT_NV),
    GLSLANG_STAGE_CLOSESTHIT_NV_MASK = (1 << GLSLANG_STAGE_CLOSESTHIT_NV),
    GLSLANG_STAGE_MISS_NV_MASK = (1 << GLSLANG_STAGE_MISS_NV),
    GLSLANG_STAGE_CALLABLE_NV_MASK = (1 << GLSLANG_STAGE_CALLABLE_NV),
    GLSLANG_STAGE_TASK_NV_MASK = (1 << GLSLANG_STAGE_TASK_NV),
    GLSLANG_STAGE_MESH_NV_MASK = (1 << GLSLANG_STAGE_MESH_NV),
    LAST_ELEMENT_MARKER(GLSLANG_STAGE_MASK_COUNT),
 } glslang_stage_mask_t;
 /* EShSource counterpart */
 typedef enum {
    GLSLANG_SOURCE_NONE,
    GLSLANG_SOURCE_GLSL,
    GLSLANG_SOURCE_HLSL,
    LAST_ELEMENT_MARKER(GLSLANG_SOURCE_COUNT),
 } glslang_source_t;
 /* EShClient counterpart */
 typedef enum {
    GLSLANG_CLIENT_NONE,
    GLSLANG_CLIENT_VULKAN,
    GLSLANG_CLIENT_OPENGL,
    LAST_ELEMENT_MARKER(GLSLANG_CLIENT_COUNT),
 } glslang_client_t;
 /* EShTargetLanguage counterpart */
 typedef enum {
    GLSLANG_TARGET_NONE,
    GLSLANG_TARGET_SPV,
    LAST_ELEMENT_MARKER(GLSLANG_TARGET_COUNT),
 } glslang_target_language_t;
 /* SH_TARGET_ClientVersion counterpart */
 typedef enum {
    GLSLANG_TARGET_VULKAN_1_0 = (1 << 22),
    GLSLANG_TARGET_VULKAN_1_1 = (1 << 22) | (1 << 12),
    GLSLANG_TARGET_OPENGL_450 = 450,
    LAST_ELEMENT_MARKER(GLSLANG_TARGET_CLIENT_VERSION_COUNT),
 } glslang_target_client_version_t;
 /* SH_TARGET_LanguageVersion counterpart */
 typedef enum {
    GLSLANG_TARGET_SPV_1_0 = (1 << 16),
    GLSLANG_TARGET_SPV_1_1 = (1 << 16) | (1 << 8),
    GLSLANG_TARGET_SPV_1_2 = (1 << 16) | (2 << 8),
    GLSLANG_TARGET_SPV_1_3 = (1 << 16) | (3 << 8),
    GLSLANG_TARGET_SPV_1_4 = (1 << 16) | (4 << 8),
    GLSLANG_TARGET_SPV_1_5 = (1 << 16) | (5 << 8),
    LAST_ELEMENT_MARKER(GLSLANG_TARGET_LANGUAGE_VERSION_COUNT),
 } glslang_target_language_version_t;
 /* EShExecutable counterpart */
 typedef enum { GLSLANG_EX_VERTEX_FRAGMENT, GLSLANG_EX_FRAGMENT } glslang_executable_t;
 /* EShOptimizationLevel counterpart  */
 typedef enum {
    GLSLANG_OPT_NO_GENERATION,
    GLSLANG_OPT_NONE,
    GLSLANG_OPT_SIMPLE,
    GLSLANG_OPT_FULL,
    LAST_ELEMENT_MARKER(GLSLANG_OPT_LEVEL_COUNT),
 } glslang_optimization_level_t;
 /* EShTextureSamplerTransformMode counterpart */
 typedef enum {
    GLSLANG_TEX_SAMP_TRANS_KEEP,
    GLSLANG_TEX_SAMP_TRANS_UPGRADE_TEXTURE_REMOVE_SAMPLER,
    LAST_ELEMENT_MARKER(GLSLANG_TEX_SAMP_TRANS_COUNT),
 } glslang_texture_sampler_transform_mode_t;
 /* EShMessages counterpart */
 typedef enum {
    GLSLANG_MSG_DEFAULT_BIT = 0,
    GLSLANG_MSG_RELAXED_ERRORS_BIT = (1 << 0),
    GLSLANG_MSG_SUPPRESS_WARNINGS_BIT = (1 << 1),
    GLSLANG_MSG_AST_BIT = (1 << 2),
    GLSLANG_MSG_SPV_RULES_BIT = (1 << 3),
    GLSLANG_MSG_VULKAN_RULES_BIT = (1 << 4),
    GLSLANG_MSG_ONLY_PREPROCESSOR_BIT = (1 << 5),
    GLSLANG_MSG_READ_HLSL_BIT = (1 << 6),
    GLSLANG_MSG_CASCADING_ERRORS_BIT = (1 << 7),
    GLSLANG_MSG_KEEP_UNCALLED_BIT = (1 << 8),
    GLSLANG_MSG_HLSL_OFFSETS_BIT = (1 << 9),
    GLSLANG_MSG_DEBUG_INFO_BIT = (1 << 10),
    GLSLANG_MSG_HLSL_ENABLE_16BIT_TYPES_BIT = (1 << 11),
    GLSLANG_MSG_HLSL_LEGALIZATION_BIT = (1 << 12),
    GLSLANG_MSG_HLSL_DX9_COMPATIBLE_BIT = (1 << 13),
    GLSLANG_MSG_BUILTIN_SYMBOL_TABLE_BIT = (1 << 14),
    LAST_ELEMENT_MARKER(GLSLANG_MSG_COUNT),
 } glslang_messages_t;
 /* EShReflectionOptions counterpart */
 typedef enum {
    GLSLANG_REFLECTION_DEFAULT_BIT = 0,
    GLSLANG_REFLECTION_STRICT_ARRAY_SUFFIX_BIT = (1 << 0),
    GLSLANG_REFLECTION_BASIC_ARRAY_SUFFIX_BIT = (1 << 1),
    GLSLANG_REFLECTION_INTERMEDIATE_IOO_BIT = (1 << 2),
    GLSLANG_REFLECTION_SEPARATE_BUFFERS_BIT = (1 << 3),
    GLSLANG_REFLECTION_ALL_BLOCK_VARIABLES_BIT = (1 << 4),
    GLSLANG_REFLECTION_UNWRAP_IO_BLOCKS_BIT = (1 << 5),
    LAST_ELEMENT_MARKER(GLSLANG_REFLECTION_COUNT),
 } glslang_reflection_options_t;
 /* EProfile counterpart (from Versions.h) */
 typedef enum {
    GLSLANG_BAD_PROFILE = 0,
    GLSLANG_NO_PROFILE = (1 << 0),
    GLSLANG_CORE_PROFILE = (1 << 1),
    GLSLANG_COMPATIBILITY_PROFILE = (1 << 2),
    GLSLANG_ES_PROFILE = (1 << 3),
    LAST_ELEMENT_MARKER(GLSLANG_PROFILE_COUNT),
 } glslang_profile_t;
 #undef LAST_ELEMENT_MARKER
 #endif
@@ -2,6 +2,7 @@
 // Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
 // Copyright (C) 2012-2016 LunarG, Inc.
 // Copyright (C) 2017 ARM Limited.
 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -621,6 +622,8 @@ enum TOperator {
    EOpIsHelperInvocation,
    EOpDebugPrintf,
    //
    // Branch
    //
@@ -908,12 +911,41 @@ enum TOperator {
    EOpAverageRounded,
    EOpMul32x16,
-    EOpTraceNV,
+    EOpTrace,
-    EOpReportIntersectionNV,
+    EOpReportIntersection,
-    EOpIgnoreIntersectionNV,
+    EOpIgnoreIntersection,
-    EOpTerminateRayNV,
+    EOpTerminateRay,
-    EOpExecuteCallableNV,
+    EOpExecuteCallable,
    EOpWritePackedPrimitiveIndices4x8NV,
    //
    // GL_EXT_ray_query operations
    //
    EOpRayQueryInitialize,
    EOpRayQueryTerminate,
    EOpRayQueryGenerateIntersection,
    EOpRayQueryConfirmIntersection,
    EOpRayQueryProceed,
    EOpRayQueryGetIntersectionType,
    EOpRayQueryGetRayTMin,
    EOpRayQueryGetRayFlags,
    EOpRayQueryGetIntersectionT,
    EOpRayQueryGetIntersectionInstanceCustomIndex,
    EOpRayQueryGetIntersectionInstanceId,
    EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset,
    EOpRayQueryGetIntersectionGeometryIndex,
    EOpRayQueryGetIntersectionPrimitiveIndex,
    EOpRayQueryGetIntersectionBarycentrics,
    EOpRayQueryGetIntersectionFrontFace,
    EOpRayQueryGetIntersectionCandidateAABBOpaque,
    EOpRayQueryGetIntersectionObjectRayDirection,
    EOpRayQueryGetIntersectionObjectRayOrigin,
    EOpRayQueryGetWorldRayDirection,
    EOpRayQueryGetWorldRayOrigin,
    EOpRayQueryGetIntersectionObjectToWorld,
    EOpRayQueryGetIntersectionWorldToObject,
    //
    // HLSL operations
    //
@@ -1,3 +1,3 @@
 // This header is generated by the make-revision script.
-#define GLSLANG_PATCH_LEVEL 3559
+#define GLSLANG_PATCH_LEVEL 3741
@@ -2,7 +2,7 @@
 // Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
 // Copyright (C) 2012-2013 LunarG, Inc.
 // Copyright (C) 2017 ARM Limited.
-// Copyright (C) 2018 Google, Inc.
+// Copyright (C) 2018-2020 Google, Inc.
 //
 // All rights reserved.
 //
@@ -1012,6 +1012,7 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode)
    case EOpMin:
    case EOpMax:
    case EOpMix:
    case EOpMod:
    case EOpClamp:
    case EOpLessThan:
    case EOpGreaterThan:
@@ -1074,6 +1075,14 @@ TIntermTyped* TIntermediate::fold(TIntermAggregate* aggrNode)
            case EOpPow:
                newConstArray[comp].setDConst(pow(childConstUnions[0][arg0comp].getDConst(), childConstUnions[1][arg1comp].getDConst()));
                break;
            case EOpMod:
            {
                double arg0 = childConstUnions[0][arg0comp].getDConst();
                double arg1 = childConstUnions[1][arg1comp].getDConst();
                double result = arg0 - arg1 * floor(arg0 / arg1);
                newConstArray[comp].setDConst(result);
                break;
            }
            case EOpMin:
                switch(children[0]->getAsTyped()->getBasicType()) {
                case EbtFloat16:
@@ -1,8 +1,9 @@
 //
 // Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
 // Copyright (C) 2012-2016 LunarG, Inc.
-// Copyright (C) 2015-2018 Google, Inc.
+// Copyright (C) 2015-2020 Google, Inc.
 // Copyright (C) 2017 ARM Limited.
 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -125,8 +126,6 @@ enum ArgClass {
 };
 // Mixtures of the above, to help the function tables
 const ArgClass ClassV1FIOCV = (ArgClass)(ClassV1 | ClassFIO | ClassCV);
 const ArgClass ClassV1FOCV  = (ArgClass)(ClassV1 | ClassFO  | ClassCV);
 const ArgClass ClassV1CV    = (ArgClass)(ClassV1 | ClassCV);
 const ArgClass ClassBNS     = (ArgClass)(ClassB  | ClassNS);
 const ArgClass ClassRSNS    = (ArgClass)(ClassRS | ClassNS);
@@ -154,6 +153,11 @@ EProfile EDesktopProfile = static_cast<EProfile>(ENoProfile | ECoreProfile | ECo
                                                  { EBadProfile } };
    const Versioning* Es300Desktop130 = &Es300Desktop130Version[0];
    const Versioning Es310Desktop420Version[] = { { EEsProfile,      0, 310, 0, nullptr },
                                                  { EDesktopProfile, 0, 420, 0, nullptr },
                                                  { EBadProfile } };
    const Versioning* Es310Desktop420 = &Es310Desktop420Version[0];
    const Versioning Es310Desktop430Version[] = { { EEsProfile,      0, 310, 0, nullptr },
                                                  { EDesktopProfile, 0, 430, 0, nullptr },
                                                  { EBadProfile } };
@@ -257,14 +261,14 @@ const BuiltInFunction BaseFunctions[] = {
    { EOpGreaterThanEqual, "greaterThanEqual", 2,   TypeU,     ClassBNS,     Es300Desktop130 },
    { EOpVectorEqual,      "equal",            2,   TypeU,     ClassBNS,     Es300Desktop130 },
    { EOpVectorNotEqual,   "notEqual",         2,   TypeU,     ClassBNS,     Es300Desktop130 },
-    { EOpAtomicAdd,        "atomicAdd",        2,   TypeIU,    ClassV1FIOCV, Es310Desktop430 },
+    { EOpAtomicAdd,        "atomicAdd",        2,   TypeIU,    ClassV1FIOCV, Es310Desktop420 },
-    { EOpAtomicMin,        "atomicMin",        2,   TypeIU,    ClassV1FIOCV, Es310Desktop430 },
+    { EOpAtomicMin,        "atomicMin",        2,   TypeIU,    ClassV1FIOCV, Es310Desktop420 },
-    { EOpAtomicMax,        "atomicMax",        2,   TypeIU,    ClassV1FIOCV, Es310Desktop430 },
+    { EOpAtomicMax,        "atomicMax",        2,   TypeIU,    ClassV1FIOCV, Es310Desktop420 },
-    { EOpAtomicAnd,        "atomicAnd",        2,   TypeIU,    ClassV1FIOCV, Es310Desktop430 },
+    { EOpAtomicAnd,        "atomicAnd",        2,   TypeIU,    ClassV1FIOCV, Es310Desktop420 },
-    { EOpAtomicOr,         "atomicOr",         2,   TypeIU,    ClassV1FIOCV, Es310Desktop430 },
+    { EOpAtomicOr,         "atomicOr",         2,   TypeIU,    ClassV1FIOCV, Es310Desktop420 },
-    { EOpAtomicXor,        "atomicXor",        2,   TypeIU,    ClassV1FIOCV, Es310Desktop430 },
+    { EOpAtomicXor,        "atomicXor",        2,   TypeIU,    ClassV1FIOCV, Es310Desktop420 },
-    { EOpAtomicExchange,   "atomicExchange",   2,   TypeIU,    ClassV1FIOCV, Es310Desktop430 },
+    { EOpAtomicExchange,   "atomicExchange",   2,   TypeIU,    ClassV1FIOCV, Es310Desktop420 },
-    { EOpAtomicCompSwap,   "atomicCompSwap",   3,   TypeIU,    ClassV1FIOCV, Es310Desktop430 },
+    { EOpAtomicCompSwap,   "atomicCompSwap",   3,   TypeIU,    ClassV1FIOCV, Es310Desktop420 },
 #ifndef GLSLANG_WEB
    { EOpMix,              "mix",              3,   TypeB,     ClassRegular, Es310Desktop450 },
    { EOpMix,              "mix",              3,   TypeIU,    ClassLB,      Es310Desktop450 },
@@ -1263,7 +1267,7 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
 #endif
    if ((profile == EEsProfile && version >= 300) ||
-        (profile != EEsProfile && version >= 330)) {
+        (profile != EEsProfile && version >= 150)) { // GL_ARB_shader_bit_encoding
        commonBuiltins.append(
            "int   floatBitsToInt(highp float value);"
            "ivec2 floatBitsToInt(highp vec2  value);"
@@ -4079,10 +4083,10 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
    }
 #ifndef GLSLANG_WEB
    if ((profile != EEsProfile && version >= 420) || esBarrier) {
-        commonBuiltins.append(
+        if (spvVersion.vulkan == 0) {
-            "void memoryBarrierAtomicCounter();"
+            commonBuiltins.append("void memoryBarrierAtomicCounter();");
-            "void memoryBarrierImage();"
+        }
-            );
+        commonBuiltins.append("void memoryBarrierImage();");
    }
    if ((profile != EEsProfile && version >= 450) || (profile == EEsProfile && version >= 320)) {
        stageBuiltins[EShLangMeshNV].append(
@@ -4098,6 +4102,8 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
    commonBuiltins.append("void controlBarrier(int, int, int, int);\n"
                          "void memoryBarrier(int, int, int);\n");
    commonBuiltins.append("void debugPrintfEXT();\n");
    if (profile != EEsProfile && version >= 450) {
        // coopMatStoreNV perhaps ought to have "out" on the buf parameter, but
        // adding it introduces undesirable tempArgs on the stack. What we want
@@ -4335,29 +4341,64 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
            "\n");
        }
-    // Builtins for GL_NV_ray_tracing
+    // Builtins for GL_NV_ray_tracing/GL_EXT_ray_tracing/GL_EXT_ray_query
    if (profile != EEsProfile && version >= 460) {
-        stageBuiltins[EShLangRayGenNV].append(
+         commonBuiltins.append("void rayQueryInitializeEXT(rayQueryEXT, accelerationStructureEXT, uint, uint, vec3, float, vec3, float);"
-            "void traceNV(accelerationStructureNV,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
+            "void rayQueryTerminateEXT(rayQueryEXT);"
-            "void executeCallableNV(uint, int);"
+            "void rayQueryGenerateIntersectionEXT(rayQueryEXT, float);"
            "void rayQueryConfirmIntersectionEXT(rayQueryEXT);"
            "bool rayQueryProceedEXT(rayQueryEXT);"
            "uint rayQueryGetIntersectionTypeEXT(rayQueryEXT, bool);"
            "float rayQueryGetRayTMinEXT(rayQueryEXT);"
            "uint rayQueryGetRayFlagsEXT(rayQueryEXT);"
            "vec3 rayQueryGetWorldRayOriginEXT(rayQueryEXT);"
            "vec3 rayQueryGetWorldRayDirectionEXT(rayQueryEXT);"
            "float rayQueryGetIntersectionTEXT(rayQueryEXT, bool);"
            "int rayQueryGetIntersectionInstanceCustomIndexEXT(rayQueryEXT, bool);"
            "int rayQueryGetIntersectionInstanceIdEXT(rayQueryEXT, bool);"
            "uint rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT(rayQueryEXT, bool);"
            "int rayQueryGetIntersectionGeometryIndexEXT(rayQueryEXT, bool);"
            "int rayQueryGetIntersectionPrimitiveIndexEXT(rayQueryEXT, bool);"
            "vec2 rayQueryGetIntersectionBarycentricsEXT(rayQueryEXT, bool);"
            "bool rayQueryGetIntersectionFrontFaceEXT(rayQueryEXT, bool);"
            "bool rayQueryGetIntersectionCandidateAABBOpaqueEXT(rayQueryEXT);"
            "vec3 rayQueryGetIntersectionObjectRayDirectionEXT(rayQueryEXT, bool);"
            "vec3 rayQueryGetIntersectionObjectRayOriginEXT(rayQueryEXT, bool);"
            "mat4x3 rayQueryGetIntersectionObjectToWorldEXT(rayQueryEXT, bool);"
            "mat4x3 rayQueryGetIntersectionWorldToObjectEXT(rayQueryEXT, bool);"
            "\n");
-        stageBuiltins[EShLangIntersectNV].append(
+
        stageBuiltins[EShLangRayGen].append(
            "void traceNV(accelerationStructureNV,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
            "void traceRayEXT(accelerationStructureEXT,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
            "void executeCallableNV(uint, int);"
            "void executeCallableEXT(uint, int);"
            "\n");
        stageBuiltins[EShLangIntersect].append(
            "bool reportIntersectionNV(float, uint);"
            "bool reportIntersectionEXT(float, uint);"
            "\n");
-        stageBuiltins[EShLangAnyHitNV].append(
+        stageBuiltins[EShLangAnyHit].append(
            "void ignoreIntersectionNV();"
            "void ignoreIntersectionEXT();"
            "void terminateRayNV();"
            "void terminateRayEXT();"
            "\n");
-        stageBuiltins[EShLangClosestHitNV].append(
+        stageBuiltins[EShLangClosestHit].append(
            "void traceNV(accelerationStructureNV,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
            "void traceRayEXT(accelerationStructureEXT,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
            "void executeCallableNV(uint, int);"
            "void executeCallableEXT(uint, int);"
            "\n");
-        stageBuiltins[EShLangMissNV].append(
+        stageBuiltins[EShLangMiss].append(
            "void traceNV(accelerationStructureNV,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
            "void traceRayEXT(accelerationStructureEXT,uint,uint,uint,uint,uint,vec3,float,vec3,float,int);"
            "void executeCallableNV(uint, int);"
            "void executeCallableEXT(uint, int);"
            "\n");
-        stageBuiltins[EShLangCallableNV].append(
+        stageBuiltins[EShLangCallable].append(
            "void executeCallableNV(uint, int);"
            "void executeCallableEXT(uint, int);"
            "\n");
    }
@@ -5406,100 +5447,160 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
        stageBuiltins[EShLangMeshNV]        .append(computeSubgroupDecls);
        stageBuiltins[EShLangTaskNV]        .append(subgroupDecls);
        stageBuiltins[EShLangTaskNV]        .append(computeSubgroupDecls);
-        stageBuiltins[EShLangRayGenNV]      .append(subgroupDecls);
+        stageBuiltins[EShLangRayGen]        .append(subgroupDecls);
-        stageBuiltins[EShLangIntersectNV]   .append(subgroupDecls);
+        stageBuiltins[EShLangIntersect]     .append(subgroupDecls);
-        stageBuiltins[EShLangAnyHitNV]      .append(subgroupDecls);
+        stageBuiltins[EShLangAnyHit]        .append(subgroupDecls);
-        stageBuiltins[EShLangClosestHitNV]  .append(subgroupDecls);
+        stageBuiltins[EShLangClosestHit]    .append(subgroupDecls);
-        stageBuiltins[EShLangMissNV]        .append(subgroupDecls);
+        stageBuiltins[EShLangMiss]          .append(subgroupDecls);
-        stageBuiltins[EShLangCallableNV]    .append(subgroupDecls);
+        stageBuiltins[EShLangCallable]      .append(subgroupDecls);
    }
-    // GL_NV_ray_tracing
+    // GL_NV_ray_tracing/GL_EXT_ray_tracing
    if (profile != EEsProfile && version >= 460) {
        const char *constRayFlags =
            "const uint gl_RayFlagsNoneNV = 0U;"
            "const uint gl_RayFlagsNoneEXT = 0U;"
            "const uint gl_RayFlagsOpaqueNV = 1U;"
            "const uint gl_RayFlagsOpaqueEXT = 1U;"
            "const uint gl_RayFlagsNoOpaqueNV = 2U;"
            "const uint gl_RayFlagsNoOpaqueEXT = 2U;"
            "const uint gl_RayFlagsTerminateOnFirstHitNV = 4U;"
            "const uint gl_RayFlagsTerminateOnFirstHitEXT = 4U;"
            "const uint gl_RayFlagsSkipClosestHitShaderNV = 8U;"
            "const uint gl_RayFlagsSkipClosestHitShaderEXT = 8U;"
            "const uint gl_RayFlagsCullBackFacingTrianglesNV = 16U;"
            "const uint gl_RayFlagsCullBackFacingTrianglesEXT = 16U;"
            "const uint gl_RayFlagsCullFrontFacingTrianglesNV = 32U;"
            "const uint gl_RayFlagsCullFrontFacingTrianglesEXT = 32U;"
            "const uint gl_RayFlagsCullOpaqueNV = 64U;"
            "const uint gl_RayFlagsCullOpaqueEXT = 64U;"
            "const uint gl_RayFlagsCullNoOpaqueNV = 128U;"
            "const uint gl_RayFlagsCullNoOpaqueEXT = 128U;"
            "const uint gl_RayFlagsSkipTrianglesEXT = 256U;"
            "const uint gl_RayFlagsSkipAABBEXT = 512U;"
            "const uint gl_HitKindFrontFacingTriangleEXT = 254U;"
            "const uint gl_HitKindBackFacingTriangleEXT = 255U;"
            "\n";
        const char *constRayQueryIntersection =
            "const uint gl_RayQueryCandidateIntersectionEXT = 0U;"
            "const uint gl_RayQueryCommittedIntersectionEXT = 1U;"
            "const uint gl_RayQueryCommittedIntersectionNoneEXT = 0U;"
            "const uint gl_RayQueryCommittedIntersectionTriangleEXT = 1U;"
            "const uint gl_RayQueryCommittedIntersectionGeneratedEXT = 2U;"
            "const uint gl_RayQueryCandidateIntersectionTriangleEXT = 0U;"
            "const uint gl_RayQueryCandidateIntersectionAABBEXT = 1U;"
            "\n";
        const char *rayGenDecls =
            "in    uvec3  gl_LaunchIDNV;"
            "in    uvec3  gl_LaunchIDEXT;"
            "in    uvec3  gl_LaunchSizeNV;"
            "in    uvec3  gl_LaunchSizeEXT;"
            "\n";
        const char *intersectDecls =
            "in    uvec3  gl_LaunchIDNV;"
            "in    uvec3  gl_LaunchIDEXT;"
            "in    uvec3  gl_LaunchSizeNV;"
            "in    uvec3  gl_LaunchSizeEXT;"
            "in     int   gl_PrimitiveID;"
            "in     int   gl_InstanceID;"
            "in     int   gl_InstanceCustomIndexNV;"
            "in     int   gl_InstanceCustomIndexEXT;"
            "in     int   gl_GeometryIndexEXT;"
            "in    vec3   gl_WorldRayOriginNV;"
            "in    vec3   gl_WorldRayOriginEXT;"
            "in    vec3   gl_WorldRayDirectionNV;"
            "in    vec3   gl_WorldRayDirectionEXT;"
            "in    vec3   gl_ObjectRayOriginNV;"
            "in    vec3   gl_ObjectRayOriginEXT;"
            "in    vec3   gl_ObjectRayDirectionNV;"
            "in    vec3   gl_ObjectRayDirectionEXT;"
            "in    float  gl_RayTminNV;"
            "in    float  gl_RayTminEXT;"
            "in    float  gl_RayTmaxNV;"
            "in    float  gl_RayTmaxEXT;"
            "in    mat4x3 gl_ObjectToWorldNV;"
            "in    mat4x3 gl_ObjectToWorldEXT;"
            "in    mat3x4 gl_ObjectToWorld3x4EXT;"
            "in    mat4x3 gl_WorldToObjectNV;"
            "in    mat4x3 gl_WorldToObjectEXT;"
            "in    mat3x4 gl_WorldToObject3x4EXT;"
            "in    uint   gl_IncomingRayFlagsNV;"
            "in    uint   gl_IncomingRayFlagsEXT;"
            "\n";
        const char *hitDecls =
            "in    uvec3  gl_LaunchIDNV;"
            "in    uvec3  gl_LaunchIDEXT;"
            "in    uvec3  gl_LaunchSizeNV;"
            "in    uvec3  gl_LaunchSizeEXT;"
            "in     int   gl_PrimitiveID;"
            "in     int   gl_InstanceID;"
            "in     int   gl_InstanceCustomIndexNV;"
            "in     int   gl_InstanceCustomIndexEXT;"
            "in     int   gl_GeometryIndexEXT;"
            "in    vec3   gl_WorldRayOriginNV;"
            "in    vec3   gl_WorldRayOriginEXT;"
            "in    vec3   gl_WorldRayDirectionNV;"
            "in    vec3   gl_WorldRayDirectionEXT;"
            "in    vec3   gl_ObjectRayOriginNV;"
            "in    vec3   gl_ObjectRayOriginEXT;"
            "in    vec3   gl_ObjectRayDirectionNV;"
            "in    vec3   gl_ObjectRayDirectionEXT;"
            "in    float  gl_RayTminNV;"
            "in    float  gl_RayTminEXT;"
            "in    float  gl_RayTmaxNV;"
            "in    float  gl_RayTmaxEXT;"
            "in    float  gl_HitTNV;"
            "in    float  gl_HitTEXT;"
            "in    uint   gl_HitKindNV;"
            "in    uint   gl_HitKindEXT;"
            "in    mat4x3 gl_ObjectToWorldNV;"
            "in    mat4x3 gl_ObjectToWorldEXT;"
            "in    mat3x4 gl_ObjectToWorld3x4EXT;"
            "in    mat4x3 gl_WorldToObjectNV;"
            "in    mat4x3 gl_WorldToObjectEXT;"
            "in    mat3x4 gl_WorldToObject3x4EXT;"
            "in    uint   gl_IncomingRayFlagsNV;"
            "in    uint   gl_IncomingRayFlagsEXT;"
            "\n";
        const char *missDecls =
            "in    uvec3  gl_LaunchIDNV;"
            "in    uvec3  gl_LaunchIDEXT;"
            "in    uvec3  gl_LaunchSizeNV;"
            "in    uvec3  gl_LaunchSizeEXT;"
            "in    vec3   gl_WorldRayOriginNV;"
            "in    vec3   gl_WorldRayOriginEXT;"
            "in    vec3   gl_WorldRayDirectionNV;"
            "in    vec3   gl_WorldRayDirectionEXT;"
            "in    vec3   gl_ObjectRayOriginNV;"
            "in    vec3   gl_ObjectRayDirectionNV;"
            "in    float  gl_RayTminNV;"
            "in    float  gl_RayTminEXT;"
            "in    float  gl_RayTmaxNV;"
            "in    float  gl_RayTmaxEXT;"
            "in    uint   gl_IncomingRayFlagsNV;"
            "in    uint   gl_IncomingRayFlagsEXT;"
            "\n";
        const char *callableDecls =
            "in    uvec3  gl_LaunchIDNV;"
            "in    uvec3  gl_LaunchIDEXT;"
            "in    uvec3  gl_LaunchSizeNV;"
            "in    uvec3  gl_LaunchSizeEXT;"
            "\n";
        stageBuiltins[EShLangRayGenNV].append(rayGenDecls);
        stageBuiltins[EShLangRayGenNV].append(constRayFlags);
-        stageBuiltins[EShLangIntersectNV].append(intersectDecls);
+        commonBuiltins.append(constRayQueryIntersection);
-        stageBuiltins[EShLangIntersectNV].append(constRayFlags);
+        commonBuiltins.append(constRayFlags);
-        stageBuiltins[EShLangAnyHitNV].append(hitDecls);
+        stageBuiltins[EShLangRayGen].append(rayGenDecls);
-        stageBuiltins[EShLangAnyHitNV].append(constRayFlags);
+        stageBuiltins[EShLangIntersect].append(intersectDecls);
-
+        stageBuiltins[EShLangAnyHit].append(hitDecls);
-        stageBuiltins[EShLangClosestHitNV].append(hitDecls);
+        stageBuiltins[EShLangClosestHit].append(hitDecls);
-        stageBuiltins[EShLangClosestHitNV].append(constRayFlags);
+        stageBuiltins[EShLangMiss].append(missDecls);
-
+        stageBuiltins[EShLangCallable].append(callableDecls);
        stageBuiltins[EShLangMissNV].append(missDecls);
        stageBuiltins[EShLangMissNV].append(constRayFlags);
        stageBuiltins[EShLangCallableNV].append(callableDecls);
        stageBuiltins[EShLangCallableNV].append(constRayFlags);
    }
    if ((profile != EEsProfile && version >= 140)) {
@@ -5507,11 +5608,11 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
            "in highp int gl_DeviceIndex;"     // GL_EXT_device_group
            "\n";
-        stageBuiltins[EShLangRayGenNV].append(deviceIndex);
+        stageBuiltins[EShLangRayGen].append(deviceIndex);
-        stageBuiltins[EShLangIntersectNV].append(deviceIndex);
+        stageBuiltins[EShLangIntersect].append(deviceIndex);
-        stageBuiltins[EShLangAnyHitNV].append(deviceIndex);
+        stageBuiltins[EShLangAnyHit].append(deviceIndex);
-        stageBuiltins[EShLangClosestHitNV].append(deviceIndex);
+        stageBuiltins[EShLangClosestHit].append(deviceIndex);
-        stageBuiltins[EShLangMissNV].append(deviceIndex);
+        stageBuiltins[EShLangMiss].append(deviceIndex);
    }
    if (version >= 300 /* both ES and non-ES */) {
@@ -5527,6 +5628,7 @@ void TBuiltIns::initialize(int version, EProfile profile, const SpvVersion& spvV
        commonBuiltins.append("const int gl_ScopeSubgroup    = 3;\n");
        commonBuiltins.append("const int gl_ScopeInvocation  = 4;\n");
        commonBuiltins.append("const int gl_ScopeQueueFamily = 5;\n");
        commonBuiltins.append("const int gl_ScopeShaderCallEXT = 6;\n");
        commonBuiltins.append("const int gl_SemanticsRelaxed         = 0x0;\n");
        commonBuiltins.append("const int gl_SemanticsAcquire         = 0x2;\n");
@@ -5723,7 +5825,7 @@ void TBuiltIns::addQueryFunctions(TSampler sampler, const TString& typeName, int
    return;
 #endif
-    if (sampler.isImage() && ((profile == EEsProfile && version < 310) || (profile != EEsProfile && version < 430)))
+    if (sampler.isImage() && ((profile == EEsProfile && version < 310) || (profile != EEsProfile && version < 420)))
        return;
    if (profile == EEsProfile)
@@ -6639,6 +6741,23 @@ void TBuiltIns::initialize(const TBuiltInResource &resources, int version, EProf
            }
        }
        if (version >= 320) {
            // tessellation
            snprintf(builtInConstant, maxSize, "const int gl_MaxTessControlImageUniforms = %d;", resources.maxTessControlImageUniforms);
            s.append(builtInConstant);
            snprintf(builtInConstant, maxSize, "const int gl_MaxTessEvaluationImageUniforms = %d;", resources.maxTessEvaluationImageUniforms);
            s.append(builtInConstant);
            snprintf(builtInConstant, maxSize, "const int gl_MaxTessControlAtomicCounters = %d;", resources.maxTessControlAtomicCounters);
            s.append(builtInConstant);
            snprintf(builtInConstant, maxSize, "const int gl_MaxTessEvaluationAtomicCounters = %d;", resources.maxTessEvaluationAtomicCounters);
            s.append(builtInConstant);
            snprintf(builtInConstant, maxSize, "const int gl_MaxTessControlAtomicCounterBuffers = %d;", resources.maxTessControlAtomicCounterBuffers);
            s.append(builtInConstant);
            snprintf(builtInConstant, maxSize, "const int gl_MaxTessEvaluationAtomicCounterBuffers = %d;", resources.maxTessEvaluationAtomicCounterBuffers);
            s.append(builtInConstant);
        }
    } else {
        // non-ES profile
@@ -7451,6 +7570,34 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
            BuiltInVariable("gl_FragStencilRefARB", EbvFragStencilRef, symbolTable);
        }
        if (profile != EEsProfile && version >= 460) {
            symbolTable.setFunctionExtensions("rayQueryInitializeEXT",                                            1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryTerminateEXT",                                             1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGenerateIntersectionEXT",                                  1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryConfirmIntersectionEXT",                                   1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryProceedEXT",                                               1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetIntersectionTypeEXT",                                   1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetIntersectionTEXT",                                      1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetRayFlagsEXT",                                           1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetRayTMinEXT",                                            1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetIntersectionInstanceCustomIndexEXT",                    1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetIntersectionInstanceIdEXT",                             1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT", 1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetIntersectionGeometryIndexEXT",                          1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetIntersectionPrimitiveIndexEXT",                         1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetIntersectionBarycentricsEXT",                           1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetIntersectionFrontFaceEXT",                              1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetIntersectionCandidateAABBOpaqueEXT",                    1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetIntersectionObjectRayDirectionEXT",                     1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetIntersectionObjectRayOriginEXT",                        1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetIntersectionObjectToWorldEXT",                          1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetIntersectionWorldToObjectEXT",                          1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetWorldRayOriginEXT",                                     1, &E_GL_EXT_ray_query);
            symbolTable.setFunctionExtensions("rayQueryGetWorldRayDirectionEXT",                                  1, &E_GL_EXT_ray_query);
            symbolTable.setVariableExtensions("gl_RayFlagsSkipAABBEXT",                         1, &E_GL_EXT_ray_flags_primitive_culling);
            symbolTable.setVariableExtensions("gl_RayFlagsSkipTrianglesEXT",                    1, &E_GL_EXT_ray_flags_primitive_culling);
        }
        if ((profile != EEsProfile && version >= 130) ||
            (profile == EEsProfile && version >= 310)) {
            BuiltInVariable("gl_SampleID",           EbvSampleId,       symbolTable);
@@ -7710,6 +7857,29 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
            symbolTable.setFunctionExtensions("imageAtomicCompSwap", 1, &E_GL_OES_shader_image_atomic);
        }
        if (profile != EEsProfile && version < 330 ) {
            symbolTable.setFunctionExtensions("floatBitsToInt", 1, &E_GL_ARB_shader_bit_encoding);
            symbolTable.setFunctionExtensions("floatBitsToUint", 1, &E_GL_ARB_shader_bit_encoding);
            symbolTable.setFunctionExtensions("intBitsToFloat", 1, &E_GL_ARB_shader_bit_encoding);
            symbolTable.setFunctionExtensions("uintBitsToFloat", 1, &E_GL_ARB_shader_bit_encoding);
        }
        if (profile != EEsProfile && version < 430 ) {
            symbolTable.setFunctionExtensions("imageSize", 1, &E_GL_ARB_shader_image_size);
        }
        // GL_ARB_shader_storage_buffer_object
        if (profile != EEsProfile && version < 430 ) {
            symbolTable.setFunctionExtensions("atomicAdd", 1, &E_GL_ARB_shader_storage_buffer_object);
            symbolTable.setFunctionExtensions("atomicMin", 1, &E_GL_ARB_shader_storage_buffer_object);
            symbolTable.setFunctionExtensions("atomicMax", 1, &E_GL_ARB_shader_storage_buffer_object);
            symbolTable.setFunctionExtensions("atomicAnd", 1, &E_GL_ARB_shader_storage_buffer_object);
            symbolTable.setFunctionExtensions("atomicOr", 1, &E_GL_ARB_shader_storage_buffer_object);
            symbolTable.setFunctionExtensions("atomicXor", 1, &E_GL_ARB_shader_storage_buffer_object);
            symbolTable.setFunctionExtensions("atomicExchange", 1, &E_GL_ARB_shader_storage_buffer_object);
            symbolTable.setFunctionExtensions("atomicCompSwap", 1, &E_GL_ARB_shader_storage_buffer_object);
        }
        symbolTable.setVariableExtensions("gl_DeviceIndex",  1, &E_GL_EXT_device_group);
        BuiltInVariable("gl_DeviceIndex", EbvDeviceIndex, symbolTable);
        symbolTable.setVariableExtensions("gl_ViewIndex", 1, &E_GL_EXT_multiview);
@@ -7922,6 +8092,7 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
        }
        symbolTable.setFunctionExtensions("controlBarrier",                 1, &E_GL_KHR_memory_scope_semantics);
        symbolTable.setFunctionExtensions("debugPrintfEXT",                 1, &E_GL_EXT_debug_printf);
        // GL_ARB_shader_ballot
        if (profile != EEsProfile) {
@@ -8011,48 +8182,96 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
        break;
 #ifndef GLSLANG_WEB
-    case EShLangRayGenNV:
+    case EShLangRayGen:
-    case EShLangIntersectNV:
+    case EShLangIntersect:
-    case EShLangAnyHitNV:
+    case EShLangAnyHit:
-    case EShLangClosestHitNV:
+    case EShLangClosestHit:
-    case EShLangMissNV:
+    case EShLangMiss:
-    case EShLangCallableNV:
+    case EShLangCallable:
        if (profile != EEsProfile && version >= 460) {
            const char *rtexts[] = { E_GL_NV_ray_tracing, E_GL_EXT_ray_tracing };
            symbolTable.setVariableExtensions("gl_LaunchIDNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setVariableExtensions("gl_LaunchIDEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setVariableExtensions("gl_LaunchSizeNV", 1, &E_GL_NV_ray_tracing);
-            symbolTable.setVariableExtensions("gl_PrimitiveID", 1, &E_GL_NV_ray_tracing);
+            symbolTable.setVariableExtensions("gl_LaunchSizeEXT", 1, &E_GL_EXT_ray_tracing);
-            symbolTable.setVariableExtensions("gl_InstanceID", 1, &E_GL_NV_ray_tracing);
+            symbolTable.setVariableExtensions("gl_PrimitiveID", 2, rtexts);
            symbolTable.setVariableExtensions("gl_InstanceID", 2, rtexts);
            symbolTable.setVariableExtensions("gl_InstanceCustomIndexNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setVariableExtensions("gl_InstanceCustomIndexEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setVariableExtensions("gl_GeometryIndexEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setVariableExtensions("gl_WorldRayOriginNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setVariableExtensions("gl_WorldRayOriginEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setVariableExtensions("gl_WorldRayDirectionNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setVariableExtensions("gl_WorldRayDirectionEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setVariableExtensions("gl_ObjectRayOriginNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setVariableExtensions("gl_ObjectRayOriginEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setVariableExtensions("gl_ObjectRayDirectionNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setVariableExtensions("gl_ObjectRayDirectionEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setVariableExtensions("gl_RayTminNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setVariableExtensions("gl_RayTminEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setVariableExtensions("gl_RayTmaxNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setVariableExtensions("gl_RayTmaxEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setVariableExtensions("gl_HitTNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setVariableExtensions("gl_HitTEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setVariableExtensions("gl_HitKindNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setVariableExtensions("gl_HitKindEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setVariableExtensions("gl_ObjectToWorldNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setVariableExtensions("gl_ObjectToWorldEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setVariableExtensions("gl_ObjectToWorld3x4EXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setVariableExtensions("gl_WorldToObjectNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setVariableExtensions("gl_WorldToObjectEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setVariableExtensions("gl_WorldToObject3x4EXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setVariableExtensions("gl_IncomingRayFlagsNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setVariableExtensions("gl_IncomingRayFlagsEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setVariableExtensions("gl_DeviceIndex", 1, &E_GL_EXT_device_group);
-            BuiltInVariable("gl_LaunchIDNV",            EbvLaunchIdNV,           symbolTable);
+
-            BuiltInVariable("gl_LaunchSizeNV",          EbvLaunchSizeNV,         symbolTable);
+            symbolTable.setFunctionExtensions("traceNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setFunctionExtensions("traceRayEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setFunctionExtensions("reportIntersectionNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setFunctionExtensions("reportIntersectionEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setFunctionExtensions("ignoreIntersectionNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setFunctionExtensions("ignoreIntersectionEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setFunctionExtensions("terminateRayNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setFunctionExtensions("terminateRayEXT", 1, &E_GL_EXT_ray_tracing);
            symbolTable.setFunctionExtensions("executeCallableNV", 1, &E_GL_NV_ray_tracing);
            symbolTable.setFunctionExtensions("executeCallableEXT", 1, &E_GL_EXT_ray_tracing);
            BuiltInVariable("gl_LaunchIDNV",             EbvLaunchId,           symbolTable);
            BuiltInVariable("gl_LaunchIDEXT",            EbvLaunchId,           symbolTable);
            BuiltInVariable("gl_LaunchSizeNV",           EbvLaunchSize,         symbolTable);
            BuiltInVariable("gl_LaunchSizeEXT",          EbvLaunchSize,         symbolTable);
            BuiltInVariable("gl_PrimitiveID",            EbvPrimitiveId,        symbolTable);
            BuiltInVariable("gl_InstanceID",             EbvInstanceId,         symbolTable);
-            BuiltInVariable("gl_InstanceCustomIndexNV", EbvInstanceCustomIndexNV,symbolTable);
+            BuiltInVariable("gl_InstanceCustomIndexNV",  EbvInstanceCustomIndex,symbolTable);
-            BuiltInVariable("gl_WorldRayOriginNV",      EbvWorldRayOriginNV,     symbolTable);
+            BuiltInVariable("gl_InstanceCustomIndexEXT", EbvInstanceCustomIndex,symbolTable);
-            BuiltInVariable("gl_WorldRayDirectionNV",   EbvWorldRayDirectionNV,  symbolTable);
+            BuiltInVariable("gl_GeometryIndexEXT",       EbvGeometryIndex,      symbolTable);
-            BuiltInVariable("gl_ObjectRayOriginNV",     EbvObjectRayOriginNV,    symbolTable);
+            BuiltInVariable("gl_WorldRayOriginNV",       EbvWorldRayOrigin,     symbolTable);
-            BuiltInVariable("gl_ObjectRayDirectionNV",  EbvObjectRayDirectionNV, symbolTable);
+            BuiltInVariable("gl_WorldRayOriginEXT",      EbvWorldRayOrigin,     symbolTable);
-            BuiltInVariable("gl_RayTminNV",             EbvRayTminNV,            symbolTable);
+            BuiltInVariable("gl_WorldRayDirectionNV",    EbvWorldRayDirection,  symbolTable);
-            BuiltInVariable("gl_RayTmaxNV",             EbvRayTmaxNV,            symbolTable);
+            BuiltInVariable("gl_WorldRayDirectionEXT",   EbvWorldRayDirection,  symbolTable);
-            BuiltInVariable("gl_HitTNV",                EbvHitTNV,               symbolTable);
+            BuiltInVariable("gl_ObjectRayOriginNV",      EbvObjectRayOrigin,    symbolTable);
-            BuiltInVariable("gl_HitKindNV",             EbvHitKindNV,            symbolTable);
+            BuiltInVariable("gl_ObjectRayOriginEXT",     EbvObjectRayOrigin,    symbolTable);
-            BuiltInVariable("gl_ObjectToWorldNV",       EbvObjectToWorldNV,      symbolTable);
+            BuiltInVariable("gl_ObjectRayDirectionNV",   EbvObjectRayDirection, symbolTable);
-            BuiltInVariable("gl_WorldToObjectNV",       EbvWorldToObjectNV,      symbolTable);
+            BuiltInVariable("gl_ObjectRayDirectionEXT",  EbvObjectRayDirection, symbolTable);
-            BuiltInVariable("gl_IncomingRayFlagsNV",    EbvIncomingRayFlagsNV,   symbolTable);
+            BuiltInVariable("gl_RayTminNV",              EbvRayTmin,            symbolTable);
            BuiltInVariable("gl_RayTminEXT",             EbvRayTmin,            symbolTable);
            BuiltInVariable("gl_RayTmaxNV",              EbvRayTmax,            symbolTable);
            BuiltInVariable("gl_RayTmaxEXT",             EbvRayTmax,            symbolTable);
            BuiltInVariable("gl_HitTNV",                 EbvHitT,               symbolTable);
            BuiltInVariable("gl_HitTEXT",                EbvHitT,               symbolTable);
            BuiltInVariable("gl_HitKindNV",              EbvHitKind,            symbolTable);
            BuiltInVariable("gl_HitKindEXT",             EbvHitKind,            symbolTable);
            BuiltInVariable("gl_ObjectToWorldNV",        EbvObjectToWorld,      symbolTable);
            BuiltInVariable("gl_ObjectToWorldEXT",       EbvObjectToWorld,      symbolTable);
            BuiltInVariable("gl_ObjectToWorld3x4EXT",    EbvObjectToWorld3x4,   symbolTable);
            BuiltInVariable("gl_WorldToObjectNV",        EbvWorldToObject,      symbolTable);
            BuiltInVariable("gl_WorldToObjectEXT",       EbvWorldToObject,      symbolTable);
            BuiltInVariable("gl_WorldToObject3x4EXT",    EbvWorldToObject3x4,   symbolTable);
            BuiltInVariable("gl_IncomingRayFlagsNV",     EbvIncomingRayFlags,   symbolTable);
            BuiltInVariable("gl_IncomingRayFlagsEXT",    EbvIncomingRayFlags,   symbolTable);
            BuiltInVariable("gl_DeviceIndex",            EbvDeviceIndex,        symbolTable);
            // GL_ARB_shader_ballot
@@ -8470,6 +8689,8 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
    symbolTable.relateToOperator("average",            EOpAverage);
    symbolTable.relateToOperator("averageRounded",     EOpAverageRounded);
    symbolTable.relateToOperator("multiply32x16",      EOpMul32x16);
    symbolTable.relateToOperator("debugPrintfEXT",     EOpDebugPrintf);
    if (PureOperatorBuiltins) {
        symbolTable.relateToOperator("imageSize",               EOpImageQuerySize);
@@ -8768,6 +8989,33 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
            symbolTable.relateToOperator("dFdyCoarse",   EOpDPdyCoarse);
            symbolTable.relateToOperator("fwidthCoarse", EOpFwidthCoarse);
        }
        if (profile != EEsProfile && version >= 460) {
            symbolTable.relateToOperator("rayQueryInitializeEXT",                                             EOpRayQueryInitialize);
            symbolTable.relateToOperator("rayQueryTerminateEXT",                                              EOpRayQueryTerminate);
            symbolTable.relateToOperator("rayQueryGenerateIntersectionEXT",                                   EOpRayQueryGenerateIntersection);
            symbolTable.relateToOperator("rayQueryConfirmIntersectionEXT",                                    EOpRayQueryConfirmIntersection);
            symbolTable.relateToOperator("rayQueryProceedEXT",                                                EOpRayQueryProceed);
            symbolTable.relateToOperator("rayQueryGetIntersectionTypeEXT",                                    EOpRayQueryGetIntersectionType);
            symbolTable.relateToOperator("rayQueryGetRayTMinEXT",                                             EOpRayQueryGetRayTMin);
            symbolTable.relateToOperator("rayQueryGetRayFlagsEXT",                                            EOpRayQueryGetRayFlags);
            symbolTable.relateToOperator("rayQueryGetIntersectionTEXT",                                       EOpRayQueryGetIntersectionT);
            symbolTable.relateToOperator("rayQueryGetIntersectionInstanceCustomIndexEXT",                     EOpRayQueryGetIntersectionInstanceCustomIndex);
            symbolTable.relateToOperator("rayQueryGetIntersectionInstanceIdEXT",                              EOpRayQueryGetIntersectionInstanceId);
            symbolTable.relateToOperator("rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT",  EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset);
            symbolTable.relateToOperator("rayQueryGetIntersectionGeometryIndexEXT",                           EOpRayQueryGetIntersectionGeometryIndex);
            symbolTable.relateToOperator("rayQueryGetIntersectionPrimitiveIndexEXT",                          EOpRayQueryGetIntersectionPrimitiveIndex);
            symbolTable.relateToOperator("rayQueryGetIntersectionBarycentricsEXT",                            EOpRayQueryGetIntersectionBarycentrics);
            symbolTable.relateToOperator("rayQueryGetIntersectionFrontFaceEXT",                               EOpRayQueryGetIntersectionFrontFace);
            symbolTable.relateToOperator("rayQueryGetIntersectionCandidateAABBOpaqueEXT",                     EOpRayQueryGetIntersectionCandidateAABBOpaque);
            symbolTable.relateToOperator("rayQueryGetIntersectionObjectRayDirectionEXT",                      EOpRayQueryGetIntersectionObjectRayDirection);
            symbolTable.relateToOperator("rayQueryGetIntersectionObjectRayOriginEXT",                         EOpRayQueryGetIntersectionObjectRayOrigin);
            symbolTable.relateToOperator("rayQueryGetWorldRayDirectionEXT",                                   EOpRayQueryGetWorldRayDirection);
            symbolTable.relateToOperator("rayQueryGetWorldRayOriginEXT",                                      EOpRayQueryGetWorldRayOrigin);
            symbolTable.relateToOperator("rayQueryGetIntersectionObjectToWorldEXT",                           EOpRayQueryGetIntersectionObjectToWorld);
            symbolTable.relateToOperator("rayQueryGetIntersectionWorldToObjectEXT",                           EOpRayQueryGetIntersectionWorldToObject);
        }
        symbolTable.relateToOperator("interpolateAtCentroid", EOpInterpolateAtCentroid);
        symbolTable.relateToOperator("interpolateAtSample",   EOpInterpolateAtSample);
        symbolTable.relateToOperator("interpolateAtOffset",   EOpInterpolateAtOffset);
@@ -8799,27 +9047,34 @@ void TBuiltIns::identifyBuiltIns(int version, EProfile profile, const SpvVersion
        symbolTable.relateToOperator("coopMatMulAddNV",            EOpCooperativeMatrixMulAdd);
        break;
-    case EShLangRayGenNV:
+    case EShLangRayGen:
-    case EShLangClosestHitNV:
+    case EShLangClosestHit:
-    case EShLangMissNV:
+    case EShLangMiss:
        if (profile != EEsProfile && version >= 460) {
-            symbolTable.relateToOperator("traceNV", EOpTraceNV);
+            symbolTable.relateToOperator("traceNV", EOpTrace);
-            symbolTable.relateToOperator("executeCallableNV", EOpExecuteCallableNV);
+            symbolTable.relateToOperator("traceRayEXT", EOpTrace);
            symbolTable.relateToOperator("executeCallableNV", EOpExecuteCallable);
            symbolTable.relateToOperator("executeCallableEXT", EOpExecuteCallable);
        }
        break;
-    case EShLangIntersectNV:
+    case EShLangIntersect:
        if (profile != EEsProfile && version >= 460)
            symbolTable.relateToOperator("reportIntersectionNV", EOpReportIntersectionNV);
        break;
    case EShLangAnyHitNV:
        if (profile != EEsProfile && version >= 460) {
-            symbolTable.relateToOperator("ignoreIntersectionNV", EOpIgnoreIntersectionNV);
+            symbolTable.relateToOperator("reportIntersectionNV", EOpReportIntersection);
-            symbolTable.relateToOperator("terminateRayNV", EOpTerminateRayNV);
+            symbolTable.relateToOperator("reportIntersectionEXT", EOpReportIntersection);
 	}
        break;
-    case EShLangCallableNV:
+    case EShLangAnyHit:
        if (profile != EEsProfile && version >= 460) {
-            symbolTable.relateToOperator("executeCallableNV", EOpExecuteCallableNV);
+            symbolTable.relateToOperator("ignoreIntersectionNV", EOpIgnoreIntersection);
            symbolTable.relateToOperator("ignoreIntersectionEXT", EOpIgnoreIntersection);
            symbolTable.relateToOperator("terminateRayNV", EOpTerminateRay);
            symbolTable.relateToOperator("terminateRayEXT", EOpTerminateRay);
        }
        break;
    case EShLangCallable:
        if (profile != EEsProfile && version >= 460) {
            symbolTable.relateToOperator("executeCallableNV", EOpExecuteCallable);
            symbolTable.relateToOperator("executeCallableEXT", EOpExecuteCallable);
        }
        break;
    case EShLangMeshNV:
@@ -1,7 +1,7 @@
 //
 // Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
 // Copyright (C) 2012-2015 LunarG, Inc.
-// Copyright (C) 2015-2018 Google, Inc.
+// Copyright (C) 2015-2020 Google, Inc.
 // Copyright (C) 2017 ARM Limited.
 //
 // All rights reserved.
@@ -538,7 +538,7 @@ bool TIntermediate::isConversionAllowed(TOperator op, TIntermTyped* node) const
        return false;
    case EbtAtomicUint:
    case EbtSampler:
-    case EbtAccStructNV:
+    case EbtAccStruct:
        // opaque types can be passed to functions
        if (op == EOpFunction)
            break;
@@ -2774,6 +2774,9 @@ bool TIntermediate::postProcess(TIntermNode* root, EShLanguage /*language*/)
    case EShTexSampTransUpgradeTextureRemoveSampler:
        performTextureUpgradeAndSamplerRemovalTransformation(root);
        break;
    case EShTexSampTransCount:
        assert(0);
        break;
    }
 #endif
@@ -3234,10 +3237,17 @@ bool TIntermediate::promoteUnary(TIntermUnary& node)
            return false;
        break;
    default:
-        if (operand->getBasicType() != EbtFloat)
+        // HLSL uses this path for initial function signature finding for built-ins
        // taking a single argument, which generally don't participate in
        // operator-based type promotion (type conversion will occur later).
        // For now, scalar argument cases are relying on the setType() call below.
        if (getSource() == EShSourceHlsl)
            break;
        // GLSL only allows integer arguments for the cases identified above in the
        // case statements.
        if (operand->getBasicType() != EbtFloat)
            return false;
    }
@@ -157,11 +157,11 @@ bool TParseContextBase::lValueErrorCheck(const TSourceLoc& loc, const char* op,
    case EvqBuffer:
        if (node->getQualifier().isReadOnly())
            message = "can't modify a readonly buffer";
-        if (node->getQualifier().isShaderRecordNV())
+        if (node->getQualifier().isShaderRecord())
            message = "can't modify a shaderrecordnv qualified buffer";
        break;
-    case EvqHitAttrNV:
+    case EvqHitAttr:
-        if (language != EShLangIntersectNV)
+        if (language != EShLangIntersect)
            message = "cannot modify hitAttributeNV in this stage";
        break;
 #endif
@@ -181,9 +181,12 @@ bool TParseContextBase::lValueErrorCheck(const TSourceLoc& loc, const char* op,
        case EbtAtomicUint:
            message = "can't modify an atomic_uint";
            break;
-        case EbtAccStructNV:
+        case EbtAccStruct:
            message = "can't modify accelerationStructureNV";
            break;
        case EbtRayQuery:
            message = "can't modify rayQueryEXT";
            break;
 #endif
        default:
            break;
@@ -3,6 +3,7 @@
 // Copyright (C) 2012-2015 LunarG, Inc.
 // Copyright (C) 2015-2018 Google, Inc.
 // Copyright (C) 2017, 2019 ARM Limited.
 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -1353,6 +1354,9 @@ void TParseContext::computeBuiltinPrecisions(TIntermTyped& node, const TFunction
        case EOpInterpolateAtSample:
            numArgs = 1;
            break;
        case EOpDebugPrintf:
            numArgs = 0;
            break;
        default:
            break;
        }
@@ -1672,6 +1676,9 @@ void TParseContext::memorySemanticsCheck(const TSourceLoc& loc, const TFunction&
    unsigned int semantics = 0, storageClassSemantics = 0;
    unsigned int semantics2 = 0, storageClassSemantics2 = 0;
    const TIntermTyped* arg0 = (*argp)[0]->getAsTyped();
    const bool isMS = arg0->getBasicType() == EbtSampler && arg0->getType().getSampler().isMultiSample();
    // Grab the semantics and storage class semantics from the operands, based on opcode
    switch (callNode.getOp()) {
    case EOpAtomicAdd:
@@ -1704,18 +1711,18 @@ void TParseContext::memorySemanticsCheck(const TSourceLoc& loc, const TFunction&
    case EOpImageAtomicXor:
    case EOpImageAtomicExchange:
    case EOpImageAtomicStore:
-        storageClassSemantics = (*argp)[4]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        storageClassSemantics = (*argp)[isMS ? 5 : 4]->getAsConstantUnion()->getConstArray()[0].getIConst();
-        semantics = (*argp)[5]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics = (*argp)[isMS ? 6 : 5]->getAsConstantUnion()->getConstArray()[0].getIConst();
        break;
    case EOpImageAtomicLoad:
-        storageClassSemantics = (*argp)[3]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        storageClassSemantics = (*argp)[isMS ? 4 : 3]->getAsConstantUnion()->getConstArray()[0].getIConst();
-        semantics = (*argp)[4]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics = (*argp)[isMS ? 5 : 4]->getAsConstantUnion()->getConstArray()[0].getIConst();
        break;
    case EOpImageAtomicCompSwap:
-        storageClassSemantics = (*argp)[5]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        storageClassSemantics = (*argp)[isMS ? 6 : 5]->getAsConstantUnion()->getConstArray()[0].getIConst();
-        semantics = (*argp)[6]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics = (*argp)[isMS ? 7 : 6]->getAsConstantUnion()->getConstArray()[0].getIConst();
-        storageClassSemantics2 = (*argp)[7]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        storageClassSemantics2 = (*argp)[isMS ? 8 : 7]->getAsConstantUnion()->getConstArray()[0].getIConst();
-        semantics2 = (*argp)[8]->getAsConstantUnion()->getConstArray()[0].getIConst();
+        semantics2 = (*argp)[isMS ? 9 : 8]->getAsConstantUnion()->getConstArray()[0].getIConst();
        break;
    case EOpBarrier:
@@ -2006,18 +2013,20 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
        if (arg > 0) {
 #ifndef GLSLANG_WEB
-            bool f16ShadowCompare = (*argp)[1]->getAsTyped()->getBasicType() == EbtFloat16 && arg0->getType().getSampler().shadow;
+            bool f16ShadowCompare = (*argp)[1]->getAsTyped()->getBasicType() == EbtFloat16 &&
                                    arg0->getType().getSampler().shadow;
            if (f16ShadowCompare)
                ++arg;
 #endif
-            if (! (*argp)[arg]->getAsConstantUnion())
+            if (! (*argp)[arg]->getAsTyped()->getQualifier().isConstant())
                error(loc, "argument must be compile-time constant", "texel offset", "");
-            else {
+            else if ((*argp)[arg]->getAsConstantUnion()) {
                const TType& type = (*argp)[arg]->getAsTyped()->getType();
                for (int c = 0; c < type.getVectorSize(); ++c) {
                    int offset = (*argp)[arg]->getAsConstantUnion()->getConstArray()[c].getIConst();
                    if (offset > resources.maxProgramTexelOffset || offset < resources.minProgramTexelOffset)
-                        error(loc, "value is out of range:", "texel offset", "[gl_MinProgramTexelOffset, gl_MaxProgramTexelOffset]");
+                        error(loc, "value is out of range:", "texel offset",
                              "[gl_MinProgramTexelOffset, gl_MaxProgramTexelOffset]");
                }
            }
        }
@@ -2026,15 +2035,32 @@ void TParseContext::builtInOpCheck(const TSourceLoc& loc, const TFunction& fnCan
    }
 #ifndef GLSLANG_WEB
-    case EOpTraceNV:
+    case EOpTrace:
        if (!(*argp)[10]->getAsConstantUnion())
            error(loc, "argument must be compile-time constant", "payload number", "");
        break;
-    case EOpExecuteCallableNV:
+    case EOpExecuteCallable:
        if (!(*argp)[1]->getAsConstantUnion())
            error(loc, "argument must be compile-time constant", "callable data number", "");
        break;
    case EOpRayQueryGetIntersectionType:
    case EOpRayQueryGetIntersectionT:
    case EOpRayQueryGetIntersectionInstanceCustomIndex:
    case EOpRayQueryGetIntersectionInstanceId:
    case EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset:
    case EOpRayQueryGetIntersectionGeometryIndex:
    case EOpRayQueryGetIntersectionPrimitiveIndex:
    case EOpRayQueryGetIntersectionBarycentrics:
    case EOpRayQueryGetIntersectionFrontFace:
    case EOpRayQueryGetIntersectionObjectRayDirection:
    case EOpRayQueryGetIntersectionObjectRayOrigin:
    case EOpRayQueryGetIntersectionObjectToWorld:
    case EOpRayQueryGetIntersectionWorldToObject:
        if (!(*argp)[1]->getAsConstantUnion())
            error(loc, "argument must be compile-time constant", "committed", "");
        break;
    case EOpTextureQuerySamples:
    case EOpImageQuerySamples:
        // GL_ARB_shader_texture_image_samples
@@ -3083,7 +3109,7 @@ bool TParseContext::constructorError(const TSourceLoc& loc, TIntermNode* node, T
        error(loc, "constructor argument does not have a type", "constructor", "");
        return true;
    }
-    if (op != EOpConstructStruct && typed->getBasicType() == EbtSampler) {
+    if (op != EOpConstructStruct && op != EOpConstructNonuniform && typed->getBasicType() == EbtSampler) {
        error(loc, "cannot convert a sampler", "constructor", "");
        return true;
    }
@@ -3128,7 +3154,7 @@ bool TParseContext::constructorTextureSamplerError(const TSourceLoc& loc, const
    if (function[0].type->getBasicType() != EbtSampler ||
        ! function[0].type->getSampler().isTexture() ||
        function[0].type->isArray()) {
-        error(loc, "sampler-constructor first argument must be a scalar textureXXX type", token, "");
+        error(loc, "sampler-constructor first argument must be a scalar *texture* type", token, "");
        return true;
    }
    // simulate the first argument's impact on the result type, so it can be compared with the encapsulated operator!=()
@@ -3136,7 +3162,8 @@ bool TParseContext::constructorTextureSamplerError(const TSourceLoc& loc, const
    texture.setCombined(false);
    texture.shadow = false;
    if (texture != function[0].type->getSampler()) {
-        error(loc, "sampler-constructor first argument must match type and dimensionality of constructor type", token, "");
+        error(loc, "sampler-constructor first argument must be a *texture* type"
                   " matching the dimensionality and sampled type of the constructor", token, "");
        return true;
    }
@@ -3146,7 +3173,7 @@ bool TParseContext::constructorTextureSamplerError(const TSourceLoc& loc, const
    if (  function[1].type->getBasicType() != EbtSampler ||
        ! function[1].type->getSampler().isPureSampler() ||
          function[1].type->isArray()) {
-        error(loc, "sampler-constructor second argument must be a scalar type 'sampler'", token, "");
+        error(loc, "sampler-constructor second argument must be a scalar sampler or samplerShadow", token, "");
        return true;
    }
@@ -3222,14 +3249,14 @@ void TParseContext::atomicUintCheck(const TSourceLoc& loc, const TType& type, co
        error(loc, "atomic_uints can only be used in uniform variables or function parameters:", type.getBasicTypeString().c_str(), identifier.c_str());
 }
-void TParseContext::accStructNVCheck(const TSourceLoc& loc, const TType& type, const TString& identifier)
+void TParseContext::accStructCheck(const TSourceLoc& loc, const TType& type, const TString& identifier)
 {
    if (type.getQualifier().storage == EvqUniform)
        return;
-    if (type.getBasicType() == EbtStruct && containsFieldWithBasicType(type, EbtAccStructNV))
+    if (type.getBasicType() == EbtStruct && containsFieldWithBasicType(type, EbtAccStruct))
        error(loc, "non-uniform struct contains an accelerationStructureNV:", type.getBasicTypeString().c_str(), identifier.c_str());
-    else if (type.getBasicType() == EbtAccStructNV && type.getQualifier().storage != EvqUniform)
+    else if (type.getBasicType() == EbtAccStruct && type.getQualifier().storage != EvqUniform)
        error(loc, "accelerationStructureNV can only be used in uniform variables or function parameters:",
            type.getBasicTypeString().c_str(), identifier.c_str());
@@ -3513,12 +3540,14 @@ void TParseContext::mergeQualifiers(const TSourceLoc& loc, TQualifier& dst, cons
        dst.precision = src.precision;
 #ifndef GLSLANG_WEB
-    if (!force && ((src.coherent && (dst.devicecoherent || dst.queuefamilycoherent || dst.workgroupcoherent || dst.subgroupcoherent)) ||
+    if (!force && ((src.coherent && (dst.devicecoherent || dst.queuefamilycoherent || dst.workgroupcoherent || dst.subgroupcoherent || dst.shadercallcoherent)) ||
-                   (src.devicecoherent && (dst.coherent || dst.queuefamilycoherent || dst.workgroupcoherent || dst.subgroupcoherent)) ||
+                   (src.devicecoherent && (dst.coherent || dst.queuefamilycoherent || dst.workgroupcoherent || dst.subgroupcoherent || dst.shadercallcoherent)) ||
-                   (src.queuefamilycoherent && (dst.coherent || dst.devicecoherent || dst.workgroupcoherent || dst.subgroupcoherent)) ||
+                   (src.queuefamilycoherent && (dst.coherent || dst.devicecoherent || dst.workgroupcoherent || dst.subgroupcoherent || dst.shadercallcoherent)) ||
-                   (src.workgroupcoherent && (dst.coherent || dst.devicecoherent || dst.queuefamilycoherent || dst.subgroupcoherent)) ||
+                   (src.workgroupcoherent && (dst.coherent || dst.devicecoherent || dst.queuefamilycoherent || dst.subgroupcoherent || dst.shadercallcoherent)) ||
-                   (src.subgroupcoherent  && (dst.coherent || dst.devicecoherent || dst.queuefamilycoherent || dst.workgroupcoherent)))) {
+                   (src.subgroupcoherent  && (dst.coherent || dst.devicecoherent || dst.queuefamilycoherent || dst.workgroupcoherent || dst.shadercallcoherent)) ||
-        error(loc, "only one coherent/devicecoherent/queuefamilycoherent/workgroupcoherent/subgroupcoherent qualifier allowed", GetPrecisionQualifierString(src.precision), "");
+                   (src.shadercallcoherent && (dst.coherent || dst.devicecoherent || dst.queuefamilycoherent || dst.workgroupcoherent || dst.subgroupcoherent)))) {
        error(loc, "only one coherent/devicecoherent/queuefamilycoherent/workgroupcoherent/subgroupcoherent/shadercallcoherent qualifier allowed", 
            GetPrecisionQualifierString(src.precision), "");
    }
 #endif
    // Layout qualifiers
@@ -3546,6 +3575,7 @@ void TParseContext::mergeQualifiers(const TSourceLoc& loc, TQualifier& dst, cons
    MERGE_SINGLETON(queuefamilycoherent);
    MERGE_SINGLETON(workgroupcoherent);
    MERGE_SINGLETON(subgroupcoherent);
    MERGE_SINGLETON(shadercallcoherent);
    MERGE_SINGLETON(nonprivate);
    MERGE_SINGLETON(volatil);
    MERGE_SINGLETON(restrict);
@@ -3983,7 +4013,7 @@ void TParseContext::checkRuntimeSizable(const TSourceLoc& loc, const TIntermType
    }
    // check for additional things allowed by GL_EXT_nonuniform_qualifier
-    if (base.getBasicType() == EbtSampler || base.getBasicType() == EbtAccStructNV ||
+    if (base.getBasicType() == EbtSampler || base.getBasicType() == EbtAccStruct || base.getBasicType() == EbtRayQuery ||
        (base.getBasicType() == EbtBlock && base.getType().getQualifier().isUniformOrBuffer()))
        requireExtensions(loc, 1, &E_GL_EXT_nonuniform_qualifier, "variable index");
    else
@@ -4487,6 +4517,7 @@ void TParseContext::paramCheckFix(const TSourceLoc& loc, const TQualifier& quali
        type.getQualifier().queuefamilycoherent  = qualifier.queuefamilycoherent;
        type.getQualifier().workgroupcoherent  = qualifier.workgroupcoherent;
        type.getQualifier().subgroupcoherent  = qualifier.subgroupcoherent;
        type.getQualifier().shadercallcoherent = qualifier.shadercallcoherent;
        type.getQualifier().nonprivate = qualifier.nonprivate;
        type.getQualifier().readonly  = qualifier.readonly;
        type.getQualifier().writeonly = qualifier.writeonly;
@@ -4868,7 +4899,7 @@ void TParseContext::setLayoutQualifier(const TSourceLoc& loc, TPublicType& publi
 #ifndef GLSLANG_WEB
    if (id == TQualifier::getLayoutPackingString(ElpStd430)) {
        requireProfile(loc, EEsProfile | ECoreProfile | ECompatibilityProfile, "std430");
-        profileRequires(loc, ECoreProfile | ECompatibilityProfile, 430, nullptr, "std430");
+        profileRequires(loc, ECoreProfile | ECompatibilityProfile, 430, E_GL_ARB_shader_storage_buffer_object, "std430");
        profileRequires(loc, EEsProfile, 310, nullptr, "std430");
        publicType.qualifier.layoutPacking = ElpStd430;
        return;
@@ -5067,13 +5098,19 @@ void TParseContext::setLayoutQualifier(const TSourceLoc& loc, TPublicType& publi
            return;
        }
    } else {
-        if (language == EShLangRayGenNV || language == EShLangIntersectNV ||
+        if (language == EShLangRayGen || language == EShLangIntersect ||
-        language == EShLangAnyHitNV || language == EShLangClosestHitNV ||
+        language == EShLangAnyHit || language == EShLangClosestHit ||
-        language == EShLangMissNV || language == EShLangCallableNV) {
+        language == EShLangMiss || language == EShLangCallable) {
            if (id == "shaderrecordnv" || id == "shaderrecordext") {
                if (id == "shaderrecordnv") {
-                publicType.qualifier.layoutShaderRecordNV = true;
+                    requireExtensions(loc, 1, &E_GL_NV_ray_tracing, "shader record NV");
                } else {
                    requireExtensions(loc, 1, &E_GL_EXT_ray_tracing, "shader record EXT");
                }
                publicType.qualifier.layoutShaderRecord = true;
                return;
            }
        }
    }
    if (language == EShLangCompute) {
@@ -5135,6 +5172,7 @@ void TParseContext::setLayoutQualifier(const TSourceLoc& loc, TPublicType& publi
            profileRequires(loc, EEsProfile, 310, nullptr, feature);
        }
        publicType.qualifier.layoutOffset = value;
        publicType.qualifier.explicitOffset = true;
        if (nonLiteral)
            error(loc, "needs a literal integer", "offset", "");
        return;
@@ -5514,8 +5552,8 @@ void TParseContext::mergeObjectLayoutQualifiers(TQualifier& dst, const TQualifie
            dst.layoutViewportRelative = true;
        if (src.layoutSecondaryViewportRelativeOffset != -2048)
            dst.layoutSecondaryViewportRelativeOffset = src.layoutSecondaryViewportRelativeOffset;
-        if (src.layoutShaderRecordNV)
+        if (src.layoutShaderRecord)
-            dst.layoutShaderRecordNV = true;
+            dst.layoutShaderRecord = true;
        if (src.pervertexNV)
            dst.pervertexNV = true;
 #endif
@@ -5583,7 +5621,7 @@ void TParseContext::layoutObjectCheck(const TSourceLoc& loc, const TSymbol& symb
                    error(loc, "cannot specify on a variable declaration", "align", "");
                if (qualifier.isPushConstant())
                    error(loc, "can only specify on a uniform block", "push_constant", "");
-                if (qualifier.isShaderRecordNV())
+                if (qualifier.isShaderRecord())
                    error(loc, "can only specify on a buffer block", "shaderRecordNV", "");
            }
            break;
@@ -5657,11 +5695,11 @@ void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type)
                error(loc, "cannot apply to uniform or buffer block", "location", "");
            break;
 #ifndef GLSLANG_WEB
-        case EvqPayloadNV:
+        case EvqPayload:
-        case EvqPayloadInNV:
+        case EvqPayloadIn:
-        case EvqHitAttrNV:
+        case EvqHitAttr:
-        case EvqCallableDataNV:
+        case EvqCallableData:
-        case EvqCallableDataInNV:
+        case EvqCallableDataIn:
            break;
 #endif
        default:
@@ -5756,7 +5794,7 @@ void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type)
        if (spvVersion.spv > 0) {
            if (qualifier.isUniformOrBuffer()) {
                if (type.getBasicType() == EbtBlock && !qualifier.isPushConstant() &&
-                       !qualifier.isShaderRecordNV() &&
+                       !qualifier.isShaderRecord() &&
                       !qualifier.hasAttachment() &&
                       !qualifier.hasBufferReference())
                    error(loc, "uniform/buffer blocks require layout(binding=X)", "binding", "");
@@ -5813,7 +5851,7 @@ void TParseContext::layoutTypeCheck(const TSourceLoc& loc, const TType& type)
    if (qualifier.hasBufferReference() && type.getBasicType() != EbtBlock)
        error(loc, "can only be used with a block", "buffer_reference", "");
-    if (qualifier.isShaderRecordNV() && type.getBasicType() != EbtBlock)
+    if (qualifier.isShaderRecord() && type.getBasicType() != EbtBlock)
        error(loc, "can only be used with a block", "shaderRecordNV", "");
    // input attachment
@@ -5958,7 +5996,7 @@ void TParseContext::layoutQualifierCheck(const TSourceLoc& loc, const TQualifier
        if (qualifier.storage != EvqBuffer)
            error(loc, "can only be used with buffer", "buffer_reference", "");
    }
-    if (qualifier.isShaderRecordNV()) {
+    if (qualifier.isShaderRecord()) {
        if (qualifier.storage != EvqBuffer)
            error(loc, "can only be used with a buffer", "shaderRecordNV", "");
        if (qualifier.hasBinding())
@@ -5967,7 +6005,7 @@ void TParseContext::layoutQualifierCheck(const TSourceLoc& loc, const TQualifier
            error(loc, "cannot be used with shaderRecordNV", "set", "");
    }
-    if (qualifier.storage == EvqHitAttrNV && qualifier.hasLayout()) {
+    if (qualifier.storage == EvqHitAttr && qualifier.hasLayout()) {
        error(loc, "cannot apply layout qualifiers to hitAttributeNV variable", "hitAttributeNV", "");
    }
 }
@@ -6079,6 +6117,15 @@ const TFunction* TParseContext::findFunction(const TSourceLoc& loc, const TFunct
 #endif
    const TFunction* function = nullptr;
    // debugPrintfEXT has var args and is in the symbol table as "debugPrintfEXT()",
    // mangled to "debugPrintfEXT("
    if (call.getName() == "debugPrintfEXT") {
        TSymbol* symbol = symbolTable.find("debugPrintfEXT(", &builtIn);
        if (symbol)
            return symbol->getAsFunction();
    }
    bool explicitTypesEnabled = extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types) ||
                                extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int8) ||
                                extensionTurnedOn(E_GL_EXT_shader_explicit_arithmetic_types_int16) ||
@@ -6461,7 +6508,7 @@ TIntermNode* TParseContext::declareVariable(const TSourceLoc& loc, TString& iden
    transparentOpaqueCheck(loc, type, identifier);
 #ifndef GLSLANG_WEB
    atomicUintCheck(loc, type, identifier);
-    accStructNVCheck(loc, type, identifier);
+    accStructCheck(loc, type, identifier);
    checkAndResizeMeshViewDim(loc, type, /*isBlockMember*/ false);
 #endif
    if (type.getQualifier().storage == EvqConst && type.containsReference()) {
@@ -7395,7 +7442,7 @@ void TParseContext::declareBlock(const TSourceLoc& loc, TTypeList& typeList, con
    // Special case for "push_constant uniform", which has a default of std430,
    // contrary to normal uniform defaults, and can't have a default tracked for it.
    if ((currentBlockQualifier.isPushConstant() && !currentBlockQualifier.hasPacking()) ||
-        (currentBlockQualifier.isShaderRecordNV() && !currentBlockQualifier.hasPacking()))
+        (currentBlockQualifier.isShaderRecord() && !currentBlockQualifier.hasPacking()))
        currentBlockQualifier.layoutPacking = ElpStd430;
    // Special case for "taskNV in/out", which has a default of std430,
@@ -7612,6 +7659,7 @@ void TParseContext::declareBlock(const TSourceLoc& loc, TTypeList& typeList, con
 // with a particular stage.
 void TParseContext::blockStageIoCheck(const TSourceLoc& loc, const TQualifier& qualifier)
 {
    const char *extsrt[2] = { E_GL_NV_ray_tracing, E_GL_EXT_ray_tracing };
    switch (qualifier.storage) {
    case EvqUniform:
        profileRequires(loc, EEsProfile, 300, nullptr, "uniform block");
@@ -7621,7 +7669,7 @@ void TParseContext::blockStageIoCheck(const TSourceLoc& loc, const TQualifier& q
        break;
    case EvqBuffer:
        requireProfile(loc, EEsProfile | ECoreProfile | ECompatibilityProfile, "buffer block");
-        profileRequires(loc, ECoreProfile | ECompatibilityProfile, 430, nullptr, "buffer block");
+        profileRequires(loc, ECoreProfile | ECompatibilityProfile, 430, E_GL_ARB_shader_storage_buffer_object, "buffer block");
        profileRequires(loc, EEsProfile, 310, nullptr, "buffer block");
        break;
    case EvqVaryingIn:
@@ -7650,28 +7698,28 @@ void TParseContext::blockStageIoCheck(const TSourceLoc& loc, const TQualifier& q
        }
        break;
 #ifndef GLSLANG_WEB
-    case EvqPayloadNV:
+    case EvqPayload:
-        profileRequires(loc, ~EEsProfile, 460, E_GL_NV_ray_tracing, "rayPayloadNV block");
+        profileRequires(loc, ~EEsProfile, 460, 2, extsrt, "rayPayloadNV block");
-        requireStage(loc, (EShLanguageMask)(EShLangRayGenNVMask | EShLangAnyHitNVMask | EShLangClosestHitNVMask | EShLangMissNVMask),
+        requireStage(loc, (EShLanguageMask)(EShLangRayGenMask | EShLangAnyHitMask | EShLangClosestHitMask | EShLangMissMask),
            "rayPayloadNV block");
        break;
-    case EvqPayloadInNV:
+    case EvqPayloadIn:
-        profileRequires(loc, ~EEsProfile, 460, E_GL_NV_ray_tracing, "rayPayloadInNV block");
+        profileRequires(loc, ~EEsProfile, 460, 2, extsrt, "rayPayloadInNV block");
-        requireStage(loc, (EShLanguageMask)(EShLangAnyHitNVMask | EShLangClosestHitNVMask | EShLangMissNVMask),
+        requireStage(loc, (EShLanguageMask)(EShLangAnyHitMask | EShLangClosestHitMask | EShLangMissMask),
            "rayPayloadInNV block");
        break;
-    case EvqHitAttrNV:
+    case EvqHitAttr:
-        profileRequires(loc, ~EEsProfile, 460, E_GL_NV_ray_tracing, "hitAttributeNV block");
+        profileRequires(loc, ~EEsProfile, 460, 2, extsrt, "hitAttributeNV block");
-        requireStage(loc, (EShLanguageMask)(EShLangIntersectNVMask | EShLangAnyHitNVMask | EShLangClosestHitNVMask), "hitAttributeNV block");
+        requireStage(loc, (EShLanguageMask)(EShLangIntersectMask | EShLangAnyHitMask | EShLangClosestHitMask), "hitAttributeNV block");
        break;
-    case EvqCallableDataNV:
+    case EvqCallableData:
-        profileRequires(loc, ~EEsProfile, 460, E_GL_NV_ray_tracing, "callableDataNV block");
+        profileRequires(loc, ~EEsProfile, 460, 2, extsrt, "callableDataNV block");
-        requireStage(loc, (EShLanguageMask)(EShLangRayGenNVMask | EShLangClosestHitNVMask | EShLangMissNVMask | EShLangCallableNVMask),
+        requireStage(loc, (EShLanguageMask)(EShLangRayGenMask | EShLangClosestHitMask | EShLangMissMask | EShLangCallableMask),
            "callableDataNV block");
        break;
-    case EvqCallableDataInNV:
+    case EvqCallableDataIn:
-        profileRequires(loc, ~EEsProfile, 460, E_GL_NV_ray_tracing, "callableDataInNV block");
+        profileRequires(loc, ~EEsProfile, 460, 2, extsrt, "callableDataInNV block");
-        requireStage(loc, (EShLanguageMask)(EShLangCallableNVMask), "callableDataInNV block");
+        requireStage(loc, (EShLanguageMask)(EShLangCallableMask), "callableDataInNV block");
        break;
 #endif
    default:
@@ -7710,8 +7758,8 @@ void TParseContext::blockQualifierCheck(const TSourceLoc& loc, const TQualifier&
        error(loc, "cannot use invariant qualifier on an interface block", "invariant", "");
    if (qualifier.isPushConstant())
        intermediate.addPushConstantCount();
-    if (qualifier.isShaderRecordNV())
+    if (qualifier.isShaderRecord())
-        intermediate.addShaderRecordNVCount();
+        intermediate.addShaderRecordCount();
    if (qualifier.isTaskMemory())
        intermediate.addTaskNVCount();
 }
@@ -8233,7 +8281,7 @@ void TParseContext::updateStandaloneQualifierDefaults(const TSourceLoc& loc, con
        error(loc, "cannot declare a default, can only be used on a block", "buffer_reference", "");
    if (qualifier.hasSpecConstantId())
        error(loc, "cannot declare a default, can only be used on a scalar", "constant_id", "");
-    if (qualifier.isShaderRecordNV())
+    if (qualifier.isShaderRecord())
        error(loc, "cannot declare a default, can only be used on a block", "shaderRecordNV", "");
 }
@@ -358,7 +358,7 @@ public:
    void boolCheck(const TSourceLoc&, const TPublicType&);
    void samplerCheck(const TSourceLoc&, const TType&, const TString& identifier, TIntermTyped* initializer);
    void atomicUintCheck(const TSourceLoc&, const TType&, const TString& identifier);
-    void accStructNVCheck(const TSourceLoc & loc, const TType & type, const TString & identifier);
+    void accStructCheck(const TSourceLoc & loc, const TType & type, const TString & identifier);
    void transparentOpaqueCheck(const TSourceLoc&, const TType&, const TString& identifier);
    void memberQualifierCheck(glslang::TPublicType&);
    void globalQualifierFixCheck(const TSourceLoc&, TQualifier&);
@@ -2,6 +2,8 @@
 // Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
 // Copyright (C) 2013 LunarG, Inc.
 // Copyright (C) 2017 ARM Limited.
 // Copyright (C) 2020 Google, Inc.
 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -187,13 +189,11 @@ bool TInputScanner::scanVersion(int& version, EProfile& profile, bool& notFirstT
        if (lookingInMiddle) {
            notFirstToken = true;
            // make forward progress by finishing off the current line plus extra new lines
-            if (peek() == '\n' || peek() == '\r') {
+            if (peek() != '\n' && peek() != '\r') {
                while (peek() == '\n' || peek() == '\r')
                    get();
            } else
                do {
                    c = get();
                } while (c != EndOfInput && c != '\n' && c != '\r');
            }
            while (peek() == '\n' || peek() == '\r')
                get();
            if (peek() == EndOfInput)
@@ -416,6 +416,7 @@ void TScanContext::fillInKeywordMap()
    (*KeywordMap)["queuefamilycoherent"] =     QUEUEFAMILYCOHERENT;
    (*KeywordMap)["workgroupcoherent"] =       WORKGROUPCOHERENT;
    (*KeywordMap)["subgroupcoherent"] =        SUBGROUPCOHERENT;
    (*KeywordMap)["shadercallcoherent"] =      SHADERCALLCOHERENT;
    (*KeywordMap)["nonprivate"] =              NONPRIVATE;
    (*KeywordMap)["restrict"] =                RESTRICT;
    (*KeywordMap)["readonly"] =                READONLY;
@@ -704,11 +705,18 @@ void TScanContext::fillInKeywordMap()
    (*KeywordMap)["precise"] =                 PRECISE;
    (*KeywordMap)["rayPayloadNV"] =            PAYLOADNV;
    (*KeywordMap)["rayPayloadEXT"] =           PAYLOADEXT;
    (*KeywordMap)["rayPayloadInNV"] =          PAYLOADINNV;
    (*KeywordMap)["rayPayloadInEXT"] =         PAYLOADINEXT;
    (*KeywordMap)["hitAttributeNV"] =          HITATTRNV;
    (*KeywordMap)["hitAttributeEXT"] =         HITATTREXT;
    (*KeywordMap)["callableDataNV"] =          CALLDATANV;
    (*KeywordMap)["callableDataEXT"] =         CALLDATAEXT;
    (*KeywordMap)["callableDataInNV"] =        CALLDATAINNV;
    (*KeywordMap)["callableDataInEXT"] =       CALLDATAINEXT;
    (*KeywordMap)["accelerationStructureNV"] = ACCSTRUCTNV;
    (*KeywordMap)["accelerationStructureEXT"]   = ACCSTRUCTEXT;
    (*KeywordMap)["rayQueryEXT"] =              RAYQUERYEXT;
    (*KeywordMap)["perprimitiveNV"] =          PERPRIMITIVENV;
    (*KeywordMap)["perviewNV"] =               PERVIEWNV;
    (*KeywordMap)["taskNV"] =                  PERTASKNV;
@@ -843,6 +851,7 @@ int TScanContext::tokenize(TPpContext* pp, TParserToken& token)
            parseContext.error(loc, "not supported", "::", "");
            break;
        case PpAtomConstString:        parserToken->sType.lex.string = NewPoolTString(tokenText);     return STRING_LITERAL;
        case PpAtomConstInt:           parserToken->sType.lex.i    = ppToken.ival;       return INTCONSTANT;
        case PpAtomConstUint:          parserToken->sType.lex.i    = ppToken.ival;       return UINTCONSTANT;
        case PpAtomConstFloat:         parserToken->sType.lex.d    = ppToken.dval;       return FLOATCONSTANT;
@@ -908,7 +917,8 @@ int TScanContext::tokenizeIdentifier()
    case BUFFER:
        afterBuffer = true;
        if ((parseContext.isEsProfile() && parseContext.version < 310) ||
-            (!parseContext.isEsProfile() && parseContext.version < 430))
+            (!parseContext.isEsProfile() && (parseContext.version < 430 &&
            !parseContext.extensionTurnedOn(E_GL_ARB_shader_storage_buffer_object))))
            return identifierOrType();
        return keyword;
@@ -1014,6 +1024,23 @@ int TScanContext::tokenizeIdentifier()
            parseContext.extensionTurnedOn(E_GL_NV_ray_tracing))
            return keyword;
        return identifierOrType();
    case PAYLOADEXT:
    case PAYLOADINEXT:
    case HITATTREXT:
    case CALLDATAEXT:
    case CALLDATAINEXT:
    case ACCSTRUCTEXT:
        if (parseContext.symbolTable.atBuiltInLevel() ||
            parseContext.extensionTurnedOn(E_GL_EXT_ray_tracing) ||
            parseContext.extensionTurnedOn(E_GL_EXT_ray_query))
            return keyword;
        return identifierOrType();
    case RAYQUERYEXT:
        if (parseContext.symbolTable.atBuiltInLevel() ||
            (!parseContext.isEsProfile() && parseContext.version >= 460
                 && parseContext.extensionTurnedOn(E_GL_EXT_ray_query)))
            return keyword;
        return identifierOrType();
    case ATOMIC_UINT:
        if ((parseContext.isEsProfile() && parseContext.version >= 310) ||
            parseContext.extensionTurnedOn(E_GL_ARB_shader_atomic_counters))
@@ -1025,6 +1052,7 @@ int TScanContext::tokenizeIdentifier()
    case QUEUEFAMILYCOHERENT:
    case WORKGROUPCOHERENT:
    case SUBGROUPCOHERENT:
    case SHADERCALLCOHERENT:
    case NONPRIVATE:
    case RESTRICT:
    case READONLY:
@@ -1,7 +1,7 @@
 //
 // Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
 // Copyright (C) 2013-2016 LunarG, Inc.
-// Copyright (C) 2015-2018 Google, Inc.
+// Copyright (C) 2015-2020 Google, Inc.
 //
 // All rights reserved.
 //
@@ -361,17 +361,17 @@ bool InitializeSymbolTables(TInfoSink& infoSink, TSymbolTable** commonTable,  TS
    // check for ray tracing stages
    if (profile != EEsProfile && version >= 450) {
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangRayGenNV, source,
+        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangRayGen, source,
            infoSink, commonTable, symbolTables);
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangIntersectNV, source,
+        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangIntersect, source,
            infoSink, commonTable, symbolTables);
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangAnyHitNV, source,
+        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangAnyHit, source,
            infoSink, commonTable, symbolTables);
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangClosestHitNV, source,
+        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangClosestHit, source,
            infoSink, commonTable, symbolTables);
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangMissNV, source,
+        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangMiss, source,
            infoSink, commonTable, symbolTables);
-        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangCallableNV, source,
+        InitializeStageSymbolTable(*builtInParseables, version, profile, spvVersion, EShLangCallable, source,
            infoSink, commonTable, symbolTables);
    }
@@ -623,12 +623,12 @@ bool DeduceVersionProfile(TInfoSink& infoSink, EShLanguage stage, bool versionNo
            version = profile == EEsProfile ? 310 : 420;
        }
        break;
-    case EShLangRayGenNV:
+    case EShLangRayGen:
-    case EShLangIntersectNV:
+    case EShLangIntersect:
-    case EShLangAnyHitNV:
+    case EShLangAnyHit:
-    case EShLangClosestHitNV:
+    case EShLangClosestHit:
-    case EShLangMissNV:
+    case EShLangMiss:
-    case EShLangCallableNV:
+    case EShLangCallable:
        if (profile == EEsProfile || version < 460) {
            correct = false;
            infoSink.info.message(EPrefixError, "#version: ray tracing shaders require non-es profile with version 460 or above");
@@ -716,6 +716,9 @@ void TranslateEnvironment(const TEnvironment* environment, EShMessages& messages
            case EShClientOpenGL:
                spvVersion.openGl = environment->input.dialectVersion;
                break;
            case EShClientCount:
                assert(0);
                break;
            }
            switch (environment->input.languageFamily) {
            case EShSourceNone:
@@ -728,6 +731,9 @@ void TranslateEnvironment(const TEnvironment* environment, EShMessages& messages
                source = EShSourceHlsl;
                messages = static_cast<EShMessages>(messages | EShMsgReadHlsl);
                break;
            case EShSourceCount:
                assert(0);
                break;
            }
        }
@@ -1771,6 +1777,8 @@ void TShader::setSourceEntryPoint(const char* name)
    sourceEntryPointName = name;
 }
 // Log initial settings and transforms.
 // See comment for class TProcesses.
 void TShader::addProcesses(const std::vector<std::string>& p)
 {
    intermediate->addProcesses(p);
@@ -3,6 +3,7 @@
 // Copyright (C) 2012-2013 LunarG, Inc.
 // Copyright (C) 2017 ARM Limited.
 // Copyright (C) 2015-2018 Google, Inc.
 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -74,7 +75,8 @@ void TType::buildMangledName(TString& mangledName) const
    case EbtInt64:              mangledName += "i64";    break;
    case EbtUint64:             mangledName += "u64";    break;
    case EbtAtomicUint:         mangledName += "au";     break;
-    case EbtAccStructNV:        mangledName += "asnv";   break;
+    case EbtAccStruct:          mangledName += "as";     break;
    case EbtRayQuery:           mangledName += "rq";     break;
 #endif
    case EbtSampler:
        switch (sampler.type) {
@@ -120,7 +122,7 @@ void TType::buildMangledName(TString& mangledName) const
            mangledName += "-tx-struct";
            char text[16]; // plenty enough space for the small integers.
-            snprintf(text, sizeof(text), "%d-", sampler.getStructReturnIndex());
+            snprintf(text, sizeof(text), "%u-", sampler.getStructReturnIndex());
            mangledName += text;
        } else {
            switch (sampler.getVectorSize()) {
@@ -2,7 +2,8 @@
 // Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
 // Copyright (C) 2012-2013 LunarG, Inc.
 // Copyright (C) 2017 ARM Limited.
-// Copyright (C) 2015-2018 Google, Inc.
+// Copyright (C) 2015-2020 Google, Inc.
 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -197,6 +198,9 @@ void TParseVersions::initializeExtensionBehavior()
    extensionBehavior[E_GL_ARB_shader_clock]                 = EBhDisable;
    extensionBehavior[E_GL_ARB_uniform_buffer_object]        = EBhDisable;
    extensionBehavior[E_GL_ARB_sample_shading]               = EBhDisable;
    extensionBehavior[E_GL_ARB_shader_bit_encoding]          = EBhDisable;
    extensionBehavior[E_GL_ARB_shader_image_size]            = EBhDisable;
    extensionBehavior[E_GL_ARB_shader_storage_buffer_object] = EBhDisable;
    extensionBehavior[E_GL_KHR_shader_subgroup_basic]            = EBhDisable;
    extensionBehavior[E_GL_KHR_shader_subgroup_vote]             = EBhDisable;
@@ -222,6 +226,7 @@ void TParseVersions::initializeExtensionBehavior()
    extensionBehavior[E_GL_EXT_buffer_reference2]                       = EBhDisable;
    extensionBehavior[E_GL_EXT_buffer_reference_uvec2]                  = EBhDisable;
    extensionBehavior[E_GL_EXT_demote_to_helper_invocation]             = EBhDisable;
    extensionBehavior[E_GL_EXT_debug_printf]                            = EBhDisable;
    extensionBehavior[E_GL_EXT_shader_16bit_storage]                    = EBhDisable;
    extensionBehavior[E_GL_EXT_shader_8bit_storage]                     = EBhDisable;
@@ -295,6 +300,9 @@ void TParseVersions::initializeExtensionBehavior()
    extensionBehavior[E_GL_EXT_device_group]                = EBhDisable;
    extensionBehavior[E_GL_EXT_multiview]                   = EBhDisable;
    extensionBehavior[E_GL_EXT_shader_realtime_clock]       = EBhDisable;
    extensionBehavior[E_GL_EXT_ray_tracing]                 = EBhDisable;
    extensionBehavior[E_GL_EXT_ray_query]                   = EBhDisable;
    extensionBehavior[E_GL_EXT_ray_flags_primitive_culling] = EBhDisable;
    // OVR extensions
    extensionBehavior[E_GL_OVR_multiview]                = EBhDisable;
@@ -403,10 +411,13 @@ void TParseVersions::getPreamble(std::string& preamble)
            "#define GL_ARB_sparse_texture_clamp 1\n"
            "#define GL_ARB_shader_stencil_export 1\n"
            "#define GL_ARB_sample_shading 1\n"
            "#define GL_ARB_shader_image_size 1\n"
 //            "#define GL_ARB_cull_distance 1\n"    // present for 4.5, but need extension control over block members
            "#define GL_ARB_post_depth_coverage 1\n"
            "#define GL_ARB_fragment_shader_interlock 1\n"
            "#define GL_ARB_uniform_buffer_object 1\n"
            "#define GL_ARB_shader_bit_encoding 1\n"
            "#define GL_ARB_shader_storage_buffer_object 1\n"
            "#define GL_EXT_shader_non_constant_global_initializers 1\n"
            "#define GL_EXT_shader_image_load_formatted 1\n"
            "#define GL_EXT_post_depth_coverage 1\n"
@@ -421,6 +432,7 @@ void TParseVersions::getPreamble(std::string& preamble)
            "#define GL_EXT_buffer_reference2 1\n"
            "#define GL_EXT_buffer_reference_uvec2 1\n"
            "#define GL_EXT_demote_to_helper_invocation 1\n"
            "#define GL_EXT_debug_printf 1\n"
            // GL_KHR_shader_subgroup
            "#define GL_KHR_shader_subgroup_basic 1\n"
@@ -434,6 +446,9 @@ void TParseVersions::getPreamble(std::string& preamble)
            "#define E_GL_EXT_shader_atomic_int64 1\n"
            "#define E_GL_EXT_shader_realtime_clock 1\n"
            "#define E_GL_EXT_ray_tracing 1\n"
            "#define E_GL_EXT_ray_query 1\n"
            "#define E_GL_EXT_ray_flags_primitive_culling 1\n"
            "#define GL_AMD_shader_ballot 1\n"
            "#define GL_AMD_shader_trinary_minmax 1\n"
@@ -547,12 +562,12 @@ const char* StageName(EShLanguage stage)
    case EShLangTessControl:    return "tessellation control";
    case EShLangTessEvaluation: return "tessellation evaluation";
    case EShLangGeometry:       return "geometry";
-    case EShLangRayGenNV:       return "ray-generation";
+    case EShLangRayGen:         return "ray-generation";
-    case EShLangIntersectNV:    return "intersection";
+    case EShLangIntersect:      return "intersection";
-    case EShLangAnyHitNV:       return "any-hit";
+    case EShLangAnyHit:         return "any-hit";
-    case EShLangClosestHitNV:   return "closest-hit";
+    case EShLangClosestHit:     return "closest-hit";
-    case EShLangMissNV:         return "miss";
+    case EShLangMiss:           return "miss";
-    case EShLangCallableNV:     return "callable";
+    case EShLangCallable:       return "callable";
    case EShLangMeshNV:         return "mesh";
    case EShLangTaskNV:         return "task";
 #endif
@@ -3,6 +3,7 @@
 // Copyright (C) 2012-2013 LunarG, Inc.
 // Copyright (C) 2017 ARM Limited.
 // Copyright (C) 2015-2018 Google, Inc.
 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -38,6 +39,8 @@
 #ifndef _VERSIONS_INCLUDED_
 #define _VERSIONS_INCLUDED_
 #define LAST_ELEMENT_MARKER(x) x
 //
 // Help manage multiple profiles, versions, extensions etc.
 //
@@ -54,7 +57,8 @@ typedef enum {
    ENoProfile            = (1 << 0), // only for desktop, before profiles showed up
    ECoreProfile          = (1 << 1),
    ECompatibilityProfile = (1 << 2),
-    EEsProfile            = (1 << 3)
+    EEsProfile            = (1 << 3),
    LAST_ELEMENT_MARKER(EProfileCount),
 } EProfile;
 namespace glslang {
@@ -149,6 +153,9 @@ const char* const E_GL_ARB_fragment_shader_interlock    = "GL_ARB_fragment_shade
 const char* const E_GL_ARB_shader_clock                 = "GL_ARB_shader_clock";
 const char* const E_GL_ARB_uniform_buffer_object        = "GL_ARB_uniform_buffer_object";
 const char* const E_GL_ARB_sample_shading               = "GL_ARB_sample_shading";
 const char* const E_GL_ARB_shader_bit_encoding          = "GL_ARB_shader_bit_encoding";
 const char* const E_GL_ARB_shader_image_size            = "GL_ARB_shader_image_size";
 const char* const E_GL_ARB_shader_storage_buffer_object = "GL_ARB_shader_storage_buffer_object";
 const char* const E_GL_KHR_shader_subgroup_basic            = "GL_KHR_shader_subgroup_basic";
 const char* const E_GL_KHR_shader_subgroup_vote             = "GL_KHR_shader_subgroup_vote";
@@ -183,6 +190,10 @@ const char* const E_GL_EXT_buffer_reference2                = "GL_EXT_buffer_ref
 const char* const E_GL_EXT_buffer_reference_uvec2           = "GL_EXT_buffer_reference_uvec2";
 const char* const E_GL_EXT_demote_to_helper_invocation      = "GL_EXT_demote_to_helper_invocation";
 const char* const E_GL_EXT_shader_realtime_clock            = "GL_EXT_shader_realtime_clock";
 const char* const E_GL_EXT_debug_printf                     = "GL_EXT_debug_printf";
 const char* const E_GL_EXT_ray_tracing                      = "GL_EXT_ray_tracing";
 const char* const E_GL_EXT_ray_query                        = "GL_EXT_ray_query";
 const char* const E_GL_EXT_ray_flags_primitive_culling      = "GL_EXT_ray_flags_primitive_culling";
 // Arrays of extensions for the above viewportEXTs duplications
@@ -30,8 +30,8 @@
   This special exception was added by the Free Software Foundation in
   version 2.2 of Bison.  */
-#ifndef YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
+#ifndef YY_YY_GLSLANG_TAB_CPP_H_INCLUDED
-# define YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED
+# define YY_YY_GLSLANG_TAB_CPP_H_INCLUDED
 /* Debug traces.  */
 #ifndef YYDEBUG
 # define YYDEBUG 1
@@ -203,256 +203,265 @@ extern int yydebug;
    F64MAT4X4 = 413,
    ATOMIC_UINT = 414,
    ACCSTRUCTNV = 415,
-    FCOOPMATNV = 416,
+    ACCSTRUCTEXT = 416,
-    ICOOPMATNV = 417,
+    RAYQUERYEXT = 417,
-    UCOOPMATNV = 418,
+    FCOOPMATNV = 418,
-    SAMPLERCUBEARRAY = 419,
+    ICOOPMATNV = 419,
-    SAMPLERCUBEARRAYSHADOW = 420,
+    UCOOPMATNV = 420,
-    ISAMPLERCUBEARRAY = 421,
+    SAMPLERCUBEARRAY = 421,
-    USAMPLERCUBEARRAY = 422,
+    SAMPLERCUBEARRAYSHADOW = 422,
-    SAMPLER1D = 423,
+    ISAMPLERCUBEARRAY = 423,
-    SAMPLER1DARRAY = 424,
+    USAMPLERCUBEARRAY = 424,
-    SAMPLER1DARRAYSHADOW = 425,
+    SAMPLER1D = 425,
-    ISAMPLER1D = 426,
+    SAMPLER1DARRAY = 426,
-    SAMPLER1DSHADOW = 427,
+    SAMPLER1DARRAYSHADOW = 427,
-    SAMPLER2DRECT = 428,
+    ISAMPLER1D = 428,
-    SAMPLER2DRECTSHADOW = 429,
+    SAMPLER1DSHADOW = 429,
-    ISAMPLER2DRECT = 430,
+    SAMPLER2DRECT = 430,
-    USAMPLER2DRECT = 431,
+    SAMPLER2DRECTSHADOW = 431,
-    SAMPLERBUFFER = 432,
+    ISAMPLER2DRECT = 432,
-    ISAMPLERBUFFER = 433,
+    USAMPLER2DRECT = 433,
-    USAMPLERBUFFER = 434,
+    SAMPLERBUFFER = 434,
-    SAMPLER2DMS = 435,
+    ISAMPLERBUFFER = 435,
-    ISAMPLER2DMS = 436,
+    USAMPLERBUFFER = 436,
-    USAMPLER2DMS = 437,
+    SAMPLER2DMS = 437,
-    SAMPLER2DMSARRAY = 438,
+    ISAMPLER2DMS = 438,
-    ISAMPLER2DMSARRAY = 439,
+    USAMPLER2DMS = 439,
-    USAMPLER2DMSARRAY = 440,
+    SAMPLER2DMSARRAY = 440,
-    SAMPLEREXTERNALOES = 441,
+    ISAMPLER2DMSARRAY = 441,
-    SAMPLEREXTERNAL2DY2YEXT = 442,
+    USAMPLER2DMSARRAY = 442,
-    ISAMPLER1DARRAY = 443,
+    SAMPLEREXTERNALOES = 443,
-    USAMPLER1D = 444,
+    SAMPLEREXTERNAL2DY2YEXT = 444,
-    USAMPLER1DARRAY = 445,
+    ISAMPLER1DARRAY = 445,
-    F16SAMPLER1D = 446,
+    USAMPLER1D = 446,
-    F16SAMPLER2D = 447,
+    USAMPLER1DARRAY = 447,
-    F16SAMPLER3D = 448,
+    F16SAMPLER1D = 448,
-    F16SAMPLER2DRECT = 449,
+    F16SAMPLER2D = 449,
-    F16SAMPLERCUBE = 450,
+    F16SAMPLER3D = 450,
-    F16SAMPLER1DARRAY = 451,
+    F16SAMPLER2DRECT = 451,
-    F16SAMPLER2DARRAY = 452,
+    F16SAMPLERCUBE = 452,
-    F16SAMPLERCUBEARRAY = 453,
+    F16SAMPLER1DARRAY = 453,
-    F16SAMPLERBUFFER = 454,
+    F16SAMPLER2DARRAY = 454,
-    F16SAMPLER2DMS = 455,
+    F16SAMPLERCUBEARRAY = 455,
-    F16SAMPLER2DMSARRAY = 456,
+    F16SAMPLERBUFFER = 456,
-    F16SAMPLER1DSHADOW = 457,
+    F16SAMPLER2DMS = 457,
-    F16SAMPLER2DSHADOW = 458,
+    F16SAMPLER2DMSARRAY = 458,
-    F16SAMPLER1DARRAYSHADOW = 459,
+    F16SAMPLER1DSHADOW = 459,
-    F16SAMPLER2DARRAYSHADOW = 460,
+    F16SAMPLER2DSHADOW = 460,
-    F16SAMPLER2DRECTSHADOW = 461,
+    F16SAMPLER1DARRAYSHADOW = 461,
-    F16SAMPLERCUBESHADOW = 462,
+    F16SAMPLER2DARRAYSHADOW = 462,
-    F16SAMPLERCUBEARRAYSHADOW = 463,
+    F16SAMPLER2DRECTSHADOW = 463,
-    IMAGE1D = 464,
+    F16SAMPLERCUBESHADOW = 464,
-    IIMAGE1D = 465,
+    F16SAMPLERCUBEARRAYSHADOW = 465,
-    UIMAGE1D = 466,
+    IMAGE1D = 466,
-    IMAGE2D = 467,
+    IIMAGE1D = 467,
-    IIMAGE2D = 468,
+    UIMAGE1D = 468,
-    UIMAGE2D = 469,
+    IMAGE2D = 469,
-    IMAGE3D = 470,
+    IIMAGE2D = 470,
-    IIMAGE3D = 471,
+    UIMAGE2D = 471,
-    UIMAGE3D = 472,
+    IMAGE3D = 472,
-    IMAGE2DRECT = 473,
+    IIMAGE3D = 473,
-    IIMAGE2DRECT = 474,
+    UIMAGE3D = 474,
-    UIMAGE2DRECT = 475,
+    IMAGE2DRECT = 475,
-    IMAGECUBE = 476,
+    IIMAGE2DRECT = 476,
-    IIMAGECUBE = 477,
+    UIMAGE2DRECT = 477,
-    UIMAGECUBE = 478,
+    IMAGECUBE = 478,
-    IMAGEBUFFER = 479,
+    IIMAGECUBE = 479,
-    IIMAGEBUFFER = 480,
+    UIMAGECUBE = 480,
-    UIMAGEBUFFER = 481,
+    IMAGEBUFFER = 481,
-    IMAGE1DARRAY = 482,
+    IIMAGEBUFFER = 482,
-    IIMAGE1DARRAY = 483,
+    UIMAGEBUFFER = 483,
-    UIMAGE1DARRAY = 484,
+    IMAGE1DARRAY = 484,
-    IMAGE2DARRAY = 485,
+    IIMAGE1DARRAY = 485,
-    IIMAGE2DARRAY = 486,
+    UIMAGE1DARRAY = 486,
-    UIMAGE2DARRAY = 487,
+    IMAGE2DARRAY = 487,
-    IMAGECUBEARRAY = 488,
+    IIMAGE2DARRAY = 488,
-    IIMAGECUBEARRAY = 489,
+    UIMAGE2DARRAY = 489,
-    UIMAGECUBEARRAY = 490,
+    IMAGECUBEARRAY = 490,
-    IMAGE2DMS = 491,
+    IIMAGECUBEARRAY = 491,
-    IIMAGE2DMS = 492,
+    UIMAGECUBEARRAY = 492,
-    UIMAGE2DMS = 493,
+    IMAGE2DMS = 493,
-    IMAGE2DMSARRAY = 494,
+    IIMAGE2DMS = 494,
-    IIMAGE2DMSARRAY = 495,
+    UIMAGE2DMS = 495,
-    UIMAGE2DMSARRAY = 496,
+    IMAGE2DMSARRAY = 496,
-    F16IMAGE1D = 497,
+    IIMAGE2DMSARRAY = 497,
-    F16IMAGE2D = 498,
+    UIMAGE2DMSARRAY = 498,
-    F16IMAGE3D = 499,
+    F16IMAGE1D = 499,
-    F16IMAGE2DRECT = 500,
+    F16IMAGE2D = 500,
-    F16IMAGECUBE = 501,
+    F16IMAGE3D = 501,
-    F16IMAGE1DARRAY = 502,
+    F16IMAGE2DRECT = 502,
-    F16IMAGE2DARRAY = 503,
+    F16IMAGECUBE = 503,
-    F16IMAGECUBEARRAY = 504,
+    F16IMAGE1DARRAY = 504,
-    F16IMAGEBUFFER = 505,
+    F16IMAGE2DARRAY = 505,
-    F16IMAGE2DMS = 506,
+    F16IMAGECUBEARRAY = 506,
-    F16IMAGE2DMSARRAY = 507,
+    F16IMAGEBUFFER = 507,
-    TEXTURECUBEARRAY = 508,
+    F16IMAGE2DMS = 508,
-    ITEXTURECUBEARRAY = 509,
+    F16IMAGE2DMSARRAY = 509,
-    UTEXTURECUBEARRAY = 510,
+    TEXTURECUBEARRAY = 510,
-    TEXTURE1D = 511,
+    ITEXTURECUBEARRAY = 511,
-    ITEXTURE1D = 512,
+    UTEXTURECUBEARRAY = 512,
-    UTEXTURE1D = 513,
+    TEXTURE1D = 513,
-    TEXTURE1DARRAY = 514,
+    ITEXTURE1D = 514,
-    ITEXTURE1DARRAY = 515,
+    UTEXTURE1D = 515,
-    UTEXTURE1DARRAY = 516,
+    TEXTURE1DARRAY = 516,
-    TEXTURE2DRECT = 517,
+    ITEXTURE1DARRAY = 517,
-    ITEXTURE2DRECT = 518,
+    UTEXTURE1DARRAY = 518,
-    UTEXTURE2DRECT = 519,
+    TEXTURE2DRECT = 519,
-    TEXTUREBUFFER = 520,
+    ITEXTURE2DRECT = 520,
-    ITEXTUREBUFFER = 521,
+    UTEXTURE2DRECT = 521,
-    UTEXTUREBUFFER = 522,
+    TEXTUREBUFFER = 522,
-    TEXTURE2DMS = 523,
+    ITEXTUREBUFFER = 523,
-    ITEXTURE2DMS = 524,
+    UTEXTUREBUFFER = 524,
-    UTEXTURE2DMS = 525,
+    TEXTURE2DMS = 525,
-    TEXTURE2DMSARRAY = 526,
+    ITEXTURE2DMS = 526,
-    ITEXTURE2DMSARRAY = 527,
+    UTEXTURE2DMS = 527,
-    UTEXTURE2DMSARRAY = 528,
+    TEXTURE2DMSARRAY = 528,
-    F16TEXTURE1D = 529,
+    ITEXTURE2DMSARRAY = 529,
-    F16TEXTURE2D = 530,
+    UTEXTURE2DMSARRAY = 530,
-    F16TEXTURE3D = 531,
+    F16TEXTURE1D = 531,
-    F16TEXTURE2DRECT = 532,
+    F16TEXTURE2D = 532,
-    F16TEXTURECUBE = 533,
+    F16TEXTURE3D = 533,
-    F16TEXTURE1DARRAY = 534,
+    F16TEXTURE2DRECT = 534,
-    F16TEXTURE2DARRAY = 535,
+    F16TEXTURECUBE = 535,
-    F16TEXTURECUBEARRAY = 536,
+    F16TEXTURE1DARRAY = 536,
-    F16TEXTUREBUFFER = 537,
+    F16TEXTURE2DARRAY = 537,
-    F16TEXTURE2DMS = 538,
+    F16TEXTURECUBEARRAY = 538,
-    F16TEXTURE2DMSARRAY = 539,
+    F16TEXTUREBUFFER = 539,
-    SUBPASSINPUT = 540,
+    F16TEXTURE2DMS = 540,
-    SUBPASSINPUTMS = 541,
+    F16TEXTURE2DMSARRAY = 541,
-    ISUBPASSINPUT = 542,
+    SUBPASSINPUT = 542,
-    ISUBPASSINPUTMS = 543,
+    SUBPASSINPUTMS = 543,
-    USUBPASSINPUT = 544,
+    ISUBPASSINPUT = 544,
-    USUBPASSINPUTMS = 545,
+    ISUBPASSINPUTMS = 545,
-    F16SUBPASSINPUT = 546,
+    USUBPASSINPUT = 546,
-    F16SUBPASSINPUTMS = 547,
+    USUBPASSINPUTMS = 547,
-    LEFT_OP = 548,
+    F16SUBPASSINPUT = 548,
-    RIGHT_OP = 549,
+    F16SUBPASSINPUTMS = 549,
-    INC_OP = 550,
+    LEFT_OP = 550,
-    DEC_OP = 551,
+    RIGHT_OP = 551,
-    LE_OP = 552,
+    INC_OP = 552,
-    GE_OP = 553,
+    DEC_OP = 553,
-    EQ_OP = 554,
+    LE_OP = 554,
-    NE_OP = 555,
+    GE_OP = 555,
-    AND_OP = 556,
+    EQ_OP = 556,
-    OR_OP = 557,
+    NE_OP = 557,
-    XOR_OP = 558,
+    AND_OP = 558,
-    MUL_ASSIGN = 559,
+    OR_OP = 559,
-    DIV_ASSIGN = 560,
+    XOR_OP = 560,
-    ADD_ASSIGN = 561,
+    MUL_ASSIGN = 561,
-    MOD_ASSIGN = 562,
+    DIV_ASSIGN = 562,
-    LEFT_ASSIGN = 563,
+    ADD_ASSIGN = 563,
-    RIGHT_ASSIGN = 564,
+    MOD_ASSIGN = 564,
-    AND_ASSIGN = 565,
+    LEFT_ASSIGN = 565,
-    XOR_ASSIGN = 566,
+    RIGHT_ASSIGN = 566,
-    OR_ASSIGN = 567,
+    AND_ASSIGN = 567,
-    SUB_ASSIGN = 568,
+    XOR_ASSIGN = 568,
-    LEFT_PAREN = 569,
+    OR_ASSIGN = 569,
-    RIGHT_PAREN = 570,
+    SUB_ASSIGN = 570,
-    LEFT_BRACKET = 571,
+    STRING_LITERAL = 571,
-    RIGHT_BRACKET = 572,
+    LEFT_PAREN = 572,
-    LEFT_BRACE = 573,
+    RIGHT_PAREN = 573,
-    RIGHT_BRACE = 574,
+    LEFT_BRACKET = 574,
-    DOT = 575,
+    RIGHT_BRACKET = 575,
-    COMMA = 576,
+    LEFT_BRACE = 576,
-    COLON = 577,
+    RIGHT_BRACE = 577,
-    EQUAL = 578,
+    DOT = 578,
-    SEMICOLON = 579,
+    COMMA = 579,
-    BANG = 580,
+    COLON = 580,
-    DASH = 581,
+    EQUAL = 581,
-    TILDE = 582,
+    SEMICOLON = 582,
-    PLUS = 583,
+    BANG = 583,
-    STAR = 584,
+    DASH = 584,
-    SLASH = 585,
+    TILDE = 585,
-    PERCENT = 586,
+    PLUS = 586,
-    LEFT_ANGLE = 587,
+    STAR = 587,
-    RIGHT_ANGLE = 588,
+    SLASH = 588,
-    VERTICAL_BAR = 589,
+    PERCENT = 589,
-    CARET = 590,
+    LEFT_ANGLE = 590,
-    AMPERSAND = 591,
+    RIGHT_ANGLE = 591,
-    QUESTION = 592,
+    VERTICAL_BAR = 592,
-    INVARIANT = 593,
+    CARET = 593,
-    HIGH_PRECISION = 594,
+    AMPERSAND = 594,
-    MEDIUM_PRECISION = 595,
+    QUESTION = 595,
-    LOW_PRECISION = 596,
+    INVARIANT = 596,
-    PRECISION = 597,
+    HIGH_PRECISION = 597,
-    PACKED = 598,
+    MEDIUM_PRECISION = 598,
-    RESOURCE = 599,
+    LOW_PRECISION = 599,
-    SUPERP = 600,
+    PRECISION = 600,
-    FLOATCONSTANT = 601,
+    PACKED = 601,
-    INTCONSTANT = 602,
+    RESOURCE = 602,
-    UINTCONSTANT = 603,
+    SUPERP = 603,
-    BOOLCONSTANT = 604,
+    FLOATCONSTANT = 604,
-    IDENTIFIER = 605,
+    INTCONSTANT = 605,
-    TYPE_NAME = 606,
+    UINTCONSTANT = 606,
-    CENTROID = 607,
+    BOOLCONSTANT = 607,
-    IN = 608,
+    IDENTIFIER = 608,
-    OUT = 609,
+    TYPE_NAME = 609,
-    INOUT = 610,
+    CENTROID = 610,
-    STRUCT = 611,
+    IN = 611,
-    VOID = 612,
+    OUT = 612,
-    WHILE = 613,
+    INOUT = 613,
-    BREAK = 614,
+    STRUCT = 614,
-    CONTINUE = 615,
+    VOID = 615,
-    DO = 616,
+    WHILE = 616,
-    ELSE = 617,
+    BREAK = 617,
-    FOR = 618,
+    CONTINUE = 618,
-    IF = 619,
+    DO = 619,
-    DISCARD = 620,
+    ELSE = 620,
-    RETURN = 621,
+    FOR = 621,
-    SWITCH = 622,
+    IF = 622,
-    CASE = 623,
+    DISCARD = 623,
-    DEFAULT = 624,
+    RETURN = 624,
-    UNIFORM = 625,
+    SWITCH = 625,
-    SHARED = 626,
+    CASE = 626,
-    BUFFER = 627,
+    DEFAULT = 627,
-    FLAT = 628,
+    UNIFORM = 628,
-    SMOOTH = 629,
+    SHARED = 629,
-    LAYOUT = 630,
+    BUFFER = 630,
-    DOUBLECONSTANT = 631,
+    FLAT = 631,
-    INT16CONSTANT = 632,
+    SMOOTH = 632,
-    UINT16CONSTANT = 633,
+    LAYOUT = 633,
-    FLOAT16CONSTANT = 634,
+    DOUBLECONSTANT = 634,
-    INT32CONSTANT = 635,
+    INT16CONSTANT = 635,
-    UINT32CONSTANT = 636,
+    UINT16CONSTANT = 636,
-    INT64CONSTANT = 637,
+    FLOAT16CONSTANT = 637,
-    UINT64CONSTANT = 638,
+    INT32CONSTANT = 638,
-    SUBROUTINE = 639,
+    UINT32CONSTANT = 639,
-    DEMOTE = 640,
+    INT64CONSTANT = 640,
-    PAYLOADNV = 641,
+    UINT64CONSTANT = 641,
-    PAYLOADINNV = 642,
+    SUBROUTINE = 642,
-    HITATTRNV = 643,
+    DEMOTE = 643,
-    CALLDATANV = 644,
+    PAYLOADNV = 644,
-    CALLDATAINNV = 645,
+    PAYLOADINNV = 645,
-    PATCH = 646,
+    HITATTRNV = 646,
-    SAMPLE = 647,
+    CALLDATANV = 647,
-    NONUNIFORM = 648,
+    CALLDATAINNV = 648,
-    COHERENT = 649,
+    PAYLOADEXT = 649,
-    VOLATILE = 650,
+    PAYLOADINEXT = 650,
-    RESTRICT = 651,
+    HITATTREXT = 651,
-    READONLY = 652,
+    CALLDATAEXT = 652,
-    WRITEONLY = 653,
+    CALLDATAINEXT = 653,
-    DEVICECOHERENT = 654,
+    PATCH = 654,
-    QUEUEFAMILYCOHERENT = 655,
+    SAMPLE = 655,
-    WORKGROUPCOHERENT = 656,
+    NONUNIFORM = 656,
-    SUBGROUPCOHERENT = 657,
+    COHERENT = 657,
-    NONPRIVATE = 658,
+    VOLATILE = 658,
-    NOPERSPECTIVE = 659,
+    RESTRICT = 659,
-    EXPLICITINTERPAMD = 660,
+    READONLY = 660,
-    PERVERTEXNV = 661,
+    WRITEONLY = 661,
-    PERPRIMITIVENV = 662,
+    DEVICECOHERENT = 662,
-    PERVIEWNV = 663,
+    QUEUEFAMILYCOHERENT = 663,
-    PERTASKNV = 664,
+    WORKGROUPCOHERENT = 664,
-    PRECISE = 665
+    SUBGROUPCOHERENT = 665,
    NONPRIVATE = 666,
    SHADERCALLCOHERENT = 667,
    NOPERSPECTIVE = 668,
    EXPLICITINTERPAMD = 669,
    PERVERTEXNV = 670,
    PERPRIMITIVENV = 671,
    PERVIEWNV = 672,
    PERTASKNV = 673,
    PRECISE = 674
  };
 #endif
@@ -461,7 +470,7 @@ extern int yydebug;
 union YYSTYPE
 {
-#line 96 "MachineIndependent/glslang.y" /* yacc.c:1909  */
+#line 97 "glslang.y" /* yacc.c:1909  */
    struct {
        glslang::TSourceLoc loc;
@@ -497,7 +506,7 @@ union YYSTYPE
        glslang::TArraySizes* typeParameters;
    } interm;
-#line 501 "MachineIndependent/glslang_tab.cpp.h" /* yacc.c:1909  */
+#line 510 "glslang_tab.cpp.h" /* yacc.c:1909  */
 };
 typedef union YYSTYPE YYSTYPE;
@@ -509,4 +518,4 @@ typedef union YYSTYPE YYSTYPE;
 int yyparse (glslang::TParseContext* pParseContext);
-#endif /* !YY_YY_MACHINEINDEPENDENT_GLSLANG_TAB_CPP_H_INCLUDED  */
+#endif /* !YY_YY_GLSLANG_TAB_CPP_H_INCLUDED  */
@@ -2,6 +2,7 @@
 // Copyright (C) 2002-2005  3Dlabs Inc. Ltd.
 // Copyright (C) 2012-2016 LunarG, Inc.
 // Copyright (C) 2017 ARM Limited.
 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
 //
 // All rights reserved.
 //
@@ -1078,18 +1079,43 @@ bool TOutputTraverser::visitAggregate(TVisit /* visit */, TIntermAggregate* node
    case EOpSubpassLoad:   out.debug << "subpassLoad";   break;
    case EOpSubpassLoadMS: out.debug << "subpassLoadMS"; break;
-    case EOpTraceNV:                          out.debug << "traceNV"; break;
+    case EOpTrace:                            out.debug << "traceNV"; break;
-    case EOpReportIntersectionNV:             out.debug << "reportIntersectionNV"; break;
+    case EOpReportIntersection:               out.debug << "reportIntersectionNV"; break;
-    case EOpIgnoreIntersectionNV:             out.debug << "ignoreIntersectionNV"; break;
+    case EOpIgnoreIntersection:               out.debug << "ignoreIntersectionNV"; break;
-    case EOpTerminateRayNV:                   out.debug << "terminateRayNV"; break;
+    case EOpTerminateRay:                     out.debug << "terminateRayNV"; break;
-    case EOpExecuteCallableNV:                out.debug << "executeCallableNV"; break;
+    case EOpExecuteCallable:                  out.debug << "executeCallableNV"; break;
    case EOpWritePackedPrimitiveIndices4x8NV: out.debug << "writePackedPrimitiveIndices4x8NV"; break;
    case EOpRayQueryInitialize:                                            out.debug << "rayQueryInitializeEXT"; break;
    case EOpRayQueryTerminate:                                             out.debug << "rayQueryTerminateEXT"; break;
    case EOpRayQueryGenerateIntersection:                                  out.debug << "rayQueryGenerateIntersectionEXT"; break;
    case EOpRayQueryConfirmIntersection:                                   out.debug << "rayQueryConfirmIntersectionEXT"; break;
    case EOpRayQueryProceed:                                               out.debug << "rayQueryProceedEXT"; break;
    case EOpRayQueryGetIntersectionType:                                   out.debug << "rayQueryGetIntersectionTypeEXT"; break;
    case EOpRayQueryGetRayTMin:                                            out.debug << "rayQueryGetRayTMinEXT"; break;
    case EOpRayQueryGetRayFlags:                                           out.debug << "rayQueryGetRayFlagsEXT"; break;
    case EOpRayQueryGetIntersectionT:                                      out.debug << "rayQueryGetIntersectionTEXT"; break;
    case EOpRayQueryGetIntersectionInstanceCustomIndex:                    out.debug << "rayQueryGetIntersectionInstanceCustomIndexEXT"; break;
    case EOpRayQueryGetIntersectionInstanceId:                             out.debug << "rayQueryGetIntersectionInstanceIdEXT"; break;
    case EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset: out.debug << "rayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetEXT"; break;
    case EOpRayQueryGetIntersectionGeometryIndex:                          out.debug << "rayQueryGetIntersectionGeometryIndexEXT"; break;
    case EOpRayQueryGetIntersectionPrimitiveIndex:                         out.debug << "rayQueryGetIntersectionPrimitiveIndexEXT"; break;
    case EOpRayQueryGetIntersectionBarycentrics:                           out.debug << "rayQueryGetIntersectionBarycentricsEXT"; break;
    case EOpRayQueryGetIntersectionFrontFace:                              out.debug << "rayQueryGetIntersectionFrontFaceEXT"; break;
    case EOpRayQueryGetIntersectionCandidateAABBOpaque:                    out.debug << "rayQueryGetIntersectionCandidateAABBOpaqueEXT"; break;
    case EOpRayQueryGetIntersectionObjectRayDirection:                     out.debug << "rayQueryGetIntersectionObjectRayDirectionEXT"; break;
    case EOpRayQueryGetIntersectionObjectRayOrigin:                        out.debug << "rayQueryGetIntersectionObjectRayOriginEXT"; break;
    case EOpRayQueryGetWorldRayDirection:                                  out.debug << "rayQueryGetWorldRayDirectionEXT"; break;
    case EOpRayQueryGetWorldRayOrigin:                                     out.debug << "rayQueryGetWorldRayOriginEXT"; break;
    case EOpRayQueryGetIntersectionObjectToWorld:                          out.debug << "rayQueryGetIntersectionObjectToWorldEXT"; break;
    case EOpRayQueryGetIntersectionWorldToObject:                          out.debug << "rayQueryGetIntersectionWorldToObjectEXT"; break;
    case EOpCooperativeMatrixLoad:  out.debug << "Load cooperative matrix";  break;
    case EOpCooperativeMatrixStore:  out.debug << "Store cooperative matrix";  break;
    case EOpCooperativeMatrixMulAdd: out.debug << "MulAdd cooperative matrices"; break;
    case EOpIsHelperInvocation: out.debug << "IsHelperInvocation"; break;
    case EOpDebugPrintf:  out.debug << "Debug printf";  break;
    default: out.debug.message(EPrefixError, "Bad aggregation op");
    }
@@ -161,7 +161,7 @@ struct TNotifyUniformAdaptor
    }
 private:
-    TNotifyUniformAdaptor& operator=(TNotifyUniformAdaptor&);
+    TNotifyUniformAdaptor& operator=(TNotifyUniformAdaptor&) = delete;
 };
 struct TNotifyInOutAdaptor
@@ -180,7 +180,7 @@ struct TNotifyInOutAdaptor
    }
 private:
-    TNotifyInOutAdaptor& operator=(TNotifyInOutAdaptor&);
+    TNotifyInOutAdaptor& operator=(TNotifyInOutAdaptor&) = delete;
 };
 struct TResolverUniformAdaptor {
@@ -236,7 +236,7 @@ struct TResolverUniformAdaptor {
    bool&           error;
 private:
-    TResolverUniformAdaptor& operator=(TResolverUniformAdaptor&);
+    TResolverUniformAdaptor& operator=(TResolverUniformAdaptor&) = delete;
 };
 struct TResolverInOutAdaptor {
@@ -283,7 +283,7 @@ struct TResolverInOutAdaptor {
    bool&           error;
 private:
-    TResolverInOutAdaptor& operator=(TResolverInOutAdaptor&);
+    TResolverInOutAdaptor& operator=(TResolverInOutAdaptor&) = delete;
 };
 // The class is used for reserving explicit uniform locations and ubo/ssbo/opaque bindings
@@ -384,7 +384,7 @@ struct TSymbolValidater
    bool& hadError;
 private:
-    TSymbolValidater& operator=(TSymbolValidater&);
+    TSymbolValidater& operator=(TSymbolValidater&) = delete;
 };
 struct TSlotCollector {
@@ -398,7 +398,7 @@ struct TSlotCollector {
    TInfoSink& infoSink;
 private:
-    TSlotCollector& operator=(TSlotCollector&);
+    TSlotCollector& operator=(TSlotCollector&) = delete;
 };
 TDefaultIoResolverBase::TDefaultIoResolverBase(const TIntermediate& intermediate)
@@ -579,7 +579,10 @@ TDefaultGlslIoResolver::TDefaultGlslIoResolver(const TIntermediate& intermediate
 int TDefaultGlslIoResolver::resolveInOutLocation(EShLanguage stage, TVarEntryInfo& ent) {
    const TType& type = ent.symbol->getType();
-    const TString& name = ent.symbol->getName();
+    const TString& name = IsAnonymous(ent.symbol->getName()) ?
                            ent.symbol->getType().getTypeName()
                            :
                            ent.symbol->getName();
    if (currentStage != stage) {
        preStage = currentStage;
        currentStage = stage;
@@ -663,7 +666,10 @@ int TDefaultGlslIoResolver::resolveInOutLocation(EShLanguage stage, TVarEntryInf
 int TDefaultGlslIoResolver::resolveUniformLocation(EShLanguage /*stage*/, TVarEntryInfo& ent) {
    const TType& type = ent.symbol->getType();
-    const TString& name = ent.symbol->getName();
+    const TString& name = IsAnonymous(ent.symbol->getName()) ?
                            ent.symbol->getType().getTypeName()
                            :
                            ent.symbol->getName();
    // kick out of not doing this
    if (! doAutoLocationMapping()) {
        return ent.newLocation = -1;
@@ -734,7 +740,10 @@ int TDefaultGlslIoResolver::resolveUniformLocation(EShLanguage /*stage*/, TVarEn
 int TDefaultGlslIoResolver::resolveBinding(EShLanguage /*stage*/, TVarEntryInfo& ent) {
    const TType& type = ent.symbol->getType();
-    const TString& name = ent.symbol->getName();
+    const TString& name = IsAnonymous(ent.symbol->getName()) ?
                            ent.symbol->getType().getTypeName()
                            :
                            ent.symbol->getName();
    // On OpenGL arrays of opaque types take a seperate binding for each element
    int numBindings = intermediate.getSpv().openGl != 0 && type.isSizedArray() ? type.getCumulativeArraySize() : 1;
    TResourceType resource = getResourceType(type);
@@ -809,7 +818,10 @@ void TDefaultGlslIoResolver::endCollect(EShLanguage /*stage*/) {
 void TDefaultGlslIoResolver::reserverStorageSlot(TVarEntryInfo& ent, TInfoSink& infoSink) {
    const TType& type = ent.symbol->getType();
-    const TString& name = ent.symbol->getName();
+    const TString& name = IsAnonymous(ent.symbol->getName()) ?
                            ent.symbol->getType().getTypeName()
                            :
                            ent.symbol->getName();
    TStorageQualifier storage = type.getQualifier().storage;
    EShLanguage stage(EShLangCount);
    switch (storage) {
@@ -831,6 +843,7 @@ void TDefaultGlslIoResolver::reserverStorageSlot(TVarEntryInfo& ent, TInfoSink&
                if (iter->second != location) {
                    TString errorMsg = "Invalid location: " + name;
                    infoSink.info.message(EPrefixInternalError, errorMsg.c_str());
                    hasError = true;
                }
            }
        }
@@ -856,6 +869,7 @@ void TDefaultGlslIoResolver::reserverStorageSlot(TVarEntryInfo& ent, TInfoSink&
                if (iter->second != location) {
                    TString errorMsg = "Invalid location: " + name;
                    infoSink.info.message(EPrefixInternalError, errorMsg.c_str());
                    hasError = true;
                }
            }
        }
@@ -867,7 +881,10 @@ void TDefaultGlslIoResolver::reserverStorageSlot(TVarEntryInfo& ent, TInfoSink&
 void TDefaultGlslIoResolver::reserverResourceSlot(TVarEntryInfo& ent, TInfoSink& infoSink) {
    const TType& type = ent.symbol->getType();
-    const TString& name = ent.symbol->getName();
+    const TString& name = IsAnonymous(ent.symbol->getName()) ?
                            ent.symbol->getType().getTypeName()
                            :
                            ent.symbol->getName();
    int resource = getResourceType(type);
    if (type.getQualifier().hasBinding()) {
        TVarSlotMap& varSlotMap = resourceSlotMap[resource];
@@ -884,6 +901,7 @@ void TDefaultGlslIoResolver::reserverResourceSlot(TVarEntryInfo& ent, TInfoSink&
            if (iter->second != binding) {
                TString errorMsg = "Invalid binding: " + name;
                infoSink.info.message(EPrefixInternalError, errorMsg.c_str());
                hasError = true;
            }
        }
    }
@@ -1158,7 +1176,7 @@ bool TGlslIoMapper::addStage(EShLanguage stage, TIntermediate& intermediate, TIn
        resolver = &defaultResolver;
    }
    resolver->addStage(stage);
-    inVarMaps[stage] = new TVarLiveMap, outVarMaps[stage] = new TVarLiveMap(), uniformVarMap[stage] = new TVarLiveMap();
+    inVarMaps[stage] = new TVarLiveMap(); outVarMaps[stage] = new TVarLiveMap(); uniformVarMap[stage] = new TVarLiveMap();
    TVarGatherTraverser iter_binding_all(intermediate, true, *inVarMaps[stage], *outVarMaps[stage],
                                         *uniformVarMap[stage]);
    TVarGatherTraverser iter_binding_live(intermediate, false, *inVarMaps[stage], *outVarMaps[stage],
@@ -129,6 +129,7 @@ public:
    uint32_t computeTypeLocationSize(const TType& type, EShLanguage stage);
    TSlotSetMap slots;
    bool hasError = false;
 protected:
    TDefaultIoResolverBase(TDefaultIoResolverBase&);
@@ -260,10 +261,10 @@ public:
 class TGlslIoMapper : public TIoMapper {
 public:
    TGlslIoMapper() {
-        memset(inVarMaps,     0, sizeof(TVarLiveMap*)   * (EShLangCount + 1));
+        memset(inVarMaps,     0, sizeof(TVarLiveMap*)   * EShLangCount);
-        memset(outVarMaps,    0, sizeof(TVarLiveMap*)   * (EShLangCount + 1));
+        memset(outVarMaps,    0, sizeof(TVarLiveMap*)   * EShLangCount);
-        memset(uniformVarMap, 0, sizeof(TVarLiveMap*)   * (EShLangCount + 1));
+        memset(uniformVarMap, 0, sizeof(TVarLiveMap*)   * EShLangCount);
-        memset(intermediates, 0, sizeof(TIntermediate*) * (EShLangCount + 1));
+        memset(intermediates, 0, sizeof(TIntermediate*) * EShLangCount);
    }
    virtual ~TGlslIoMapper() {
        for (size_t stage = 0; stage < EShLangCount; stage++) {
@@ -138,7 +138,11 @@ void TIntermediate::mergeModes(TInfoSink& infoSink, TIntermediate& unit)
    MERGE_MAX(spvVersion.openGl);
    numErrors += unit.getNumErrors();
-    numPushConstants += unit.numPushConstants;
+    // Only one push_constant is allowed, mergeLinkerObjects() will ensure the push_constant
    // is the same for all units.
    if (numPushConstants > 1 || unit.numPushConstants > 1)
        error(infoSink, "Only one push_constant block is allowed per stage");
    numPushConstants = std::min(numPushConstants + unit.numPushConstants, 1);
    if (unit.invocations != TQualifier::layoutNotSet) {
        if (invocations == TQualifier::layoutNotSet)
@@ -286,7 +290,7 @@ void TIntermediate::mergeTrees(TInfoSink& infoSink, TIntermediate& unit)
    }
    // Getting this far means we have two existing trees to merge...
-    numShaderRecordNVBlocks += unit.numShaderRecordNVBlocks;
+    numShaderRecordBlocks += unit.numShaderRecordBlocks;
    numTaskNVBlocks += unit.numTaskNVBlocks;
    // Get the top-level globals of each unit
@@ -299,10 +303,10 @@ void TIntermediate::mergeTrees(TInfoSink& infoSink, TIntermediate& unit)
    // Map by global name to unique ID to rationalize the same object having
    // differing IDs in different trees.
-    TMap<TString, int> idMap;
+    TIdMaps idMaps;
    int maxId;
-    seedIdMap(idMap, maxId);
+    seedIdMap(idMaps, maxId);
-    remapIds(idMap, maxId + 1, unit);
+    remapIds(idMaps, maxId + 1, unit);
    mergeBodies(infoSink, globals, unitGlobals);
    mergeLinkerObjects(infoSink, linkerObjects, unitLinkerObjects);
@@ -311,27 +315,40 @@ void TIntermediate::mergeTrees(TInfoSink& infoSink, TIntermediate& unit)
 #endif
 static const TString& getNameForIdMap(TIntermSymbol* symbol)
 {
    TShaderInterface si = symbol->getType().getShaderInterface();
    if (si == EsiNone)
        return symbol->getName();
    else
        return symbol->getType().getTypeName();
 }
 // Traverser that seeds an ID map with all built-ins, and tracks the
 // maximum ID used.
 // (It would be nice to put this in a function, but that causes warnings
 // on having no bodies for the copy-constructor/operator=.)
 class TBuiltInIdTraverser : public TIntermTraverser {
 public:
-    TBuiltInIdTraverser(TMap<TString, int>& idMap) : idMap(idMap), maxId(0) { }
+    TBuiltInIdTraverser(TIdMaps& idMaps) : idMaps(idMaps), maxId(0) { }
    // If it's a built in, add it to the map.
    // Track the max ID.
    virtual void visitSymbol(TIntermSymbol* symbol)
    {
        const TQualifier& qualifier = symbol->getType().getQualifier();
-        if (qualifier.builtIn != EbvNone)
+        if (qualifier.builtIn != EbvNone) {
-            idMap[symbol->getName()] = symbol->getId();
+            TShaderInterface si = symbol->getType().getShaderInterface();
            idMaps[si][getNameForIdMap(symbol)] = symbol->getId();
        }
        maxId = std::max(maxId, symbol->getId());
    }
    int getMaxId() const { return maxId; }
 protected:
    TBuiltInIdTraverser(TBuiltInIdTraverser&);
    TBuiltInIdTraverser& operator=(TBuiltInIdTraverser&);
-    TMap<TString, int>& idMap;
+    TIdMaps& idMaps;
    int maxId;
 };
@@ -340,31 +357,33 @@ protected:
 // on having no bodies for the copy-constructor/operator=.)
 class TUserIdTraverser : public TIntermTraverser {
 public:
-    TUserIdTraverser(TMap<TString, int>& idMap) : idMap(idMap) { }
+    TUserIdTraverser(TIdMaps& idMaps) : idMaps(idMaps) { }
    // If its a non-built-in global, add it to the map.
    virtual void visitSymbol(TIntermSymbol* symbol)
    {
        const TQualifier& qualifier = symbol->getType().getQualifier();
-        if (qualifier.builtIn == EbvNone)
+        if (qualifier.builtIn == EbvNone) {
-            idMap[symbol->getName()] = symbol->getId();
+            TShaderInterface si = symbol->getType().getShaderInterface();
            idMaps[si][getNameForIdMap(symbol)] = symbol->getId();
        }
    }
 protected:
    TUserIdTraverser(TUserIdTraverser&);
    TUserIdTraverser& operator=(TUserIdTraverser&);
-    TMap<TString, int>& idMap; // over biggest id
+    TIdMaps& idMaps; // over biggest id
 };
 // Initialize the the ID map with what we know of 'this' AST.
-void TIntermediate::seedIdMap(TMap<TString, int>& idMap, int& maxId)
+void TIntermediate::seedIdMap(TIdMaps& idMaps, int& maxId)
 {
    // all built-ins everywhere need to align on IDs and contribute to the max ID
-    TBuiltInIdTraverser builtInIdTraverser(idMap);
+    TBuiltInIdTraverser builtInIdTraverser(idMaps);
    treeRoot->traverse(&builtInIdTraverser);
    maxId = builtInIdTraverser.getMaxId();
    // user variables in the linker object list need to align on ids
-    TUserIdTraverser userIdTraverser(idMap);
+    TUserIdTraverser userIdTraverser(idMaps);
    findLinkerObjects()->traverse(&userIdTraverser);
 }
@@ -373,7 +392,7 @@ void TIntermediate::seedIdMap(TMap<TString, int>& idMap, int& maxId)
 // on having no bodies for the copy-constructor/operator=.)
 class TRemapIdTraverser : public TIntermTraverser {
 public:
-    TRemapIdTraverser(const TMap<TString, int>& idMap, int idShift) : idMap(idMap), idShift(idShift) { }
+    TRemapIdTraverser(const TIdMaps& idMaps, int idShift) : idMaps(idMaps), idShift(idShift) { }
    // Do the mapping:
    //  - if the same symbol, adopt the 'this' ID
    //  - otherwise, ensure a unique ID by shifting to a new space
@@ -382,8 +401,9 @@ public:
        const TQualifier& qualifier = symbol->getType().getQualifier();
        bool remapped = false;
        if (qualifier.isLinkable() || qualifier.builtIn != EbvNone) {
-            auto it = idMap.find(symbol->getName());
+            TShaderInterface si = symbol->getType().getShaderInterface();
-            if (it != idMap.end()) {
+            auto it = idMaps[si].find(getNameForIdMap(symbol));
            if (it != idMaps[si].end()) {
                symbol->changeId(it->second);
                remapped = true;
            }
@@ -394,14 +414,14 @@ public:
 protected:
    TRemapIdTraverser(TRemapIdTraverser&);
    TRemapIdTraverser& operator=(TRemapIdTraverser&);
-    const TMap<TString, int>& idMap;
+    const TIdMaps& idMaps;
    int idShift;
 };
-void TIntermediate::remapIds(const TMap<TString, int>& idMap, int idShift, TIntermediate& unit)
+void TIntermediate::remapIds(const TIdMaps& idMaps, int idShift, TIntermediate& unit)
 {
    // Remap all IDs to either share or be unique, as dictated by the idMap and idShift.
-    TRemapIdTraverser idTraverser(idMap, idShift);
+    TRemapIdTraverser idTraverser(idMaps, idShift);
    unit.getTreeRoot()->traverse(&idTraverser);
 }
@@ -443,7 +463,19 @@ void TIntermediate::mergeLinkerObjects(TInfoSink& infoSink, TIntermSequence& lin
            TIntermSymbol* symbol = linkerObjects[linkObj]->getAsSymbolNode();
            TIntermSymbol* unitSymbol = unitLinkerObjects[unitLinkObj]->getAsSymbolNode();
            assert(symbol && unitSymbol);
-            if (symbol->getName() == unitSymbol->getName()) {
+
            bool isSameSymbol = false;
            // If they are both blocks in the same shader interface,
            // match by the block-name, not the identifier name.
            if (symbol->getType().getBasicType() == EbtBlock && unitSymbol->getType().getBasicType() == EbtBlock) {
                if (symbol->getType().getShaderInterface() == unitSymbol->getType().getShaderInterface()) {
                    isSameSymbol = symbol->getType().getTypeName() == unitSymbol->getType().getTypeName();
                }
            }
            else if (symbol->getName() == unitSymbol->getName())
                isSameSymbol = true;
            if (isSameSymbol) {
                // filter out copy
                merge = false;
@@ -462,6 +494,9 @@ void TIntermediate::mergeLinkerObjects(TInfoSink& infoSink, TIntermSequence& lin
                // Check for consistent types/qualification/initializers etc.
                mergeErrorCheck(infoSink, *symbol, *unitSymbol, false);
            }
            // If different symbols, verify they arn't push_constant since there can only be one per stage
            else if (symbol->getQualifier().isPushConstant() && unitSymbol->getQualifier().isPushConstant())
                error(infoSink, "Only one push_constant block is allowed per stage");
        }
        if (merge)
            linkerObjects.push_back(unitLinkerObjects[unitLinkObj]);
@@ -520,6 +555,22 @@ void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& sy
        writeTypeComparison = true;
    }
    // Uniform and buffer blocks must either both have an instance name, or
    // must both be anonymous. The names don't need to match though.
    if (symbol.getQualifier().isUniformOrBuffer() &&
        (IsAnonymous(symbol.getName()) != IsAnonymous(unitSymbol.getName()))) {
        error(infoSink, "Matched Uniform or Storage blocks must all be anonymous,"
                        " or all be named:");
        writeTypeComparison = true;
    }
    if (symbol.getQualifier().storage == unitSymbol.getQualifier().storage &&
        (IsAnonymous(symbol.getName()) != IsAnonymous(unitSymbol.getName()) ||
         (!IsAnonymous(symbol.getName()) && symbol.getName() != unitSymbol.getName()))) {
        warn(infoSink, "Matched shader interfaces are using different instance names.");
        writeTypeComparison = true;
    }
    // Precision...
    if (symbol.getQualifier().precision != unitSymbol.getQualifier().precision) {
        error(infoSink, "Precision qualifiers must match:");
@@ -555,6 +606,7 @@ void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& sy
        symbol.getQualifier().queuefamilycoherent  != unitSymbol.getQualifier().queuefamilycoherent ||
        symbol.getQualifier().workgroupcoherent != unitSymbol.getQualifier().workgroupcoherent ||
        symbol.getQualifier().subgroupcoherent  != unitSymbol.getQualifier().subgroupcoherent ||
        symbol.getQualifier().shadercallcoherent!= unitSymbol.getQualifier().shadercallcoherent ||
        symbol.getQualifier().nonprivate        != unitSymbol.getQualifier().nonprivate ||
        symbol.getQualifier().volatil           != unitSymbol.getQualifier().volatil ||
        symbol.getQualifier().restrict          != unitSymbol.getQualifier().restrict ||
@@ -589,9 +641,13 @@ void TIntermediate::mergeErrorCheck(TInfoSink& infoSink, const TIntermSymbol& sy
        }
    }
-    if (writeTypeComparison)
+    if (writeTypeComparison) {
-        infoSink.info << "    " << symbol.getName() << ": \"" << symbol.getType().getCompleteString() << "\" versus \"" <<
+        infoSink.info << "    " << symbol.getName() << ": \"" << symbol.getType().getCompleteString() << "\" versus ";
-                                                             unitSymbol.getType().getCompleteString() << "\"\n";
+        if (symbol.getName() != unitSymbol.getName())
            infoSink.info << unitSymbol.getName() << ": ";
        infoSink.info << "\"" << unitSymbol.getType().getCompleteString() << "\"\n";
    }
 #endif
 }
@@ -721,13 +777,13 @@ void TIntermediate::finalCheck(TInfoSink& infoSink, bool keepUncalled)
        break;
    case EShLangCompute:
        break;
-    case EShLangRayGenNV:
+    case EShLangRayGen:
-    case EShLangIntersectNV:
+    case EShLangIntersect:
-    case EShLangAnyHitNV:
+    case EShLangAnyHit:
-    case EShLangClosestHitNV:
+    case EShLangClosestHit:
-    case EShLangMissNV:
+    case EShLangMiss:
-    case EShLangCallableNV:
+    case EShLangCallable:
-        if (numShaderRecordNVBlocks > 1)
+        if (numShaderRecordBlocks > 1)
            error(infoSink, "Only one shaderRecordNV buffer block is allowed per stage");
        break;
    case EShLangMeshNV:
@@ -162,7 +162,10 @@ struct TXfbBuffer {
 #endif
 // Track a set of strings describing how the module was processed.
-// Using the form:
+// This includes command line options, transforms, etc., ideally inclusive enough
 // to reproduce the steps used to transform the input source to the output.
 // E.g., see SPIR-V OpModuleProcessed.
 // Each "process" or "transform" uses is expressed in the form:
 //   process arg0 arg1 arg2 ...
 //   process arg0 arg1 arg2 ...
 // where everything is textual, and there can be zero or more arguments
@@ -222,6 +225,15 @@ enum ComputeDerivativeMode {
    LayoutDerivativeGroupLinear,  // derivative_group_linearNV
 };
 class TIdMaps {
 public:
    TMap<TString, int>& operator[](int i) { return maps[i]; }
    const TMap<TString, int>& operator[](int i) const { return maps[i]; }
 private:
    TMap<TString, int> maps[EsiCount];
 };
 //
 // Set of helper functions to help parse and build the tree.
 //
@@ -249,7 +261,7 @@ public:
        blendEquations(0), xfbMode(false), multiStream(false),
        layoutOverrideCoverage(false),
        geoPassthroughEXT(false),
-        numShaderRecordNVBlocks(0),
+        numShaderRecordBlocks(0),
        computeDerivativeMode(LayoutDerivativeNone),
        primitives(TQualifier::layoutNotSet),
        numTaskNVBlocks(0),
@@ -332,6 +344,9 @@ public:
        case EShTargetVulkan_1_1:
            processes.addProcess("target-env vulkan1.1");
            break;
        case EShTargetVulkan_1_2:
            processes.addProcess("target-env vulkan1.2");
            break;
        default:
            processes.addProcess("target-env vulkanUnknown");
            break;
@@ -500,7 +515,7 @@ public:
    bool getAutoMapBindings() const { return false; }
    bool getAutoMapLocations() const { return false; }
    int getNumPushConstants() const { return 0; }
-    void addShaderRecordNVCount() { }
+    void addShaderRecordCount() { }
    void addTaskNVCount() { }
    void setUseVulkanMemoryModel() { }
    bool usingVulkanMemoryModel() const { return false; }
@@ -617,7 +632,7 @@ public:
    void setTextureSamplerTransformMode(EShTextureSamplerTransformMode mode) { textureSamplerTransformMode = mode; }
    int getNumPushConstants() const { return numPushConstants; }
-    void addShaderRecordNVCount() { ++numShaderRecordNVBlocks; }
+    void addShaderRecordCount() { ++numShaderRecordBlocks; }
    void addTaskNVCount() { ++numTaskNVBlocks; }
    bool setInvocations(int i)
@@ -856,8 +871,8 @@ protected:
    void mergeCallGraphs(TInfoSink&, TIntermediate&);
    void mergeModes(TInfoSink&, TIntermediate&);
    void mergeTrees(TInfoSink&, TIntermediate&);
-    void seedIdMap(TMap<TString, int>& idMap, int& maxId);
+    void seedIdMap(TIdMaps& idMaps, int& maxId);
-    void remapIds(const TMap<TString, int>& idMap, int idShift, TIntermediate&);
+    void remapIds(const TIdMaps& idMaps, int idShift, TIntermediate&);
    void mergeBodies(TInfoSink&, TIntermSequence& globals, const TIntermSequence& unitGlobals);
    void mergeLinkerObjects(TInfoSink&, TIntermSequence& linkerObjects, const TIntermSequence& unitLinkerObjects);
    void mergeImplicitArraySizes(TType&, const TType&);
@@ -942,7 +957,7 @@ protected:
    bool multiStream;
    bool layoutOverrideCoverage;
    bool geoPassthroughEXT;
-    int numShaderRecordNVBlocks;
+    int numShaderRecordBlocks;
    ComputeDerivativeMode computeDerivativeMode;
    int primitives;
    int numTaskNVBlocks;
@@ -165,17 +165,27 @@ void TConstTraverser::visitConstantUnion(TIntermConstantUnion* node)
                    }
                }
            } else {
-                // matrix from vector
+                // matrix from vector or scalar
                int count = 0;
                const int startIndex = index;
                int nodeComps = node->getType().computeNumComponents();
                for (int i = startIndex; i < endIndex; i++) {
                    if (i >= instanceSize)
                        return;
                    if (nodeComps == 1) {
                        // If there is a single scalar parameter to a matrix
                        // constructor, it is used to initialize all the
                        // components on the matrix's diagonal, with the
                        // remaining components initialized to 0.0.
                        if (i == startIndex || (i - startIndex) % (matrixRows + 1) == 0 )
                            leftUnionArray[i] = rightUnionArray[count];
                        else
                            leftUnionArray[i].setDConst(0.0);
                    } else {
                        // construct the matrix in column-major order, from
                        // the components provided, in order
                        leftUnionArray[i] = rightUnionArray[count];
                    }
                    index++;
@@ -621,14 +621,25 @@ int TPpContext::CPPinclude(TPpToken* ppToken)
 {
    const TSourceLoc directiveLoc = ppToken->loc;
    bool startWithLocalSearch = true; // to additionally include the extra "" paths
-    int token = scanToken(ppToken);
+    int token;
-    // handle <header-name>-style #include
+    // Find the first non-whitespace char after #include
-    if (token == '<') {
+    int ch = getChar();
    while (ch == ' ' || ch == '\t') {
        ch = getChar();
    }
    if (ch == '<') {
        // <header-name> style
        startWithLocalSearch = false;
        token = scanHeaderName(ppToken, '>');
    } else if (ch == '"') {
        // "header-name" style
        token = scanHeaderName(ppToken, '"');
    } else {
        // unexpected, get the full token to generate the error
        ungetChar();
        token = scanToken(ppToken);
    }
    // otherwise ppToken already has the header name and it was "header-name" style
    if (token != PpAtomConstString) {
        parseContext.ppError(directiveLoc, "must be followed by a header name", "#include", "");
@@ -711,7 +722,9 @@ int TPpContext::CPPline(TPpToken* ppToken)
    const char* sourceName = nullptr; // Optional source file name.
    bool lineErr = false;
    bool fileErr = false;
    disableEscapeSequences = true;
    token = eval(token, MIN_PRECEDENCE, false, lineRes, lineErr, ppToken);
    disableEscapeSequences = false;
    if (! lineErr) {
        lineToken = lineRes;
        if (token == '\n')
@@ -754,7 +767,9 @@ int TPpContext::CPPline(TPpToken* ppToken)
 // Handle #error
 int TPpContext::CPPerror(TPpToken* ppToken)
 {
    disableEscapeSequences = true;
    int token = scanToken(ppToken);
    disableEscapeSequences = false;
    std::string message;
    TSourceLoc loc = ppToken->loc;
@@ -87,7 +87,8 @@ namespace glslang {
 TPpContext::TPpContext(TParseContextBase& pc, const std::string& rootFileName, TShader::Includer& inclr) :
    preamble(0), strings(0), previous_token('\n'), parseContext(pc), includer(inclr), inComment(false),
    rootFileName(rootFileName),
-    currentSourceFile(rootFileName)
+    currentSourceFile(rootFileName),
    disableEscapeSequences(false)
 {
    ifdepth = 0;
    for (elsetracker = 0; elsetracker < maxIfNesting; elsetracker++)
@@ -105,13 +105,13 @@ public:
    }
    // Used for comparing macro definitions, so checks what is relevant for that.
-    bool operator==(const TPpToken& right)
+    bool operator==(const TPpToken& right) const
    {
        return space == right.space &&
               ival == right.ival && dval == right.dval && i64val == right.i64val &&
               strncmp(name, right.name, MaxTokenLength) == 0;
    }
-    bool operator!=(const TPpToken& right) { return ! operator==(right); }
+    bool operator!=(const TPpToken& right) const { return ! operator==(right); }
    TSourceLoc loc;
    // True if a space (for white space or a removed comment) should also be
@@ -695,6 +695,7 @@ protected:
    std::string currentSourceFile;
    std::istringstream strtodStream;
    bool disableEscapeSequences;
 };
 } // end namespace glslang
@@ -1026,12 +1026,80 @@ int TPpContext::tStringInput::scan(TPpToken* ppToken)
        case '\'':
            return pp->characterLiteral(ppToken);
        case '"':
-            // TODO: If this gets enhanced to handle escape sequences, or
+            // #include uses scanHeaderName() to ignore these escape sequences.
            // anything that is different than what #include needs, then
            // #include needs to use scanHeaderName() for this.
            ch = getch();
            while (ch != '"' && ch != '\n' && ch != EndOfInput) {
                if (len < MaxTokenLength) {
                    if (ch == '\\' && !pp->disableEscapeSequences) {
                        int nextCh = getch();
                        switch (nextCh) {
                        case '\'': ch = 0x27; break;
                        case '"':  ch = 0x22; break;
                        case '?':  ch = 0x3f; break;
                        case '\\': ch = 0x5c; break;
                        case 'a':  ch = 0x07; break;
                        case 'b':  ch = 0x08; break;
                        case 'f':  ch = 0x0c; break;
                        case 'n':  ch = 0x0a; break;
                        case 'r':  ch = 0x0d; break;
                        case 't':  ch = 0x09; break;
                        case 'v':  ch = 0x0b; break;
                        case 'x': 
                            // Hex value, arbitrary number of characters. Terminated by the first
                            // non-hex digit
                            {
                                int numDigits = 0;
                                ch = 0;
                                while (true) {
                                    nextCh = getch();
                                    if (nextCh >= '0' && nextCh <= '9')
                                        nextCh -= '0';
                                    else if (nextCh >= 'A' && nextCh <= 'F')
                                        nextCh -= 'A' - 10;
                                    else if (nextCh >= 'a' && nextCh <= 'f')
                                        nextCh -= 'a' - 10;
                                    else {
                                        ungetch();
                                        break;
                                    }
                                    numDigits++;
                                    ch = ch * 0x10 + nextCh;
                                }
                                if (numDigits == 0) {
                                    pp->parseContext.ppError(ppToken->loc, "Expected hex value in escape sequence", "string", "");
                                }
                                break;
                            }
                        case '0':
                        case '1':
                        case '2':
                        case '3':
                        case '4':
                        case '5':
                        case '6':
                        case '7':
                            // Octal value, up to three octal digits
                            {
                                int numDigits = 1;
                                ch = nextCh - '0';
                                while (numDigits < 3) {
                                    nextCh = getch();
                                    if (nextCh >= '0' && nextCh <= '7')
                                        nextCh -= '0';
                                    else {
                                        ungetch();
                                        break;
                                    }
                                    numDigits++;
                                    ch = ch * 8 + nextCh;
                                }
                                break;
                            }
                        default:
                            pp->parseContext.ppError(ppToken->loc, "Invalid escape sequence", "string", "");
                            break;
                        }
                    }
                    ppToken->name[len] = (char)ch;
                    len++;
                    ch = getch();
@@ -1120,9 +1188,11 @@ int TPpContext::tokenize(TPpToken& ppToken)
                continue;
            break;
        case PpAtomConstString:
            if (ifdepth == 0 && parseContext.intermediate.getSource() != EShSourceHlsl) {
            // HLSL allows string literals.
-                parseContext.ppError(ppToken.loc, "string literals not supported", "\"\"", "");
+            // GLSL allows string literals with GL_EXT_debug_printf.
            if (ifdepth == 0 && parseContext.intermediate.getSource() != EShSourceHlsl) {
                parseContext.requireExtensions(ppToken.loc, 1, &E_GL_EXT_debug_printf, "string literal");
                if (!parseContext.extensionTurnedOn(E_GL_EXT_debug_printf))
                    continue;
            }
            break;
@@ -1188,7 +1188,7 @@ void TReflection::dump()
        for (int dim=0; dim<3; ++dim)
            if (getLocalSize(dim) > 1)
-                printf("Local size %s: %d\n", axis[dim], getLocalSize(dim));
+                printf("Local size %s: %u\n", axis[dim], getLocalSize(dim));
        printf("\n");
    }
@@ -176,7 +176,12 @@ extern "C" {
 * If null, the compilation failed.
 */
 EMSCRIPTEN_KEEPALIVE
-void* convert_glsl_to_spirv(const char* glsl, int stage_int, bool gen_debug, uint32_t** spirv, size_t* spirv_len)
+void* convert_glsl_to_spirv(const char* glsl,
                            int stage_int,
                            bool gen_debug,
                            glslang::EShTargetLanguageVersion spirv_version,
                            uint32_t** spirv,
                            size_t* spirv_len)
 {
    if (glsl == nullptr) {
        fprintf(stderr, "Input pointer null\n");
@@ -194,6 +199,18 @@ void* convert_glsl_to_spirv(const char* glsl, int stage_int, bool gen_debug, uin
        return nullptr;
    }
    EShLanguage stage = static_cast<EShLanguage>(stage_int);
    switch (spirv_version) {
        case glslang::EShTargetSpv_1_0:
        case glslang::EShTargetSpv_1_1:
        case glslang::EShTargetSpv_1_2:
        case glslang::EShTargetSpv_1_3:
        case glslang::EShTargetSpv_1_4:
        case glslang::EShTargetSpv_1_5:
            break;
        default:
            fprintf(stderr, "Invalid SPIR-V version number\n");
            return nullptr;
    }
    if (!initialized) {
        glslang::InitializeProcess();
@@ -203,8 +220,8 @@ void* convert_glsl_to_spirv(const char* glsl, int stage_int, bool gen_debug, uin
    glslang::TShader shader(stage);
    shader.setStrings(&glsl, 1);
    shader.setEnvInput(glslang::EShSourceGlsl, stage, glslang::EShClientVulkan, 100);
-    shader.setEnvClient(glslang::EShClientVulkan, glslang::EShTargetVulkan_1_1);
+    shader.setEnvClient(glslang::EShClientVulkan, glslang::EShTargetVulkan_1_0);
-    shader.setEnvTarget(glslang::EShTargetSpv, glslang::EShTargetSpv_1_3);
+    shader.setEnvTarget(glslang::EShTargetSpv, spirv_version);
    if (!shader.parse(&DefaultTBuiltInResource, 100, true, EShMsgDefault)) {
        fprintf(stderr, "Parse failed\n");
        fprintf(stderr, "%s\n", shader.getInfoLog());
@@ -260,7 +277,7 @@ void main() { })";
    uint32_t* output;
    size_t output_len;
-    void* id = convert_glsl_to_spirv(input, 4, false, &output, &output_len);
+    void* id = convert_glsl_to_spirv(input, 4, false, glslang::EShTargetSpv_1_0, &output, &output_len);
    assert(output != nullptr);
    assert(output_len != 0);
    destroy_output_buffer(id);
@@ -1,23 +1,34 @@
-Module['compileGLSLZeroCopy'] = function(glsl, shader_stage, gen_debug) {
+Module['compileGLSLZeroCopy'] = function(glsl, shader_stage, gen_debug, spirv_version) {
    gen_debug = !!gen_debug;
-    var shader_stage_int;
+    var shader_stage_int; // EShLanguage
-    if (shader_stage === 'vertex') {
+    switch (shader_stage) {
-        shader_stage_int = 0;
+        case 'vertex':   shader_stage_int = 0; break;
-    } else if (shader_stage === 'fragment') {
+        case 'fragment': shader_stage_int = 4; break;
-        shader_stage_int = 4;
+        case 'compute':  shader_stage_int = 5; break;
-    } else if (shader_stage === 'compute') {
+        default:
-        shader_stage_int = 5;
+            throw new Error("shader_stage must be 'vertex', 'fragment', or 'compute'.");
-    } else {
+    }
-        throw new Error("shader_stage must be 'vertex', 'fragment', or 'compute'");
+
    spirv_version = spirv_version || '1.0';
    var spirv_version_int; // EShTargetLanguageVersion
    switch (spirv_version) {
        case '1.0': spirv_version_int = (1 << 16) | (0 << 8); break;
        case '1.1': spirv_version_int = (1 << 16) | (1 << 8); break;
        case '1.2': spirv_version_int = (1 << 16) | (2 << 8); break;
        case '1.3': spirv_version_int = (1 << 16) | (3 << 8); break;
        case '1.4': spirv_version_int = (1 << 16) | (4 << 8); break;
        case '1.5': spirv_version_int = (1 << 16) | (5 << 8); break;
        default:
            throw new Error("spirv_version must be '1.0' ~ '1.5'.");
    }
    var p_output = Module['_malloc'](4);
    var p_output_len = Module['_malloc'](4);
    var id = ccall('convert_glsl_to_spirv',
        'number',
-        ['string', 'number', 'boolean', 'number', 'number'],
+        ['string', 'number', 'boolean', 'number', 'number', 'number'],
-        [glsl, shader_stage_int, gen_debug, p_output, p_output_len]);
+        [glsl, shader_stage_int, gen_debug, spirv_version_int, p_output, p_output_len]);
    var output = getValue(p_output, 'i32');
    var output_len = getValue(p_output_len, 'i32');
    Module['_free'](p_output);
@@ -37,8 +48,8 @@ Module['compileGLSLZeroCopy'] = function(glsl, shader_stage, gen_debug) {
    return ret;
 };
-Module['compileGLSL'] = function(glsl, shader_stage, gen_debug) {
+Module['compileGLSL'] = function(glsl, shader_stage, gen_debug, spirv_version) {
-    var compiled = Module['compileGLSLZeroCopy'](glsl, shader_stage, gen_debug);
+    var compiled = Module['compileGLSLZeroCopy'](glsl, shader_stage, gen_debug, spirv_version);
    var ret = compiled['data'].slice()
    compiled['free']();
    return ret;
@@ -92,15 +92,21 @@ typedef enum {
    EShLangGeometry,
    EShLangFragment,
    EShLangCompute,
-    EShLangRayGenNV,
+    EShLangRayGen,
-    EShLangIntersectNV,
+    EShLangRayGenNV = EShLangRayGen,
-    EShLangAnyHitNV,
+    EShLangIntersect,
-    EShLangClosestHitNV,
+    EShLangIntersectNV = EShLangIntersect,
-    EShLangMissNV,
+    EShLangAnyHit,
-    EShLangCallableNV,
+    EShLangAnyHitNV = EShLangAnyHit,
    EShLangClosestHit,
    EShLangClosestHitNV = EShLangClosestHit,
    EShLangMiss,
    EShLangMissNV = EShLangMiss,
    EShLangCallable,
    EShLangCallableNV = EShLangCallable,
    EShLangTaskNV,
    EShLangMeshNV,
-    EShLangCount,
+    LAST_ELEMENT_MARKER(EShLangCount),
 } EShLanguage;         // would be better as stage, but this is ancient now
 typedef enum {
@@ -110,14 +116,21 @@ typedef enum {
    EShLangGeometryMask       = (1 << EShLangGeometry),
    EShLangFragmentMask       = (1 << EShLangFragment),
    EShLangComputeMask        = (1 << EShLangCompute),
-    EShLangRayGenNVMask       = (1 << EShLangRayGenNV),
+    EShLangRayGenMask         = (1 << EShLangRayGen),
-    EShLangIntersectNVMask    = (1 << EShLangIntersectNV),
+    EShLangRayGenNVMask       = EShLangRayGenMask,
-    EShLangAnyHitNVMask       = (1 << EShLangAnyHitNV),
+    EShLangIntersectMask      = (1 << EShLangIntersect),
-    EShLangClosestHitNVMask   = (1 << EShLangClosestHitNV),
+    EShLangIntersectNVMask    = EShLangIntersectMask,
-    EShLangMissNVMask         = (1 << EShLangMissNV),
+    EShLangAnyHitMask         = (1 << EShLangAnyHit),
-    EShLangCallableNVMask     = (1 << EShLangCallableNV),
+    EShLangAnyHitNVMask       = EShLangAnyHitMask,
    EShLangClosestHitMask     = (1 << EShLangClosestHit),
    EShLangClosestHitNVMask   = EShLangClosestHitMask,
    EShLangMissMask           = (1 << EShLangMiss),
    EShLangMissNVMask         = EShLangMissMask,
    EShLangCallableMask       = (1 << EShLangCallable),
    EShLangCallableNVMask     = EShLangCallableMask,
    EShLangTaskNVMask         = (1 << EShLangTaskNV),
    EShLangMeshNVMask         = (1 << EShLangMeshNV),
    LAST_ELEMENT_MARKER(EShLanguageMaskCount),
 } EShLanguageMask;
 namespace glslang {
@@ -128,24 +141,29 @@ typedef enum {
    EShSourceNone,
    EShSourceGlsl,               // GLSL, includes ESSL (OpenGL ES GLSL)
    EShSourceHlsl,               // HLSL
    LAST_ELEMENT_MARKER(EShSourceCount),
 } EShSource;                     // if EShLanguage were EShStage, this could be EShLanguage instead
 typedef enum {
    EShClientNone,               // use when there is no client, e.g. for validation
    EShClientVulkan,
    EShClientOpenGL,
    LAST_ELEMENT_MARKER(EShClientCount),
 } EShClient;
 typedef enum {
    EShTargetNone,
    EShTargetSpv,                 // SPIR-V (preferred spelling)
    EshTargetSpv = EShTargetSpv,  // legacy spelling
    LAST_ELEMENT_MARKER(EShTargetCount),
 } EShTargetLanguage;
 typedef enum {
    EShTargetVulkan_1_0 = (1 << 22),                  // Vulkan 1.0
    EShTargetVulkan_1_1 = (1 << 22) | (1 << 12),      // Vulkan 1.1
    EShTargetVulkan_1_2 = (1 << 22) | (2 << 12),      // Vulkan 1.2
    EShTargetOpenGL_450 = 450,                        // OpenGL
    LAST_ELEMENT_MARKER(EShTargetClientVersionCount),
 } EShTargetClientVersion;
 typedef EShTargetClientVersion EshTargetClientVersion;
@@ -157,6 +175,7 @@ typedef enum {
    EShTargetSpv_1_3 = (1 << 16) | (3 << 8),          // SPIR-V 1.3
    EShTargetSpv_1_4 = (1 << 16) | (4 << 8),          // SPIR-V 1.4
    EShTargetSpv_1_5 = (1 << 16) | (5 << 8),          // SPIR-V 1.5
    LAST_ELEMENT_MARKER(EShTargetLanguageVersionCount),
 } EShTargetLanguageVersion;
 struct TInputLanguage {
@@ -206,6 +225,7 @@ typedef enum {
    EShOptNone,
    EShOptSimple,       // Optimizations that can be done quickly
    EShOptFull,         // Optimizations that will take more time
    LAST_ELEMENT_MARKER(EshOptLevelCount),
 } EShOptimizationLevel;
 //
@@ -214,6 +234,7 @@ typedef enum {
 typedef enum {
    EShTexSampTransKeep,   // keep textures and samplers as is (default)
    EShTexSampTransUpgradeTextureRemoveSampler,  // change texture w/o embeded sampler into sampled texture and throw away all samplers
    LAST_ELEMENT_MARKER(EShTexSampTransCount),
 } EShTextureSamplerTransformMode;
 //
@@ -236,6 +257,7 @@ enum EShMessages {
    EShMsgHlslLegalization  = (1 << 12), // enable HLSL Legalization messages
    EShMsgHlslDX9Compatible = (1 << 13), // enable HLSL DX9 compatible mode (right now only for samplers)
    EShMsgBuiltinSymbolTable = (1 << 14), // print the builtin symbol table
    LAST_ELEMENT_MARKER(EShMsgCount),
 };
 //
@@ -249,6 +271,7 @@ typedef enum {
    EShReflectionSeparateBuffers   = (1 << 3), // buffer variables and buffer blocks are reflected separately
    EShReflectionAllBlockVariables = (1 << 4), // reflect all variables in blocks, even if they are inactive
    EShReflectionUnwrapIOBlocks    = (1 << 5), // unwrap input/output blocks the same as with uniform blocks
    LAST_ELEMENT_MARKER(EShReflectionCount),
 } EShReflectionOptions;
 //
@@ -394,6 +417,8 @@ enum TResourceType {
 //  - optionally call setEnv*(), see below for more detail
 //  - optionally use setPreamble() to set a special shader string that will be
 //    processed before all others but won't affect the validity of #version
 //  - optionally call addProcesses() for each setting/transform,
 //    see comment for class TProcesses
 //  - call parse(): source language and target environment must be selected
 //    either by correct setting of EShMessages sent to parse(), or by
 //    explicitly calling setEnv*()
@@ -628,11 +653,11 @@ protected:
    // stringNames is the optional names for all the strings. If stringNames
    // is null, then none of the strings has name. If a certain element in
    // stringNames is null, then the corresponding string does not have name.
-    const char* const* strings;
+    const char* const* strings;      // explicit code to compile, see previous comment
    const int* lengths;
    const char* const* stringNames;
-    const char* preamble;
+    int numStrings;                  // size of the above arrays
-    int numStrings;
+    const char* preamble;            // string of implicit code to compile before the explicitly provided code
    // a function in the source string can be renamed FROM this TO the name given in setEntryPoint.
    std::string sourceEntryPointName;
`@@ -1,3 +1,3 @@`
	`// This header is generated by the make-revision script.`	`// This header is generated by the make-revision script.`

	`#define GLSLANG_PATCH_LEVEL 3559`	`#define GLSLANG_PATCH_LEVEL 3741`