//

// Copyright (C) 2014-2016 LunarG, Inc.

// Copyright (C) 2015-2020 Google, Inc.

// Copyright (C) 2017, 2022-2025 Arm Limited.

// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.

//

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions

// are met:

//

//    Redistributions of source code must retain the above copyright

//    notice, this list of conditions and the following disclaimer.

//

//    Redistributions in binary form must reproduce the above

//    copyright notice, this list of conditions and the following

//    disclaimer in the documentation and/or other materials provided

//    with the distribution.

//

//    Neither the name of 3Dlabs Inc. Ltd. nor the names of its

//    contributors may be used to endorse or promote products derived

//    from this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS

// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE

// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,

// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,

// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

// POSSIBILITY OF SUCH DAMAGE.

//

// Visit the nodes in the glslang intermediate tree representation to

// translate them to SPIR-V.

//

#include "spirv.hpp11"

#include "GlslangToSpv.h"

#include "SpvBuilder.h"

#include "SpvTools.h"

#include "spvUtil.h"

namespace spv {

    #include "GLSL.std.450.h"

    #include "GLSL.ext.KHR.h"

    #include "GLSL.ext.EXT.h"

    #include "GLSL.ext.AMD.h"

    #include "GLSL.ext.NV.h"

    #include "GLSL.ext.ARM.h"

    #include "GLSL.ext.QCOM.h"

    #include "NonSemanticDebugPrintf.h"

}

// Glslang includes

#include "../glslang/MachineIndependent/localintermediate.h"

#include "../glslang/MachineIndependent/SymbolTable.h"

#include "../glslang/Include/Common.h"

// Build-time generated includes

#include "glslang/build_info.h"

#include <fstream>

#include <iomanip>

#include <list>

#include <map>

#include <optional>

#include <stack>

#include <string>

#include <vector>

namespace {

namespace {

class SpecConstantOpModeGuard {

public:

    SpecConstantOpModeGuard(spv::Builder* builder)

        : builder_(builder) {

        previous_flag_ = builder->isInSpecConstCodeGenMode();

    }

    ~SpecConstantOpModeGuard() {

        previous_flag_ ? builder_->setToSpecConstCodeGenMode()

                       : builder_->setToNormalCodeGenMode();

    }

    void turnOnSpecConstantOpMode() {

        builder_->setToSpecConstCodeGenMode();

    }

private:

    spv::Builder* builder_;

    bool previous_flag_;

};

struct OpDecorations {

    public:

        OpDecorations(spv::Decoration precision, spv::Decoration noContraction, spv::Decoration nonUniform) :

            precision(precision)

            ,

            noContraction(noContraction),

            nonUniform(nonUniform)

        { }

    spv::Decoration precision;

        void addNoContraction(spv::Builder& builder, spv::Id t) { builder.addDecoration(t, noContraction); }

        void addNonUniform(spv::Builder& builder, spv::Id t)  { builder.addDecoration(t, nonUniform); }

    protected:

    spv::Decoration noContraction;

    spv::Decoration nonUniform;

};

void addDerivativeGroupExecutionMode(spv::Builder& builder, const glslang::TIntermediate& intermediate,

                                     spv::Function* shaderEntry)

{

    if (intermediate.getLayoutDerivativeModeNone() == glslang::LayoutDerivativeGroupQuads) {

        if (intermediate.getLayoutDerivativeExtension() == glslang::EdgKHR) {

            builder.addCapability(spv::Capability::ComputeDerivativeGroupQuadsKHR);

            builder.addExecutionMode(shaderEntry, spv::ExecutionMode::DerivativeGroupQuadsKHR);

            builder.addExtension(spv::E_SPV_KHR_compute_shader_derivatives);

        } else {

            builder.addCapability(spv::Capability::ComputeDerivativeGroupQuadsNV);

            builder.addExecutionMode(shaderEntry, spv::ExecutionMode::DerivativeGroupQuadsNV);

            builder.addExtension(spv::E_SPV_NV_compute_shader_derivatives);

        }

    } else if (intermediate.getLayoutDerivativeModeNone() == glslang::LayoutDerivativeGroupLinear) {

        if (intermediate.getLayoutDerivativeExtension() == glslang::EdgKHR) {

            builder.addCapability(spv::Capability::ComputeDerivativeGroupLinearKHR);

            builder.addExecutionMode(shaderEntry, spv::ExecutionMode::DerivativeGroupLinearKHR);

            builder.addExtension(spv::E_SPV_KHR_compute_shader_derivatives);

        } else {

            builder.addCapability(spv::Capability::ComputeDerivativeGroupLinearNV);

            builder.addExecutionMode(shaderEntry, spv::ExecutionMode::DerivativeGroupLinearNV);

            builder.addExtension(spv::E_SPV_NV_compute_shader_derivatives);

        }

    }

}

} // namespace

//

// The main holder of information for translating glslang to SPIR-V.

//

// Derives from the AST walking base class.

//

class TGlslangToSpvTraverser : public glslang::TIntermTraverser {

public:

    TGlslangToSpvTraverser(unsigned int spvVersion, const glslang::TIntermediate*, spv::SpvBuildLogger* logger,

        glslang::SpvOptions& options);

    virtual ~TGlslangToSpvTraverser() { }

    bool visitAggregate(glslang::TVisit, glslang::TIntermAggregate*) override;

    bool visitBinary(glslang::TVisit, glslang::TIntermBinary*) override;

    void visitConstantUnion(glslang::TIntermConstantUnion*) override;

    bool visitSelection(glslang::TVisit, glslang::TIntermSelection*) override;

    bool visitSwitch(glslang::TVisit, glslang::TIntermSwitch*) override;

    void visitSymbol(glslang::TIntermSymbol* symbol) override;

    bool visitUnary(glslang::TVisit, glslang::TIntermUnary*) override;

    bool visitLoop(glslang::TVisit, glslang::TIntermLoop*) override;

    bool visitBranch(glslang::TVisit visit, glslang::TIntermBranch*) override;

    bool visitVariableDecl(glslang::TVisit, glslang::TIntermVariableDecl*) override;

    void finishSpv(bool compileOnly);

    void dumpSpv(std::vector<unsigned int>& out);

protected:

    TGlslangToSpvTraverser(TGlslangToSpvTraverser&);

    TGlslangToSpvTraverser& operator=(TGlslangToSpvTraverser&);

    spv::Decoration TranslateInterpolationDecoration(const glslang::TQualifier& qualifier);

    spv::Decoration TranslateAuxiliaryStorageDecoration(const glslang::TQualifier& qualifier);

    spv::Decoration TranslateNonUniformDecoration(const glslang::TQualifier& qualifier);

    spv::Decoration TranslateNonUniformDecoration(const spv::Builder::AccessChain::CoherentFlags& coherentFlags);

    spv::Builder::AccessChain::CoherentFlags TranslateCoherent(const glslang::TType& type);

    spv::MemoryAccessMask TranslateMemoryAccess(const spv::Builder::AccessChain::CoherentFlags &coherentFlags);

    spv::ImageOperandsMask TranslateImageOperands(const spv::Builder::AccessChain::CoherentFlags &coherentFlags);

    spv::Scope TranslateMemoryScope(const spv::Builder::AccessChain::CoherentFlags &coherentFlags);

    spv::BuiltIn TranslateBuiltInDecoration(glslang::TBuiltInVariable, bool memberDeclaration);

    spv::ImageFormat TranslateImageFormat(const glslang::TType& type);

    spv::SelectionControlMask TranslateSelectionControl(const glslang::TIntermSelection&) const;

    spv::SelectionControlMask TranslateSwitchControl(const glslang::TIntermSwitch&) const;

    spv::LoopControlMask TranslateLoopControl(const glslang::TIntermLoop&, std::vector<unsigned int>& operands) const;

    spv::StorageClass TranslateStorageClass(const glslang::TType&);

    void TranslateLiterals(const glslang::TVector<const glslang::TIntermConstantUnion*>&, std::vector<unsigned>&) const;

    void addIndirectionIndexCapabilities(const glslang::TType& baseType, const glslang::TType& indexType);

    spv::Id createSpvVariable(const glslang::TIntermSymbol*, spv::Id forcedType);

    spv::Id getSampledType(const glslang::TSampler&);

    spv::Id getInvertedSwizzleType(const glslang::TIntermTyped&);

    spv::Id createInvertedSwizzle(spv::Decoration precision, const glslang::TIntermTyped&, spv::Id parentResult);

    void convertSwizzle(const glslang::TIntermAggregate&, std::vector<unsigned>& swizzle);

    spv::Id convertGlslangToSpvType(const glslang::TType& type, bool forwardReferenceOnly = false);

    spv::Id convertGlslangToSpvType(const glslang::TType& type, glslang::TLayoutPacking, const glslang::TQualifier&,

        bool lastBufferBlockMember, bool forwardReferenceOnly = false);

    void applySpirvDecorate(const glslang::TType& type, spv::Id id, std::optional<int> member);

    bool filterMember(const glslang::TType& member);

    spv::Id convertGlslangStructToSpvType(const glslang::TType&, const glslang::TTypeList* glslangStruct,

                                          glslang::TLayoutPacking, const glslang::TQualifier&);

    spv::LinkageType convertGlslangLinkageToSpv(glslang::TLinkType glslangLinkType);

    spv::Id decorateDescHeapType(const glslang::TType& type, spv::Id& memberBaseOffset, spv::Id& alignment,

                                 int& maxPlainDataAlignment);

    void decorateStructType(const glslang::TType&, const glslang::TTypeList* glslangStruct, glslang::TLayoutPacking,

                            const glslang::TQualifier&, spv::Id, const std::vector<spv::Id>& spvMembers);

    spv::Id makeArraySizeId(const glslang::TArraySizes&, int dim, bool allowZero = false, bool boolType = false);

    spv::Id accessChainLoad(const glslang::TType& type);

    void    accessChainStore(const glslang::TType& type, spv::Id rvalue);

    void multiTypeStore(const glslang::TType&, spv::Id rValue);

    spv::Id convertLoadedBoolInUniformToUint(const glslang::TType& type, spv::Id nominalTypeId, spv::Id loadedId);

    glslang::TLayoutPacking getExplicitLayout(const glslang::TType& type) const;

    int getArrayStride(const glslang::TType& arrayType, glslang::TLayoutPacking, glslang::TLayoutMatrix);

    int getMatrixStride(const glslang::TType& matrixType, glslang::TLayoutPacking, glslang::TLayoutMatrix);

    void updateMemberOffset(const glslang::TType& structType, const glslang::TType& memberType, int& currentOffset,

                            int& nextOffset, glslang::TLayoutPacking, glslang::TLayoutMatrix);

    void declareUseOfStructMember(const glslang::TTypeList& members, int glslangMember);

    bool isShaderEntryPoint(const glslang::TIntermAggregate* node);

    bool writableParam(glslang::TStorageQualifier) const;

    bool originalParam(glslang::TStorageQualifier, const glslang::TType&, bool implicitThisParam);

    void makeFunctions(const glslang::TIntermSequence&);

    void makeGlobalInitializers(const glslang::TIntermSequence&);

    void collectRayTracingLinkerObjects();

    void visitFunctions(const glslang::TIntermSequence&);

    void translateArguments(const glslang::TIntermAggregate& node, std::vector<spv::Id>& arguments,

        spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags);

    void translateArguments(glslang::TIntermUnary& node, std::vector<spv::Id>& arguments);

    spv::Id createImageTextureFunctionCall(glslang::TIntermOperator* node);

    spv::Id handleUserFunctionCall(const glslang::TIntermAggregate*);

    spv::Id createBinaryOperation(glslang::TOperator op, OpDecorations&, spv::Id typeId, spv::Id left, spv::Id right,

                                  glslang::TBasicType typeProxy, bool reduceComparison = true);

    spv::Id createBinaryMatrixOperation(spv::Op, OpDecorations&, spv::Id typeId, spv::Id left, spv::Id right);

    spv::Id createUnaryOperation(glslang::TOperator op, OpDecorations&, spv::Id typeId, spv::Id operand,

                                 glslang::TBasicType typeProxy,

                                 const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags,

                                 const glslang::TType &opType);

    spv::Id createUnaryMatrixOperation(spv::Op op, OpDecorations&, spv::Id typeId, spv::Id operand,

                                       glslang::TBasicType typeProxy);

    spv::Id createConversion(glslang::TOperator op, OpDecorations&, spv::Id destTypeId, spv::Id operand,

                             glslang::TBasicType resultBasicType, glslang::TBasicType operandBasicType);

    spv::Id createIntWidthConversion(spv::Id operand, int vectorSize, spv::Id destType,

                                     glslang::TBasicType resultBasicType, glslang::TBasicType operandBasicType);

    spv::Id makeSmearedConstant(spv::Id constant, int vectorSize);

    spv::Id createAtomicOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId,

        std::vector<spv::Id>& operands, glslang::TBasicType typeProxy,

        const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags,

        const glslang::TType &opType);

    spv::Id createInvocationsOperation(glslang::TOperator op, spv::Id typeId, std::vector<spv::Id>& operands,

        glslang::TBasicType typeProxy);

    spv::Id CreateInvocationsVectorOperation(spv::Op op, spv::GroupOperation groupOperation,

        spv::Id typeId, std::vector<spv::Id>& operands);

    spv::Id createSubgroupOperation(glslang::TOperator op, spv::Id typeId, std::vector<spv::Id>& operands,

        glslang::TBasicType typeProxy);

    spv::Id createMiscOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId,

        std::vector<spv::Id>& operands, glslang::TBasicType typeProxy);

    spv::Id createNoArgOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId);

    spv::Id getSymbolId(const glslang::TIntermSymbol* node);

    void addMeshNVDecoration(spv::Id id, int member, const glslang::TQualifier & qualifier);

    bool hasQCOMImageProceessingDecoration(spv::Id id, spv::Decoration decor);

    void addImageProcessingQCOMDecoration(spv::Id id, spv::Decoration decor);

    void addImageProcessing2QCOMDecoration(spv::Id id, bool isForGather);

    spv::Id createSpvConstant(const glslang::TIntermTyped&);

    spv::Id createSpvConstantFromConstUnionArray(const glslang::TType& type, const glslang::TConstUnionArray&,

        int& nextConst, bool specConstant);

    bool isTrivialLeaf(const glslang::TIntermTyped* node);

    bool isTrivial(const glslang::TIntermTyped* node);

    spv::Id createShortCircuit(glslang::TOperator, glslang::TIntermTyped& left, glslang::TIntermTyped& right);

    spv::Id getExtBuiltins(const char* name);

    std::pair<spv::Id, spv::Id> getForcedType(glslang::TBuiltInVariable builtIn, const glslang::TType&);

    spv::Id translateForcedType(spv::Id object);

    spv::Id createCompositeConstruct(spv::Id typeId, std::vector<spv::Id> constituents);

    void recordDescHeapAccessChainInfo(glslang::TIntermBinary* node);

    void createAbortEXT(const glslang::TIntermSequence &glslangOperands);

    glslang::SpvOptions& options;

    spv::Function* shaderEntry;

    spv::Function* currentFunction;

    spv::Instruction* entryPoint;

    int sequenceDepth;

    spv::SpvBuildLogger* logger;

    // There is a 1:1 mapping between a spv builder and a module; this is thread safe

    spv::Builder builder;

    bool inEntryPoint;

    bool entryPointTerminated;

    bool linkageOnly;                  // true when visiting the set of objects in the AST present only for

                                       // establishing interface, whether or not they were statically used

    std::set<spv::Id> iOSet;           // all input/output variables from either static use or declaration of interface

    const glslang::TIntermediate* glslangIntermediate;

    bool nanMinMaxClamp;               // true if use NMin/NMax/NClamp instead of FMin/FMax/FClamp

    spv::Id stdBuiltins;

    spv::Id nonSemanticDebugPrintf;

    std::unordered_map<std::string, spv::Id> extBuiltinMap;

    std::unordered_map<long long, spv::Id> symbolValues;

    std::unordered_map<uint32_t, spv::Id> builtInVariableIds;

    std::unordered_set<long long> rValueParameters;  // set of formal function parameters passed as rValues,

                                               // rather than a pointer

    std::unordered_map<std::string, spv::Function*> functionMap;

    std::unordered_map<const glslang::TTypeList*, spv::Id> structMap[glslang::ElpCount][glslang::ElmCount];

    // for mapping glslang block indices to spv indices (e.g., due to hidden members):

    std::unordered_map<long long, std::vector<int>> memberRemapper;

    // for mapping glslang symbol struct to symbol Id

    std::unordered_map<const glslang::TTypeList*, long long> glslangTypeToIdMap;

    std::stack<bool> breakForLoop;  // false means break for switch

    std::unordered_map<std::string, const glslang::TIntermSymbol*> counterOriginator;

    // Map pointee types for EbtReference to their forward pointers

    std::map<const glslang::TType *, spv::Id> forwardPointers;

    // Type forcing, for when SPIR-V wants a different type than the AST,

    // requiring local translation to and from SPIR-V type on every access.

    // Maps <builtin-variable-id -> AST-required-type-id>

    std::unordered_map<spv::Id, spv::Id> forceType;

    // Used by Task shader while generating opearnds for OpEmitMeshTasksEXT

    spv::Id taskPayloadID;

    // Used later for generating OpTraceKHR/OpExecuteCallableKHR/OpHitObjectRecordHit*/OpHitObjectGetShaderBindingTableData

    std::unordered_map<unsigned int, glslang::TIntermSymbol *> locationToSymbol[4];

    std::unordered_map<spv::Id, std::vector<spv::Decoration> > idToQCOMDecorations;

    // For nested or inner resource heap structure's alignment and offset records.

    typedef struct heapMetaData {

        spv::Id typeStride;

        spv::Id maxRsrcTypeAlignment;

        int maxPlainDataAlignment;

    } HeapMetaData;

    std::unordered_map<const glslang::TType*, HeapMetaData> heapStructureTypeMetaData;

    std::unordered_map<spv::Id, spv::Id> heapStructureTypeSize;

    std::vector<spv::Id> heapStructureMemberOffsets;

};

//

// Helper functions for translating glslang representations to SPIR-V enumerants.

//

// Translate glslang profile to SPIR-V source language.

spv::SourceLanguage TranslateSourceLanguage(glslang::EShSource source, EProfile profile)

{

    switch (source) {

    case glslang::EShSourceGlsl:

        switch (profile) {

        case ENoProfile:

        case ECoreProfile:

        case ECompatibilityProfile:

            return spv::SourceLanguage::GLSL;

        case EEsProfile:

            return spv::SourceLanguage::ESSL;

        default:

            return spv::SourceLanguage::Unknown;

        }

    case glslang::EShSourceHlsl:

        return spv::SourceLanguage::HLSL;

    default:

        return spv::SourceLanguage::Unknown;

    }

}

// Translate glslang language (stage) to SPIR-V execution model.

spv::ExecutionModel TranslateExecutionModel(EShLanguage stage, bool isMeshShaderEXT = false)

{

    switch (stage) {

    case EShLangVertex:           return spv::ExecutionModel::Vertex;

    case EShLangFragment:         return spv::ExecutionModel::Fragment;

    case EShLangCompute:          return spv::ExecutionModel::GLCompute;

    case EShLangTessControl:      return spv::ExecutionModel::TessellationControl;

    case EShLangTessEvaluation:   return spv::ExecutionModel::TessellationEvaluation;

    case EShLangGeometry:         return spv::ExecutionModel::Geometry;

    case EShLangRayGen:           return spv::ExecutionModel::RayGenerationKHR;

    case EShLangIntersect:        return spv::ExecutionModel::IntersectionKHR;

    case EShLangAnyHit:           return spv::ExecutionModel::AnyHitKHR;

    case EShLangClosestHit:       return spv::ExecutionModel::ClosestHitKHR;

    case EShLangMiss:             return spv::ExecutionModel::MissKHR;

    case EShLangCallable:         return spv::ExecutionModel::CallableKHR;

    case EShLangTask:             return (isMeshShaderEXT)? spv::ExecutionModel::TaskEXT : spv::ExecutionModel::TaskNV;

    case EShLangMesh:             return (isMeshShaderEXT)? spv::ExecutionModel::MeshEXT : spv::ExecutionModel::MeshNV;

    default:

        assert(0);

        return spv::ExecutionModel::Fragment;

    }

}

// Translate glslang sampler type to SPIR-V dimensionality.

spv::Dim TranslateDimensionality(const glslang::TSampler& sampler)

{

    switch (sampler.dim) {

    case glslang::Esd1D:      return spv::Dim::Dim1D;

    case glslang::Esd2D:      return spv::Dim::Dim2D;

    case glslang::Esd3D:      return spv::Dim::Dim3D;

    case glslang::EsdCube:    return spv::Dim::Cube;

    case glslang::EsdRect:    return spv::Dim::Rect;

    case glslang::EsdBuffer:  return spv::Dim::Buffer;

    case glslang::EsdSubpass: return spv::Dim::SubpassData;

    case glslang::EsdAttachmentEXT: return spv::Dim::TileImageDataEXT;

    default:

        assert(0);

        return spv::Dim::Dim2D;

    }

}

// Translate glslang precision to SPIR-V precision decorations.

spv::Decoration TranslatePrecisionDecoration(glslang::TPrecisionQualifier glslangPrecision)

{

    switch (glslangPrecision) {

    case glslang::EpqLow:    return spv::Decoration::RelaxedPrecision;

    case glslang::EpqMedium: return spv::Decoration::RelaxedPrecision;

    default:

        return spv::NoPrecision;

    }

}

// Translate glslang type to SPIR-V precision decorations.

spv::Decoration TranslatePrecisionDecoration(const glslang::TType& type)

{

    return TranslatePrecisionDecoration(type.getQualifier().precision);

}

// Translate glslang type to SPIR-V block decorations.

spv::Decoration TranslateBlockDecoration(const glslang::TStorageQualifier storage, bool useStorageBuffer)

{

    switch (storage) {

    case glslang::EvqUniform:      return spv::Decoration::Block;

    case glslang::EvqBuffer:       return useStorageBuffer ? spv::Decoration::Block : spv::Decoration::BufferBlock;

    case glslang::EvqVaryingIn:    return spv::Decoration::Block;

    case glslang::EvqVaryingOut:   return spv::Decoration::Block;

    case glslang::EvqShared:       return spv::Decoration::Block;

    case glslang::EvqPayload:      return spv::Decoration::Block;

    case glslang::EvqPayloadIn:    return spv::Decoration::Block;

    case glslang::EvqHitAttr:      return spv::Decoration::Block;

    case glslang::EvqCallableData:   return spv::Decoration::Block;

    case glslang::EvqCallableDataIn: return spv::Decoration::Block;

    case glslang::EvqHitObjectAttrNV: return spv::Decoration::Block;

    case glslang::EvqHitObjectAttrEXT: return spv::Decoration::Block;

    case glslang::EvqResourceHeap:  return spv::Decoration::Block;

    case glslang::EvqSamplerHeap:   return spv::Decoration::Block;

    default:

        assert(0);

        break;

    }

    return spv::Decoration::Max;

}

// Translate glslang type to SPIR-V memory decorations.

void TranslateMemoryDecoration(const glslang::TQualifier& qualifier, std::vector<spv::Decoration>& memory,

    bool useVulkanMemoryModel)

{

    if (!useVulkanMemoryModel) {

        if (qualifier.isVolatile()) {

            memory.push_back(spv::Decoration::Volatile);

            memory.push_back(spv::Decoration::Coherent);

        } else if (qualifier.isCoherent()) {

            memory.push_back(spv::Decoration::Coherent);

        }

    }

    if (qualifier.isRestrict())

        memory.push_back(spv::Decoration::Restrict);

    if (qualifier.isReadOnly())

        memory.push_back(spv::Decoration::NonWritable);

    if (qualifier.isWriteOnly())

        memory.push_back(spv::Decoration::NonReadable);

}

// Translate glslang type to SPIR-V layout decorations.

spv::Decoration TranslateLayoutDecoration(const glslang::TType& type, glslang::TLayoutMatrix matrixLayout)

{

    if (type.isMatrix()) {

        switch (matrixLayout) {

        case glslang::ElmRowMajor:

            return spv::Decoration::RowMajor;

        case glslang::ElmColumnMajor:

            return spv::Decoration::ColMajor;

        default:

            // opaque layouts don't need a majorness

            return spv::Decoration::Max;

        }

    } else {

        switch (type.getBasicType()) {

        default:

            return spv::Decoration::Max;

            break;

        case glslang::EbtBlock:

            switch (type.getQualifier().storage) {

            case glslang::EvqShared:

            case glslang::EvqUniform:

            case glslang::EvqBuffer:

                switch (type.getQualifier().layoutPacking) {

                case glslang::ElpShared:  return spv::Decoration::GLSLShared;

                case glslang::ElpPacked:  return spv::Decoration::GLSLPacked;

                default:

                    return spv::Decoration::Max;

                }

            case glslang::EvqVaryingIn:

            case glslang::EvqVaryingOut:

                if (type.getQualifier().isTaskMemory()) {

                    switch (type.getQualifier().layoutPacking) {

                    case glslang::ElpShared:  return spv::Decoration::GLSLShared;

                    case glslang::ElpPacked:  return spv::Decoration::GLSLPacked;

                    default: break;

                    }

                } else {

                    assert(type.getQualifier().layoutPacking == glslang::ElpNone);

                }

                return spv::Decoration::Max;

            case glslang::EvqPayload:

            case glslang::EvqPayloadIn:

            case glslang::EvqHitAttr:

            case glslang::EvqCallableData:

            case glslang::EvqCallableDataIn:

            case glslang::EvqHitObjectAttrNV:

            case glslang::EvqHitObjectAttrEXT:

            case glslang::EvqResourceHeap:

            case glslang::EvqSamplerHeap:

                return spv::Decoration::Max;

            default:

                assert(0);

                return spv::Decoration::Max;

            }

        }

    }

}

// Translate glslang type to SPIR-V interpolation decorations.

// Returns spv::Decoration::Max when no decoration

// should be applied.

spv::Decoration TGlslangToSpvTraverser::TranslateInterpolationDecoration(const glslang::TQualifier& qualifier)

{

    if (qualifier.smooth)

        // Smooth decoration doesn't exist in SPIR-V 1.0

        return spv::Decoration::Max;

    else if (qualifier.isNonPerspective())

        return spv::Decoration::NoPerspective;

    else if (qualifier.flat)

        return spv::Decoration::Flat;

    else if (qualifier.isExplicitInterpolation()) {

        builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);

        return spv::Decoration::ExplicitInterpAMD;

    }

    else

        return spv::Decoration::Max;

}

// Translate glslang type to SPIR-V auxiliary storage decorations.

// Returns spv::Decoration::Max when no decoration

// should be applied.

spv::Decoration TGlslangToSpvTraverser::TranslateAuxiliaryStorageDecoration(const glslang::TQualifier& qualifier)

{

    if (qualifier.centroid)

        return spv::Decoration::Centroid;

    else if (qualifier.patch)

        return spv::Decoration::Patch;

    else if (qualifier.sample) {

        builder.addCapability(spv::Capability::SampleRateShading);

        return spv::Decoration::Sample;

    }

    return spv::Decoration::Max;

}

// If glslang type is invariant, return SPIR-V invariant decoration.

spv::Decoration TranslateInvariantDecoration(const glslang::TQualifier& qualifier)

{

    if (qualifier.invariant)

        return spv::Decoration::Invariant;

    else

        return spv::Decoration::Max;

}

// If glslang type is noContraction, return SPIR-V NoContraction decoration.

spv::Decoration TranslateNoContractionDecoration(const glslang::TQualifier& qualifier)

{

    if (qualifier.isNoContraction())

        return spv::Decoration::NoContraction;

    else

        return spv::Decoration::Max;

}

// If glslang type is nonUniform, return SPIR-V NonUniform decoration.

spv::Decoration TGlslangToSpvTraverser::TranslateNonUniformDecoration(const glslang::TQualifier& qualifier)

{

    if (qualifier.isNonUniform()) {

        builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);

        builder.addCapability(spv::Capability::ShaderNonUniformEXT);

        auto& extensions = glslangIntermediate->getRequestedExtensions();

        if (extensions.find("GL_EXT_descriptor_heap") != extensions.end()) {

            builder.addExtension("SPV_EXT_descriptor_heap");

            builder.addCapability(spv::Capability::DescriptorHeapEXT);

        }

        else {

            return spv::Decoration::NonUniformEXT;

        }

    }

    return spv::Decoration::Max;

}

// If lvalue flags contains nonUniform, return SPIR-V NonUniform decoration.

spv::Decoration TGlslangToSpvTraverser::TranslateNonUniformDecoration(

    const spv::Builder::AccessChain::CoherentFlags& coherentFlags)

{

    if (coherentFlags.isNonUniform()) {

        builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);

        builder.addCapability(spv::Capability::ShaderNonUniformEXT);

        auto& extensions = glslangIntermediate->getRequestedExtensions();

        if (extensions.find("GL_EXT_descriptor_heap") != extensions.end()) {

            builder.addExtension("SPV_EXT_descriptor_heap");

            builder.addCapability(spv::Capability::DescriptorHeapEXT);

        }

        else {

            return spv::Decoration::NonUniformEXT;

        }

    }

    return spv::Decoration::Max;

}

spv::MemoryAccessMask TGlslangToSpvTraverser::TranslateMemoryAccess(

    const spv::Builder::AccessChain::CoherentFlags &coherentFlags)

{

    spv::MemoryAccessMask mask = spv::MemoryAccessMask::MaskNone;

    if (!glslangIntermediate->usingVulkanMemoryModel() || coherentFlags.isImage)

        return mask;

    if (coherentFlags.isVolatile() || coherentFlags.anyCoherent()) {

        mask = mask | spv::MemoryAccessMask::MakePointerAvailableKHR | 

                      spv::MemoryAccessMask::MakePointerVisibleKHR;

    }

    if (coherentFlags.nonprivate) {

        mask = mask | spv::MemoryAccessMask::NonPrivatePointerKHR;

    }

    if (coherentFlags.volatil) {

        mask = mask | spv::MemoryAccessMask::Volatile;

    }

    if (coherentFlags.nontemporal) {

        mask = mask | spv::MemoryAccessMask::Nontemporal;

    }

    if (mask != spv::MemoryAccessMask::MaskNone) {

        builder.addCapability(spv::Capability::VulkanMemoryModelKHR);

    }

    return mask;

}

spv::ImageOperandsMask TGlslangToSpvTraverser::TranslateImageOperands(

    const spv::Builder::AccessChain::CoherentFlags &coherentFlags)

{

    spv::ImageOperandsMask mask = spv::ImageOperandsMask::MaskNone;

    if (!glslangIntermediate->usingVulkanMemoryModel())

        return mask;

    if (coherentFlags.volatil ||

        coherentFlags.anyCoherent()) {

        mask = mask | spv::ImageOperandsMask::MakeTexelAvailableKHR |

                      spv::ImageOperandsMask::MakeTexelVisibleKHR;

    }

    if (coherentFlags.nonprivate) {

        mask = mask | spv::ImageOperandsMask::NonPrivateTexelKHR;

    }

    if (coherentFlags.volatil) {

        mask = mask | spv::ImageOperandsMask::VolatileTexelKHR;

    }

    if (coherentFlags.nontemporal && builder.getSpvVersion() >= spv::Spv_1_6) {

        mask = mask | spv::ImageOperandsMask::Nontemporal;

    }

    if (mask != spv::ImageOperandsMask::MaskNone) {

        builder.addCapability(spv::Capability::VulkanMemoryModelKHR);

    }

    return mask;

}

spv::Builder::AccessChain::CoherentFlags TGlslangToSpvTraverser::TranslateCoherent(const glslang::TType& type)

{

    spv::Builder::AccessChain::CoherentFlags flags = {};

    flags.coherent = type.getQualifier().coherent;

    flags.devicecoherent = type.getQualifier().devicecoherent;

    flags.queuefamilycoherent = type.getQualifier().queuefamilycoherent;

    // shared variables are implicitly workgroupcoherent in GLSL.

    flags.workgroupcoherent = type.getQualifier().workgroupcoherent ||

                              type.getQualifier().storage == glslang::EvqShared;

    flags.subgroupcoherent = type.getQualifier().subgroupcoherent;

    flags.shadercallcoherent = type.getQualifier().shadercallcoherent;

    flags.volatil = type.getQualifier().volatil;

    flags.nontemporal = type.getQualifier().nontemporal;

    // *coherent variables are implicitly nonprivate in GLSL

    flags.nonprivate = type.getQualifier().nonprivate ||

                       flags.anyCoherent() ||

                       flags.volatil;

    flags.isImage = type.getBasicType() == glslang::EbtSampler;

    flags.nonUniform = type.getQualifier().nonUniform;

    return flags;

}

spv::Scope TGlslangToSpvTraverser::TranslateMemoryScope(

    const spv::Builder::AccessChain::CoherentFlags &coherentFlags)

{

    spv::Scope scope = spv::Scope::Max;

    if (coherentFlags.volatil || coherentFlags.coherent) {

        // coherent defaults to Device scope in the old model, QueueFamilyKHR scope in the new model

        scope = glslangIntermediate->usingVulkanMemoryModel() ? spv::Scope::QueueFamilyKHR : spv::Scope::Device;

    } else if (coherentFlags.devicecoherent) {

        scope = spv::Scope::Device;

    } else if (coherentFlags.queuefamilycoherent) {

        scope = spv::Scope::QueueFamilyKHR;

    } else if (coherentFlags.workgroupcoherent) {

        scope = spv::Scope::Workgroup;

    } else if (coherentFlags.subgroupcoherent) {

        scope = spv::Scope::Subgroup;

    } else if (coherentFlags.shadercallcoherent) {

        scope = spv::Scope::ShaderCallKHR;

    }

    if (glslangIntermediate->usingVulkanMemoryModel() && scope == spv::Scope::Device) {

        builder.addCapability(spv::Capability::VulkanMemoryModelDeviceScopeKHR);

    }

    return scope;

}

// Translate a glslang built-in variable to a SPIR-V built in decoration.  Also generate

// associated capabilities when required.  For some built-in variables, a capability

// is generated only when using the variable in an executable instruction, but not when

// just declaring a struct member variable with it.  This is true for PointSize,

// ClipDistance, and CullDistance.

spv::BuiltIn TGlslangToSpvTraverser::TranslateBuiltInDecoration(glslang::TBuiltInVariable builtIn,

    bool memberDeclaration)

{

    switch (builtIn) {

    case glslang::EbvPointSize:

        // Defer adding the capability until the built-in is actually used.

        if (! memberDeclaration) {

            switch (glslangIntermediate->getStage()) {

            case EShLangGeometry:

                builder.addCapability(spv::Capability::GeometryPointSize);

                break;

            case EShLangTessControl:

            case EShLangTessEvaluation:

                builder.addCapability(spv::Capability::TessellationPointSize);

                break;

            default:

                break;

            }

        }

        return spv::BuiltIn::PointSize;

    case glslang::EbvPosition:             return spv::BuiltIn::Position;

    case glslang::EbvVertexId:             return spv::BuiltIn::VertexId;

    case glslang::EbvInstanceId:           return spv::BuiltIn::InstanceId;

    case glslang::EbvVertexIndex:          return spv::BuiltIn::VertexIndex;

    case glslang::EbvInstanceIndex:        return spv::BuiltIn::InstanceIndex;

    case glslang::EbvFragCoord:            return spv::BuiltIn::FragCoord;

    case glslang::EbvPointCoord:           return spv::BuiltIn::PointCoord;

    case glslang::EbvFace:                 return spv::BuiltIn::FrontFacing;

    case glslang::EbvFragDepth:            return spv::BuiltIn::FragDepth;

    case glslang::EbvNumWorkGroups:        return spv::BuiltIn::NumWorkgroups;

    case glslang::EbvWorkGroupSize:        return spv::BuiltIn::WorkgroupSize;

    case glslang::EbvWorkGroupId:          return spv::BuiltIn::WorkgroupId;

    case glslang::EbvLocalInvocationId:    return spv::BuiltIn::LocalInvocationId;

    case glslang::EbvLocalInvocationIndex: return spv::BuiltIn::LocalInvocationIndex;

    case glslang::EbvGlobalInvocationId:   return spv::BuiltIn::GlobalInvocationId;

    // These *Distance capabilities logically belong here, but if the member is declared and

    // then never used, consumers of SPIR-V prefer the capability not be declared.

    // They are now generated when used, rather than here when declared.

    // Potentially, the specification should be more clear what the minimum

    // use needed is to trigger the capability.

    //

    case glslang::EbvClipDistance:

        if (!memberDeclaration)

            builder.addCapability(spv::Capability::ClipDistance);

        return spv::BuiltIn::ClipDistance;

    case glslang::EbvCullDistance:

        if (!memberDeclaration)

            builder.addCapability(spv::Capability::CullDistance);

        return spv::BuiltIn::CullDistance;

    case glslang::EbvViewportIndex:

        if (glslangIntermediate->getStage() == EShLangGeometry ||

            glslangIntermediate->getStage() == EShLangFragment) {

            builder.addCapability(spv::Capability::MultiViewport);

        }

        if (glslangIntermediate->getStage() == EShLangVertex ||

            glslangIntermediate->getStage() == EShLangTessControl ||

            glslangIntermediate->getStage() == EShLangTessEvaluation) {

            if (builder.getSpvVersion() < spv::Spv_1_5) {

                builder.addIncorporatedExtension(spv::E_SPV_EXT_shader_viewport_index_layer, spv::Spv_1_5);

                builder.addCapability(spv::Capability::ShaderViewportIndexLayerEXT);

            }

            else

                builder.addCapability(spv::Capability::ShaderViewportIndex);

        }

        return spv::BuiltIn::ViewportIndex;

    case glslang::EbvSampleId:

        builder.addCapability(spv::Capability::SampleRateShading);

        return spv::BuiltIn::SampleId;

    case glslang::EbvSamplePosition:

        builder.addCapability(spv::Capability::SampleRateShading);

        return spv::BuiltIn::SamplePosition;

    case glslang::EbvSampleMask:

        return spv::BuiltIn::SampleMask;

    case glslang::EbvLayer:

        if (glslangIntermediate->getStage() == EShLangMesh) {

            return spv::BuiltIn::Layer;

        }

        if (glslangIntermediate->getStage() == EShLangGeometry ||

            glslangIntermediate->getStage() == EShLangFragment) {

            builder.addCapability(spv::Capability::Geometry);

        }

        if (glslangIntermediate->getStage() == EShLangVertex ||

            glslangIntermediate->getStage() == EShLangTessControl ||

            glslangIntermediate->getStage() == EShLangTessEvaluation) {

            if (builder.getSpvVersion() < spv::Spv_1_5) {

                builder.addIncorporatedExtension(spv::E_SPV_EXT_shader_viewport_index_layer, spv::Spv_1_5);

                builder.addCapability(spv::Capability::ShaderViewportIndexLayerEXT);

            } else

                builder.addCapability(spv::Capability::ShaderLayer);

        }

        return spv::BuiltIn::Layer;

    case glslang::EbvBaseVertex:

        builder.addIncorporatedExtension(spv::E_SPV_KHR_shader_draw_parameters, spv::Spv_1_3);

        builder.addCapability(spv::Capability::DrawParameters);

        return spv::BuiltIn::BaseVertex;

    case glslang::EbvBaseInstance:

        builder.addIncorporatedExtension(spv::E_SPV_KHR_shader_draw_parameters, spv::Spv_1_3);

        builder.addCapability(spv::Capability::DrawParameters);

        return spv::BuiltIn::BaseInstance;

    case glslang::EbvDrawId:

        builder.addIncorporatedExtension(spv::E_SPV_KHR_shader_draw_parameters, spv::Spv_1_3);

        builder.addCapability(spv::Capability::DrawParameters);

        return spv::BuiltIn::DrawIndex;

    case glslang::EbvPrimitiveId:

        if (glslangIntermediate->getStage() == EShLangFragment)

            builder.addCapability(spv::Capability::Geometry);

        return spv::BuiltIn::PrimitiveId;

    case glslang::EbvFragStencilRef:

        builder.addExtension(spv::E_SPV_EXT_shader_stencil_export);

        builder.addCapability(spv::Capability::StencilExportEXT);

        return spv::BuiltIn::FragStencilRefEXT;

    case glslang::EbvShadingRateKHR:

        builder.addExtension(spv::E_SPV_KHR_fragment_shading_rate);

        builder.addCapability(spv::Capability::FragmentShadingRateKHR);

        return spv::BuiltIn::ShadingRateKHR;

    case glslang::EbvPrimitiveShadingRateKHR:

        builder.addExtension(spv::E_SPV_KHR_fragment_shading_rate);

        builder.addCapability(spv::Capability::FragmentShadingRateKHR);

        return spv::BuiltIn::PrimitiveShadingRateKHR;

    case glslang::EbvInvocationId:         return spv::BuiltIn::InvocationId;

    case glslang::EbvTessLevelInner:       return spv::BuiltIn::TessLevelInner;

    case glslang::EbvTessLevelOuter:       return spv::BuiltIn::TessLevelOuter;

    case glslang::EbvTessCoord:            return spv::BuiltIn::TessCoord;

    case glslang::EbvPatchVertices:        return spv::BuiltIn::PatchVertices;

    case glslang::EbvHelperInvocation:     return spv::BuiltIn::HelperInvocation;

    case glslang::EbvSubGroupSize:

        builder.addExtension(spv::E_SPV_KHR_shader_ballot);

        builder.addCapability(spv::Capability::SubgroupBallotKHR);

        return spv::BuiltIn::SubgroupSize;

    case glslang::EbvSubGroupInvocation:

        builder.addExtension(spv::E_SPV_KHR_shader_ballot);

        builder.addCapability(spv::Capability::SubgroupBallotKHR);

        return spv::BuiltIn::SubgroupLocalInvocationId;

    case glslang::EbvSubGroupEqMask:

        builder.addExtension(spv::E_SPV_KHR_shader_ballot);

        builder.addCapability(spv::Capability::SubgroupBallotKHR);

        return spv::BuiltIn::SubgroupEqMask;

    case glslang::EbvSubGroupGeMask:

        builder.addExtension(spv::E_SPV_KHR_shader_ballot);

        builder.addCapability(spv::Capability::SubgroupBallotKHR);

        return spv::BuiltIn::SubgroupGeMask;

    case glslang::EbvSubGroupGtMask:

        builder.addExtension(spv::E_SPV_KHR_shader_ballot);

        builder.addCapability(spv::Capability::SubgroupBallotKHR);

        return spv::BuiltIn::SubgroupGtMask;

    case glslang::EbvSubGroupLeMask:

        builder.addExtension(spv::E_SPV_KHR_shader_ballot);

        builder.addCapability(spv::Capability::SubgroupBallotKHR);

        return spv::BuiltIn::SubgroupLeMask;

    case glslang::EbvSubGroupLtMask:

        builder.addExtension(spv::E_SPV_KHR_shader_ballot);

        builder.addCapability(spv::Capability::SubgroupBallotKHR);

        return spv::BuiltIn::SubgroupLtMask;

    case glslang::EbvNumSubgroups:

        builder.addCapability(spv::Capability::GroupNonUniform);

        return spv::BuiltIn::NumSubgroups;

    case glslang::EbvSubgroupID:

        builder.addCapability(spv::Capability::GroupNonUniform);

        return spv::BuiltIn::SubgroupId;

    case glslang::EbvSubgroupSize2:

        builder.addCapability(spv::Capability::GroupNonUniform);

        return spv::BuiltIn::SubgroupSize;

    case glslang::EbvSubgroupInvocation2:

        builder.addCapability(spv::Capability::GroupNonUniform);

        return spv::BuiltIn::SubgroupLocalInvocationId;

    case glslang::EbvSubgroupEqMask2:

        builder.addCapability(spv::Capability::GroupNonUniform);

        builder.addCapability(spv::Capability::GroupNonUniformBallot);

        return spv::BuiltIn::SubgroupEqMask;

    case glslang::EbvSubgroupGeMask2:

        builder.addCapability(spv::Capability::GroupNonUniform);

        builder.addCapability(spv::Capability::GroupNonUniformBallot);

        return spv::BuiltIn::SubgroupGeMask;

    case glslang::EbvSubgroupGtMask2:

        builder.addCapability(spv::Capability::GroupNonUniform);

        builder.addCapability(spv::Capability::GroupNonUniformBallot);

        return spv::BuiltIn::SubgroupGtMask;

    case glslang::EbvSubgroupLeMask2:

        builder.addCapability(spv::Capability::GroupNonUniform);

        builder.addCapability(spv::Capability::GroupNonUniformBallot);

        return spv::BuiltIn::SubgroupLeMask;

    case glslang::EbvSubgroupLtMask2:

        builder.addCapability(spv::Capability::GroupNonUniform);

        builder.addCapability(spv::Capability::GroupNonUniformBallot);

        return spv::BuiltIn::SubgroupLtMask;

    case glslang::EbvBaryCoordNoPersp:

        builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);

        return spv::BuiltIn::BaryCoordNoPerspAMD;

    case glslang::EbvBaryCoordNoPerspCentroid:

        builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);

        return spv::BuiltIn::BaryCoordNoPerspCentroidAMD;

    case glslang::EbvBaryCoordNoPerspSample:

        builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);

        return spv::BuiltIn::BaryCoordNoPerspSampleAMD;

    case glslang::EbvBaryCoordSmooth:

        builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);

        return spv::BuiltIn::BaryCoordSmoothAMD;

    case glslang::EbvBaryCoordSmoothCentroid:

        builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);