SPIRV/GlslangToSpv.cpp

   1 //
   2 // Copyright (C) 2014-2016 LunarG, Inc.
   3 // Copyright (C) 2015-2020 Google, Inc.
   4 // Copyright (C) 2017 ARM Limited.
   5 // Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
   6 //
   7 // All rights reserved.
   8 //
   9 // Redistribution and use in source and binary forms, with or without
  10 // modification, are permitted provided that the following conditions
  11 // are met:
  12 //
  13 //    Redistributions of source code must retain the above copyright
  14 //    notice, this list of conditions and the following disclaimer.
  15 //
  16 //    Redistributions in binary form must reproduce the above
  17 //    copyright notice, this list of conditions and the following
  18 //    disclaimer in the documentation and/or other materials provided
  19 //    with the distribution.
  20 //
  21 //    Neither the name of 3Dlabs Inc. Ltd. nor the names of its
  22 //    contributors may be used to endorse or promote products derived
  23 //    from this software without specific prior written permission.
  24 //
  25 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  28 // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  29 // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  30 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  31 // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  32 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  33 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  34 // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  35 // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  36 // POSSIBILITY OF SUCH DAMAGE.
  37
  38 //
  39 // Visit the nodes in the glslang intermediate tree representation to
  40 // translate them to SPIR-V.
  41 //
  42
  43 #include "spirv.hpp"
  44 #include "GlslangToSpv.h"
  45 #include "SpvBuilder.h"
  46 namespace spv {
  47     #include "GLSL.std.450.h"
  48     #include "GLSL.ext.KHR.h"
  49     #include "GLSL.ext.EXT.h"
  50     #include "GLSL.ext.AMD.h"
  51     #include "GLSL.ext.NV.h"
  52     #include "NonSemanticDebugPrintf.h"
  53 }
  54
  55 // Glslang includes
  56 #include "../glslang/MachineIndependent/localintermediate.h"
  57 #include "../glslang/MachineIndependent/SymbolTable.h"
  58 #include "../glslang/Include/Common.h"
  59
  60 // Build-time generated includes
  61 #include "glslang/build_info.h"
  62
  63 #include <fstream>
  64 #include <iomanip>
  65 #include <list>
  66 #include <map>
  67 #include <stack>
  68 #include <string>
  69 #include <vector>
  70
  71 namespace {
  72
  73 namespace {
  74 class SpecConstantOpModeGuard {
  75 public:
  76     SpecConstantOpModeGuard(spv::Builder* builder)
  77         : builder_(builder) {
  78         previous_flag_ = builder->isInSpecConstCodeGenMode();
  79     }
  80     ~SpecConstantOpModeGuard() {
  81         previous_flag_ ? builder_->setToSpecConstCodeGenMode()
  82                        : builder_->setToNormalCodeGenMode();
  83     }
  84     void turnOnSpecConstantOpMode() {
  85         builder_->setToSpecConstCodeGenMode();
  86     }
  87
  88 private:
  89     spv::Builder* builder_;
  90     bool previous_flag_;
  91 };
  92
  93 struct OpDecorations {
  94     public:
  95         OpDecorations(spv::Decoration precision, spv::Decoration noContraction, spv::Decoration nonUniform) :
  96             precision(precision)
  97 #ifndef GLSLANG_WEB
  98             ,
  99             noContraction(noContraction),
 100             nonUniform(nonUniform)
 101 #endif
 102         { }
 103
 104     spv::Decoration precision;
 105
 106 #ifdef GLSLANG_WEB
 107         void addNoContraction(spv::Builder&, spv::Id) const { }
 108         void addNonUniform(spv::Builder&, spv::Id) const { }
 109 #else
 110         void addNoContraction(spv::Builder& builder, spv::Id t) { builder.addDecoration(t, noContraction); }
 111         void addNonUniform(spv::Builder& builder, spv::Id t)  { builder.addDecoration(t, nonUniform); }
 112     protected:
 113         spv::Decoration noContraction;
 114         spv::Decoration nonUniform;
 115 #endif
 116
 117 };
 118
 119 } // namespace
 120
 121 //
 122 // The main holder of information for translating glslang to SPIR-V.
 123 //
 124 // Derives from the AST walking base class.
 125 //
 126 class TGlslangToSpvTraverser : public glslang::TIntermTraverser {
 127 public:
 128     TGlslangToSpvTraverser(unsigned int spvVersion, const glslang::TIntermediate*, spv::SpvBuildLogger* logger,
 129         glslang::SpvOptions& options);
 130     virtual ~TGlslangToSpvTraverser() { }
 131
 132     bool visitAggregate(glslang::TVisit, glslang::TIntermAggregate*);
 133     bool visitBinary(glslang::TVisit, glslang::TIntermBinary*);
 134     void visitConstantUnion(glslang::TIntermConstantUnion*);
 135     bool visitSelection(glslang::TVisit, glslang::TIntermSelection*);
 136     bool visitSwitch(glslang::TVisit, glslang::TIntermSwitch*);
 137     void visitSymbol(glslang::TIntermSymbol* symbol);
 138     bool visitUnary(glslang::TVisit, glslang::TIntermUnary*);
 139     bool visitLoop(glslang::TVisit, glslang::TIntermLoop*);
 140     bool visitBranch(glslang::TVisit visit, glslang::TIntermBranch*);
 141
 142     void finishSpv();
 143     void dumpSpv(std::vector<unsigned int>& out);
 144
 145 protected:
 146     TGlslangToSpvTraverser(TGlslangToSpvTraverser&);
 147     TGlslangToSpvTraverser& operator=(TGlslangToSpvTraverser&);
 148
 149     spv::Decoration TranslateInterpolationDecoration(const glslang::TQualifier& qualifier);
 150     spv::Decoration TranslateAuxiliaryStorageDecoration(const glslang::TQualifier& qualifier);
 151     spv::Decoration TranslateNonUniformDecoration(const glslang::TQualifier& qualifier);
 152     spv::Decoration TranslateNonUniformDecoration(const spv::Builder::AccessChain::CoherentFlags& coherentFlags);
 153     spv::Builder::AccessChain::CoherentFlags TranslateCoherent(const glslang::TType& type);
 154     spv::MemoryAccessMask TranslateMemoryAccess(const spv::Builder::AccessChain::CoherentFlags &coherentFlags);
 155     spv::ImageOperandsMask TranslateImageOperands(const spv::Builder::AccessChain::CoherentFlags &coherentFlags);
 156     spv::Scope TranslateMemoryScope(const spv::Builder::AccessChain::CoherentFlags &coherentFlags);
 157     spv::BuiltIn TranslateBuiltInDecoration(glslang::TBuiltInVariable, bool memberDeclaration);
 158     spv::ImageFormat TranslateImageFormat(const glslang::TType& type);
 159     spv::SelectionControlMask TranslateSelectionControl(const glslang::TIntermSelection&) const;
 160     spv::SelectionControlMask TranslateSwitchControl(const glslang::TIntermSwitch&) const;
 161     spv::LoopControlMask TranslateLoopControl(const glslang::TIntermLoop&, std::vector<unsigned int>& operands) const;
 162     spv::StorageClass TranslateStorageClass(const glslang::TType&);
 163     void TranslateLiterals(const glslang::TVector<const glslang::TIntermConstantUnion*>&, std::vector<unsigned>&) const;
 164     void addIndirectionIndexCapabilities(const glslang::TType& baseType, const glslang::TType& indexType);
 165     spv::Id createSpvVariable(const glslang::TIntermSymbol*, spv::Id forcedType);
 166     spv::Id getSampledType(const glslang::TSampler&);
 167     spv::Id getInvertedSwizzleType(const glslang::TIntermTyped&);
 168     spv::Id createInvertedSwizzle(spv::Decoration precision, const glslang::TIntermTyped&, spv::Id parentResult);
 169     void convertSwizzle(const glslang::TIntermAggregate&, std::vector<unsigned>& swizzle);
 170     spv::Id convertGlslangToSpvType(const glslang::TType& type, bool forwardReferenceOnly = false);
 171     spv::Id convertGlslangToSpvType(const glslang::TType& type, glslang::TLayoutPacking, const glslang::TQualifier&,
 172         bool lastBufferBlockMember, bool forwardReferenceOnly = false);
 173     bool filterMember(const glslang::TType& member);
 174     spv::Id convertGlslangStructToSpvType(const glslang::TType&, const glslang::TTypeList* glslangStruct,
 175                                           glslang::TLayoutPacking, const glslang::TQualifier&);
 176     void decorateStructType(const glslang::TType&, const glslang::TTypeList* glslangStruct, glslang::TLayoutPacking,
 177                             const glslang::TQualifier&, spv::Id);
 178     spv::Id makeArraySizeId(const glslang::TArraySizes&, int dim);
 179     spv::Id accessChainLoad(const glslang::TType& type);
 180     void    accessChainStore(const glslang::TType& type, spv::Id rvalue);
 181     void multiTypeStore(const glslang::TType&, spv::Id rValue);
 182     spv::Id convertLoadedBoolInUniformToUint(const glslang::TType& type, spv::Id nominalTypeId, spv::Id loadedId);
 183     glslang::TLayoutPacking getExplicitLayout(const glslang::TType& type) const;
 184     int getArrayStride(const glslang::TType& arrayType, glslang::TLayoutPacking, glslang::TLayoutMatrix);
 185     int getMatrixStride(const glslang::TType& matrixType, glslang::TLayoutPacking, glslang::TLayoutMatrix);
 186     void updateMemberOffset(const glslang::TType& structType, const glslang::TType& memberType, int& currentOffset,
 187                             int& nextOffset, glslang::TLayoutPacking, glslang::TLayoutMatrix);
 188     void declareUseOfStructMember(const glslang::TTypeList& members, int glslangMember);
 189
 190     bool isShaderEntryPoint(const glslang::TIntermAggregate* node);
 191     bool writableParam(glslang::TStorageQualifier) const;
 192     bool originalParam(glslang::TStorageQualifier, const glslang::TType&, bool implicitThisParam);
 193     void makeFunctions(const glslang::TIntermSequence&);
 194     void makeGlobalInitializers(const glslang::TIntermSequence&);
 195     void collectRayTracingLinkerObjects();
 196     void visitFunctions(const glslang::TIntermSequence&);
 197     void handleFunctionEntry(const glslang::TIntermAggregate* node);
 198     void translateArguments(const glslang::TIntermAggregate& node, std::vector<spv::Id>& arguments,
 199         spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags);
 200     void translateArguments(glslang::TIntermUnary& node, std::vector<spv::Id>& arguments);
 201     spv::Id createImageTextureFunctionCall(glslang::TIntermOperator* node);
 202     spv::Id handleUserFunctionCall(const glslang::TIntermAggregate*);
 203
 204     spv::Id createBinaryOperation(glslang::TOperator op, OpDecorations&, spv::Id typeId, spv::Id left, spv::Id right,
 205                                   glslang::TBasicType typeProxy, bool reduceComparison = true);
 206     spv::Id createBinaryMatrixOperation(spv::Op, OpDecorations&, spv::Id typeId, spv::Id left, spv::Id right);
 207     spv::Id createUnaryOperation(glslang::TOperator op, OpDecorations&, spv::Id typeId, spv::Id operand,
 208                                  glslang::TBasicType typeProxy,
 209                                  const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags);
 210     spv::Id createUnaryMatrixOperation(spv::Op op, OpDecorations&, spv::Id typeId, spv::Id operand,
 211                                        glslang::TBasicType typeProxy);
 212     spv::Id createConversion(glslang::TOperator op, OpDecorations&, spv::Id destTypeId, spv::Id operand,
 213                              glslang::TBasicType typeProxy);
 214     spv::Id createIntWidthConversion(glslang::TOperator op, spv::Id operand, int vectorSize);
 215     spv::Id makeSmearedConstant(spv::Id constant, int vectorSize);
 216     spv::Id createAtomicOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId,
 217         std::vector<spv::Id>& operands, glslang::TBasicType typeProxy,
 218         const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags);
 219     spv::Id createInvocationsOperation(glslang::TOperator op, spv::Id typeId, std::vector<spv::Id>& operands,
 220         glslang::TBasicType typeProxy);
 221     spv::Id CreateInvocationsVectorOperation(spv::Op op, spv::GroupOperation groupOperation,
 222         spv::Id typeId, std::vector<spv::Id>& operands);
 223     spv::Id createSubgroupOperation(glslang::TOperator op, spv::Id typeId, std::vector<spv::Id>& operands,
 224         glslang::TBasicType typeProxy);
 225     spv::Id createMiscOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId,
 226         std::vector<spv::Id>& operands, glslang::TBasicType typeProxy);
 227     spv::Id createNoArgOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId);
 228     spv::Id getSymbolId(const glslang::TIntermSymbol* node);
 229     void addMeshNVDecoration(spv::Id id, int member, const glslang::TQualifier & qualifier);
 230     spv::Id createSpvConstant(const glslang::TIntermTyped&);
 231     spv::Id createSpvConstantFromConstUnionArray(const glslang::TType& type, const glslang::TConstUnionArray&,
 232         int& nextConst, bool specConstant);
 233     bool isTrivialLeaf(const glslang::TIntermTyped* node);
 234     bool isTrivial(const glslang::TIntermTyped* node);
 235     spv::Id createShortCircuit(glslang::TOperator, glslang::TIntermTyped& left, glslang::TIntermTyped& right);
 236     spv::Id getExtBuiltins(const char* name);
 237     std::pair<spv::Id, spv::Id> getForcedType(glslang::TBuiltInVariable builtIn, const glslang::TType&);
 238     spv::Id translateForcedType(spv::Id object);
 239     spv::Id createCompositeConstruct(spv::Id typeId, std::vector<spv::Id> constituents);
 240
 241     glslang::SpvOptions& options;
 242     spv::Function* shaderEntry;
 243     spv::Function* currentFunction;
 244     spv::Instruction* entryPoint;
 245     int sequenceDepth;
 246
 247     spv::SpvBuildLogger* logger;
 248
 249     // There is a 1:1 mapping between a spv builder and a module; this is thread safe
 250     spv::Builder builder;
 251     bool inEntryPoint;
 252     bool entryPointTerminated;
 253     bool linkageOnly;                  // true when visiting the set of objects in the AST present only for
 254                                        // establishing interface, whether or not they were statically used
 255     std::set<spv::Id> iOSet;           // all input/output variables from either static use or declaration of interface
 256     const glslang::TIntermediate* glslangIntermediate;
 257     bool nanMinMaxClamp;               // true if use NMin/NMax/NClamp instead of FMin/FMax/FClamp
 258     spv::Id stdBuiltins;
 259     spv::Id nonSemanticDebugPrintf;
 260     std::unordered_map<std::string, spv::Id> extBuiltinMap;
 261
 262     std::unordered_map<long long, spv::Id> symbolValues;
 263     std::unordered_map<uint32_t, spv::Id> builtInVariableIds;
 264     std::unordered_set<long long> rValueParameters;  // set of formal function parameters passed as rValues,
 265                                                // rather than a pointer
 266     std::unordered_map<std::string, spv::Function*> functionMap;
 267     std::unordered_map<const glslang::TTypeList*, spv::Id> structMap[glslang::ElpCount][glslang::ElmCount];
 268     // for mapping glslang block indices to spv indices (e.g., due to hidden members):
 269     std::unordered_map<long long, std::vector<int>> memberRemapper;
 270     // for mapping glslang symbol struct to symbol Id
 271     std::unordered_map<const glslang::TTypeList*, long long> glslangTypeToIdMap;
 272     std::stack<bool> breakForLoop;  // false means break for switch
 273     std::unordered_map<std::string, const glslang::TIntermSymbol*> counterOriginator;
 274     // Map pointee types for EbtReference to their forward pointers
 275     std::map<const glslang::TType *, spv::Id> forwardPointers;
 276     // Type forcing, for when SPIR-V wants a different type than the AST,
 277     // requiring local translation to and from SPIR-V type on every access.
 278     // Maps <builtin-variable-id -> AST-required-type-id>
 279     std::unordered_map<spv::Id, spv::Id> forceType;
 280
 281     // Used later for generating OpTraceKHR/OpExecuteCallableKHR
 282     std::unordered_map<unsigned int, glslang::TIntermSymbol *> locationToSymbol[2];
 283
 284     // Used by Task shader while generating opearnds for OpEmitMeshTasksEXT
 285     spv::Id taskPayloadID;
 286 };
 287
 288 //
 289 // Helper functions for translating glslang representations to SPIR-V enumerants.
 290 //
 291
 292 // Translate glslang profile to SPIR-V source language.
 293 spv::SourceLanguage TranslateSourceLanguage(glslang::EShSource source, EProfile profile)
 294 {
 295 #ifdef GLSLANG_WEB
 296     return spv::SourceLanguageESSL;
 297 #elif defined(GLSLANG_ANGLE)
 298     return spv::SourceLanguageGLSL;
 299 #endif
 300
 301     switch (source) {
 302     case glslang::EShSourceGlsl:
 303         switch (profile) {
 304         case ENoProfile:
 305         case ECoreProfile:
 306         case ECompatibilityProfile:
 307             return spv::SourceLanguageGLSL;
 308         case EEsProfile:
 309             return spv::SourceLanguageESSL;
 310         default:
 311             return spv::SourceLanguageUnknown;
 312         }
 313     case glslang::EShSourceHlsl:
 314         return spv::SourceLanguageHLSL;
 315     default:
 316         return spv::SourceLanguageUnknown;
 317     }
 318 }
 319
 320 // Translate glslang language (stage) to SPIR-V execution model.
 321 spv::ExecutionModel TranslateExecutionModel(EShLanguage stage, bool isMeshShaderEXT = false)
 322 {
 323     switch (stage) {
 324     case EShLangVertex:           return spv::ExecutionModelVertex;
 325     case EShLangFragment:         return spv::ExecutionModelFragment;
 326     case EShLangCompute:          return spv::ExecutionModelGLCompute;
 327 #ifndef GLSLANG_WEB
 328     case EShLangTessControl:      return spv::ExecutionModelTessellationControl;
 329     case EShLangTessEvaluation:   return spv::ExecutionModelTessellationEvaluation;
 330     case EShLangGeometry:         return spv::ExecutionModelGeometry;
 331     case EShLangRayGen:           return spv::ExecutionModelRayGenerationKHR;
 332     case EShLangIntersect:        return spv::ExecutionModelIntersectionKHR;
 333     case EShLangAnyHit:           return spv::ExecutionModelAnyHitKHR;
 334     case EShLangClosestHit:       return spv::ExecutionModelClosestHitKHR;
 335     case EShLangMiss:             return spv::ExecutionModelMissKHR;
 336     case EShLangCallable:         return spv::ExecutionModelCallableKHR;
 337     case EShLangTask:             return (isMeshShaderEXT)? spv::ExecutionModelTaskEXT : spv::ExecutionModelTaskNV;
 338     case EShLangMesh:             return (isMeshShaderEXT)? spv::ExecutionModelMeshEXT: spv::ExecutionModelMeshNV;
 339 #endif
 340     default:
 341         assert(0);
 342         return spv::ExecutionModelFragment;
 343     }
 344 }
 345
 346 // Translate glslang sampler type to SPIR-V dimensionality.
 347 spv::Dim TranslateDimensionality(const glslang::TSampler& sampler)
 348 {
 349     switch (sampler.dim) {
 350     case glslang::Esd1D:      return spv::Dim1D;
 351     case glslang::Esd2D:      return spv::Dim2D;
 352     case glslang::Esd3D:      return spv::Dim3D;
 353     case glslang::EsdCube:    return spv::DimCube;
 354     case glslang::EsdRect:    return spv::DimRect;
 355     case glslang::EsdBuffer:  return spv::DimBuffer;
 356     case glslang::EsdSubpass: return spv::DimSubpassData;
 357     default:
 358         assert(0);
 359         return spv::Dim2D;
 360     }
 361 }
 362
 363 // Translate glslang precision to SPIR-V precision decorations.
 364 spv::Decoration TranslatePrecisionDecoration(glslang::TPrecisionQualifier glslangPrecision)
 365 {
 366     switch (glslangPrecision) {
 367     case glslang::EpqLow:    return spv::DecorationRelaxedPrecision;
 368     case glslang::EpqMedium: return spv::DecorationRelaxedPrecision;
 369     default:
 370         return spv::NoPrecision;
 371     }
 372 }
 373
 374 // Translate glslang type to SPIR-V precision decorations.
 375 spv::Decoration TranslatePrecisionDecoration(const glslang::TType& type)
 376 {
 377     return TranslatePrecisionDecoration(type.getQualifier().precision);
 378 }
 379
 380 // Translate glslang type to SPIR-V block decorations.
 381 spv::Decoration TranslateBlockDecoration(const glslang::TType& type, bool useStorageBuffer)
 382 {
 383     if (type.getBasicType() == glslang::EbtBlock) {
 384         switch (type.getQualifier().storage) {
 385         case glslang::EvqUniform:      return spv::DecorationBlock;
 386         case glslang::EvqBuffer:       return useStorageBuffer ? spv::DecorationBlock : spv::DecorationBufferBlock;
 387         case glslang::EvqVaryingIn:    return spv::DecorationBlock;
 388         case glslang::EvqVaryingOut:   return spv::DecorationBlock;
 389         case glslang::EvqShared:       return spv::DecorationBlock;
 390 #ifndef GLSLANG_WEB
 391         case glslang::EvqPayload:      return spv::DecorationBlock;
 392         case glslang::EvqPayloadIn:    return spv::DecorationBlock;
 393         case glslang::EvqHitAttr:      return spv::DecorationBlock;
 394         case glslang::EvqCallableData:   return spv::DecorationBlock;
 395         case glslang::EvqCallableDataIn: return spv::DecorationBlock;
 396 #endif
 397         default:
 398             assert(0);
 399             break;
 400         }
 401     }
 402
 403     return spv::DecorationMax;
 404 }
 405
 406 // Translate glslang type to SPIR-V memory decorations.
 407 void TranslateMemoryDecoration(const glslang::TQualifier& qualifier, std::vector<spv::Decoration>& memory,
 408     bool useVulkanMemoryModel)
 409 {
 410     if (!useVulkanMemoryModel) {
 411         if (qualifier.isCoherent())
 412             memory.push_back(spv::DecorationCoherent);
 413         if (qualifier.isVolatile()) {
 414             memory.push_back(spv::DecorationVolatile);
 415             memory.push_back(spv::DecorationCoherent);
 416         }
 417     }
 418     if (qualifier.isRestrict())
 419         memory.push_back(spv::DecorationRestrict);
 420     if (qualifier.isReadOnly())
 421         memory.push_back(spv::DecorationNonWritable);
 422     if (qualifier.isWriteOnly())
 423        memory.push_back(spv::DecorationNonReadable);
 424 }
 425
 426 // Translate glslang type to SPIR-V layout decorations.
 427 spv::Decoration TranslateLayoutDecoration(const glslang::TType& type, glslang::TLayoutMatrix matrixLayout)
 428 {
 429     if (type.isMatrix()) {
 430         switch (matrixLayout) {
 431         case glslang::ElmRowMajor:
 432             return spv::DecorationRowMajor;
 433         case glslang::ElmColumnMajor:
 434             return spv::DecorationColMajor;
 435         default:
 436             // opaque layouts don't need a majorness
 437             return spv::DecorationMax;
 438         }
 439     } else {
 440         switch (type.getBasicType()) {
 441         default:
 442             return spv::DecorationMax;
 443             break;
 444         case glslang::EbtBlock:
 445             switch (type.getQualifier().storage) {
 446             case glslang::EvqShared:
 447             case glslang::EvqUniform:
 448             case glslang::EvqBuffer:
 449                 switch (type.getQualifier().layoutPacking) {
 450                 case glslang::ElpShared:  return spv::DecorationGLSLShared;
 451                 case glslang::ElpPacked:  return spv::DecorationGLSLPacked;
 452                 default:
 453                     return spv::DecorationMax;
 454                 }
 455             case glslang::EvqVaryingIn:
 456             case glslang::EvqVaryingOut:
 457                 if (type.getQualifier().isTaskMemory()) {
 458                     switch (type.getQualifier().layoutPacking) {
 459                     case glslang::ElpShared:  return spv::DecorationGLSLShared;
 460                     case glslang::ElpPacked:  return spv::DecorationGLSLPacked;
 461                     default: break;
 462                     }
 463                 } else {
 464                     assert(type.getQualifier().layoutPacking == glslang::ElpNone);
 465                 }
 466                 return spv::DecorationMax;
 467 #ifndef GLSLANG_WEB
 468             case glslang::EvqPayload:
 469             case glslang::EvqPayloadIn:
 470             case glslang::EvqHitAttr:
 471             case glslang::EvqCallableData:
 472             case glslang::EvqCallableDataIn:
 473                 return spv::DecorationMax;
 474 #endif
 475             default:
 476                 assert(0);
 477                 return spv::DecorationMax;
 478             }
 479         }
 480     }
 481 }
 482
 483 // Translate glslang type to SPIR-V interpolation decorations.
 484 // Returns spv::DecorationMax when no decoration
 485 // should be applied.
 486 spv::Decoration TGlslangToSpvTraverser::TranslateInterpolationDecoration(const glslang::TQualifier& qualifier)
 487 {
 488     if (qualifier.smooth)
 489         // Smooth decoration doesn't exist in SPIR-V 1.0
 490         return spv::DecorationMax;
 491     else if (qualifier.isNonPerspective())
 492         return spv::DecorationNoPerspective;
 493     else if (qualifier.flat)
 494         return spv::DecorationFlat;
 495     else if (qualifier.isExplicitInterpolation()) {
 496         builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
 497         return spv::DecorationExplicitInterpAMD;
 498     }
 499     else
 500         return spv::DecorationMax;
 501 }
 502
 503 // Translate glslang type to SPIR-V auxiliary storage decorations.
 504 // Returns spv::DecorationMax when no decoration
 505 // should be applied.
 506 spv::Decoration TGlslangToSpvTraverser::TranslateAuxiliaryStorageDecoration(const glslang::TQualifier& qualifier)
 507 {
 508     if (qualifier.centroid)
 509         return spv::DecorationCentroid;
 510 #ifndef GLSLANG_WEB
 511     else if (qualifier.patch)
 512         return spv::DecorationPatch;
 513     else if (qualifier.sample) {
 514         builder.addCapability(spv::CapabilitySampleRateShading);
 515         return spv::DecorationSample;
 516     }
 517 #endif
 518
 519     return spv::DecorationMax;
 520 }
 521
 522 // If glslang type is invariant, return SPIR-V invariant decoration.
 523 spv::Decoration TranslateInvariantDecoration(const glslang::TQualifier& qualifier)
 524 {
 525     if (qualifier.invariant)
 526         return spv::DecorationInvariant;
 527     else
 528         return spv::DecorationMax;
 529 }
 530
 531 // If glslang type is noContraction, return SPIR-V NoContraction decoration.
 532 spv::Decoration TranslateNoContractionDecoration(const glslang::TQualifier& qualifier)
 533 {
 534 #ifndef GLSLANG_WEB
 535     if (qualifier.isNoContraction())
 536         return spv::DecorationNoContraction;
 537     else
 538 #endif
 539         return spv::DecorationMax;
 540 }
 541
 542 // If glslang type is nonUniform, return SPIR-V NonUniform decoration.
 543 spv::Decoration TGlslangToSpvTraverser::TranslateNonUniformDecoration(const glslang::TQualifier& qualifier)
 544 {
 545 #ifndef GLSLANG_WEB
 546     if (qualifier.isNonUniform()) {
 547         builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
 548         builder.addCapability(spv::CapabilityShaderNonUniformEXT);
 549         return spv::DecorationNonUniformEXT;
 550     } else
 551 #endif
 552         return spv::DecorationMax;
 553 }
 554
 555 // If lvalue flags contains nonUniform, return SPIR-V NonUniform decoration.
 556 spv::Decoration TGlslangToSpvTraverser::TranslateNonUniformDecoration(
 557     const spv::Builder::AccessChain::CoherentFlags& coherentFlags)
 558 {
 559 #ifndef GLSLANG_WEB
 560     if (coherentFlags.isNonUniform()) {
 561         builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
 562         builder.addCapability(spv::CapabilityShaderNonUniformEXT);
 563         return spv::DecorationNonUniformEXT;
 564     } else
 565 #endif
 566         return spv::DecorationMax;
 567 }
 568
 569 spv::MemoryAccessMask TGlslangToSpvTraverser::TranslateMemoryAccess(
 570     const spv::Builder::AccessChain::CoherentFlags &coherentFlags)
 571 {
 572     spv::MemoryAccessMask mask = spv::MemoryAccessMaskNone;
 573
 574 #ifndef GLSLANG_WEB
 575     if (!glslangIntermediate->usingVulkanMemoryModel() || coherentFlags.isImage)
 576         return mask;
 577
 578     if (coherentFlags.isVolatile() || coherentFlags.anyCoherent()) {
 579         mask = mask | spv::MemoryAccessMakePointerAvailableKHRMask |
 580                       spv::MemoryAccessMakePointerVisibleKHRMask;
 581     }
 582
 583     if (coherentFlags.nonprivate) {
 584         mask = mask | spv::MemoryAccessNonPrivatePointerKHRMask;
 585     }
 586     if (coherentFlags.volatil) {
 587         mask = mask | spv::MemoryAccessVolatileMask;
 588     }
 589     if (mask != spv::MemoryAccessMaskNone) {
 590         builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
 591     }
 592 #endif
 593
 594     return mask;
 595 }
 596
 597 spv::ImageOperandsMask TGlslangToSpvTraverser::TranslateImageOperands(
 598     const spv::Builder::AccessChain::CoherentFlags &coherentFlags)
 599 {
 600     spv::ImageOperandsMask mask = spv::ImageOperandsMaskNone;
 601
 602 #ifndef GLSLANG_WEB
 603     if (!glslangIntermediate->usingVulkanMemoryModel())
 604         return mask;
 605
 606     if (coherentFlags.volatil ||
 607         coherentFlags.anyCoherent()) {
 608         mask = mask | spv::ImageOperandsMakeTexelAvailableKHRMask |
 609                       spv::ImageOperandsMakeTexelVisibleKHRMask;
 610     }
 611     if (coherentFlags.nonprivate) {
 612         mask = mask | spv::ImageOperandsNonPrivateTexelKHRMask;
 613     }
 614     if (coherentFlags.volatil) {
 615         mask = mask | spv::ImageOperandsVolatileTexelKHRMask;
 616     }
 617     if (mask != spv::ImageOperandsMaskNone) {
 618         builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
 619     }
 620 #endif
 621
 622     return mask;
 623 }
 624
 625 spv::Builder::AccessChain::CoherentFlags TGlslangToSpvTraverser::TranslateCoherent(const glslang::TType& type)
 626 {
 627     spv::Builder::AccessChain::CoherentFlags flags = {};
 628 #ifndef GLSLANG_WEB
 629     flags.coherent = type.getQualifier().coherent;
 630     flags.devicecoherent = type.getQualifier().devicecoherent;
 631     flags.queuefamilycoherent = type.getQualifier().queuefamilycoherent;
 632     // shared variables are implicitly workgroupcoherent in GLSL.
 633     flags.workgroupcoherent = type.getQualifier().workgroupcoherent ||
 634                               type.getQualifier().storage == glslang::EvqShared;
 635     flags.subgroupcoherent = type.getQualifier().subgroupcoherent;
 636     flags.shadercallcoherent = type.getQualifier().shadercallcoherent;
 637     flags.volatil = type.getQualifier().volatil;
 638     // *coherent variables are implicitly nonprivate in GLSL
 639     flags.nonprivate = type.getQualifier().nonprivate ||
 640                        flags.anyCoherent() ||
 641                        flags.volatil;
 642     flags.isImage = type.getBasicType() == glslang::EbtSampler;
 643 #endif
 644     flags.nonUniform = type.getQualifier().nonUniform;
 645     return flags;
 646 }
 647
 648 spv::Scope TGlslangToSpvTraverser::TranslateMemoryScope(
 649     const spv::Builder::AccessChain::CoherentFlags &coherentFlags)
 650 {
 651     spv::Scope scope = spv::ScopeMax;
 652
 653 #ifndef GLSLANG_WEB
 654     if (coherentFlags.volatil || coherentFlags.coherent) {
 655         // coherent defaults to Device scope in the old model, QueueFamilyKHR scope in the new model
 656         scope = glslangIntermediate->usingVulkanMemoryModel() ? spv::ScopeQueueFamilyKHR : spv::ScopeDevice;
 657     } else if (coherentFlags.devicecoherent) {
 658         scope = spv::ScopeDevice;
 659     } else if (coherentFlags.queuefamilycoherent) {
 660         scope = spv::ScopeQueueFamilyKHR;
 661     } else if (coherentFlags.workgroupcoherent) {
 662         scope = spv::ScopeWorkgroup;
 663     } else if (coherentFlags.subgroupcoherent) {
 664         scope = spv::ScopeSubgroup;
 665     } else if (coherentFlags.shadercallcoherent) {
 666         scope = spv::ScopeShaderCallKHR;
 667     }
 668     if (glslangIntermediate->usingVulkanMemoryModel() && scope == spv::ScopeDevice) {
 669         builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR);
 670     }
 671 #endif
 672
 673     return scope;
 674 }
 675
 676 // Translate a glslang built-in variable to a SPIR-V built in decoration.  Also generate
 677 // associated capabilities when required.  For some built-in variables, a capability
 678 // is generated only when using the variable in an executable instruction, but not when
 679 // just declaring a struct member variable with it.  This is true for PointSize,
 680 // ClipDistance, and CullDistance.
 681 spv::BuiltIn TGlslangToSpvTraverser::TranslateBuiltInDecoration(glslang::TBuiltInVariable builtIn,
 682     bool memberDeclaration)
 683 {
 684     switch (builtIn) {
 685     case glslang::EbvPointSize:
 686 #ifndef GLSLANG_WEB
 687         // Defer adding the capability until the built-in is actually used.
 688         if (! memberDeclaration) {
 689             switch (glslangIntermediate->getStage()) {
 690             case EShLangGeometry:
 691                 builder.addCapability(spv::CapabilityGeometryPointSize);
 692                 break;
 693             case EShLangTessControl:
 694             case EShLangTessEvaluation:
 695                 builder.addCapability(spv::CapabilityTessellationPointSize);
 696                 break;
 697             default:
 698                 break;
 699             }
 700         }
 701 #endif
 702         return spv::BuiltInPointSize;
 703
 704     case glslang::EbvPosition:             return spv::BuiltInPosition;
 705     case glslang::EbvVertexId:             return spv::BuiltInVertexId;
 706     case glslang::EbvInstanceId:           return spv::BuiltInInstanceId;
 707     case glslang::EbvVertexIndex:          return spv::BuiltInVertexIndex;
 708     case glslang::EbvInstanceIndex:        return spv::BuiltInInstanceIndex;
 709
 710     case glslang::EbvFragCoord:            return spv::BuiltInFragCoord;
 711     case glslang::EbvPointCoord:           return spv::BuiltInPointCoord;
 712     case glslang::EbvFace:                 return spv::BuiltInFrontFacing;
 713     case glslang::EbvFragDepth:            return spv::BuiltInFragDepth;
 714
 715     case glslang::EbvNumWorkGroups:        return spv::BuiltInNumWorkgroups;
 716     case glslang::EbvWorkGroupSize:        return spv::BuiltInWorkgroupSize;
 717     case glslang::EbvWorkGroupId:          return spv::BuiltInWorkgroupId;
 718     case glslang::EbvLocalInvocationId:    return spv::BuiltInLocalInvocationId;
 719     case glslang::EbvLocalInvocationIndex: return spv::BuiltInLocalInvocationIndex;
 720     case glslang::EbvGlobalInvocationId:   return spv::BuiltInGlobalInvocationId;
 721
 722 #ifndef GLSLANG_WEB
 723     // These *Distance capabilities logically belong here, but if the member is declared and
 724     // then never used, consumers of SPIR-V prefer the capability not be declared.
 725     // They are now generated when used, rather than here when declared.
 726     // Potentially, the specification should be more clear what the minimum
 727     // use needed is to trigger the capability.
 728     //
 729     case glslang::EbvClipDistance:
 730         if (!memberDeclaration)
 731             builder.addCapability(spv::CapabilityClipDistance);
 732         return spv::BuiltInClipDistance;
 733
 734     case glslang::EbvCullDistance:
 735         if (!memberDeclaration)
 736             builder.addCapability(spv::CapabilityCullDistance);
 737         return spv::BuiltInCullDistance;
 738
 739     case glslang::EbvViewportIndex:
 740         if (glslangIntermediate->getStage() == EShLangGeometry ||
 741             glslangIntermediate->getStage() == EShLangFragment) {
 742             builder.addCapability(spv::CapabilityMultiViewport);
 743         }
 744         if (glslangIntermediate->getStage() == EShLangVertex ||
 745             glslangIntermediate->getStage() == EShLangTessControl ||
 746             glslangIntermediate->getStage() == EShLangTessEvaluation) {
 747
 748             if (builder.getSpvVersion() < spv::Spv_1_5) {
 749                 builder.addIncorporatedExtension(spv::E_SPV_EXT_shader_viewport_index_layer, spv::Spv_1_5);
 750                 builder.addCapability(spv::CapabilityShaderViewportIndexLayerEXT);
 751             }
 752             else
 753                 builder.addCapability(spv::CapabilityShaderViewportIndex);
 754         }
 755         return spv::BuiltInViewportIndex;
 756
 757     case glslang::EbvSampleId:
 758         builder.addCapability(spv::CapabilitySampleRateShading);
 759         return spv::BuiltInSampleId;
 760
 761     case glslang::EbvSamplePosition:
 762         builder.addCapability(spv::CapabilitySampleRateShading);
 763         return spv::BuiltInSamplePosition;
 764
 765     case glslang::EbvSampleMask:
 766         return spv::BuiltInSampleMask;
 767
 768     case glslang::EbvLayer:
 769         if (glslangIntermediate->getStage() == EShLangMesh) {
 770             return spv::BuiltInLayer;
 771         }
 772         if (glslangIntermediate->getStage() == EShLangGeometry ||
 773             glslangIntermediate->getStage() == EShLangFragment) {
 774             builder.addCapability(spv::CapabilityGeometry);
 775         }
 776         if (glslangIntermediate->getStage() == EShLangVertex ||
 777             glslangIntermediate->getStage() == EShLangTessControl ||
 778             glslangIntermediate->getStage() == EShLangTessEvaluation) {
 779
 780             if (builder.getSpvVersion() < spv::Spv_1_5) {
 781                 builder.addIncorporatedExtension(spv::E_SPV_EXT_shader_viewport_index_layer, spv::Spv_1_5);
 782                 builder.addCapability(spv::CapabilityShaderViewportIndexLayerEXT);
 783             } else
 784                 builder.addCapability(spv::CapabilityShaderLayer);
 785         }
 786         return spv::BuiltInLayer;
 787
 788     case glslang::EbvBaseVertex:
 789         builder.addIncorporatedExtension(spv::E_SPV_KHR_shader_draw_parameters, spv::Spv_1_3);
 790         builder.addCapability(spv::CapabilityDrawParameters);
 791         return spv::BuiltInBaseVertex;
 792
 793     case glslang::EbvBaseInstance:
 794         builder.addIncorporatedExtension(spv::E_SPV_KHR_shader_draw_parameters, spv::Spv_1_3);
 795         builder.addCapability(spv::CapabilityDrawParameters);
 796         return spv::BuiltInBaseInstance;
 797
 798     case glslang::EbvDrawId:
 799         builder.addIncorporatedExtension(spv::E_SPV_KHR_shader_draw_parameters, spv::Spv_1_3);
 800         builder.addCapability(spv::CapabilityDrawParameters);
 801         return spv::BuiltInDrawIndex;
 802
 803     case glslang::EbvPrimitiveId:
 804         if (glslangIntermediate->getStage() == EShLangFragment)
 805             builder.addCapability(spv::CapabilityGeometry);
 806         return spv::BuiltInPrimitiveId;
 807
 808     case glslang::EbvFragStencilRef:
 809         builder.addExtension(spv::E_SPV_EXT_shader_stencil_export);
 810         builder.addCapability(spv::CapabilityStencilExportEXT);
 811         return spv::BuiltInFragStencilRefEXT;
 812
 813     case glslang::EbvShadingRateKHR:
 814         builder.addExtension(spv::E_SPV_KHR_fragment_shading_rate);
 815         builder.addCapability(spv::CapabilityFragmentShadingRateKHR);
 816         return spv::BuiltInShadingRateKHR;
 817
 818     case glslang::EbvPrimitiveShadingRateKHR:
 819         builder.addExtension(spv::E_SPV_KHR_fragment_shading_rate);
 820         builder.addCapability(spv::CapabilityFragmentShadingRateKHR);
 821         return spv::BuiltInPrimitiveShadingRateKHR;
 822
 823     case glslang::EbvInvocationId:         return spv::BuiltInInvocationId;
 824     case glslang::EbvTessLevelInner:       return spv::BuiltInTessLevelInner;
 825     case glslang::EbvTessLevelOuter:       return spv::BuiltInTessLevelOuter;
 826     case glslang::EbvTessCoord:            return spv::BuiltInTessCoord;
 827     case glslang::EbvPatchVertices:        return spv::BuiltInPatchVertices;
 828     case glslang::EbvHelperInvocation:     return spv::BuiltInHelperInvocation;
 829
 830     case glslang::EbvSubGroupSize:
 831         builder.addExtension(spv::E_SPV_KHR_shader_ballot);
 832         builder.addCapability(spv::CapabilitySubgroupBallotKHR);
 833         return spv::BuiltInSubgroupSize;
 834
 835     case glslang::EbvSubGroupInvocation:
 836         builder.addExtension(spv::E_SPV_KHR_shader_ballot);
 837         builder.addCapability(spv::CapabilitySubgroupBallotKHR);
 838         return spv::BuiltInSubgroupLocalInvocationId;
 839
 840     case glslang::EbvSubGroupEqMask:
 841         builder.addExtension(spv::E_SPV_KHR_shader_ballot);
 842         builder.addCapability(spv::CapabilitySubgroupBallotKHR);
 843         return spv::BuiltInSubgroupEqMask;
 844
 845     case glslang::EbvSubGroupGeMask:
 846         builder.addExtension(spv::E_SPV_KHR_shader_ballot);
 847         builder.addCapability(spv::CapabilitySubgroupBallotKHR);
 848         return spv::BuiltInSubgroupGeMask;
 849
 850     case glslang::EbvSubGroupGtMask:
 851         builder.addExtension(spv::E_SPV_KHR_shader_ballot);
 852         builder.addCapability(spv::CapabilitySubgroupBallotKHR);
 853         return spv::BuiltInSubgroupGtMask;
 854
 855     case glslang::EbvSubGroupLeMask:
 856         builder.addExtension(spv::E_SPV_KHR_shader_ballot);
 857         builder.addCapability(spv::CapabilitySubgroupBallotKHR);
 858         return spv::BuiltInSubgroupLeMask;
 859
 860     case glslang::EbvSubGroupLtMask:
 861         builder.addExtension(spv::E_SPV_KHR_shader_ballot);
 862         builder.addCapability(spv::CapabilitySubgroupBallotKHR);
 863         return spv::BuiltInSubgroupLtMask;
 864
 865     case glslang::EbvNumSubgroups:
 866         builder.addCapability(spv::CapabilityGroupNonUniform);
 867         return spv::BuiltInNumSubgroups;
 868
 869     case glslang::EbvSubgroupID:
 870         builder.addCapability(spv::CapabilityGroupNonUniform);
 871         return spv::BuiltInSubgroupId;
 872
 873     case glslang::EbvSubgroupSize2:
 874         builder.addCapability(spv::CapabilityGroupNonUniform);
 875         return spv::BuiltInSubgroupSize;
 876
 877     case glslang::EbvSubgroupInvocation2:
 878         builder.addCapability(spv::CapabilityGroupNonUniform);
 879         return spv::BuiltInSubgroupLocalInvocationId;
 880
 881     case glslang::EbvSubgroupEqMask2:
 882         builder.addCapability(spv::CapabilityGroupNonUniform);
 883         builder.addCapability(spv::CapabilityGroupNonUniformBallot);
 884         return spv::BuiltInSubgroupEqMask;
 885
 886     case glslang::EbvSubgroupGeMask2:
 887         builder.addCapability(spv::CapabilityGroupNonUniform);
 888         builder.addCapability(spv::CapabilityGroupNonUniformBallot);
 889         return spv::BuiltInSubgroupGeMask;
 890
 891     case glslang::EbvSubgroupGtMask2:
 892         builder.addCapability(spv::CapabilityGroupNonUniform);
 893         builder.addCapability(spv::CapabilityGroupNonUniformBallot);
 894         return spv::BuiltInSubgroupGtMask;
 895
 896     case glslang::EbvSubgroupLeMask2:
 897         builder.addCapability(spv::CapabilityGroupNonUniform);
 898         builder.addCapability(spv::CapabilityGroupNonUniformBallot);
 899         return spv::BuiltInSubgroupLeMask;
 900
 901     case glslang::EbvSubgroupLtMask2:
 902         builder.addCapability(spv::CapabilityGroupNonUniform);
 903         builder.addCapability(spv::CapabilityGroupNonUniformBallot);
 904         return spv::BuiltInSubgroupLtMask;
 905
 906     case glslang::EbvBaryCoordNoPersp:
 907         builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
 908         return spv::BuiltInBaryCoordNoPerspAMD;
 909
 910     case glslang::EbvBaryCoordNoPerspCentroid:
 911         builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
 912         return spv::BuiltInBaryCoordNoPerspCentroidAMD;
 913
 914     case glslang::EbvBaryCoordNoPerspSample:
 915         builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
 916         return spv::BuiltInBaryCoordNoPerspSampleAMD;
 917
 918     case glslang::EbvBaryCoordSmooth:
 919         builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
 920         return spv::BuiltInBaryCoordSmoothAMD;
 921
 922     case glslang::EbvBaryCoordSmoothCentroid:
 923         builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
 924         return spv::BuiltInBaryCoordSmoothCentroidAMD;
 925
 926     case glslang::EbvBaryCoordSmoothSample:
 927         builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
 928         return spv::BuiltInBaryCoordSmoothSampleAMD;
 929
 930     case glslang::EbvBaryCoordPullModel:
 931         builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
 932         return spv::BuiltInBaryCoordPullModelAMD;
 933
 934     case glslang::EbvDeviceIndex:
 935         builder.addIncorporatedExtension(spv::E_SPV_KHR_device_group, spv::Spv_1_3);
 936         builder.addCapability(spv::CapabilityDeviceGroup);
 937         return spv::BuiltInDeviceIndex;
 938
 939     case glslang::EbvViewIndex:
 940         builder.addIncorporatedExtension(spv::E_SPV_KHR_multiview, spv::Spv_1_3);
 941         builder.addCapability(spv::CapabilityMultiView);
 942         return spv::BuiltInViewIndex;
 943
 944     case glslang::EbvFragSizeEXT:
 945         builder.addExtension(spv::E_SPV_EXT_fragment_invocation_density);
 946         builder.addCapability(spv::CapabilityFragmentDensityEXT);
 947         return spv::BuiltInFragSizeEXT;
 948
 949     case glslang::EbvFragInvocationCountEXT:
 950         builder.addExtension(spv::E_SPV_EXT_fragment_invocation_density);
 951         builder.addCapability(spv::CapabilityFragmentDensityEXT);
 952         return spv::BuiltInFragInvocationCountEXT;
 953
 954     case glslang::EbvViewportMaskNV:
 955         if (!memberDeclaration) {
 956             builder.addExtension(spv::E_SPV_NV_viewport_array2);
 957             builder.addCapability(spv::CapabilityShaderViewportMaskNV);
 958         }
 959         return spv::BuiltInViewportMaskNV;
 960     case glslang::EbvSecondaryPositionNV:
 961         if (!memberDeclaration) {
 962             builder.addExtension(spv::E_SPV_NV_stereo_view_rendering);
 963             builder.addCapability(spv::CapabilityShaderStereoViewNV);
 964         }
 965         return spv::BuiltInSecondaryPositionNV;
 966     case glslang::EbvSecondaryViewportMaskNV:
 967         if (!memberDeclaration) {
 968             builder.addExtension(spv::E_SPV_NV_stereo_view_rendering);
 969             builder.addCapability(spv::CapabilityShaderStereoViewNV);
 970         }
 971         return spv::BuiltInSecondaryViewportMaskNV;
 972     case glslang::EbvPositionPerViewNV:
 973         if (!memberDeclaration) {
 974             builder.addExtension(spv::E_SPV_NVX_multiview_per_view_attributes);
 975             builder.addCapability(spv::CapabilityPerViewAttributesNV);
 976         }
 977         return spv::BuiltInPositionPerViewNV;
 978     case glslang::EbvViewportMaskPerViewNV:
 979         if (!memberDeclaration) {
 980             builder.addExtension(spv::E_SPV_NVX_multiview_per_view_attributes);
 981             builder.addCapability(spv::CapabilityPerViewAttributesNV);
 982         }
 983         return spv::BuiltInViewportMaskPerViewNV;
 984     case glslang::EbvFragFullyCoveredNV:
 985         builder.addExtension(spv::E_SPV_EXT_fragment_fully_covered);
 986         builder.addCapability(spv::CapabilityFragmentFullyCoveredEXT);
 987         return spv::BuiltInFullyCoveredEXT;
 988     case glslang::EbvFragmentSizeNV:
 989         builder.addExtension(spv::E_SPV_NV_shading_rate);
 990         builder.addCapability(spv::CapabilityShadingRateNV);
 991         return spv::BuiltInFragmentSizeNV;
 992     case glslang::EbvInvocationsPerPixelNV:
 993         builder.addExtension(spv::E_SPV_NV_shading_rate);
 994         builder.addCapability(spv::CapabilityShadingRateNV);
 995         return spv::BuiltInInvocationsPerPixelNV;
 996
 997     // ray tracing
 998     case glslang::EbvLaunchId:
 999         return spv::BuiltInLaunchIdKHR;
1000     case glslang::EbvLaunchSize:
1001         return spv::BuiltInLaunchSizeKHR;
1002     case glslang::EbvWorldRayOrigin:
1003         return spv::BuiltInWorldRayOriginKHR;
1004     case glslang::EbvWorldRayDirection:
1005         return spv::BuiltInWorldRayDirectionKHR;
1006     case glslang::EbvObjectRayOrigin:
1007         return spv::BuiltInObjectRayOriginKHR;
1008     case glslang::EbvObjectRayDirection:
1009         return spv::BuiltInObjectRayDirectionKHR;
1010     case glslang::EbvRayTmin:
1011         return spv::BuiltInRayTminKHR;
1012     case glslang::EbvRayTmax:
1013         return spv::BuiltInRayTmaxKHR;
1014     case glslang::EbvCullMask:
1015         return spv::BuiltInCullMaskKHR;
1016     case glslang::EbvInstanceCustomIndex:
1017         return spv::BuiltInInstanceCustomIndexKHR;
1018     case glslang::EbvHitT:
1019         {
1020             // this is a GLSL alias of RayTmax
1021             // in SPV_NV_ray_tracing it has a dedicated builtin
1022             // but in SPV_KHR_ray_tracing it gets mapped to RayTmax
1023             auto& extensions = glslangIntermediate->getRequestedExtensions();
1024             if (extensions.find("GL_NV_ray_tracing") != extensions.end()) {
1025                 return spv::BuiltInHitTNV;
1026             } else {
1027                 return spv::BuiltInRayTmaxKHR;
1028             }
1029         }
1030     case glslang::EbvHitKind:
1031         return spv::BuiltInHitKindKHR;
1032     case glslang::EbvObjectToWorld:
1033     case glslang::EbvObjectToWorld3x4:
1034         return spv::BuiltInObjectToWorldKHR;
1035     case glslang::EbvWorldToObject:
1036     case glslang::EbvWorldToObject3x4:
1037         return spv::BuiltInWorldToObjectKHR;
1038     case glslang::EbvIncomingRayFlags:
1039         return spv::BuiltInIncomingRayFlagsKHR;
1040     case glslang::EbvGeometryIndex:
1041         return spv::BuiltInRayGeometryIndexKHR;
1042     case glslang::EbvCurrentRayTimeNV:
1043         builder.addExtension(spv::E_SPV_NV_ray_tracing_motion_blur);
1044         builder.addCapability(spv::CapabilityRayTracingMotionBlurNV);
1045         return spv::BuiltInCurrentRayTimeNV;
1046
1047     // barycentrics
1048     case glslang::EbvBaryCoordNV:
1049         builder.addExtension(spv::E_SPV_NV_fragment_shader_barycentric);
1050         builder.addCapability(spv::CapabilityFragmentBarycentricNV);
1051         return spv::BuiltInBaryCoordNV;
1052     case glslang::EbvBaryCoordNoPerspNV:
1053         builder.addExtension(spv::E_SPV_NV_fragment_shader_barycentric);
1054         builder.addCapability(spv::CapabilityFragmentBarycentricNV);
1055         return spv::BuiltInBaryCoordNoPerspNV;
1056
1057     case glslang::EbvBaryCoordEXT:
1058         builder.addExtension(spv::E_SPV_KHR_fragment_shader_barycentric);
1059         builder.addCapability(spv::CapabilityFragmentBarycentricKHR);
1060         return spv::BuiltInBaryCoordKHR;
1061     case glslang::EbvBaryCoordNoPerspEXT:
1062         builder.addExtension(spv::E_SPV_KHR_fragment_shader_barycentric);
1063         builder.addCapability(spv::CapabilityFragmentBarycentricKHR);
1064         return spv::BuiltInBaryCoordNoPerspKHR;
1065
1066     // mesh shaders
1067     case glslang::EbvTaskCountNV:
1068         return spv::BuiltInTaskCountNV;
1069     case glslang::EbvPrimitiveCountNV:
1070         return spv::BuiltInPrimitiveCountNV;
1071     case glslang::EbvPrimitiveIndicesNV:
1072         return spv::BuiltInPrimitiveIndicesNV;
1073     case glslang::EbvClipDistancePerViewNV:
1074         return spv::BuiltInClipDistancePerViewNV;
1075     case glslang::EbvCullDistancePerViewNV:
1076         return spv::BuiltInCullDistancePerViewNV;
1077     case glslang::EbvLayerPerViewNV:
1078         return spv::BuiltInLayerPerViewNV;
1079     case glslang::EbvMeshViewCountNV:
1080         return spv::BuiltInMeshViewCountNV;
1081     case glslang::EbvMeshViewIndicesNV:
1082         return spv::BuiltInMeshViewIndicesNV;
1083
1084     // SPV_EXT_mesh_shader
1085     case glslang::EbvPrimitivePointIndicesEXT:
1086         return spv::BuiltInPrimitivePointIndicesEXT;
1087     case glslang::EbvPrimitiveLineIndicesEXT:
1088         return spv::BuiltInPrimitiveLineIndicesEXT;
1089     case glslang::EbvPrimitiveTriangleIndicesEXT:
1090         return spv::BuiltInPrimitiveTriangleIndicesEXT;
1091     case glslang::EbvCullPrimitiveEXT:
1092         return spv::BuiltInCullPrimitiveEXT;
1093
1094     // sm builtins
1095     case glslang::EbvWarpsPerSM:
1096         builder.addExtension(spv::E_SPV_NV_shader_sm_builtins);
1097         builder.addCapability(spv::CapabilityShaderSMBuiltinsNV);
1098         return spv::BuiltInWarpsPerSMNV;
1099     case glslang::EbvSMCount:
1100         builder.addExtension(spv::E_SPV_NV_shader_sm_builtins);
1101         builder.addCapability(spv::CapabilityShaderSMBuiltinsNV);
1102         return spv::BuiltInSMCountNV;
1103     case glslang::EbvWarpID:
1104         builder.addExtension(spv::E_SPV_NV_shader_sm_builtins);
1105         builder.addCapability(spv::CapabilityShaderSMBuiltinsNV);
1106         return spv::BuiltInWarpIDNV;
1107     case glslang::EbvSMID:
1108         builder.addExtension(spv::E_SPV_NV_shader_sm_builtins);
1109         builder.addCapability(spv::CapabilityShaderSMBuiltinsNV);
1110         return spv::BuiltInSMIDNV;
1111 #endif
1112
1113     default:
1114         return spv::BuiltInMax;
1115     }
1116 }
1117
1118 // Translate glslang image layout format to SPIR-V image format.
1119 spv::ImageFormat TGlslangToSpvTraverser::TranslateImageFormat(const glslang::TType& type)
1120 {
1121     assert(type.getBasicType() == glslang::EbtSampler);
1122
1123 #ifdef GLSLANG_WEB
1124     return spv::ImageFormatUnknown;
1125 #endif
1126
1127     // Check for capabilities
1128     switch (type.getQualifier().getFormat()) {
1129     case glslang::ElfRg32f:
1130     case glslang::ElfRg16f:
1131     case glslang::ElfR11fG11fB10f:
1132     case glslang::ElfR16f:
1133     case glslang::ElfRgba16:
1134     case glslang::ElfRgb10A2:
1135     case glslang::ElfRg16:
1136     case glslang::ElfRg8:
1137     case glslang::ElfR16:
1138     case glslang::ElfR8:
1139     case glslang::ElfRgba16Snorm:
1140     case glslang::ElfRg16Snorm:
1141     case glslang::ElfRg8Snorm:
1142     case glslang::ElfR16Snorm:
1143     case glslang::ElfR8Snorm:
1144
1145     case glslang::ElfRg32i:
1146     case glslang::ElfRg16i:
1147     case glslang::ElfRg8i:
1148     case glslang::ElfR16i:
1149     case glslang::ElfR8i:
1150
1151     case glslang::ElfRgb10a2ui:
1152     case glslang::ElfRg32ui:
1153     case glslang::ElfRg16ui:
1154     case glslang::ElfRg8ui:
1155     case glslang::ElfR16ui:
1156     case glslang::ElfR8ui:
1157         builder.addCapability(spv::CapabilityStorageImageExtendedFormats);
1158         break;
1159
1160     case glslang::ElfR64ui:
1161     case glslang::ElfR64i:
1162         builder.addExtension(spv::E_SPV_EXT_shader_image_int64);
1163         builder.addCapability(spv::CapabilityInt64ImageEXT);
1164     default:
1165         break;
1166     }
1167
1168     // do the translation
1169     switch (type.getQualifier().getFormat()) {
1170     case glslang::ElfNone:          return spv::ImageFormatUnknown;
1171     case glslang::ElfRgba32f:       return spv::ImageFormatRgba32f;
1172     case glslang::ElfRgba16f:       return spv::ImageFormatRgba16f;
1173     case glslang::ElfR32f:          return spv::ImageFormatR32f;
1174     case glslang::ElfRgba8:         return spv::ImageFormatRgba8;
1175     case glslang::ElfRgba8Snorm:    return spv::ImageFormatRgba8Snorm;
1176     case glslang::ElfRg32f:         return spv::ImageFormatRg32f;
1177     case glslang::ElfRg16f:         return spv::ImageFormatRg16f;
1178     case glslang::ElfR11fG11fB10f:  return spv::ImageFormatR11fG11fB10f;
1179     case glslang::ElfR16f:          return spv::ImageFormatR16f;
1180     case glslang::ElfRgba16:        return spv::ImageFormatRgba16;
1181     case glslang::ElfRgb10A2:       return spv::ImageFormatRgb10A2;
1182     case glslang::ElfRg16:          return spv::ImageFormatRg16;
1183     case glslang::ElfRg8:           return spv::ImageFormatRg8;
1184     case glslang::ElfR16:           return spv::ImageFormatR16;
1185     case glslang::ElfR8:            return spv::ImageFormatR8;
1186     case glslang::ElfRgba16Snorm:   return spv::ImageFormatRgba16Snorm;
1187     case glslang::ElfRg16Snorm:     return spv::ImageFormatRg16Snorm;
1188     case glslang::ElfRg8Snorm:      return spv::ImageFormatRg8Snorm;
1189     case glslang::ElfR16Snorm:      return spv::ImageFormatR16Snorm;
1190     case glslang::ElfR8Snorm:       return spv::ImageFormatR8Snorm;
1191     case glslang::ElfRgba32i:       return spv::ImageFormatRgba32i;
1192     case glslang::ElfRgba16i:       return spv::ImageFormatRgba16i;
1193     case glslang::ElfRgba8i:        return spv::ImageFormatRgba8i;
1194     case glslang::ElfR32i:          return spv::ImageFormatR32i;
1195     case glslang::ElfRg32i:         return spv::ImageFormatRg32i;
1196     case glslang::ElfRg16i:         return spv::ImageFormatRg16i;
1197     case glslang::ElfRg8i:          return spv::ImageFormatRg8i;
1198     case glslang::ElfR16i:          return spv::ImageFormatR16i;
1199     case glslang::ElfR8i:           return spv::ImageFormatR8i;
1200     case glslang::ElfRgba32ui:      return spv::ImageFormatRgba32ui;
1201     case glslang::ElfRgba16ui:      return spv::ImageFormatRgba16ui;
1202     case glslang::ElfRgba8ui:       return spv::ImageFormatRgba8ui;
1203     case glslang::ElfR32ui:         return spv::ImageFormatR32ui;
1204     case glslang::ElfRg32ui:        return spv::ImageFormatRg32ui;
1205     case glslang::ElfRg16ui:        return spv::ImageFormatRg16ui;
1206     case glslang::ElfRgb10a2ui:     return spv::ImageFormatRgb10a2ui;
1207     case glslang::ElfRg8ui:         return spv::ImageFormatRg8ui;
1208     case glslang::ElfR16ui:         return spv::ImageFormatR16ui;
1209     case glslang::ElfR8ui:          return spv::ImageFormatR8ui;
1210     case glslang::ElfR64ui:         return spv::ImageFormatR64ui;
1211     case glslang::ElfR64i:          return spv::ImageFormatR64i;
1212     default:                        return spv::ImageFormatMax;
1213     }
1214 }
1215
1216 spv::SelectionControlMask TGlslangToSpvTraverser::TranslateSelectionControl(
1217     const glslang::TIntermSelection& selectionNode) const
1218 {
1219     if (selectionNode.getFlatten())
1220         return spv::SelectionControlFlattenMask;
1221     if (selectionNode.getDontFlatten())
1222         return spv::SelectionControlDontFlattenMask;
1223     return spv::SelectionControlMaskNone;
1224 }
1225
1226 spv::SelectionControlMask TGlslangToSpvTraverser::TranslateSwitchControl(const glslang::TIntermSwitch& switchNode)
1227     const
1228 {
1229     if (switchNode.getFlatten())
1230         return spv::SelectionControlFlattenMask;
1231     if (switchNode.getDontFlatten())
1232         return spv::SelectionControlDontFlattenMask;
1233     return spv::SelectionControlMaskNone;
1234 }
1235
1236 // return a non-0 dependency if the dependency argument must be set
1237 spv::LoopControlMask TGlslangToSpvTraverser::TranslateLoopControl(const glslang::TIntermLoop& loopNode,
1238     std::vector<unsigned int>& operands) const
1239 {
1240     spv::LoopControlMask control = spv::LoopControlMaskNone;
1241
1242     if (loopNode.getDontUnroll())
1243         control = control | spv::LoopControlDontUnrollMask;
1244     if (loopNode.getUnroll())
1245         control = control | spv::LoopControlUnrollMask;
1246     if (unsigned(loopNode.getLoopDependency()) == glslang::TIntermLoop::dependencyInfinite)
1247         control = control | spv::LoopControlDependencyInfiniteMask;
1248     else if (loopNode.getLoopDependency() > 0) {
1249         control = control | spv::LoopControlDependencyLengthMask;
1250         operands.push_back((unsigned int)loopNode.getLoopDependency());
1251     }
1252     if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4) {
1253         if (loopNode.getMinIterations() > 0) {
1254             control = control | spv::LoopControlMinIterationsMask;
1255             operands.push_back(loopNode.getMinIterations());
1256         }
1257         if (loopNode.getMaxIterations() < glslang::TIntermLoop::iterationsInfinite) {
1258             control = control | spv::LoopControlMaxIterationsMask;
1259             operands.push_back(loopNode.getMaxIterations());
1260         }
1261         if (loopNode.getIterationMultiple() > 1) {
1262             control = control | spv::LoopControlIterationMultipleMask;
1263             operands.push_back(loopNode.getIterationMultiple());
1264         }
1265         if (loopNode.getPeelCount() > 0) {
1266             control = control | spv::LoopControlPeelCountMask;
1267             operands.push_back(loopNode.getPeelCount());
1268         }
1269         if (loopNode.getPartialCount() > 0) {
1270             control = control | spv::LoopControlPartialCountMask;
1271             operands.push_back(loopNode.getPartialCount());
1272         }
1273     }
1274
1275     return control;
1276 }
1277
1278 // Translate glslang type to SPIR-V storage class.
1279 spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::TType& type)
1280 {
1281     if (type.getBasicType() == glslang::EbtRayQuery)
1282         return spv::StorageClassPrivate;
1283 #ifndef GLSLANG_WEB
1284     if (type.getQualifier().isSpirvByReference()) {
1285         if (type.getQualifier().isParamInput() || type.getQualifier().isParamOutput())
1286             return spv::StorageClassFunction;
1287     }
1288 #endif
1289     if (type.getQualifier().isPipeInput())
1290         return spv::StorageClassInput;
1291     if (type.getQualifier().isPipeOutput())
1292         return spv::StorageClassOutput;
1293
1294     if (glslangIntermediate->getSource() != glslang::EShSourceHlsl ||
1295             type.getQualifier().storage == glslang::EvqUniform) {
1296         if (type.isAtomic())
1297             return spv::StorageClassAtomicCounter;
1298         if (type.containsOpaque())
1299             return spv::StorageClassUniformConstant;
1300     }
1301
1302     if (type.getQualifier().isUniformOrBuffer() &&
1303         type.getQualifier().isShaderRecord()) {
1304         return spv::StorageClassShaderRecordBufferKHR;
1305     }
1306
1307     if (glslangIntermediate->usingStorageBuffer() && type.getQualifier().storage == glslang::EvqBuffer) {
1308         builder.addIncorporatedExtension(spv::E_SPV_KHR_storage_buffer_storage_class, spv::Spv_1_3);
1309         return spv::StorageClassStorageBuffer;
1310     }
1311
1312     if (type.getQualifier().isUniformOrBuffer()) {
1313         if (type.getQualifier().isPushConstant())
1314             return spv::StorageClassPushConstant;
1315         if (type.getBasicType() == glslang::EbtBlock)
1316             return spv::StorageClassUniform;
1317         return spv::StorageClassUniformConstant;
1318     }
1319
1320     if (type.getQualifier().storage == glslang::EvqShared && type.getBasicType() == glslang::EbtBlock) {
1321         builder.addExtension(spv::E_SPV_KHR_workgroup_memory_explicit_layout);
1322         builder.addCapability(spv::CapabilityWorkgroupMemoryExplicitLayoutKHR);
1323         return spv::StorageClassWorkgroup;
1324     }
1325
1326     switch (type.getQualifier().storage) {
1327     case glslang::EvqGlobal:        return spv::StorageClassPrivate;
1328     case glslang::EvqConstReadOnly: return spv::StorageClassFunction;
1329     case glslang::EvqTemporary:     return spv::StorageClassFunction;
1330     case glslang::EvqShared:           return spv::StorageClassWorkgroup;
1331 #ifndef GLSLANG_WEB
1332     case glslang::EvqPayload:        return spv::StorageClassRayPayloadKHR;
1333     case glslang::EvqPayloadIn:      return spv::StorageClassIncomingRayPayloadKHR;
1334     case glslang::EvqHitAttr:        return spv::StorageClassHitAttributeKHR;
1335     case glslang::EvqCallableData:   return spv::StorageClassCallableDataKHR;
1336     case glslang::EvqCallableDataIn: return spv::StorageClassIncomingCallableDataKHR;
1337     case glslang::EvqtaskPayloadSharedEXT : return spv::StorageClassTaskPayloadWorkgroupEXT;
1338     case glslang::EvqSpirvStorageClass: return static_cast<spv::StorageClass>(type.getQualifier().spirvStorageClass);
1339 #endif
1340     default:
1341         assert(0);
1342         break;
1343     }
1344
1345     return spv::StorageClassFunction;
1346 }
1347
1348 // Translate glslang constants to SPIR-V literals
1349 void TGlslangToSpvTraverser::TranslateLiterals(const glslang::TVector<const glslang::TIntermConstantUnion*>& constants,
1350                                                std::vector<unsigned>& literals) const
1351 {
1352     for (auto constant : constants) {
1353         if (constant->getBasicType() == glslang::EbtFloat) {
1354             float floatValue = static_cast<float>(constant->getConstArray()[0].getDConst());
1355             unsigned literal;
1356             static_assert(sizeof(literal) == sizeof(floatValue), "sizeof(unsigned) != sizeof(float)");
1357             memcpy(&literal, &floatValue, sizeof(literal));
1358             literals.push_back(literal);
1359         } else if (constant->getBasicType() == glslang::EbtInt) {
1360             unsigned literal = constant->getConstArray()[0].getIConst();
1361             literals.push_back(literal);
1362         } else if (constant->getBasicType() == glslang::EbtUint) {
1363             unsigned literal = constant->getConstArray()[0].getUConst();
1364             literals.push_back(literal);
1365         } else if (constant->getBasicType() == glslang::EbtBool) {
1366             unsigned literal = constant->getConstArray()[0].getBConst();
1367             literals.push_back(literal);
1368         } else if (constant->getBasicType() == glslang::EbtString) {
1369             auto str = constant->getConstArray()[0].getSConst()->c_str();
1370             unsigned literal = 0;
1371             char* literalPtr = reinterpret_cast<char*>(&literal);
1372             unsigned charCount = 0;
1373             char ch = 0;
1374             do {
1375                 ch = *(str++);
1376                 *(literalPtr++) = ch;
1377                 ++charCount;
1378                 if (charCount == 4) {
1379                     literals.push_back(literal);
1380                     literalPtr = reinterpret_cast<char*>(&literal);
1381                     charCount = 0;
1382                 }
1383             } while (ch != 0);
1384
1385             // Partial literal is padded with 0
1386             if (charCount > 0) {
1387                 for (; charCount < 4; ++charCount)
1388                     *(literalPtr++) = 0;
1389                 literals.push_back(literal);
1390             }
1391         } else
1392             assert(0); // Unexpected type
1393     }
1394 }
1395
1396 // Add capabilities pertaining to how an array is indexed.
1397 void TGlslangToSpvTraverser::addIndirectionIndexCapabilities(const glslang::TType& baseType,
1398                                                              const glslang::TType& indexType)
1399 {
1400 #ifndef GLSLANG_WEB
1401     if (indexType.getQualifier().isNonUniform()) {
1402         // deal with an asserted non-uniform index
1403         // SPV_EXT_descriptor_indexing already added in TranslateNonUniformDecoration
1404         if (baseType.getBasicType() == glslang::EbtSampler) {
1405             if (baseType.getQualifier().hasAttachment())
1406                 builder.addCapability(spv::CapabilityInputAttachmentArrayNonUniformIndexingEXT);
1407             else if (baseType.isImage() && baseType.getSampler().isBuffer())
1408                 builder.addCapability(spv::CapabilityStorageTexelBufferArrayNonUniformIndexingEXT);
1409             else if (baseType.isTexture() && baseType.getSampler().isBuffer())
1410                 builder.addCapability(spv::CapabilityUniformTexelBufferArrayNonUniformIndexingEXT);
1411             else if (baseType.isImage())
1412                 builder.addCapability(spv::CapabilityStorageImageArrayNonUniformIndexingEXT);
1413             else if (baseType.isTexture())
1414                 builder.addCapability(spv::CapabilitySampledImageArrayNonUniformIndexingEXT);
1415         } else if (baseType.getBasicType() == glslang::EbtBlock) {
1416             if (baseType.getQualifier().storage == glslang::EvqBuffer)
1417                 builder.addCapability(spv::CapabilityStorageBufferArrayNonUniformIndexingEXT);
1418             else if (baseType.getQualifier().storage == glslang::EvqUniform)
1419                 builder.addCapability(spv::CapabilityUniformBufferArrayNonUniformIndexingEXT);
1420         }
1421     } else {
1422         // assume a dynamically uniform index
1423         if (baseType.getBasicType() == glslang::EbtSampler) {
1424             if (baseType.getQualifier().hasAttachment()) {
1425                 builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
1426                 builder.addCapability(spv::CapabilityInputAttachmentArrayDynamicIndexingEXT);
1427             } else if (baseType.isImage() && baseType.getSampler().isBuffer()) {
1428                 builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
1429                 builder.addCapability(spv::CapabilityStorageTexelBufferArrayDynamicIndexingEXT);
1430             } else if (baseType.isTexture() && baseType.getSampler().isBuffer()) {
1431                 builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
1432                 builder.addCapability(spv::CapabilityUniformTexelBufferArrayDynamicIndexingEXT);
1433             }
1434         }
1435     }
1436 #endif
1437 }
1438
1439 // Return whether or not the given type is something that should be tied to a
1440 // descriptor set.
1441 bool IsDescriptorResource(const glslang::TType& type)
1442 {
1443     // uniform and buffer blocks are included, unless it is a push_constant
1444     if (type.getBasicType() == glslang::EbtBlock)
1445         return type.getQualifier().isUniformOrBuffer() &&
1446         ! type.getQualifier().isShaderRecord() &&
1447         ! type.getQualifier().isPushConstant();
1448
1449     // non block...
1450     // basically samplerXXX/subpass/sampler/texture are all included
1451     // if they are the global-scope-class, not the function parameter
1452     // (or local, if they ever exist) class.
1453     if (type.getBasicType() == glslang::EbtSampler ||
1454         type.getBasicType() == glslang::EbtAccStruct)
1455         return type.getQualifier().isUniformOrBuffer();
1456
1457     // None of the above.
1458     return false;
1459 }
1460
1461 void InheritQualifiers(glslang::TQualifier& child, const glslang::TQualifier& parent)
1462 {
1463     if (child.layoutMatrix == glslang::ElmNone)
1464         child.layoutMatrix = parent.layoutMatrix;
1465
1466     if (parent.invariant)
1467         child.invariant = true;
1468     if (parent.flat)
1469         child.flat = true;
1470     if (parent.centroid)
1471         child.centroid = true;
1472 #ifndef GLSLANG_WEB
1473     if (parent.nopersp)
1474         child.nopersp = true;
1475     if (parent.explicitInterp)
1476         child.explicitInterp = true;
1477     if (parent.perPrimitiveNV)
1478         child.perPrimitiveNV = true;
1479     if (parent.perViewNV)
1480         child.perViewNV = true;
1481     if (parent.perTaskNV)
1482         child.perTaskNV = true;
1483     if (parent.storage == glslang::EvqtaskPayloadSharedEXT)
1484         child.storage = glslang::EvqtaskPayloadSharedEXT;
1485     if (parent.patch)
1486         child.patch = true;
1487     if (parent.sample)
1488         child.sample = true;
1489     if (parent.coherent)
1490         child.coherent = true;
1491     if (parent.devicecoherent)
1492         child.devicecoherent = true;
1493     if (parent.queuefamilycoherent)
1494         child.queuefamilycoherent = true;
1495     if (parent.workgroupcoherent)
1496         child.workgroupcoherent = true;
1497     if (parent.subgroupcoherent)
1498         child.subgroupcoherent = true;
1499     if (parent.shadercallcoherent)
1500         child.shadercallcoherent = true;
1501     if (parent.nonprivate)
1502         child.nonprivate = true;
1503     if (parent.volatil)
1504         child.volatil = true;
1505     if (parent.restrict)
1506         child.restrict = true;
1507     if (parent.readonly)
1508         child.readonly = true;
1509     if (parent.writeonly)
1510         child.writeonly = true;
1511 #endif
1512     if (parent.nonUniform)
1513         child.nonUniform = true;
1514 }
1515
1516 bool HasNonLayoutQualifiers(const glslang::TType& type, const glslang::TQualifier& qualifier)
1517 {
1518     // This should list qualifiers that simultaneous satisfy:
1519     // - struct members might inherit from a struct declaration
1520     //     (note that non-block structs don't explicitly inherit,
1521     //      only implicitly, meaning no decoration involved)
1522     // - affect decorations on the struct members
1523     //     (note smooth does not, and expecting something like volatile
1524     //      to effect the whole object)
1525     // - are not part of the offset/st430/etc or row/column-major layout
1526     return qualifier.invariant || (qualifier.hasLocation() && type.getBasicType() == glslang::EbtBlock);
1527 }
1528
1529 //
1530 // Implement the TGlslangToSpvTraverser class.
1531 //
1532
1533 TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion,
1534     const glslang::TIntermediate* glslangIntermediate,
1535     spv::SpvBuildLogger* buildLogger, glslang::SpvOptions& options) :
1536         TIntermTraverser(true, false, true),
1537         options(options),
1538         shaderEntry(nullptr), currentFunction(nullptr),
1539         sequenceDepth(0), logger(buildLogger),
1540         builder(spvVersion, (glslang::GetKhronosToolId() << 16) | glslang::GetSpirvGeneratorVersion(), logger),
1541         inEntryPoint(false), entryPointTerminated(false), linkageOnly(false),
1542         glslangIntermediate(glslangIntermediate),
1543         nanMinMaxClamp(glslangIntermediate->getNanMinMaxClamp()),
1544         nonSemanticDebugPrintf(0),
1545         taskPayloadID(0)
1546 {
1547     bool isMeshShaderExt = (glslangIntermediate->getRequestedExtensions().find(glslang::E_GL_EXT_mesh_shader) !=
1548                             glslangIntermediate->getRequestedExtensions().end());
1549     spv::ExecutionModel executionModel = TranslateExecutionModel(glslangIntermediate->getStage(), isMeshShaderExt);
1550
1551     builder.clearAccessChain();
1552     builder.setSource(TranslateSourceLanguage(glslangIntermediate->getSource(), glslangIntermediate->getProfile()),
1553                       glslangIntermediate->getVersion());
1554
1555     if (options.generateDebugInfo) {
1556         builder.setEmitOpLines();
1557         builder.setSourceFile(glslangIntermediate->getSourceFile());
1558
1559         // Set the source shader's text. If for SPV version 1.0, include
1560         // a preamble in comments stating the OpModuleProcessed instructions.
1561         // Otherwise, emit those as actual instructions.
1562         std::string text;
1563         const std::vector<std::string>& processes = glslangIntermediate->getProcesses();
1564         for (int p = 0; p < (int)processes.size(); ++p) {
1565             if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_1) {
1566                 text.append("// OpModuleProcessed ");
1567                 text.append(processes[p]);
1568                 text.append("\n");
1569             } else
1570                 builder.addModuleProcessed(processes[p]);
1571         }
1572         if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_1 && (int)processes.size() > 0)
1573             text.append("#line 1\n");
1574         text.append(glslangIntermediate->getSourceText());
1575         builder.setSourceText(text);
1576         // Pass name and text for all included files
1577         const std::map<std::string, std::string>& include_txt = glslangIntermediate->getIncludeText();
1578         for (auto iItr = include_txt.begin(); iItr != include_txt.end(); ++iItr)
1579             builder.addInclude(iItr->first, iItr->second);
1580     }
1581     stdBuiltins = builder.import("GLSL.std.450");
1582
1583     spv::AddressingModel addressingModel = spv::AddressingModelLogical;
1584     spv::MemoryModel memoryModel = spv::MemoryModelGLSL450;
1585
1586     if (glslangIntermediate->usingPhysicalStorageBuffer()) {
1587         addressingModel = spv::AddressingModelPhysicalStorageBuffer64EXT;
1588         builder.addIncorporatedExtension(spv::E_SPV_KHR_physical_storage_buffer, spv::Spv_1_5);
1589         builder.addCapability(spv::CapabilityPhysicalStorageBufferAddressesEXT);
1590     }
1591     if (glslangIntermediate->usingVulkanMemoryModel()) {
1592         memoryModel = spv::MemoryModelVulkanKHR;
1593         builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
1594         builder.addIncorporatedExtension(spv::E_SPV_KHR_vulkan_memory_model, spv::Spv_1_5);
1595     }
1596     builder.setMemoryModel(addressingModel, memoryModel);
1597
1598     if (glslangIntermediate->usingVariablePointers()) {
1599         builder.addCapability(spv::CapabilityVariablePointers);
1600     }
1601
1602     shaderEntry = builder.makeEntryPoint(glslangIntermediate->getEntryPointName().c_str());
1603     entryPoint = builder.addEntryPoint(executionModel, shaderEntry, glslangIntermediate->getEntryPointName().c_str());
1604
1605     // Add the source extensions
1606     const auto& sourceExtensions = glslangIntermediate->getRequestedExtensions();
1607     for (auto it = sourceExtensions.begin(); it != sourceExtensions.end(); ++it)
1608         builder.addSourceExtension(it->c_str());
1609
1610     // Add the top-level modes for this shader.
1611
1612     if (glslangIntermediate->getXfbMode()) {
1613         builder.addCapability(spv::CapabilityTransformFeedback);
1614         builder.addExecutionMode(shaderEntry, spv::ExecutionModeXfb);
1615     }
1616
1617     if (glslangIntermediate->getLayoutPrimitiveCulling()) {
1618         builder.addCapability(spv::CapabilityRayTraversalPrimitiveCullingKHR);
1619     }
1620
1621 #ifndef GLSLANG_WEB
1622     if (glslangIntermediate->getSubgroupUniformControlFlow()) {
1623         builder.addExtension(spv::E_SPV_KHR_subgroup_uniform_control_flow);
1624         builder.addExecutionMode(shaderEntry, spv::ExecutionModeSubgroupUniformControlFlowKHR);
1625     }
1626 #endif
1627
1628     unsigned int mode;
1629     switch (glslangIntermediate->getStage()) {
1630     case EShLangVertex:
1631         builder.addCapability(spv::CapabilityShader);
1632         break;
1633
1634     case EShLangFragment:
1635         builder.addCapability(spv::CapabilityShader);
1636         if (glslangIntermediate->getPixelCenterInteger())
1637             builder.addExecutionMode(shaderEntry, spv::ExecutionModePixelCenterInteger);
1638
1639         if (glslangIntermediate->getOriginUpperLeft())
1640             builder.addExecutionMode(shaderEntry, spv::ExecutionModeOriginUpperLeft);
1641         else
1642             builder.addExecutionMode(shaderEntry, spv::ExecutionModeOriginLowerLeft);
1643
1644         if (glslangIntermediate->getEarlyFragmentTests())
1645             builder.addExecutionMode(shaderEntry, spv::ExecutionModeEarlyFragmentTests);
1646
1647         if (glslangIntermediate->getEarlyAndLateFragmentTestsAMD())
1648         {
1649             builder.addExecutionMode(shaderEntry, spv::ExecutionModeEarlyAndLateFragmentTestsAMD);
1650             builder.addExtension(spv::E_SPV_AMD_shader_early_and_late_fragment_tests);
1651         }
1652
1653         if (glslangIntermediate->getPostDepthCoverage()) {
1654             builder.addCapability(spv::CapabilitySampleMaskPostDepthCoverage);
1655             builder.addExecutionMode(shaderEntry, spv::ExecutionModePostDepthCoverage);
1656             builder.addExtension(spv::E_SPV_KHR_post_depth_coverage);
1657         }
1658
1659         if (glslangIntermediate->isDepthReplacing())
1660             builder.addExecutionMode(shaderEntry, spv::ExecutionModeDepthReplacing);
1661
1662         if (glslangIntermediate->isStencilReplacing())
1663             builder.addExecutionMode(shaderEntry, spv::ExecutionModeStencilRefReplacingEXT);
1664
1665 #ifndef GLSLANG_WEB
1666
1667         switch(glslangIntermediate->getDepth()) {
1668         case glslang::EldGreater:   mode = spv::ExecutionModeDepthGreater;   break;
1669         case glslang::EldLess:      mode = spv::ExecutionModeDepthLess;      break;
1670         case glslang::EldUnchanged: mode = spv::ExecutionModeDepthUnchanged; break;
1671         default:                    mode = spv::ExecutionModeMax;            break;
1672         }
1673
1674         if (mode != spv::ExecutionModeMax)
1675             builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1676
1677         switch (glslangIntermediate->getStencil()) {
1678         case glslang::ElsRefUnchangedFrontAMD:  mode = spv::ExecutionModeStencilRefUnchangedFrontAMD; break;
1679         case glslang::ElsRefGreaterFrontAMD:    mode = spv::ExecutionModeStencilRefGreaterFrontAMD;   break;
1680         case glslang::ElsRefLessFrontAMD:       mode = spv::ExecutionModeStencilRefLessFrontAMD;      break;
1681         case glslang::ElsRefUnchangedBackAMD:   mode = spv::ExecutionModeStencilRefUnchangedBackAMD;  break;
1682         case glslang::ElsRefGreaterBackAMD:     mode = spv::ExecutionModeStencilRefGreaterBackAMD;    break;
1683         case glslang::ElsRefLessBackAMD:        mode = spv::ExecutionModeStencilRefLessBackAMD;       break;
1684         default:                       mode = spv::ExecutionModeMax;                         break;
1685         }
1686
1687         if (mode != spv::ExecutionModeMax)
1688             builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1689         switch (glslangIntermediate->getInterlockOrdering()) {
1690         case glslang::EioPixelInterlockOrdered:         mode = spv::ExecutionModePixelInterlockOrderedEXT;
1691             break;
1692         case glslang::EioPixelInterlockUnordered:       mode = spv::ExecutionModePixelInterlockUnorderedEXT;
1693             break;
1694         case glslang::EioSampleInterlockOrdered:        mode = spv::ExecutionModeSampleInterlockOrderedEXT;
1695             break;
1696         case glslang::EioSampleInterlockUnordered:      mode = spv::ExecutionModeSampleInterlockUnorderedEXT;
1697             break;
1698         case glslang::EioShadingRateInterlockOrdered:   mode = spv::ExecutionModeShadingRateInterlockOrderedEXT;
1699             break;
1700         case glslang::EioShadingRateInterlockUnordered: mode = spv::ExecutionModeShadingRateInterlockUnorderedEXT;
1701             break;
1702         default:                                        mode = spv::ExecutionModeMax;
1703             break;
1704         }
1705         if (mode != spv::ExecutionModeMax) {
1706             builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1707             if (mode == spv::ExecutionModeShadingRateInterlockOrderedEXT ||
1708                 mode == spv::ExecutionModeShadingRateInterlockUnorderedEXT) {
1709                 builder.addCapability(spv::CapabilityFragmentShaderShadingRateInterlockEXT);
1710             } else if (mode == spv::ExecutionModePixelInterlockOrderedEXT ||
1711                        mode == spv::ExecutionModePixelInterlockUnorderedEXT) {
1712                 builder.addCapability(spv::CapabilityFragmentShaderPixelInterlockEXT);
1713             } else {
1714                 builder.addCapability(spv::CapabilityFragmentShaderSampleInterlockEXT);
1715             }
1716             builder.addExtension(spv::E_SPV_EXT_fragment_shader_interlock);
1717         }
1718 #endif
1719     break;
1720
1721     case EShLangCompute:
1722         builder.addCapability(spv::CapabilityShader);
1723         if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
1724           std::vector<spv::Id> dimConstId;
1725           for (int dim = 0; dim < 3; ++dim) {
1726             bool specConst = (glslangIntermediate->getLocalSizeSpecId(dim) != glslang::TQualifier::layoutNotSet);
1727             dimConstId.push_back(builder.makeUintConstant(glslangIntermediate->getLocalSize(dim), specConst));
1728             if (specConst) {
1729                 builder.addDecoration(dimConstId.back(), spv::DecorationSpecId,
1730                                       glslangIntermediate->getLocalSizeSpecId(dim));
1731             }
1732           }
1733           builder.addExecutionModeId(shaderEntry, spv::ExecutionModeLocalSizeId, dimConstId);
1734         } else {
1735           builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
1736                                                                              glslangIntermediate->getLocalSize(1),
1737                                                                              glslangIntermediate->getLocalSize(2));
1738         }
1739         if (glslangIntermediate->getLayoutDerivativeModeNone() == glslang::LayoutDerivativeGroupQuads) {
1740             builder.addCapability(spv::CapabilityComputeDerivativeGroupQuadsNV);
1741             builder.addExecutionMode(shaderEntry, spv::ExecutionModeDerivativeGroupQuadsNV);
1742             builder.addExtension(spv::E_SPV_NV_compute_shader_derivatives);
1743         } else if (glslangIntermediate->getLayoutDerivativeModeNone() == glslang::LayoutDerivativeGroupLinear) {
1744             builder.addCapability(spv::CapabilityComputeDerivativeGroupLinearNV);
1745             builder.addExecutionMode(shaderEntry, spv::ExecutionModeDerivativeGroupLinearNV);
1746             builder.addExtension(spv::E_SPV_NV_compute_shader_derivatives);
1747         }
1748         break;
1749 #ifndef GLSLANG_WEB
1750     case EShLangTessEvaluation:
1751     case EShLangTessControl:
1752         builder.addCapability(spv::CapabilityTessellation);
1753
1754         glslang::TLayoutGeometry primitive;
1755
1756         if (glslangIntermediate->getStage() == EShLangTessControl) {
1757             builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputVertices,
1758                 glslangIntermediate->getVertices());
1759             primitive = glslangIntermediate->getOutputPrimitive();
1760         } else {
1761             primitive = glslangIntermediate->getInputPrimitive();
1762         }
1763
1764         switch (primitive) {
1765         case glslang::ElgTriangles:           mode = spv::ExecutionModeTriangles;     break;
1766         case glslang::ElgQuads:               mode = spv::ExecutionModeQuads;         break;
1767         case glslang::ElgIsolines:            mode = spv::ExecutionModeIsolines;      break;
1768         default:                              mode = spv::ExecutionModeMax;           break;
1769         }
1770         if (mode != spv::ExecutionModeMax)
1771             builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1772
1773         switch (glslangIntermediate->getVertexSpacing()) {
1774         case glslang::EvsEqual:            mode = spv::ExecutionModeSpacingEqual;          break;
1775         case glslang::EvsFractionalEven:   mode = spv::ExecutionModeSpacingFractionalEven; break;
1776         case glslang::EvsFractionalOdd:    mode = spv::ExecutionModeSpacingFractionalOdd;  break;
1777         default:                           mode = spv::ExecutionModeMax;                   break;
1778         }
1779         if (mode != spv::ExecutionModeMax)
1780             builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1781
1782         switch (glslangIntermediate->getVertexOrder()) {
1783         case glslang::EvoCw:     mode = spv::ExecutionModeVertexOrderCw;  break;
1784         case glslang::EvoCcw:    mode = spv::ExecutionModeVertexOrderCcw; break;
1785         default:                 mode = spv::ExecutionModeMax;            break;
1786         }
1787         if (mode != spv::ExecutionModeMax)
1788             builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1789
1790         if (glslangIntermediate->getPointMode())
1791             builder.addExecutionMode(shaderEntry, spv::ExecutionModePointMode);
1792         break;
1793
1794     case EShLangGeometry:
1795         builder.addCapability(spv::CapabilityGeometry);
1796         switch (glslangIntermediate->getInputPrimitive()) {
1797         case glslang::ElgPoints:             mode = spv::ExecutionModeInputPoints;             break;
1798         case glslang::ElgLines:              mode = spv::ExecutionModeInputLines;              break;
1799         case glslang::ElgLinesAdjacency:     mode = spv::ExecutionModeInputLinesAdjacency;     break;
1800         case glslang::ElgTriangles:          mode = spv::ExecutionModeTriangles;               break;
1801         case glslang::ElgTrianglesAdjacency: mode = spv::ExecutionModeInputTrianglesAdjacency; break;
1802         default:                             mode = spv::ExecutionModeMax;                     break;
1803         }
1804         if (mode != spv::ExecutionModeMax)
1805             builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1806
1807         builder.addExecutionMode(shaderEntry, spv::ExecutionModeInvocations, glslangIntermediate->getInvocations());
1808
1809         switch (glslangIntermediate->getOutputPrimitive()) {
1810         case glslang::ElgPoints:        mode = spv::ExecutionModeOutputPoints;                 break;
1811         case glslang::ElgLineStrip:     mode = spv::ExecutionModeOutputLineStrip;              break;
1812         case glslang::ElgTriangleStrip: mode = spv::ExecutionModeOutputTriangleStrip;          break;
1813         default:                        mode = spv::ExecutionModeMax;                          break;
1814         }
1815         if (mode != spv::ExecutionModeMax)
1816             builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1817         builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputVertices, glslangIntermediate->getVertices());
1818         break;
1819
1820     case EShLangRayGen:
1821     case EShLangIntersect:
1822     case EShLangAnyHit:
1823     case EShLangClosestHit:
1824     case EShLangMiss:
1825     case EShLangCallable:
1826     {
1827         auto& extensions = glslangIntermediate->getRequestedExtensions();
1828         if (extensions.find("GL_NV_ray_tracing") == extensions.end()) {
1829             builder.addCapability(spv::CapabilityRayTracingKHR);
1830             builder.addExtension("SPV_KHR_ray_tracing");
1831         }
1832         else {
1833             builder.addCapability(spv::CapabilityRayTracingNV);
1834             builder.addExtension("SPV_NV_ray_tracing");
1835         }
1836         if (glslangIntermediate->getStage() != EShLangRayGen && glslangIntermediate->getStage() != EShLangCallable)
1837         {
1838                 if (extensions.find("GL_EXT_ray_cull_mask") != extensions.end()) {
1839                         builder.addCapability(spv::CapabilityRayCullMaskKHR);
1840                         builder.addExtension("SPV_KHR_ray_cull_mask");
1841                 }
1842         }
1843         break;
1844     }
1845     case EShLangTask:
1846     case EShLangMesh:
1847         if(isMeshShaderExt) {
1848             builder.addCapability(spv::CapabilityMeshShadingEXT);
1849             builder.addExtension(spv::E_SPV_EXT_mesh_shader);
1850         } else {
1851             builder.addCapability(spv::CapabilityMeshShadingNV);
1852             builder.addExtension(spv::E_SPV_NV_mesh_shader);
1853         }
1854         if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
1855             std::vector<spv::Id> dimConstId;
1856             for (int dim = 0; dim < 3; ++dim) {
1857                 bool specConst = (glslangIntermediate->getLocalSizeSpecId(dim) != glslang::TQualifier::layoutNotSet);
1858                 dimConstId.push_back(builder.makeUintConstant(glslangIntermediate->getLocalSize(dim), specConst));
1859                 if (specConst) {
1860                     builder.addDecoration(dimConstId.back(), spv::DecorationSpecId,
1861                                           glslangIntermediate->getLocalSizeSpecId(dim));
1862                 }
1863             }
1864             builder.addExecutionModeId(shaderEntry, spv::ExecutionModeLocalSizeId, dimConstId);
1865         } else {
1866             builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
1867                                                                                glslangIntermediate->getLocalSize(1),
1868                                                                                glslangIntermediate->getLocalSize(2));
1869         }
1870         if (glslangIntermediate->getStage() == EShLangMesh) {
1871             builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputVertices,
1872                 glslangIntermediate->getVertices());
1873             builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputPrimitivesNV,
1874                 glslangIntermediate->getPrimitives());
1875
1876             switch (glslangIntermediate->getOutputPrimitive()) {
1877             case glslang::ElgPoints:        mode = spv::ExecutionModeOutputPoints;      break;
1878             case glslang::ElgLines:         mode = spv::ExecutionModeOutputLinesNV;     break;
1879             case glslang::ElgTriangles:     mode = spv::ExecutionModeOutputTrianglesNV; break;
1880             default:                        mode = spv::ExecutionModeMax;               break;
1881             }
1882             if (mode != spv::ExecutionModeMax)
1883                 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1884         }
1885         break;
1886 #endif
1887
1888     default:
1889         break;
1890     }
1891
1892 #ifndef GLSLANG_WEB
1893     //
1894     // Add SPIR-V requirements (GL_EXT_spirv_intrinsics)
1895     //
1896     if (glslangIntermediate->hasSpirvRequirement()) {
1897         const glslang::TSpirvRequirement& spirvRequirement = glslangIntermediate->getSpirvRequirement();
1898
1899         // Add SPIR-V extension requirement
1900         for (auto& extension : spirvRequirement.extensions)
1901             builder.addExtension(extension.c_str());
1902
1903         // Add SPIR-V capability requirement
1904         for (auto capability : spirvRequirement.capabilities)
1905             builder.addCapability(static_cast<spv::Capability>(capability));
1906     }
1907
1908     //
1909     // Add SPIR-V execution mode qualifiers (GL_EXT_spirv_intrinsics)
1910     //
1911     if (glslangIntermediate->hasSpirvExecutionMode()) {
1912         const glslang::TSpirvExecutionMode spirvExecutionMode = glslangIntermediate->getSpirvExecutionMode();
1913
1914         // Add spirv_execution_mode
1915         for (auto& mode : spirvExecutionMode.modes) {
1916             if (!mode.second.empty()) {
1917                 std::vector<unsigned> literals;
1918                 TranslateLiterals(mode.second, literals);
1919                 builder.addExecutionMode(shaderEntry, static_cast<spv::ExecutionMode>(mode.first), literals);
1920             } else
1921                 builder.addExecutionMode(shaderEntry, static_cast<spv::ExecutionMode>(mode.first));
1922         }
1923
1924         // Add spirv_execution_mode_id
1925         for (auto& modeId : spirvExecutionMode.modeIds) {
1926             std::vector<spv::Id> operandIds;
1927             assert(!modeId.second.empty());
1928             for (auto extraOperand : modeId.second) {
1929                 if (extraOperand->getType().getQualifier().isSpecConstant())
1930                     operandIds.push_back(getSymbolId(extraOperand->getAsSymbolNode()));
1931                 else
1932                     operandIds.push_back(createSpvConstant(*extraOperand));
1933             }
1934             builder.addExecutionModeId(shaderEntry, static_cast<spv::ExecutionMode>(modeId.first), operandIds);
1935         }
1936     }
1937 #endif
1938 }
1939
1940 // Finish creating SPV, after the traversal is complete.
1941 void TGlslangToSpvTraverser::finishSpv()
1942 {
1943     // Finish the entry point function
1944     if (! entryPointTerminated) {
1945         builder.setBuildPoint(shaderEntry->getLastBlock());
1946         builder.leaveFunction();
1947     }
1948
1949     // finish off the entry-point SPV instruction by adding the Input/Output <id>
1950     for (auto it = iOSet.cbegin(); it != iOSet.cend(); ++it)
1951         entryPoint->addIdOperand(*it);
1952
1953     // Add capabilities, extensions, remove unneeded decorations, etc.,
1954     // based on the resulting SPIR-V.
1955     // Note: WebGPU code generation must have the opportunity to aggressively
1956     // prune unreachable merge blocks and continue targets.
1957     builder.postProcess();
1958 }
1959
1960 // Write the SPV into 'out'.
1961 void TGlslangToSpvTraverser::dumpSpv(std::vector<unsigned int>& out)
1962 {
1963     builder.dump(out);
1964 }
1965
1966 //
1967 // Implement the traversal functions.
1968 //
1969 // Return true from interior nodes to have the external traversal
1970 // continue on to children.  Return false if children were
1971 // already processed.
1972 //
1973
1974 //
1975 // Symbols can turn into
1976 //  - uniform/input reads
1977 //  - output writes
1978 //  - complex lvalue base setups:  foo.bar[3]....  , where we see foo and start up an access chain
1979 //  - something simple that degenerates into the last bullet
1980 //
1981 void TGlslangToSpvTraverser::visitSymbol(glslang::TIntermSymbol* symbol)
1982 {
1983     SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder);
1984     if (symbol->getType().isStruct())
1985         glslangTypeToIdMap[symbol->getType().getStruct()] = symbol->getId();
1986
1987     if (symbol->getType().getQualifier().isSpecConstant())
1988         spec_constant_op_mode_setter.turnOnSpecConstantOpMode();
1989 #ifdef ENABLE_HLSL
1990     // Skip symbol handling if it is string-typed
1991     if (symbol->getBasicType() == glslang::EbtString)
1992         return;
1993 #endif
1994
1995     // getSymbolId() will set up all the IO decorations on the first call.
1996     // Formal function parameters were mapped during makeFunctions().
1997     spv::Id id = getSymbolId(symbol);
1998
1999     if (symbol->getType().getQualifier().isTaskPayload())
2000         taskPayloadID = id; // cache the taskPayloadID to be used it as operand for OpEmitMeshTasksEXT
2001
2002     if (builder.isPointer(id)) {
2003         if (!symbol->getType().getQualifier().isParamInput() &&
2004             !symbol->getType().getQualifier().isParamOutput()) {
2005             // Include all "static use" and "linkage only" interface variables on the OpEntryPoint instruction
2006             // Consider adding to the OpEntryPoint interface list.
2007             // Only looking at structures if they have at least one member.
2008             if (!symbol->getType().isStruct() || symbol->getType().getStruct()->size() > 0) {
2009                 spv::StorageClass sc = builder.getStorageClass(id);
2010                 // Before SPIR-V 1.4, we only want to include Input and Output.
2011                 // Starting with SPIR-V 1.4, we want all globals.
2012                 if ((glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4 && builder.isGlobalStorage(id)) ||
2013                     (sc == spv::StorageClassInput || sc == spv::StorageClassOutput)) {
2014                     iOSet.insert(id);
2015                 }
2016             }
2017         }
2018
2019         // If the SPIR-V type is required to be different than the AST type
2020         // (for ex SubgroupMasks or 3x4 ObjectToWorld/WorldToObject matrices),
2021         // translate now from the SPIR-V type to the AST type, for the consuming
2022         // operation.
2023         // Note this turns it from an l-value to an r-value.
2024         // Currently, all symbols needing this are inputs; avoid the map lookup when non-input.
2025         if (symbol->getType().getQualifier().storage == glslang::EvqVaryingIn)
2026             id = translateForcedType(id);
2027     }
2028
2029     // Only process non-linkage-only nodes for generating actual static uses
2030     if (! linkageOnly || symbol->getQualifier().isSpecConstant()) {
2031         // Prepare to generate code for the access
2032
2033         // L-value chains will be computed left to right.  We're on the symbol now,
2034         // which is the left-most part of the access chain, so now is "clear" time,
2035         // followed by setting the base.
2036         builder.clearAccessChain();
2037
2038         // For now, we consider all user variables as being in memory, so they are pointers,
2039         // except for
2040         // A) R-Value arguments to a function, which are an intermediate object.
2041         //    See comments in handleUserFunctionCall().
2042         // B) Specialization constants (normal constants don't even come in as a variable),
2043         //    These are also pure R-values.
2044         // C) R-Values from type translation, see above call to translateForcedType()
2045         glslang::TQualifier qualifier = symbol->getQualifier();
2046         if (qualifier.isSpecConstant() || rValueParameters.find(symbol->getId()) != rValueParameters.end() ||
2047             !builder.isPointerType(builder.getTypeId(id)))
2048             builder.setAccessChainRValue(id);
2049         else
2050             builder.setAccessChainLValue(id);
2051     }
2052
2053 #ifdef ENABLE_HLSL
2054     // Process linkage-only nodes for any special additional interface work.
2055     if (linkageOnly) {
2056         if (glslangIntermediate->getHlslFunctionality1()) {
2057             // Map implicit counter buffers to their originating buffers, which should have been
2058             // seen by now, given earlier pruning of unused counters, and preservation of order
2059             // of declaration.
2060             if (symbol->getType().getQualifier().isUniformOrBuffer()) {
2061                 if (!glslangIntermediate->hasCounterBufferName(symbol->getName())) {
2062                     // Save possible originating buffers for counter buffers, keyed by
2063                     // making the potential counter-buffer name.
2064                     std::string keyName = symbol->getName().c_str();
2065                     keyName = glslangIntermediate->addCounterBufferName(keyName);
2066                     counterOriginator[keyName] = symbol;
2067                 } else {
2068                     // Handle a counter buffer, by finding the saved originating buffer.
2069                     std::string keyName = symbol->getName().c_str();
2070                     auto it = counterOriginator.find(keyName);
2071                     if (it != counterOriginator.end()) {
2072                         id = getSymbolId(it->second);
2073                         if (id != spv::NoResult) {
2074                             spv::Id counterId = getSymbolId(symbol);
2075                             if (counterId != spv::NoResult) {
2076                                 builder.addExtension("SPV_GOOGLE_hlsl_functionality1");
2077                                 builder.addDecorationId(id, spv::DecorationHlslCounterBufferGOOGLE, counterId);
2078                             }
2079                         }
2080                     }
2081                 }
2082             }
2083         }
2084     }
2085 #endif
2086 }
2087
2088 bool TGlslangToSpvTraverser::visitBinary(glslang::TVisit /* visit */, glslang::TIntermBinary* node)
2089 {
2090     builder.setLine(node->getLoc().line, node->getLoc().getFilename());
2091     if (node->getLeft()->getAsSymbolNode() != nullptr && node->getLeft()->getType().isStruct()) {
2092         glslangTypeToIdMap[node->getLeft()->getType().getStruct()] = node->getLeft()->getAsSymbolNode()->getId();
2093     }
2094     if (node->getRight()->getAsSymbolNode() != nullptr && node->getRight()->getType().isStruct()) {
2095         glslangTypeToIdMap[node->getRight()->getType().getStruct()] = node->getRight()->getAsSymbolNode()->getId();
2096     }
2097
2098     SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder);
2099     if (node->getType().getQualifier().isSpecConstant())
2100         spec_constant_op_mode_setter.turnOnSpecConstantOpMode();
2101
2102     // First, handle special cases
2103     switch (node->getOp()) {
2104     case glslang::EOpAssign:
2105     case glslang::EOpAddAssign:
2106     case glslang::EOpSubAssign:
2107     case glslang::EOpMulAssign:
2108     case glslang::EOpVectorTimesMatrixAssign:
2109     case glslang::EOpVectorTimesScalarAssign:
2110     case glslang::EOpMatrixTimesScalarAssign:
2111     case glslang::EOpMatrixTimesMatrixAssign:
2112     case glslang::EOpDivAssign:
2113     case glslang::EOpModAssign:
2114     case glslang::EOpAndAssign:
2115     case glslang::EOpInclusiveOrAssign:
2116     case glslang::EOpExclusiveOrAssign:
2117     case glslang::EOpLeftShiftAssign:
2118     case glslang::EOpRightShiftAssign:
2119         // A bin-op assign "a += b" means the same thing as "a = a + b"
2120         // where a is evaluated before b. For a simple assignment, GLSL
2121         // says to evaluate the left before the right.  So, always, left
2122         // node then right node.
2123         {
2124             // get the left l-value, save it away
2125             builder.clearAccessChain();
2126             node->getLeft()->traverse(this);
2127             spv::Builder::AccessChain lValue = builder.getAccessChain();
2128
2129             // evaluate the right
2130             builder.clearAccessChain();
2131             node->getRight()->traverse(this);
2132             spv::Id rValue = accessChainLoad(node->getRight()->getType());
2133
2134             if (node->getOp() != glslang::EOpAssign) {
2135                 // the left is also an r-value
2136                 builder.setAccessChain(lValue);
2137                 spv::Id leftRValue = accessChainLoad(node->getLeft()->getType());
2138
2139                 // do the operation
2140                 spv::Builder::AccessChain::CoherentFlags coherentFlags = TranslateCoherent(node->getLeft()->getType());
2141                 coherentFlags |= TranslateCoherent(node->getRight()->getType());
2142                 OpDecorations decorations = { TranslatePrecisionDecoration(node->getOperationPrecision()),
2143                                               TranslateNoContractionDecoration(node->getType().getQualifier()),
2144                                               TranslateNonUniformDecoration(coherentFlags) };
2145                 rValue = createBinaryOperation(node->getOp(), decorations,
2146                                                convertGlslangToSpvType(node->getType()), leftRValue, rValue,
2147                                                node->getType().getBasicType());
2148
2149                 // these all need their counterparts in createBinaryOperation()
2150                 assert(rValue != spv::NoResult);
2151             }
2152
2153             // store the result
2154             builder.setAccessChain(lValue);
2155             multiTypeStore(node->getLeft()->getType(), rValue);
2156
2157             // assignments are expressions having an rValue after they are evaluated...
2158             builder.clearAccessChain();
2159             builder.setAccessChainRValue(rValue);
2160         }
2161         return false;
2162     case glslang::EOpIndexDirect:
2163     case glslang::EOpIndexDirectStruct:
2164         {
2165             // Structure, array, matrix, or vector indirection with statically known index.
2166             // Get the left part of the access chain.
2167             node->getLeft()->traverse(this);
2168
2169             // Add the next element in the chain
2170
2171             const int glslangIndex = node->getRight()->getAsConstantUnion()->getConstArray()[0].getIConst();
2172             if (! node->getLeft()->getType().isArray() &&
2173                 node->getLeft()->getType().isVector() &&
2174                 node->getOp() == glslang::EOpIndexDirect) {
2175                 // Swizzle is uniform so propagate uniform into access chain
2176                 spv::Builder::AccessChain::CoherentFlags coherentFlags = TranslateCoherent(node->getLeft()->getType());
2177                 coherentFlags.nonUniform = 0;
2178                 // This is essentially a hard-coded vector swizzle of size 1,
2179                 // so short circuit the access-chain stuff with a swizzle.
2180                 std::vector<unsigned> swizzle;
2181                 swizzle.push_back(glslangIndex);
2182                 int dummySize;
2183                 builder.accessChainPushSwizzle(swizzle, convertGlslangToSpvType(node->getLeft()->getType()),
2184                                                coherentFlags,
2185                                                glslangIntermediate->getBaseAlignmentScalar(
2186                                                    node->getLeft()->getType(), dummySize));
2187             } else {
2188
2189                 // Load through a block reference is performed with a dot operator that
2190                 // is mapped to EOpIndexDirectStruct. When we get to the actual reference,
2191                 // do a load and reset the access chain.
2192                 if (node->getLeft()->isReference() &&
2193                     !node->getLeft()->getType().isArray() &&
2194                     node->getOp() == glslang::EOpIndexDirectStruct)
2195                 {
2196                     spv::Id left = accessChainLoad(node->getLeft()->getType());
2197                     builder.clearAccessChain();
2198                     builder.setAccessChainLValue(left);
2199                 }
2200
2201                 int spvIndex = glslangIndex;
2202                 if (node->getLeft()->getBasicType() == glslang::EbtBlock &&
2203                     node->getOp() == glslang::EOpIndexDirectStruct)
2204                 {
2205                     // This may be, e.g., an anonymous block-member selection, which generally need
2206                     // index remapping due to hidden members in anonymous blocks.
2207                     long long glslangId = glslangTypeToIdMap[node->getLeft()->getType().getStruct()];
2208                     if (memberRemapper.find(glslangId) != memberRemapper.end()) {
2209                         std::vector<int>& remapper = memberRemapper[glslangId];
2210                         assert(remapper.size() > 0);
2211                         spvIndex = remapper[glslangIndex];
2212                     }
2213                 }
2214
2215                 // Struct reference propagates uniform lvalue
2216                 spv::Builder::AccessChain::CoherentFlags coherentFlags =
2217                         TranslateCoherent(node->getLeft()->getType());
2218                 coherentFlags.nonUniform = 0;
2219
2220                 // normal case for indexing array or structure or block
2221                 builder.accessChainPush(builder.makeIntConstant(spvIndex),
2222                         coherentFlags,
2223                         node->getLeft()->getType().getBufferReferenceAlignment());
2224
2225                 // Add capabilities here for accessing PointSize and clip/cull distance.
2226                 // We have deferred generation of associated capabilities until now.
2227                 if (node->getLeft()->getType().isStruct() && ! node->getLeft()->getType().isArray())
2228                     declareUseOfStructMember(*(node->getLeft()->getType().getStruct()), glslangIndex);
2229             }
2230         }
2231         return false;
2232     case glslang::EOpIndexIndirect:
2233         {
2234             // Array, matrix, or vector indirection with variable index.
2235             // Will use native SPIR-V access-chain for and array indirection;
2236             // matrices are arrays of vectors, so will also work for a matrix.
2237             // Will use the access chain's 'component' for variable index into a vector.
2238
2239             // This adapter is building access chains left to right.
2240             // Set up the access chain to the left.
2241             node->getLeft()->traverse(this);
2242
2243             // save it so that computing the right side doesn't trash it
2244             spv::Builder::AccessChain partial = builder.getAccessChain();
2245
2246             // compute the next index in the chain
2247             builder.clearAccessChain();
2248             node->getRight()->traverse(this);
2249             spv::Id index = accessChainLoad(node->getRight()->getType());
2250
2251             addIndirectionIndexCapabilities(node->getLeft()->getType(), node->getRight()->getType());
2252
2253             // restore the saved access chain
2254             builder.setAccessChain(partial);
2255
2256             // Only if index is nonUniform should we propagate nonUniform into access chain
2257             spv::Builder::AccessChain::CoherentFlags index_flags = TranslateCoherent(node->getRight()->getType());
2258             spv::Builder::AccessChain::CoherentFlags coherent_flags = TranslateCoherent(node->getLeft()->getType());
2259             coherent_flags.nonUniform = index_flags.nonUniform;
2260
2261             if (! node->getLeft()->getType().isArray() && node->getLeft()->getType().isVector()) {
2262                 int dummySize;
2263                 builder.accessChainPushComponent(
2264                     index, convertGlslangToSpvType(node->getLeft()->getType()), coherent_flags,
2265                                                 glslangIntermediate->getBaseAlignmentScalar(node->getLeft()->getType(),
2266                                                 dummySize));
2267             } else
2268                 builder.accessChainPush(index, coherent_flags,
2269                                         node->getLeft()->getType().getBufferReferenceAlignment());
2270         }
2271         return false;
2272     case glslang::EOpVectorSwizzle:
2273         {
2274             node->getLeft()->traverse(this);
2275             std::vector<unsigned> swizzle;
2276             convertSwizzle(*node->getRight()->getAsAggregate(), swizzle);
2277             int dummySize;
2278             builder.accessChainPushSwizzle(swizzle, convertGlslangToSpvType(node->getLeft()->getType()),
2279                                            TranslateCoherent(node->getLeft()->getType()),
2280                                            glslangIntermediate->getBaseAlignmentScalar(node->getLeft()->getType(),
2281                                                dummySize));
2282         }
2283         return false;
2284     case glslang::EOpMatrixSwizzle:
2285         logger->missingFunctionality("matrix swizzle");
2286         return true;
2287     case glslang::EOpLogicalOr:
2288     case glslang::EOpLogicalAnd:
2289         {
2290
2291             // These may require short circuiting, but can sometimes be done as straight
2292             // binary operations.  The right operand must be short circuited if it has
2293             // side effects, and should probably be if it is complex.
2294             if (isTrivial(node->getRight()->getAsTyped()))
2295                 break; // handle below as a normal binary operation
2296             // otherwise, we need to do dynamic short circuiting on the right operand
2297             spv::Id result = createShortCircuit(node->getOp(), *node->getLeft()->getAsTyped(),
2298                 *node->getRight()->getAsTyped());
2299             builder.clearAccessChain();
2300             builder.setAccessChainRValue(result);
2301         }
2302         return false;
2303     default:
2304         break;
2305     }
2306
2307     // Assume generic binary op...
2308
2309     // get right operand
2310     builder.clearAccessChain();
2311     node->getLeft()->traverse(this);
2312     spv::Id left = accessChainLoad(node->getLeft()->getType());
2313
2314     // get left operand
2315     builder.clearAccessChain();
2316     node->getRight()->traverse(this);
2317     spv::Id right = accessChainLoad(node->getRight()->getType());
2318
2319     // get result
2320     OpDecorations decorations = { TranslatePrecisionDecoration(node->getOperationPrecision()),
2321                                   TranslateNoContractionDecoration(node->getType().getQualifier()),
2322                                   TranslateNonUniformDecoration(node->getType().getQualifier()) };
2323     spv::Id result = createBinaryOperation(node->getOp(), decorations,
2324                                            convertGlslangToSpvType(node->getType()), left, right,
2325                                            node->getLeft()->getType().getBasicType());
2326
2327     builder.clearAccessChain();
2328     if (! result) {
2329         logger->missingFunctionality("unknown glslang binary operation");
2330         return true;  // pick up a child as the place-holder result
2331     } else {
2332         builder.setAccessChainRValue(result);
2333         return false;
2334     }
2335 }
2336
2337 spv::Id TGlslangToSpvTraverser::convertLoadedBoolInUniformToUint(const glslang::TType& type,
2338                                                                  spv::Id nominalTypeId,
2339                                                                  spv::Id loadedId)
2340 {
2341     if (builder.isScalarType(nominalTypeId)) {
2342         // Conversion for bool
2343         spv::Id boolType = builder.makeBoolType();
2344         if (nominalTypeId != boolType)
2345             return builder.createBinOp(spv::OpINotEqual, boolType, loadedId, builder.makeUintConstant(0));
2346     } else if (builder.isVectorType(nominalTypeId)) {
2347         // Conversion for bvec
2348         int vecSize = builder.getNumTypeComponents(nominalTypeId);
2349         spv::Id bvecType = builder.makeVectorType(builder.makeBoolType(), vecSize);
2350         if (nominalTypeId != bvecType)
2351             loadedId = builder.createBinOp(spv::OpINotEqual, bvecType, loadedId,
2352                 makeSmearedConstant(builder.makeUintConstant(0), vecSize));
2353     } else if (builder.isArrayType(nominalTypeId)) {
2354         // Conversion for bool array
2355         spv::Id boolArrayTypeId = convertGlslangToSpvType(type);
2356         if (nominalTypeId != boolArrayTypeId)
2357         {
2358             // Use OpCopyLogical from SPIR-V 1.4 if available.
2359             if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4)
2360                 return builder.createUnaryOp(spv::OpCopyLogical, boolArrayTypeId, loadedId);
2361
2362             glslang::TType glslangElementType(type, 0);
2363             spv::Id elementNominalTypeId = builder.getContainedTypeId(nominalTypeId);
2364             std::vector<spv::Id> constituents;
2365             for (int index = 0; index < type.getOuterArraySize(); ++index) {
2366                 // get the element
2367                 spv::Id elementValue = builder.createCompositeExtract(loadedId, elementNominalTypeId, index);
2368
2369                 // recursively convert it
2370                 spv::Id elementConvertedValue = convertLoadedBoolInUniformToUint(glslangElementType, elementNominalTypeId, elementValue);
2371                 constituents.push_back(elementConvertedValue);
2372             }
2373             return builder.createCompositeConstruct(boolArrayTypeId, constituents);
2374         }
2375     }
2376
2377     return loadedId;
2378 }
2379
2380 // Figure out what, if any, type changes are needed when accessing a specific built-in.
2381 // Returns <the type SPIR-V requires for declarion, the type to translate to on use>.
2382 // Also see comment for 'forceType', regarding tracking SPIR-V-required types.
2383 std::pair<spv::Id, spv::Id> TGlslangToSpvTraverser::getForcedType(glslang::TBuiltInVariable glslangBuiltIn,
2384     const glslang::TType& glslangType)
2385 {
2386     switch(glslangBuiltIn)
2387     {
2388         case glslang::EbvSubGroupEqMask:
2389         case glslang::EbvSubGroupGeMask:
2390         case glslang::EbvSubGroupGtMask:
2391         case glslang::EbvSubGroupLeMask:
2392         case glslang::EbvSubGroupLtMask: {
2393             // these require changing a 64-bit scaler -> a vector of 32-bit components
2394             if (glslangType.isVector())
2395                 break;
2396             spv::Id ivec4_type = builder.makeVectorType(builder.makeUintType(32), 4);
2397             spv::Id uint64_type = builder.makeUintType(64);
2398             std::pair<spv::Id, spv::Id> ret(ivec4_type, uint64_type);
2399             return ret;
2400         }
2401         // There are no SPIR-V builtins defined for these and map onto original non-transposed
2402         // builtins. During visitBinary we insert a transpose
2403         case glslang::EbvWorldToObject3x4:
2404         case glslang::EbvObjectToWorld3x4: {
2405             spv::Id mat43 = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
2406             spv::Id mat34 = builder.makeMatrixType(builder.makeFloatType(32), 3, 4);
2407             std::pair<spv::Id, spv::Id> ret(mat43, mat34);
2408             return ret;
2409         }
2410         default:
2411             break;
2412     }
2413
2414     std::pair<spv::Id, spv::Id> ret(spv::NoType, spv::NoType);
2415     return ret;
2416 }
2417
2418 // For an object previously identified (see getForcedType() and forceType)
2419 // as needing type translations, do the translation needed for a load, turning
2420 // an L-value into in R-value.
2421 spv::Id TGlslangToSpvTraverser::translateForcedType(spv::Id object)
2422 {
2423     const auto forceIt = forceType.find(object);
2424     if (forceIt == forceType.end())
2425         return object;
2426
2427     spv::Id desiredTypeId = forceIt->second;
2428     spv::Id objectTypeId = builder.getTypeId(object);
2429     assert(builder.isPointerType(objectTypeId));
2430     objectTypeId = builder.getContainedTypeId(objectTypeId);
2431     if (builder.isVectorType(objectTypeId) &&
2432         builder.getScalarTypeWidth(builder.getContainedTypeId(objectTypeId)) == 32) {
2433         if (builder.getScalarTypeWidth(desiredTypeId) == 64) {
2434             // handle 32-bit v.xy* -> 64-bit
2435             builder.clearAccessChain();
2436             builder.setAccessChainLValue(object);
2437             object = builder.accessChainLoad(spv::NoPrecision, spv::DecorationMax, spv::DecorationMax, objectTypeId);
2438             std::vector<spv::Id> components;
2439             components.push_back(builder.createCompositeExtract(object, builder.getContainedTypeId(objectTypeId), 0));
2440             components.push_back(builder.createCompositeExtract(object, builder.getContainedTypeId(objectTypeId), 1));
2441
2442             spv::Id vecType = builder.makeVectorType(builder.getContainedTypeId(objectTypeId), 2);
2443             return builder.createUnaryOp(spv::OpBitcast, desiredTypeId,
2444                                          builder.createCompositeConstruct(vecType, components));
2445         } else {
2446             logger->missingFunctionality("forcing 32-bit vector type to non 64-bit scalar");
2447         }
2448     } else if (builder.isMatrixType(objectTypeId)) {
2449             // There are no SPIR-V builtins defined for 3x4 variants of ObjectToWorld/WorldToObject
2450             // and we insert a transpose after loading the original non-transposed builtins
2451             builder.clearAccessChain();
2452             builder.setAccessChainLValue(object);
2453             object = builder.accessChainLoad(spv::NoPrecision, spv::DecorationMax, spv::DecorationMax, objectTypeId);
2454             return builder.createUnaryOp(spv::OpTranspose, desiredTypeId, object);
2455
2456     } else  {
2457         logger->missingFunctionality("forcing non 32-bit vector type");
2458     }
2459
2460     return object;
2461 }
2462
2463 bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TIntermUnary* node)
2464 {
2465     builder.setLine(node->getLoc().line, node->getLoc().getFilename());
2466
2467     SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder);
2468     if (node->getType().getQualifier().isSpecConstant())
2469         spec_constant_op_mode_setter.turnOnSpecConstantOpMode();
2470
2471     spv::Id result = spv::NoResult;
2472
2473     // try texturing first
2474     result = createImageTextureFunctionCall(node);
2475     if (result != spv::NoResult) {
2476         builder.clearAccessChain();
2477         builder.setAccessChainRValue(result);
2478
2479         return false; // done with this node
2480     }
2481
2482     // Non-texturing.
2483
2484     if (node->getOp() == glslang::EOpArrayLength) {
2485         // Quite special; won't want to evaluate the operand.
2486
2487         // Currently, the front-end does not allow .length() on an array until it is sized,
2488         // except for the last block membeor of an SSBO.
2489         // TODO: If this changes, link-time sized arrays might show up here, and need their
2490         // size extracted.
2491
2492         // Normal .length() would have been constant folded by the front-end.
2493         // So, this has to be block.lastMember.length().
2494         // SPV wants "block" and member number as the operands, go get them.
2495
2496         spv::Id length;
2497         if (node->getOperand()->getType().isCoopMat()) {
2498             spec_constant_op_mode_setter.turnOnSpecConstantOpMode();
2499
2500             spv::Id typeId = convertGlslangToSpvType(node->getOperand()->getType());
2501             assert(builder.isCooperativeMatrixType(typeId));
2502
2503             length = builder.createCooperativeMatrixLength(typeId);
2504         } else {
2505             glslang::TIntermTyped* block = node->getOperand()->getAsBinaryNode()->getLeft();
2506             block->traverse(this);
2507             unsigned int member = node->getOperand()->getAsBinaryNode()->getRight()->getAsConstantUnion()
2508                 ->getConstArray()[0].getUConst();
2509             length = builder.createArrayLength(builder.accessChainGetLValue(), member);
2510         }
2511
2512         // GLSL semantics say the result of .length() is an int, while SPIR-V says
2513         // signedness must be 0. So, convert from SPIR-V unsigned back to GLSL's
2514         // AST expectation of a signed result.
2515         if (glslangIntermediate->getSource() == glslang::EShSourceGlsl) {
2516             if (builder.isInSpecConstCodeGenMode()) {
2517                 length = builder.createBinOp(spv::OpIAdd, builder.makeIntType(32), length, builder.makeIntConstant(0));
2518             } else {
2519                 length = builder.createUnaryOp(spv::OpBitcast, builder.makeIntType(32), length);
2520             }
2521         }
2522
2523         builder.clearAccessChain();
2524         builder.setAccessChainRValue(length);
2525
2526         return false;
2527     }
2528
2529     // Start by evaluating the operand
2530
2531     // Does it need a swizzle inversion?  If so, evaluation is inverted;
2532     // operate first on the swizzle base, then apply the swizzle.
2533     spv::Id invertedType = spv::NoType;
2534     auto resultType = [&invertedType, &node, this](){ return invertedType != spv::NoType ?
2535         invertedType : convertGlslangToSpvType(node->getType()); };
2536     if (node->getOp() == glslang::EOpInterpolateAtCentroid)
2537         invertedType = getInvertedSwizzleType(*node->getOperand());
2538
2539     builder.clearAccessChain();
2540     TIntermNode *operandNode;
2541     if (invertedType != spv::NoType)
2542         operandNode = node->getOperand()->getAsBinaryNode()->getLeft();
2543     else
2544         operandNode = node->getOperand();
2545
2546     operandNode->traverse(this);
2547
2548     spv::Id operand = spv::NoResult;
2549
2550     spv::Builder::AccessChain::CoherentFlags lvalueCoherentFlags;
2551
2552 #ifndef GLSLANG_WEB
2553     if (node->getOp() == glslang::EOpAtomicCounterIncrement ||
2554         node->getOp() == glslang::EOpAtomicCounterDecrement ||
2555         node->getOp() == glslang::EOpAtomicCounter          ||
2556         (node->getOp() == glslang::EOpInterpolateAtCentroid &&
2557           glslangIntermediate->getSource() != glslang::EShSourceHlsl)  ||
2558         node->getOp() == glslang::EOpRayQueryProceed        ||
2559         node->getOp() == glslang::EOpRayQueryGetRayTMin     ||
2560         node->getOp() == glslang::EOpRayQueryGetRayFlags    ||
2561         node->getOp() == glslang::EOpRayQueryGetWorldRayOrigin ||
2562         node->getOp() == glslang::EOpRayQueryGetWorldRayDirection ||
2563         node->getOp() == glslang::EOpRayQueryGetIntersectionCandidateAABBOpaque ||
2564         node->getOp() == glslang::EOpRayQueryTerminate ||
2565         node->getOp() == glslang::EOpRayQueryConfirmIntersection ||
2566         (node->getOp() == glslang::EOpSpirvInst && operandNode->getAsTyped()->getQualifier().isSpirvByReference())) {
2567         operand = builder.accessChainGetLValue(); // Special case l-value operands
2568         lvalueCoherentFlags = builder.getAccessChain().coherentFlags;
2569         lvalueCoherentFlags |= TranslateCoherent(operandNode->getAsTyped()->getType());
2570     } else if (operandNode->getAsTyped()->getQualifier().isSpirvLiteral()) {
2571         // Will be translated to a literal value, make a placeholder here
2572         operand = spv::NoResult;
2573     } else
2574 #endif
2575     {
2576         operand = accessChainLoad(node->getOperand()->getType());
2577     }
2578
2579     OpDecorations decorations = { TranslatePrecisionDecoration(node->getOperationPrecision()),
2580                                   TranslateNoContractionDecoration(node->getType().getQualifier()),
2581                                   TranslateNonUniformDecoration(node->getType().getQualifier()) };
2582
2583     // it could be a conversion
2584     if (! result)
2585         result = createConversion(node->getOp(), decorations, resultType(), operand,
2586             node->getOperand()->getBasicType());
2587
2588     // if not, then possibly an operation
2589     if (! result)
2590         result = createUnaryOperation(node->getOp(), decorations, resultType(), operand,
2591             node->getOperand()->getBasicType(), lvalueCoherentFlags);
2592
2593 #ifndef GLSLANG_WEB
2594     // it could be attached to a SPIR-V intruction
2595     if (!result) {
2596         if (node->getOp() == glslang::EOpSpirvInst) {
2597             const auto& spirvInst = node->getSpirvInstruction();
2598             if (spirvInst.set == "") {
2599                 spv::IdImmediate idImmOp = {true, operand};
2600                 if (operandNode->getAsTyped()->getQualifier().isSpirvLiteral()) {
2601                     // Translate the constant to a literal value
2602                     std::vector<unsigned> literals;
2603                     glslang::TVector<const glslang::TIntermConstantUnion*> constants;
2604                     constants.push_back(operandNode->getAsConstantUnion());
2605                     TranslateLiterals(constants, literals);
2606                     idImmOp = {false, literals[0]};
2607                 }
2608
2609                 if (node->getBasicType() == glslang::EbtVoid)
2610                     builder.createNoResultOp(static_cast<spv::Op>(spirvInst.id), {idImmOp});
2611                 else
2612                     result = builder.createOp(static_cast<spv::Op>(spirvInst.id), resultType(), {idImmOp});
2613             } else {
2614                 result = builder.createBuiltinCall(
2615                     resultType(), spirvInst.set == "GLSL.std.450" ? stdBuiltins : getExtBuiltins(spirvInst.set.c_str()),
2616                     spirvInst.id, {operand});
2617             }
2618
2619             if (node->getBasicType() == glslang::EbtVoid)
2620                 return false; // done with this node
2621         }
2622     }
2623 #endif
2624
2625     if (result) {
2626         if (invertedType) {
2627             result = createInvertedSwizzle(decorations.precision, *node->getOperand(), result);
2628             decorations.addNonUniform(builder, result);
2629         }
2630
2631         builder.clearAccessChain();
2632         builder.setAccessChainRValue(result);
2633
2634         return false; // done with this node
2635     }
2636
2637     // it must be a special case, check...
2638     switch (node->getOp()) {
2639     case glslang::EOpPostIncrement:
2640     case glslang::EOpPostDecrement:
2641     case glslang::EOpPreIncrement:
2642     case glslang::EOpPreDecrement:
2643         {
2644             // we need the integer value "1" or the floating point "1.0" to add/subtract
2645             spv::Id one = 0;
2646             if (node->getBasicType() == glslang::EbtFloat)
2647                 one = builder.makeFloatConstant(1.0F);
2648 #ifndef GLSLANG_WEB
2649             else if (node->getBasicType() == glslang::EbtDouble)
2650                 one = builder.makeDoubleConstant(1.0);
2651             else if (node->getBasicType() == glslang::EbtFloat16)
2652                 one = builder.makeFloat16Constant(1.0F);
2653             else if (node->getBasicType() == glslang::EbtInt8  || node->getBasicType() == glslang::EbtUint8)
2654                 one = builder.makeInt8Constant(1);
2655             else if (node->getBasicType() == glslang::EbtInt16 || node->getBasicType() == glslang::EbtUint16)
2656                 one = builder.makeInt16Constant(1);
2657             else if (node->getBasicType() == glslang::EbtInt64 || node->getBasicType() == glslang::EbtUint64)
2658                 one = builder.makeInt64Constant(1);
2659 #endif
2660             else
2661                 one = builder.makeIntConstant(1);
2662             glslang::TOperator op;
2663             if (node->getOp() == glslang::EOpPreIncrement ||
2664                 node->getOp() == glslang::EOpPostIncrement)
2665                 op = glslang::EOpAdd;
2666             else
2667                 op = glslang::EOpSub;
2668
2669             spv::Id result = createBinaryOperation(op, decorations,
2670                                                    convertGlslangToSpvType(node->getType()), operand, one,
2671                                                    node->getType().getBasicType());
2672             assert(result != spv::NoResult);
2673
2674             // The result of operation is always stored, but conditionally the
2675             // consumed result.  The consumed result is always an r-value.
2676             builder.accessChainStore(result,
2677                                      TranslateNonUniformDecoration(builder.getAccessChain().coherentFlags));
2678             builder.clearAccessChain();
2679             if (node->getOp() == glslang::EOpPreIncrement ||
2680                 node->getOp() == glslang::EOpPreDecrement)
2681                 builder.setAccessChainRValue(result);
2682             else
2683                 builder.setAccessChainRValue(operand);
2684         }
2685
2686         return false;
2687
2688 #ifndef GLSLANG_WEB
2689     case glslang::EOpEmitStreamVertex:
2690         builder.createNoResultOp(spv::OpEmitStreamVertex, operand);
2691         return false;
2692     case glslang::EOpEndStreamPrimitive:
2693         builder.createNoResultOp(spv::OpEndStreamPrimitive, operand);
2694         return false;
2695     case glslang::EOpRayQueryTerminate:
2696         builder.createNoResultOp(spv::OpRayQueryTerminateKHR, operand);
2697         return false;
2698     case glslang::EOpRayQueryConfirmIntersection:
2699         builder.createNoResultOp(spv::OpRayQueryConfirmIntersectionKHR, operand);
2700         return false;
2701 #endif
2702
2703     default:
2704         logger->missingFunctionality("unknown glslang unary");
2705         return true;  // pick up operand as placeholder result
2706     }
2707 }
2708
2709 // Construct a composite object, recursively copying members if their types don't match
2710 spv::Id TGlslangToSpvTraverser::createCompositeConstruct(spv::Id resultTypeId, std::vector<spv::Id> constituents)
2711 {
2712     for (int c = 0; c < (int)constituents.size(); ++c) {
2713         spv::Id& constituent = constituents[c];
2714         spv::Id lType = builder.getContainedTypeId(resultTypeId, c);
2715         spv::Id rType = builder.getTypeId(constituent);
2716         if (lType != rType) {
2717             if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4) {
2718                 constituent = builder.createUnaryOp(spv::OpCopyLogical, lType, constituent);
2719             } else if (builder.isStructType(rType)) {
2720                 std::vector<spv::Id> rTypeConstituents;
2721                 int numrTypeConstituents = builder.getNumTypeConstituents(rType);
2722                 for (int i = 0; i < numrTypeConstituents; ++i) {
2723                     rTypeConstituents.push_back(builder.createCompositeExtract(constituent,
2724                         builder.getContainedTypeId(rType, i), i));
2725                 }
2726                 constituents[c] = createCompositeConstruct(lType, rTypeConstituents);
2727             } else {
2728                 assert(builder.isArrayType(rType));
2729                 std::vector<spv::Id> rTypeConstituents;
2730                 int numrTypeConstituents = builder.getNumTypeConstituents(rType);
2731
2732                 spv::Id elementRType = builder.getContainedTypeId(rType);
2733                 for (int i = 0; i < numrTypeConstituents; ++i) {
2734                     rTypeConstituents.push_back(builder.createCompositeExtract(constituent, elementRType, i));
2735                 }
2736                 constituents[c] = createCompositeConstruct(lType, rTypeConstituents);
2737             }
2738         }
2739     }
2740     return builder.createCompositeConstruct(resultTypeId, constituents);
2741 }
2742
2743 bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TIntermAggregate* node)
2744 {
2745     SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder);
2746     if (node->getType().getQualifier().isSpecConstant())
2747         spec_constant_op_mode_setter.turnOnSpecConstantOpMode();
2748
2749     spv::Id result = spv::NoResult;
2750     spv::Id invertedType = spv::NoType;                     // to use to override the natural type of the node
2751     std::vector<spv::Builder::AccessChain> complexLvalues;  // for holding swizzling l-values too complex for
2752                                                             // SPIR-V, for an out parameter
2753     std::vector<spv::Id> temporaryLvalues;                  // temporaries to pass, as proxies for complexLValues
2754
2755     auto resultType = [&invertedType, &node, this](){ return invertedType != spv::NoType ?
2756         invertedType :
2757         convertGlslangToSpvType(node->getType()); };
2758
2759     // try texturing
2760     result = createImageTextureFunctionCall(node);
2761     if (result != spv::NoResult) {
2762         builder.clearAccessChain();
2763         builder.setAccessChainRValue(result);
2764
2765         return false;
2766     }
2767 #ifndef GLSLANG_WEB
2768     else if (node->getOp() == glslang::EOpImageStore ||
2769         node->getOp() == glslang::EOpImageStoreLod ||
2770         node->getOp() == glslang::EOpImageAtomicStore) {
2771         // "imageStore" is a special case, which has no result
2772         return false;
2773     }
2774 #endif
2775
2776     glslang::TOperator binOp = glslang::EOpNull;
2777     bool reduceComparison = true;
2778     bool isMatrix = false;
2779     bool noReturnValue = false;
2780     bool atomic = false;
2781
2782     spv::Builder::AccessChain::CoherentFlags lvalueCoherentFlags;
2783
2784     assert(node->getOp());
2785
2786     spv::Decoration precision = TranslatePrecisionDecoration(node->getOperationPrecision());
2787
2788     switch (node->getOp()) {
2789     case glslang::EOpSequence:
2790     {
2791         if (preVisit)
2792             ++sequenceDepth;
2793         else
2794             --sequenceDepth;
2795
2796         if (sequenceDepth == 1) {
2797             // If this is the parent node of all the functions, we want to see them
2798             // early, so all call points have actual SPIR-V functions to reference.
2799             // In all cases, still let the traverser visit the children for us.
2800             makeFunctions(node->getAsAggregate()->getSequence());
2801
2802             // Also, we want all globals initializers to go into the beginning of the entry point, before
2803             // anything else gets there, so visit out of order, doing them all now.
2804             makeGlobalInitializers(node->getAsAggregate()->getSequence());
2805
2806             //Pre process linker objects for ray tracing stages
2807             if (glslangIntermediate->isRayTracingStage())
2808                 collectRayTracingLinkerObjects();
2809
2810             // Initializers are done, don't want to visit again, but functions and link objects need to be processed,
2811             // so do them manually.
2812             visitFunctions(node->getAsAggregate()->getSequence());
2813
2814             return false;
2815         }
2816
2817         return true;
2818     }
2819     case glslang::EOpLinkerObjects:
2820     {
2821         if (visit == glslang::EvPreVisit)
2822             linkageOnly = true;
2823         else
2824             linkageOnly = false;
2825
2826         return true;
2827     }
2828     case glslang::EOpComma:
2829     {
2830         // processing from left to right naturally leaves the right-most
2831         // lying around in the access chain
2832         glslang::TIntermSequence& glslangOperands = node->getSequence();
2833         for (int i = 0; i < (int)glslangOperands.size(); ++i)
2834             glslangOperands[i]->traverse(this);
2835
2836         return false;
2837     }
2838     case glslang::EOpFunction:
2839         if (visit == glslang::EvPreVisit) {
2840             if (isShaderEntryPoint(node)) {
2841                 inEntryPoint = true;
2842                 builder.setBuildPoint(shaderEntry->getLastBlock());
2843                 currentFunction = shaderEntry;
2844             } else {
2845                 handleFunctionEntry(node);
2846             }
2847             if (options.generateDebugInfo) {
2848                 const auto& loc = node->getLoc();
2849                 currentFunction->setDebugLineInfo(builder.getSourceFile(), loc.line, loc.column);
2850             }
2851         } else {
2852             if (inEntryPoint)
2853                 entryPointTerminated = true;
2854             builder.leaveFunction();
2855             inEntryPoint = false;
2856         }
2857
2858         return true;
2859     case glslang::EOpParameters:
2860         // Parameters will have been consumed by EOpFunction processing, but not
2861         // the body, so we still visited the function node's children, making this
2862         // child redundant.
2863         return false;
2864     case glslang::EOpFunctionCall:
2865     {
2866         builder.setLine(node->getLoc().line, node->getLoc().getFilename());
2867         if (node->isUserDefined())
2868             result = handleUserFunctionCall(node);
2869         if (result) {
2870             builder.clearAccessChain();
2871             builder.setAccessChainRValue(result);
2872         } else
2873             logger->missingFunctionality("missing user function; linker needs to catch that");
2874
2875         return false;
2876     }
2877     case glslang::EOpConstructMat2x2:
2878     case glslang::EOpConstructMat2x3:
2879     case glslang::EOpConstructMat2x4:
2880     case glslang::EOpConstructMat3x2:
2881     case glslang::EOpConstructMat3x3:
2882     case glslang::EOpConstructMat3x4:
2883     case glslang::EOpConstructMat4x2:
2884     case glslang::EOpConstructMat4x3:
2885     case glslang::EOpConstructMat4x4:
2886     case glslang::EOpConstructDMat2x2:
2887     case glslang::EOpConstructDMat2x3:
2888     case glslang::EOpConstructDMat2x4:
2889     case glslang::EOpConstructDMat3x2:
2890     case glslang::EOpConstructDMat3x3:
2891     case glslang::EOpConstructDMat3x4:
2892     case glslang::EOpConstructDMat4x2:
2893     case glslang::EOpConstructDMat4x3:
2894     case glslang::EOpConstructDMat4x4:
2895     case glslang::EOpConstructIMat2x2:
2896     case glslang::EOpConstructIMat2x3:
2897     case glslang::EOpConstructIMat2x4:
2898     case glslang::EOpConstructIMat3x2:
2899     case glslang::EOpConstructIMat3x3:
2900     case glslang::EOpConstructIMat3x4:
2901     case glslang::EOpConstructIMat4x2:
2902     case glslang::EOpConstructIMat4x3:
2903     case glslang::EOpConstructIMat4x4:
2904     case glslang::EOpConstructUMat2x2:
2905     case glslang::EOpConstructUMat2x3:
2906     case glslang::EOpConstructUMat2x4:
2907     case glslang::EOpConstructUMat3x2:
2908     case glslang::EOpConstructUMat3x3:
2909     case glslang::EOpConstructUMat3x4:
2910     case glslang::EOpConstructUMat4x2:
2911     case glslang::EOpConstructUMat4x3:
2912     case glslang::EOpConstructUMat4x4:
2913     case glslang::EOpConstructBMat2x2:
2914     case glslang::EOpConstructBMat2x3:
2915     case glslang::EOpConstructBMat2x4:
2916     case glslang::EOpConstructBMat3x2:
2917     case glslang::EOpConstructBMat3x3:
2918     case glslang::EOpConstructBMat3x4:
2919     case glslang::EOpConstructBMat4x2:
2920     case glslang::EOpConstructBMat4x3:
2921     case glslang::EOpConstructBMat4x4:
2922     case glslang::EOpConstructF16Mat2x2:
2923     case glslang::EOpConstructF16Mat2x3:
2924     case glslang::EOpConstructF16Mat2x4:
2925     case glslang::EOpConstructF16Mat3x2:
2926     case glslang::EOpConstructF16Mat3x3:
2927     case glslang::EOpConstructF16Mat3x4:
2928     case glslang::EOpConstructF16Mat4x2:
2929     case glslang::EOpConstructF16Mat4x3:
2930     case glslang::EOpConstructF16Mat4x4:
2931         isMatrix = true;
2932         // fall through
2933     case glslang::EOpConstructFloat:
2934     case glslang::EOpConstructVec2:
2935     case glslang::EOpConstructVec3:
2936     case glslang::EOpConstructVec4:
2937     case glslang::EOpConstructDouble:
2938     case glslang::EOpConstructDVec2:
2939     case glslang::EOpConstructDVec3:
2940     case glslang::EOpConstructDVec4:
2941     case glslang::EOpConstructFloat16:
2942     case glslang::EOpConstructF16Vec2:
2943     case glslang::EOpConstructF16Vec3:
2944     case glslang::EOpConstructF16Vec4:
2945     case glslang::EOpConstructBool:
2946     case glslang::EOpConstructBVec2:
2947     case glslang::EOpConstructBVec3:
2948     case glslang::EOpConstructBVec4:
2949     case glslang::EOpConstructInt8:
2950     case glslang::EOpConstructI8Vec2:
2951     case glslang::EOpConstructI8Vec3:
2952     case glslang::EOpConstructI8Vec4:
2953     case glslang::EOpConstructUint8:
2954     case glslang::EOpConstructU8Vec2:
2955     case glslang::EOpConstructU8Vec3:
2956     case glslang::EOpConstructU8Vec4:
2957     case glslang::EOpConstructInt16:
2958     case glslang::EOpConstructI16Vec2:
2959     case glslang::EOpConstructI16Vec3:
2960     case glslang::EOpConstructI16Vec4:
2961     case glslang::EOpConstructUint16:
2962     case glslang::EOpConstructU16Vec2:
2963     case glslang::EOpConstructU16Vec3:
2964     case glslang::EOpConstructU16Vec4:
2965     case glslang::EOpConstructInt:
2966     case glslang::EOpConstructIVec2:
2967     case glslang::EOpConstructIVec3:
2968     case glslang::EOpConstructIVec4:
2969     case glslang::EOpConstructUint:
2970     case glslang::EOpConstructUVec2:
2971     case glslang::EOpConstructUVec3:
2972     case glslang::EOpConstructUVec4:
2973     case glslang::EOpConstructInt64:
2974     case glslang::EOpConstructI64Vec2:
2975     case glslang::EOpConstructI64Vec3:
2976     case glslang::EOpConstructI64Vec4:
2977     case glslang::EOpConstructUint64:
2978     case glslang::EOpConstructU64Vec2:
2979     case glslang::EOpConstructU64Vec3:
2980     case glslang::EOpConstructU64Vec4:
2981     case glslang::EOpConstructStruct:
2982     case glslang::EOpConstructTextureSampler:
2983     case glslang::EOpConstructReference:
2984     case glslang::EOpConstructCooperativeMatrix:
2985     {
2986         builder.setLine(node->getLoc().line, node->getLoc().getFilename());
2987         std::vector<spv::Id> arguments;
2988         translateArguments(*node, arguments, lvalueCoherentFlags);
2989         spv::Id constructed;
2990         if (node->getOp() == glslang::EOpConstructTextureSampler) {
2991             const glslang::TType& texType = node->getSequence()[0]->getAsTyped()->getType();
2992             if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6 &&
2993                 texType.getSampler().isBuffer()) {
2994                 // SamplerBuffer is not supported in spirv1.6 so
2995                 // `samplerBuffer(textureBuffer, sampler)` is a no-op
2996                 // and textureBuffer is the result going forward
2997                 constructed = arguments[0];
2998             } else
2999                 constructed = builder.createOp(spv::OpSampledImage, resultType(), arguments);
3000         } else if (node->getOp() == glslang::EOpConstructStruct ||
3001                  node->getOp() == glslang::EOpConstructCooperativeMatrix ||
3002                  node->getType().isArray()) {
3003             std::vector<spv::Id> constituents;
3004             for (int c = 0; c < (int)arguments.size(); ++c)
3005                 constituents.push_back(arguments[c]);
3006             constructed = createCompositeConstruct(resultType(), constituents);
3007         } else if (isMatrix)
3008             constructed = builder.createMatrixConstructor(precision, arguments, resultType());
3009         else
3010             constructed = builder.createConstructor(precision, arguments, resultType());
3011
3012         if (node->getType().getQualifier().isNonUniform()) {
3013             builder.addDecoration(constructed, spv::DecorationNonUniformEXT);
3014         }
3015
3016         builder.clearAccessChain();
3017         builder.setAccessChainRValue(constructed);
3018
3019         return false;
3020     }
3021
3022     // These six are component-wise compares with component-wise results.
3023     // Forward on to createBinaryOperation(), requesting a vector result.
3024     case glslang::EOpLessThan:
3025     case glslang::EOpGreaterThan:
3026     case glslang::EOpLessThanEqual:
3027     case glslang::EOpGreaterThanEqual:
3028     case glslang::EOpVectorEqual:
3029     case glslang::EOpVectorNotEqual:
3030     {
3031         // Map the operation to a binary
3032         binOp = node->getOp();
3033         reduceComparison = false;
3034         switch (node->getOp()) {
3035         case glslang::EOpVectorEqual:     binOp = glslang::EOpVectorEqual;      break;
3036         case glslang::EOpVectorNotEqual:  binOp = glslang::EOpVectorNotEqual;   break;
3037         default:                          binOp = node->getOp();                break;
3038         }
3039
3040         break;
3041     }
3042     case glslang::EOpMul:
3043         // component-wise matrix multiply
3044         binOp = glslang::EOpMul;
3045         break;
3046     case glslang::EOpOuterProduct:
3047         // two vectors multiplied to make a matrix
3048         binOp = glslang::EOpOuterProduct;
3049         break;
3050     case glslang::EOpDot:
3051     {
3052         // for scalar dot product, use multiply
3053         glslang::TIntermSequence& glslangOperands = node->getSequence();
3054         if (glslangOperands[0]->getAsTyped()->getVectorSize() == 1)
3055             binOp = glslang::EOpMul;
3056         break;
3057     }
3058     case glslang::EOpMod:
3059         // when an aggregate, this is the floating-point mod built-in function,
3060         // which can be emitted by the one in createBinaryOperation()
3061         binOp = glslang::EOpMod;
3062         break;
3063
3064     case glslang::EOpEmitVertex:
3065     case glslang::EOpEndPrimitive:
3066     case glslang::EOpBarrier:
3067     case glslang::EOpMemoryBarrier:
3068     case glslang::EOpMemoryBarrierAtomicCounter:
3069     case glslang::EOpMemoryBarrierBuffer:
3070     case glslang::EOpMemoryBarrierImage:
3071     case glslang::EOpMemoryBarrierShared:
3072     case glslang::EOpGroupMemoryBarrier:
3073     case glslang::EOpDeviceMemoryBarrier:
3074     case glslang::EOpAllMemoryBarrierWithGroupSync:
3075     case glslang::EOpDeviceMemoryBarrierWithGroupSync:
3076     case glslang::EOpWorkgroupMemoryBarrier:
3077     case glslang::EOpWorkgroupMemoryBarrierWithGroupSync:
3078     case glslang::EOpSubgroupBarrier:
3079     case glslang::EOpSubgroupMemoryBarrier:
3080     case glslang::EOpSubgroupMemoryBarrierBuffer:
3081     case glslang::EOpSubgroupMemoryBarrierImage:
3082     case glslang::EOpSubgroupMemoryBarrierShared:
3083         noReturnValue = true;
3084         // These all have 0 operands and will naturally finish up in the code below for 0 operands
3085         break;
3086
3087     case glslang::EOpAtomicAdd:
3088     case glslang::EOpAtomicSubtract:
3089     case glslang::EOpAtomicMin:
3090     case glslang::EOpAtomicMax:
3091     case glslang::EOpAtomicAnd:
3092     case glslang::EOpAtomicOr:
3093     case glslang::EOpAtomicXor:
3094     case glslang::EOpAtomicExchange:
3095     case glslang::EOpAtomicCompSwap:
3096         atomic = true;
3097         break;
3098
3099 #ifndef GLSLANG_WEB
3100     case glslang::EOpAtomicStore:
3101         noReturnValue = true;
3102         // fallthrough
3103     case glslang::EOpAtomicLoad:
3104         atomic = true;
3105         break;
3106
3107     case glslang::EOpAtomicCounterAdd:
3108     case glslang::EOpAtomicCounterSubtract:
3109     case glslang::EOpAtomicCounterMin:
3110     case glslang::EOpAtomicCounterMax:
3111     case glslang::EOpAtomicCounterAnd:
3112     case glslang::EOpAtomicCounterOr:
3113     case glslang::EOpAtomicCounterXor:
3114     case glslang::EOpAtomicCounterExchange:
3115     case glslang::EOpAtomicCounterCompSwap:
3116         builder.addExtension("SPV_KHR_shader_atomic_counter_ops");
3117         builder.addCapability(spv::CapabilityAtomicStorageOps);
3118         atomic = true;
3119         break;
3120
3121     case glslang::EOpAbsDifference:
3122     case glslang::EOpAddSaturate:
3123     case glslang::EOpSubSaturate:
3124     case glslang::EOpAverage:
3125     case glslang::EOpAverageRounded:
3126     case glslang::EOpMul32x16:
3127         builder.addCapability(spv::CapabilityIntegerFunctions2INTEL);
3128         builder.addExtension("SPV_INTEL_shader_integer_functions2");
3129         binOp = node->getOp();
3130         break;
3131
3132     case glslang::EOpIgnoreIntersectionNV:
3133     case glslang::EOpTerminateRayNV:
3134     case glslang::EOpTraceNV:
3135     case glslang::EOpTraceRayMotionNV:
3136     case glslang::EOpTraceKHR:
3137     case glslang::EOpExecuteCallableNV:
3138     case glslang::EOpExecuteCallableKHR:
3139     case glslang::EOpWritePackedPrimitiveIndices4x8NV:
3140     case glslang::EOpEmitMeshTasksEXT:
3141     case glslang::EOpSetMeshOutputsEXT:
3142         noReturnValue = true;
3143         break;
3144     case glslang::EOpRayQueryInitialize:
3145     case glslang::EOpRayQueryTerminate:
3146     case glslang::EOpRayQueryGenerateIntersection:
3147     case glslang::EOpRayQueryConfirmIntersection:
3148         builder.addExtension("SPV_KHR_ray_query");
3149         builder.addCapability(spv::CapabilityRayQueryKHR);
3150         noReturnValue = true;
3151         break;
3152     case glslang::EOpRayQueryProceed:
3153     case glslang::EOpRayQueryGetIntersectionType:
3154     case glslang::EOpRayQueryGetRayTMin:
3155     case glslang::EOpRayQueryGetRayFlags:
3156     case glslang::EOpRayQueryGetIntersectionT:
3157     case glslang::EOpRayQueryGetIntersectionInstanceCustomIndex:
3158     case glslang::EOpRayQueryGetIntersectionInstanceId:
3159     case glslang::EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset:
3160     case glslang::EOpRayQueryGetIntersectionGeometryIndex:
3161     case glslang::EOpRayQueryGetIntersectionPrimitiveIndex:
3162     case glslang::EOpRayQueryGetIntersectionBarycentrics:
3163     case glslang::EOpRayQueryGetIntersectionFrontFace:
3164     case glslang::EOpRayQueryGetIntersectionCandidateAABBOpaque:
3165     case glslang::EOpRayQueryGetIntersectionObjectRayDirection:
3166     case glslang::EOpRayQueryGetIntersectionObjectRayOrigin:
3167     case glslang::EOpRayQueryGetWorldRayDirection:
3168     case glslang::EOpRayQueryGetWorldRayOrigin:
3169     case glslang::EOpRayQueryGetIntersectionObjectToWorld:
3170     case glslang::EOpRayQueryGetIntersectionWorldToObject:
3171         builder.addExtension("SPV_KHR_ray_query");
3172         builder.addCapability(spv::CapabilityRayQueryKHR);
3173         break;
3174     case glslang::EOpCooperativeMatrixLoad:
3175     case glslang::EOpCooperativeMatrixStore:
3176         noReturnValue = true;
3177         break;
3178     case glslang::EOpBeginInvocationInterlock:
3179     case glslang::EOpEndInvocationInterlock:
3180         builder.addExtension(spv::E_SPV_EXT_fragment_shader_interlock);
3181         noReturnValue = true;
3182         break;
3183 #endif
3184
3185     case glslang::EOpDebugPrintf:
3186         noReturnValue = true;
3187         break;
3188
3189     default:
3190         break;
3191     }
3192
3193     //
3194     // See if it maps to a regular operation.
3195     //
3196     if (binOp != glslang::EOpNull) {
3197         glslang::TIntermTyped* left = node->getSequence()[0]->getAsTyped();
3198         glslang::TIntermTyped* right = node->getSequence()[1]->getAsTyped();
3199         assert(left && right);
3200
3201         builder.clearAccessChain();
3202         left->traverse(this);
3203         spv::Id leftId = accessChainLoad(left->getType());
3204
3205         builder.clearAccessChain();
3206         right->traverse(this);
3207         spv::Id rightId = accessChainLoad(right->getType());
3208
3209         builder.setLine(node->getLoc().line, node->getLoc().getFilename());
3210         OpDecorations decorations = { precision,
3211                                       TranslateNoContractionDecoration(node->getType().getQualifier()),
3212                                       TranslateNonUniformDecoration(node->getType().getQualifier()) };
3213         result = createBinaryOperation(binOp, decorations,
3214                                        resultType(), leftId, rightId,
3215                                        left->getType().getBasicType(), reduceComparison);
3216
3217         // code above should only make binOp that exists in createBinaryOperation
3218         assert(result != spv::NoResult);
3219         builder.clearAccessChain();
3220         builder.setAccessChainRValue(result);
3221
3222         return false;
3223     }
3224
3225     //
3226     // Create the list of operands.
3227     //
3228     glslang::TIntermSequence& glslangOperands = node->getSequence();
3229     std::vector<spv::Id> operands;
3230     std::vector<spv::IdImmediate> memoryAccessOperands;
3231     for (int arg = 0; arg < (int)glslangOperands.size(); ++arg) {
3232         // special case l-value operands; there are just a few
3233         bool lvalue = false;
3234         switch (node->getOp()) {
3235         case glslang::EOpModf:
3236             if (arg == 1)
3237                 lvalue = true;
3238             break;
3239
3240         case glslang::EOpRayQueryInitialize:
3241         case glslang::EOpRayQueryTerminate:
3242         case glslang::EOpRayQueryConfirmIntersection:
3243         case glslang::EOpRayQueryProceed:
3244         case glslang::EOpRayQueryGenerateIntersection:
3245         case glslang::EOpRayQueryGetIntersectionType:
3246         case glslang::EOpRayQueryGetIntersectionT:
3247         case glslang::EOpRayQueryGetIntersectionInstanceCustomIndex:
3248         case glslang::EOpRayQueryGetIntersectionInstanceId:
3249         case glslang::EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset:
3250         case glslang::EOpRayQueryGetIntersectionGeometryIndex:
3251         case glslang::EOpRayQueryGetIntersectionPrimitiveIndex:
3252         case glslang::EOpRayQueryGetIntersectionBarycentrics:
3253         case glslang::EOpRayQueryGetIntersectionFrontFace:
3254         case glslang::EOpRayQueryGetIntersectionObjectRayDirection:
3255         case glslang::EOpRayQueryGetIntersectionObjectRayOrigin:
3256         case glslang::EOpRayQueryGetIntersectionObjectToWorld:
3257         case glslang::EOpRayQueryGetIntersectionWorldToObject:
3258             if (arg == 0)
3259                 lvalue = true;
3260             break;
3261
3262         case glslang::EOpAtomicAdd:
3263         case glslang::EOpAtomicSubtract:
3264         case glslang::EOpAtomicMin:
3265         case glslang::EOpAtomicMax:
3266         case glslang::EOpAtomicAnd:
3267         case glslang::EOpAtomicOr:
3268         case glslang::EOpAtomicXor:
3269         case glslang::EOpAtomicExchange:
3270         case glslang::EOpAtomicCompSwap:
3271             if (arg == 0)
3272                 lvalue = true;
3273             break;
3274
3275 #ifndef GLSLANG_WEB
3276         case glslang::EOpFrexp:
3277             if (arg == 1)
3278                 lvalue = true;
3279             break;
3280         case glslang::EOpInterpolateAtSample:
3281         case glslang::EOpInterpolateAtOffset:
3282         case glslang::EOpInterpolateAtVertex:
3283             if (arg == 0) {
3284                 // If GLSL, use the address of the interpolant argument.
3285                 // If HLSL, use an internal version of OpInterolates that takes
3286                 // the rvalue of the interpolant. A fixup pass in spirv-opt
3287                 // legalization will remove the OpLoad and convert to an lvalue.
3288                 // Had to do this because legalization will only propagate a
3289                 // builtin into an rvalue.
3290                 lvalue = glslangIntermediate->getSource() != glslang::EShSourceHlsl;
3291
3292                 // Does it need a swizzle inversion?  If so, evaluation is inverted;
3293                 // operate first on the swizzle base, then apply the swizzle.
3294                 // That is, we transform
3295                 //
3296                 //    interpolate(v.zy)  ->  interpolate(v).zy
3297                 //
3298                 if (glslangOperands[0]->getAsOperator() &&
3299                     glslangOperands[0]->getAsOperator()->getOp() == glslang::EOpVectorSwizzle)
3300                     invertedType = convertGlslangToSpvType(
3301                         glslangOperands[0]->getAsBinaryNode()->getLeft()->getType());
3302             }
3303             break;
3304         case glslang::EOpAtomicLoad:
3305         case glslang::EOpAtomicStore:
3306         case glslang::EOpAtomicCounterAdd:
3307         case glslang::EOpAtomicCounterSubtract:
3308         case glslang::EOpAtomicCounterMin:
3309         case glslang::EOpAtomicCounterMax:
3310         case glslang::EOpAtomicCounterAnd:
3311         case glslang::EOpAtomicCounterOr:
3312         case glslang::EOpAtomicCounterXor:
3313         case glslang::EOpAtomicCounterExchange:
3314         case glslang::EOpAtomicCounterCompSwap:
3315             if (arg == 0)
3316                 lvalue = true;
3317             break;
3318         case glslang::EOpAddCarry:
3319         case glslang::EOpSubBorrow:
3320             if (arg == 2)
3321                 lvalue = true;
3322             break;
3323         case glslang::EOpUMulExtended:
3324         case glslang::EOpIMulExtended:
3325             if (arg >= 2)
3326                 lvalue = true;
3327             break;
3328         case glslang::EOpCooperativeMatrixLoad:
3329             if (arg == 0 || arg == 1)
3330                 lvalue = true;
3331             break;
3332         case glslang::EOpCooperativeMatrixStore:
3333             if (arg == 1)
3334                 lvalue = true;
3335             break;
3336         case glslang::EOpSpirvInst:
3337             if (glslangOperands[arg]->getAsTyped()->getQualifier().isSpirvByReference())
3338                 lvalue = true;
3339             break;
3340 #endif
3341         default:
3342             break;
3343         }
3344         builder.clearAccessChain();
3345         if (invertedType != spv::NoType && arg == 0)
3346             glslangOperands[0]->getAsBinaryNode()->getLeft()->traverse(this);
3347         else
3348             glslangOperands[arg]->traverse(this);
3349
3350 #ifndef GLSLANG_WEB
3351         if (node->getOp() == glslang::EOpCooperativeMatrixLoad ||
3352             node->getOp() == glslang::EOpCooperativeMatrixStore) {
3353
3354             if (arg == 1) {
3355                 // fold "element" parameter into the access chain
3356                 spv::Builder::AccessChain save = builder.getAccessChain();
3357                 builder.clearAccessChain();
3358                 glslangOperands[2]->traverse(this);
3359
3360                 spv::Id elementId = accessChainLoad(glslangOperands[2]->getAsTyped()->getType());
3361
3362                 builder.setAccessChain(save);
3363
3364                 // Point to the first element of the array.
3365                 builder.accessChainPush(elementId,
3366                     TranslateCoherent(glslangOperands[arg]->getAsTyped()->getType()),
3367                                       glslangOperands[arg]->getAsTyped()->getType().getBufferReferenceAlignment());
3368
3369                 spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags;
3370                 unsigned int alignment = builder.getAccessChain().alignment;
3371
3372                 int memoryAccess = TranslateMemoryAccess(coherentFlags);
3373                 if (node->getOp() == glslang::EOpCooperativeMatrixLoad)
3374                     memoryAccess &= ~spv::MemoryAccessMakePointerAvailableKHRMask;
3375                 if (node->getOp() == glslang::EOpCooperativeMatrixStore)
3376                     memoryAccess &= ~spv::MemoryAccessMakePointerVisibleKHRMask;
3377                 if (builder.getStorageClass(builder.getAccessChain().base) ==
3378                     spv::StorageClassPhysicalStorageBufferEXT) {
3379                     memoryAccess = (spv::MemoryAccessMask)(memoryAccess | spv::MemoryAccessAlignedMask);
3380                 }
3381
3382                 memoryAccessOperands.push_back(spv::IdImmediate(false, memoryAccess));
3383
3384                 if (memoryAccess & spv::MemoryAccessAlignedMask) {
3385                     memoryAccessOperands.push_back(spv::IdImmediate(false, alignment));
3386                 }
3387
3388                 if (memoryAccess &
3389                     (spv::MemoryAccessMakePointerAvailableKHRMask | spv::MemoryAccessMakePointerVisibleKHRMask)) {
3390                     memoryAccessOperands.push_back(spv::IdImmediate(true,
3391                         builder.makeUintConstant(TranslateMemoryScope(coherentFlags))));
3392                 }
3393             } else if (arg == 2) {
3394                 continue;
3395             }
3396         }
3397 #endif
3398
3399         // for l-values, pass the address, for r-values, pass the value
3400         if (lvalue) {
3401             if (invertedType == spv::NoType && !builder.isSpvLvalue()) {
3402                 // SPIR-V cannot represent an l-value containing a swizzle that doesn't
3403                 // reduce to a simple access chain.  So, we need a temporary vector to
3404                 // receive the result, and must later swizzle that into the original
3405                 // l-value.
3406                 complexLvalues.push_back(builder.getAccessChain());
3407                 temporaryLvalues.push_back(builder.createVariable(
3408                     spv::NoPrecision, spv::StorageClassFunction,
3409                     builder.accessChainGetInferredType(), "swizzleTemp"));
3410                 operands.push_back(temporaryLvalues.back());
3411             } else {
3412                 operands.push_back(builder.accessChainGetLValue());
3413             }
3414             lvalueCoherentFlags = builder.getAccessChain().coherentFlags;
3415             lvalueCoherentFlags |= TranslateCoherent(glslangOperands[arg]->getAsTyped()->getType());
3416         } else {
3417             builder.setLine(node->getLoc().line, node->getLoc().getFilename());
3418              glslang::TOperator glslangOp = node->getOp();
3419              if (arg == 1 &&
3420                 (glslangOp == glslang::EOpRayQueryGetIntersectionType ||
3421                  glslangOp == glslang::EOpRayQueryGetIntersectionT ||
3422                  glslangOp == glslang::EOpRayQueryGetIntersectionInstanceCustomIndex ||
3423                  glslangOp == glslang::EOpRayQueryGetIntersectionInstanceId ||
3424                  glslangOp == glslang::EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset ||
3425                  glslangOp == glslang::EOpRayQueryGetIntersectionGeometryIndex ||
3426                  glslangOp == glslang::EOpRayQueryGetIntersectionPrimitiveIndex ||
3427                  glslangOp == glslang::EOpRayQueryGetIntersectionBarycentrics ||
3428                  glslangOp == glslang::EOpRayQueryGetIntersectionFrontFace ||
3429                  glslangOp == glslang::EOpRayQueryGetIntersectionObjectRayDirection ||
3430                  glslangOp == glslang::EOpRayQueryGetIntersectionObjectRayOrigin ||
3431                  glslangOp == glslang::EOpRayQueryGetIntersectionObjectToWorld ||
3432                  glslangOp == glslang::EOpRayQueryGetIntersectionWorldToObject
3433                     )) {
3434                 bool cond = glslangOperands[arg]->getAsConstantUnion()->getConstArray()[0].getBConst();
3435                 operands.push_back(builder.makeIntConstant(cond ? 1 : 0));
3436              } else if ((arg == 10 && glslangOp == glslang::EOpTraceKHR) ||
3437                         (arg == 11 && glslangOp == glslang::EOpTraceRayMotionNV) ||
3438                         (arg == 1  && glslangOp == glslang::EOpExecuteCallableKHR)) {
3439                  const int opdNum = glslangOp == glslang::EOpTraceKHR ? 10 : (glslangOp == glslang::EOpTraceRayMotionNV ? 11 : 1);
3440                  const int set = glslangOp == glslang::EOpExecuteCallableKHR ? 1 : 0;
3441
3442                  const int location = glslangOperands[opdNum]->getAsConstantUnion()->getConstArray()[0].getUConst();
3443                  auto itNode = locationToSymbol[set].find(location);
3444                  visitSymbol(itNode->second);
3445                  spv::Id symId = getSymbolId(itNode->second);
3446                  operands.push_back(symId);
3447 #ifndef GLSLANG_WEB
3448              } else if (glslangOperands[arg]->getAsTyped()->getQualifier().isSpirvLiteral()) {
3449                  // Will be translated to a literal value, make a placeholder here
3450                  operands.push_back(spv::NoResult);
3451 #endif
3452              } else  {
3453                 operands.push_back(accessChainLoad(glslangOperands[arg]->getAsTyped()->getType()));
3454              }
3455         }
3456     }
3457
3458     builder.setLine(node->getLoc().line, node->getLoc().getFilename());
3459 #ifndef GLSLANG_WEB
3460     if (node->getOp() == glslang::EOpCooperativeMatrixLoad) {
3461         std::vector<spv::IdImmediate> idImmOps;
3462
3463         idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf
3464         idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride
3465         idImmOps.push_back(spv::IdImmediate(true, operands[3])); // colMajor
3466         idImmOps.insert(idImmOps.end(), memoryAccessOperands.begin(), memoryAccessOperands.end());
3467         // get the pointee type
3468         spv::Id typeId = builder.getContainedTypeId(builder.getTypeId(operands[0]));
3469         assert(builder.isCooperativeMatrixType(typeId));
3470         // do the op
3471         spv::Id result = builder.createOp(spv::OpCooperativeMatrixLoadNV, typeId, idImmOps);
3472         // store the result to the pointer (out param 'm')
3473         builder.createStore(result, operands[0]);
3474         result = 0;
3475     } else if (node->getOp() == glslang::EOpCooperativeMatrixStore) {
3476         std::vector<spv::IdImmediate> idImmOps;
3477
3478         idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf
3479         idImmOps.push_back(spv::IdImmediate(true, operands[0])); // object
3480         idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride
3481         idImmOps.push_back(spv::IdImmediate(true, operands[3])); // colMajor
3482         idImmOps.insert(idImmOps.end(), memoryAccessOperands.begin(), memoryAccessOperands.end());
3483
3484         builder.createNoResultOp(spv::OpCooperativeMatrixStoreNV, idImmOps);
3485         result = 0;
3486     } else
3487 #endif
3488     if (atomic) {
3489         // Handle all atomics
3490         glslang::TBasicType typeProxy = (node->getOp() == glslang::EOpAtomicStore)
3491             ? node->getSequence()[0]->getAsTyped()->getBasicType() : node->getBasicType();
3492         result = createAtomicOperation(node->getOp(), precision, resultType(), operands, typeProxy,
3493             lvalueCoherentFlags);
3494 #ifndef GLSLANG_WEB
3495     } else if (node->getOp() == glslang::EOpSpirvInst) {
3496         const auto& spirvInst = node->getSpirvInstruction();
3497         if (spirvInst.set == "") {
3498             std::vector<spv::IdImmediate> idImmOps;
3499             for (unsigned int i = 0; i < glslangOperands.size(); ++i) {
3500                 if (glslangOperands[i]->getAsTyped()->getQualifier().isSpirvLiteral()) {
3501                     // Translate the constant to a literal value
3502                     std::vector<unsigned> literals;
3503                     glslang::TVector<const glslang::TIntermConstantUnion*> constants;
3504                     constants.push_back(glslangOperands[i]->getAsConstantUnion());
3505                     TranslateLiterals(constants, literals);
3506                     idImmOps.push_back({false, literals[0]});
3507                 } else
3508                     idImmOps.push_back({true, operands[i]});
3509             }
3510
3511             if (node->getBasicType() == glslang::EbtVoid)
3512                 builder.createNoResultOp(static_cast<spv::Op>(spirvInst.id), idImmOps);
3513             else
3514                 result = builder.createOp(static_cast<spv::Op>(spirvInst.id), resultType(), idImmOps);
3515         } else {
3516             result = builder.createBuiltinCall(
3517                 resultType(), spirvInst.set == "GLSL.std.450" ? stdBuiltins : getExtBuiltins(spirvInst.set.c_str()),
3518                 spirvInst.id, operands);
3519         }
3520         noReturnValue = node->getBasicType() == glslang::EbtVoid;
3521 #endif
3522     } else if (node->getOp() == glslang::EOpDebugPrintf) {
3523         if (!nonSemanticDebugPrintf) {
3524             nonSemanticDebugPrintf = builder.import("NonSemantic.DebugPrintf");
3525         }
3526         result = builder.createBuiltinCall(builder.makeVoidType(), nonSemanticDebugPrintf, spv::NonSemanticDebugPrintfDebugPrintf, operands);
3527         builder.addExtension(spv::E_SPV_KHR_non_semantic_info);
3528     } else {
3529         // Pass through to generic operations.
3530         switch (glslangOperands.size()) {
3531         case 0:
3532             result = createNoArgOperation(node->getOp(), precision, resultType());
3533             break;
3534         case 1:
3535             {
3536                 OpDecorations decorations = { precision,
3537                                               TranslateNoContractionDecoration(node->getType().getQualifier()),
3538                                               TranslateNonUniformDecoration(node->getType().getQualifier()) };
3539                 result = createUnaryOperation(
3540                     node->getOp(), decorations,
3541                     resultType(), operands.front(),
3542                     glslangOperands[0]->getAsTyped()->getBasicType(), lvalueCoherentFlags);
3543             }
3544             break;
3545         default:
3546             result = createMiscOperation(node->getOp(), precision, resultType(), operands, node->getBasicType());
3547             break;
3548         }
3549
3550         if (invertedType != spv::NoResult)
3551             result = createInvertedSwizzle(precision, *glslangOperands[0]->getAsBinaryNode(), result);
3552
3553         for (unsigned int i = 0; i < temporaryLvalues.size(); ++i) {
3554             builder.setAccessChain(complexLvalues[i]);
3555             builder.accessChainStore(builder.createLoad(temporaryLvalues[i], spv::NoPrecision),
3556                 TranslateNonUniformDecoration(complexLvalues[i].coherentFlags));
3557         }
3558     }
3559
3560     if (noReturnValue)
3561         return false;
3562
3563     if (! result) {
3564         logger->missingFunctionality("unknown glslang aggregate");
3565         return true;  // pick up a child as a placeholder operand
3566     } else {
3567         builder.clearAccessChain();
3568         builder.setAccessChainRValue(result);
3569         return false;
3570     }
3571 }
3572
3573 // This path handles both if-then-else and ?:
3574 // The if-then-else has a node type of void, while
3575 // ?: has either a void or a non-void node type
3576 //
3577 // Leaving the result, when not void:
3578 // GLSL only has r-values as the result of a :?, but
3579 // if we have an l-value, that can be more efficient if it will
3580 // become the base of a complex r-value expression, because the
3581 // next layer copies r-values into memory to use the access-chain mechanism
3582 bool TGlslangToSpvTraverser::visitSelection(glslang::TVisit /* visit */, glslang::TIntermSelection* node)
3583 {
3584     // see if OpSelect can handle it
3585     const auto isOpSelectable = [&]() {
3586         if (node->getBasicType() == glslang::EbtVoid)
3587             return false;
3588         // OpSelect can do all other types starting with SPV 1.4
3589         if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_4) {
3590             // pre-1.4, only scalars and vectors can be handled
3591             if ((!node->getType().isScalar() && !node->getType().isVector()))
3592                 return false;
3593         }
3594         return true;
3595     };
3596
3597     // See if it simple and safe, or required, to execute both sides.
3598     // Crucially, side effects must be either semantically required or avoided,
3599     // and there are performance trade-offs.
3600     // Return true if required or a good idea (and safe) to execute both sides,
3601     // false otherwise.
3602     const auto bothSidesPolicy = [&]() -> bool {
3603         // do we have both sides?
3604         if (node->getTrueBlock()  == nullptr ||
3605             node->getFalseBlock() == nullptr)
3606             return false;
3607
3608         // required? (unless we write additional code to look for side effects
3609         // and make performance trade-offs if none are present)
3610         if (!node->getShortCircuit())
3611             return true;
3612
3613         // if not required to execute both, decide based on performance/practicality...
3614
3615         if (!isOpSelectable())
3616             return false;
3617
3618         assert(node->getType() == node->getTrueBlock() ->getAsTyped()->getType() &&
3619                node->getType() == node->getFalseBlock()->getAsTyped()->getType());
3620
3621         // return true if a single operand to ? : is okay for OpSelect
3622         const auto operandOkay = [](glslang::TIntermTyped* node) {
3623             return node->getAsSymbolNode() || node->getType().getQualifier().isConstant();
3624         };
3625
3626         return operandOkay(node->getTrueBlock() ->getAsTyped()) &&
3627                operandOkay(node->getFalseBlock()->getAsTyped());
3628     };
3629
3630     spv::Id result = spv::NoResult; // upcoming result selecting between trueValue and falseValue
3631     // emit the condition before doing anything with selection
3632     node->getCondition()->traverse(this);
3633     spv::Id condition = accessChainLoad(node->getCondition()->getType());
3634
3635     // Find a way of executing both sides and selecting the right result.
3636     const auto executeBothSides = [&]() -> void {
3637         // execute both sides
3638         node->getTrueBlock()->traverse(this);
3639         spv::Id trueValue = accessChainLoad(node->getTrueBlock()->getAsTyped()->getType());
3640         node->getFalseBlock()->traverse(this);
3641         spv::Id falseValue = accessChainLoad(node->getTrueBlock()->getAsTyped()->getType());
3642
3643         builder.setLine(node->getLoc().line, node->getLoc().getFilename());
3644
3645         // done if void
3646         if (node->getBasicType() == glslang::EbtVoid)
3647             return;
3648
3649         // emit code to select between trueValue and falseValue
3650
3651         // see if OpSelect can handle it
3652         if (isOpSelectable()) {
3653             // Emit OpSelect for this selection.
3654
3655             // smear condition to vector, if necessary (AST is always scalar)
3656             // Before 1.4, smear like for mix(), starting with 1.4, keep it scalar
3657             if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_4 && builder.isVector(trueValue)) {
3658                 condition = builder.smearScalar(spv::NoPrecision, condition,
3659                                                 builder.makeVectorType(builder.makeBoolType(),
3660                                                                        builder.getNumComponents(trueValue)));
3661             }
3662
3663             // OpSelect
3664             result = builder.createTriOp(spv::OpSelect,
3665                                          convertGlslangToSpvType(node->getType()), condition,
3666                                                                  trueValue, falseValue);
3667
3668             builder.clearAccessChain();
3669             builder.setAccessChainRValue(result);
3670         } else {
3671             // We need control flow to select the result.
3672             // TODO: Once SPIR-V OpSelect allows arbitrary types, eliminate this path.
3673             result = builder.createVariable(TranslatePrecisionDecoration(node->getType()),
3674                 spv::StorageClassFunction, convertGlslangToSpvType(node->getType()));
3675
3676             // Selection control:
3677             const spv::SelectionControlMask control = TranslateSelectionControl(*node);
3678
3679             // make an "if" based on the value created by the condition
3680             spv::Builder::If ifBuilder(condition, control, builder);
3681
3682             // emit the "then" statement
3683             builder.createStore(trueValue, result);
3684             ifBuilder.makeBeginElse();
3685             // emit the "else" statement
3686             builder.createStore(falseValue, result);
3687
3688             // finish off the control flow
3689             ifBuilder.makeEndIf();
3690
3691             builder.clearAccessChain();
3692             builder.setAccessChainLValue(result);
3693         }
3694     };
3695
3696     // Execute the one side needed, as per the condition
3697     const auto executeOneSide = [&]() {
3698         // Always emit control flow.
3699         if (node->getBasicType() != glslang::EbtVoid) {
3700             result = builder.createVariable(TranslatePrecisionDecoration(node->getType()), spv::StorageClassFunction,
3701                 convertGlslangToSpvType(node->getType()));
3702         }
3703
3704         // Selection control:
3705         const spv::SelectionControlMask control = TranslateSelectionControl(*node);
3706
3707         // make an "if" based on the value created by the condition
3708         spv::Builder::If ifBuilder(condition, control, builder);
3709
3710         // emit the "then" statement
3711         if (node->getTrueBlock() != nullptr) {
3712             node->getTrueBlock()->traverse(this);
3713             if (result != spv::NoResult)
3714                 builder.createStore(accessChainLoad(node->getTrueBlock()->getAsTyped()->getType()), result);
3715         }
3716
3717         if (node->getFalseBlock() != nullptr) {
3718             ifBuilder.makeBeginElse();
3719             // emit the "else" statement
3720             node->getFalseBlock()->traverse(this);
3721             if (result != spv::NoResult)
3722                 builder.createStore(accessChainLoad(node->getFalseBlock()->getAsTyped()->getType()), result);
3723         }
3724
3725         // finish off the control flow
3726         ifBuilder.makeEndIf();
3727
3728         if (result != spv::NoResult) {
3729             builder.clearAccessChain();
3730             builder.setAccessChainLValue(result);
3731         }
3732     };
3733
3734     // Try for OpSelect (or a requirement to execute both sides)
3735     if (bothSidesPolicy()) {
3736         SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder);
3737         if (node->getType().getQualifier().isSpecConstant())
3738             spec_constant_op_mode_setter.turnOnSpecConstantOpMode();
3739         executeBothSides();
3740     } else
3741         executeOneSide();
3742
3743     return false;
3744 }
3745
3746 bool TGlslangToSpvTraverser::visitSwitch(glslang::TVisit /* visit */, glslang::TIntermSwitch* node)
3747 {
3748     // emit and get the condition before doing anything with switch
3749     node->getCondition()->traverse(this);
3750     spv::Id selector = accessChainLoad(node->getCondition()->getAsTyped()->getType());
3751
3752     // Selection control:
3753     const spv::SelectionControlMask control = TranslateSwitchControl(*node);
3754
3755     // browse the children to sort out code segments
3756     int defaultSegment = -1;
3757     std::vector<TIntermNode*> codeSegments;
3758     glslang::TIntermSequence& sequence = node->getBody()->getSequence();
3759     std::vector<int> caseValues;
3760     std::vector<int> valueIndexToSegment(sequence.size());  // note: probably not all are used, it is an overestimate
3761     for (glslang::TIntermSequence::iterator c = sequence.begin(); c != sequence.end(); ++c) {
3762         TIntermNode* child = *c;
3763         if (child->getAsBranchNode() && child->getAsBranchNode()->getFlowOp() == glslang::EOpDefault)
3764             defaultSegment = (int)codeSegments.size();
3765         else if (child->getAsBranchNode() && child->getAsBranchNode()->getFlowOp() == glslang::EOpCase) {
3766             valueIndexToSegment[caseValues.size()] = (int)codeSegments.size();
3767             caseValues.push_back(child->getAsBranchNode()->getExpression()->getAsConstantUnion()
3768                 ->getConstArray()[0].getIConst());
3769         } else
3770             codeSegments.push_back(child);
3771     }
3772
3773     // handle the case where the last code segment is missing, due to no code
3774     // statements between the last case and the end of the switch statement
3775     if ((caseValues.size() && (int)codeSegments.size() == valueIndexToSegment[caseValues.size() - 1]) ||
3776         (int)codeSegments.size() == defaultSegment)
3777         codeSegments.push_back(nullptr);
3778
3779     // make the switch statement
3780     std::vector<spv::Block*> segmentBlocks; // returned, as the blocks allocated in the call
3781     builder.makeSwitch(selector, control, (int)codeSegments.size(), caseValues, valueIndexToSegment, defaultSegment,
3782         segmentBlocks);
3783
3784     // emit all the code in the segments
3785     breakForLoop.push(false);
3786     for (unsigned int s = 0; s < codeSegments.size(); ++s) {
3787         builder.nextSwitchSegment(segmentBlocks, s);
3788         if (codeSegments[s])
3789             codeSegments[s]->traverse(this);
3790         else
3791             builder.addSwitchBreak();
3792     }
3793     breakForLoop.pop();
3794
3795     builder.endSwitch(segmentBlocks);
3796
3797     return false;
3798 }
3799
3800 void TGlslangToSpvTraverser::visitConstantUnion(glslang::TIntermConstantUnion* node)
3801 {
3802 #ifndef GLSLANG_WEB
3803     if (node->getQualifier().isSpirvLiteral())
3804         return; // Translated to a literal value, skip further processing
3805 #endif
3806
3807     int nextConst = 0;
3808     spv::Id constant = createSpvConstantFromConstUnionArray(node->getType(), node->getConstArray(), nextConst, false);
3809
3810     builder.clearAccessChain();
3811     builder.setAccessChainRValue(constant);
3812 }
3813
3814 bool TGlslangToSpvTraverser::visitLoop(glslang::TVisit /* visit */, glslang::TIntermLoop* node)
3815 {
3816     auto blocks = builder.makeNewLoop();
3817     builder.createBranch(&blocks.head);
3818
3819     // Loop control:
3820     std::vector<unsigned int> operands;
3821     const spv::LoopControlMask control = TranslateLoopControl(*node, operands);
3822
3823     // Spec requires back edges to target header blocks, and every header block
3824     // must dominate its merge block.  Make a header block first to ensure these
3825     // conditions are met.  By definition, it will contain OpLoopMerge, followed
3826     // by a block-ending branch.  But we don't want to put any other body/test
3827     // instructions in it, since the body/test may have arbitrary instructions,
3828     // including merges of its own.
3829     builder.setLine(node->getLoc().line, node->getLoc().getFilename());
3830     builder.setBuildPoint(&blocks.head);
3831     builder.createLoopMerge(&blocks.merge, &blocks.continue_target, control, operands);
3832     if (node->testFirst() && node->getTest()) {
3833         spv::Block& test = builder.makeNewBlock();
3834         builder.createBranch(&test);
3835
3836         builder.setBuildPoint(&test);
3837         node->getTest()->traverse(this);
3838         spv::Id condition = accessChainLoad(node->getTest()->getType());
3839         builder.createConditionalBranch(condition, &blocks.body, &blocks.merge);
3840
3841         builder.setBuildPoint(&blocks.body);
3842         breakForLoop.push(true);
3843         if (node->getBody())
3844             node->getBody()->traverse(this);
3845         builder.createBranch(&blocks.continue_target);
3846         breakForLoop.pop();
3847
3848         builder.setBuildPoint(&blocks.continue_target);
3849         if (node->getTerminal())
3850             node->getTerminal()->traverse(this);
3851         builder.createBranch(&blocks.head);
3852     } else {
3853         builder.setLine(node->getLoc().line, node->getLoc().getFilename());
3854         builder.createBranch(&blocks.body);
3855
3856         breakForLoop.push(true);
3857         builder.setBuildPoint(&blocks.body);
3858         if (node->getBody())
3859             node->getBody()->traverse(this);
3860         builder.createBranch(&blocks.continue_target);
3861         breakForLoop.pop();
3862
3863         builder.setBuildPoint(&blocks.continue_target);
3864         if (node->getTerminal())
3865             node->getTerminal()->traverse(this);
3866         if (node->getTest()) {
3867             node->getTest()->traverse(this);
3868             spv::Id condition =
3869                 accessChainLoad(node->getTest()->getType());
3870             builder.createConditionalBranch(condition, &blocks.head, &blocks.merge);
3871         } else {
3872             // TODO: unless there was a break/return/discard instruction
3873             // somewhere in the body, this is an infinite loop, so we should
3874             // issue a warning.
3875             builder.createBranch(&blocks.head);
3876         }
3877     }
3878     builder.setBuildPoint(&blocks.merge);
3879     builder.closeLoop();
3880     return false;
3881 }
3882
3883 bool TGlslangToSpvTraverser::visitBranch(glslang::TVisit /* visit */, glslang::TIntermBranch* node)
3884 {
3885     if (node->getExpression())
3886         node->getExpression()->traverse(this);
3887
3888     builder.setLine(node->getLoc().line, node->getLoc().getFilename());
3889
3890     switch (node->getFlowOp()) {
3891     case glslang::EOpKill:
3892         if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
3893             if (glslangIntermediate->getSource() == glslang::EShSourceHlsl) {
3894               builder.addCapability(spv::CapabilityDemoteToHelperInvocation);
3895               builder.createNoResultOp(spv::OpDemoteToHelperInvocationEXT);
3896             } else {
3897                 builder.makeStatementTerminator(spv::OpTerminateInvocation, "post-terminate-invocation");
3898             }
3899         } else {
3900             builder.makeStatementTerminator(spv::OpKill, "post-discard");
3901         }
3902         break;
3903     case glslang::EOpTerminateInvocation:
3904         builder.addExtension(spv::E_SPV_KHR_terminate_invocation);
3905         builder.makeStatementTerminator(spv::OpTerminateInvocation, "post-terminate-invocation");
3906         break;
3907     case glslang::EOpBreak:
3908         if (breakForLoop.top())
3909             builder.createLoopExit();
3910         else
3911             builder.addSwitchBreak();
3912         break;
3913     case glslang::EOpContinue:
3914         builder.createLoopContinue();
3915         break;
3916     case glslang::EOpReturn:
3917         if (node->getExpression() != nullptr) {
3918             const glslang::TType& glslangReturnType = node->getExpression()->getType();
3919             spv::Id returnId = accessChainLoad(glslangReturnType);
3920             if (builder.getTypeId(returnId) != currentFunction->getReturnType() ||
3921                 TranslatePrecisionDecoration(glslangReturnType) != currentFunction->getReturnPrecision()) {
3922                 builder.clearAccessChain();
3923                 spv::Id copyId = builder.createVariable(currentFunction->getReturnPrecision(),
3924                     spv::StorageClassFunction, currentFunction->getReturnType());
3925                 builder.setAccessChainLValue(copyId);
3926                 multiTypeStore(glslangReturnType, returnId);
3927                 returnId = builder.createLoad(copyId, currentFunction->getReturnPrecision());
3928             }
3929             builder.makeReturn(false, returnId);
3930         } else
3931             builder.makeReturn(false);
3932
3933         builder.clearAccessChain();
3934         break;
3935
3936 #ifndef GLSLANG_WEB
3937     case glslang::EOpDemote:
3938         builder.createNoResultOp(spv::OpDemoteToHelperInvocationEXT);
3939         builder.addExtension(spv::E_SPV_EXT_demote_to_helper_invocation);
3940         builder.addCapability(spv::CapabilityDemoteToHelperInvocationEXT);
3941         break;
3942     case glslang::EOpTerminateRayKHR:
3943         builder.makeStatementTerminator(spv::OpTerminateRayKHR, "post-terminateRayKHR");
3944         break;
3945     case glslang::EOpIgnoreIntersectionKHR:
3946         builder.makeStatementTerminator(spv::OpIgnoreIntersectionKHR, "post-ignoreIntersectionKHR");
3947         break;
3948 #endif
3949
3950     default:
3951         assert(0);
3952         break;
3953     }
3954
3955     return false;
3956 }
3957
3958 spv::Id TGlslangToSpvTraverser::createSpvVariable(const glslang::TIntermSymbol* node, spv::Id forcedType)
3959 {
3960     // First, steer off constants, which are not SPIR-V variables, but
3961     // can still have a mapping to a SPIR-V Id.
3962     // This includes specialization constants.
3963     if (node->getQualifier().isConstant()) {
3964         spv::Id result = createSpvConstant(*node);
3965         if (result != spv::NoResult)
3966             return result;
3967     }
3968
3969     // Now, handle actual variables
3970     spv::StorageClass storageClass = TranslateStorageClass(node->getType());
3971     spv::Id spvType = forcedType == spv::NoType ? convertGlslangToSpvType(node->getType())
3972                                                 : forcedType;
3973
3974     const bool contains16BitType = node->getType().contains16BitFloat() ||
3975                                    node->getType().contains16BitInt();
3976     if (contains16BitType) {
3977         switch (storageClass) {
3978         case spv::StorageClassInput:
3979         case spv::StorageClassOutput:
3980             builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3);
3981             builder.addCapability(spv::CapabilityStorageInputOutput16);
3982             break;
3983         case spv::StorageClassUniform:
3984             builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3);
3985             if (node->getType().getQualifier().storage == glslang::EvqBuffer)
3986                 builder.addCapability(spv::CapabilityStorageUniformBufferBlock16);
3987             else
3988                 builder.addCapability(spv::CapabilityStorageUniform16);
3989             break;
3990 #ifndef GLSLANG_WEB
3991         case spv::StorageClassPushConstant:
3992             builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3);
3993             builder.addCapability(spv::CapabilityStoragePushConstant16);
3994             break;
3995         case spv::StorageClassStorageBuffer:
3996         case spv::StorageClassPhysicalStorageBufferEXT:
3997             builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3);
3998             builder.addCapability(spv::CapabilityStorageUniformBufferBlock16);
3999             break;
4000 #endif
4001         default:
4002             if (storageClass == spv::StorageClassWorkgroup &&
4003                 node->getType().getBasicType() == glslang::EbtBlock) {
4004                 builder.addCapability(spv::CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR);
4005                 break;
4006             }
4007             if (node->getType().contains16BitFloat())
4008                 builder.addCapability(spv::CapabilityFloat16);
4009             if (node->getType().contains16BitInt())
4010                 builder.addCapability(spv::CapabilityInt16);
4011             break;
4012         }
4013     }
4014
4015     if (node->getType().contains8BitInt()) {
4016         if (storageClass == spv::StorageClassPushConstant) {
4017             builder.addIncorporatedExtension(spv::E_SPV_KHR_8bit_storage, spv::Spv_1_5);
4018             builder.addCapability(spv::CapabilityStoragePushConstant8);
4019         } else if (storageClass == spv::StorageClassUniform) {
4020             builder.addIncorporatedExtension(spv::E_SPV_KHR_8bit_storage, spv::Spv_1_5);
4021             builder.addCapability(spv::CapabilityUniformAndStorageBuffer8BitAccess);
4022         } else if (storageClass == spv::StorageClassStorageBuffer) {
4023             builder.addIncorporatedExtension(spv::E_SPV_KHR_8bit_storage, spv::Spv_1_5);
4024             builder.addCapability(spv::CapabilityStorageBuffer8BitAccess);
4025         } else if (storageClass == spv::StorageClassWorkgroup &&
4026                    node->getType().getBasicType() == glslang::EbtBlock) {
4027             builder.addCapability(spv::CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR);
4028         } else {
4029             builder.addCapability(spv::CapabilityInt8);
4030         }
4031     }
4032
4033     const char* name = node->getName().c_str();
4034     if (glslang::IsAnonymous(name))
4035         name = "";
4036
4037     spv::Id initializer = spv::NoResult;
4038
4039     if (node->getType().getQualifier().storage == glslang::EvqUniform && !node->getConstArray().empty()) {
4040         int nextConst = 0;
4041         initializer = createSpvConstantFromConstUnionArray(node->getType(),
4042                                                            node->getConstArray(),
4043                                                            nextConst,
4044                                                            false /* specConst */);
4045     } else if (node->getType().getQualifier().isNullInit()) {
4046         initializer = builder.makeNullConstant(spvType);
4047     }
4048
4049     return builder.createVariable(spv::NoPrecision, storageClass, spvType, name, initializer);
4050 }
4051
4052 // Return type Id of the sampled type.
4053 spv::Id TGlslangToSpvTraverser::getSampledType(const glslang::TSampler& sampler)
4054 {
4055     switch (sampler.type) {
4056         case glslang::EbtInt:      return builder.makeIntType(32);
4057         case glslang::EbtUint:     return builder.makeUintType(32);
4058         case glslang::EbtFloat:    return builder.makeFloatType(32);
4059 #ifndef GLSLANG_WEB
4060         case glslang::EbtFloat16:
4061             builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float_fetch);
4062             builder.addCapability(spv::CapabilityFloat16ImageAMD);
4063             return builder.makeFloatType(16);
4064         case glslang::EbtInt64:
4065             builder.addExtension(spv::E_SPV_EXT_shader_image_int64);
4066             builder.addCapability(spv::CapabilityInt64ImageEXT);
4067             return builder.makeIntType(64);
4068         case glslang::EbtUint64:
4069             builder.addExtension(spv::E_SPV_EXT_shader_image_int64);
4070             builder.addCapability(spv::CapabilityInt64ImageEXT);
4071             return builder.makeUintType(64);
4072 #endif
4073         default:
4074             assert(0);
4075             return builder.makeFloatType(32);
4076     }
4077 }
4078
4079 // If node is a swizzle operation, return the type that should be used if
4080 // the swizzle base is first consumed by another operation, before the swizzle
4081 // is applied.
4082 spv::Id TGlslangToSpvTraverser::getInvertedSwizzleType(const glslang::TIntermTyped& node)
4083 {
4084     if (node.getAsOperator() &&
4085         node.getAsOperator()->getOp() == glslang::EOpVectorSwizzle)
4086         return convertGlslangToSpvType(node.getAsBinaryNode()->getLeft()->getType());
4087     else
4088         return spv::NoType;
4089 }
4090
4091 // When inverting a swizzle with a parent op, this function
4092 // will apply the swizzle operation to a completed parent operation.
4093 spv::Id TGlslangToSpvTraverser::createInvertedSwizzle(spv::Decoration precision, const glslang::TIntermTyped& node,
4094     spv::Id parentResult)
4095 {
4096     std::vector<unsigned> swizzle;
4097     convertSwizzle(*node.getAsBinaryNode()->getRight()->getAsAggregate(), swizzle);
4098     return builder.createRvalueSwizzle(precision, convertGlslangToSpvType(node.getType()), parentResult, swizzle);
4099 }
4100
4101 // Convert a glslang AST swizzle node to a swizzle vector for building SPIR-V.
4102 void TGlslangToSpvTraverser::convertSwizzle(const glslang::TIntermAggregate& node, std::vector<unsigned>& swizzle)
4103 {
4104     const glslang::TIntermSequence& swizzleSequence = node.getSequence();
4105     for (int i = 0; i < (int)swizzleSequence.size(); ++i)
4106         swizzle.push_back(swizzleSequence[i]->getAsConstantUnion()->getConstArray()[0].getIConst());
4107 }
4108
4109 // Convert from a glslang type to an SPV type, by calling into a
4110 // recursive version of this function. This establishes the inherited
4111 // layout state rooted from the top-level type.
4112 spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& type, bool forwardReferenceOnly)
4113 {
4114     return convertGlslangToSpvType(type, getExplicitLayout(type), type.getQualifier(), false, forwardReferenceOnly);
4115 }
4116
4117 // Do full recursive conversion of an arbitrary glslang type to a SPIR-V Id.
4118 // explicitLayout can be kept the same throughout the hierarchical recursive walk.
4119 // Mutually recursive with convertGlslangStructToSpvType().
4120 spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& type,
4121     glslang::TLayoutPacking explicitLayout, const glslang::TQualifier& qualifier,
4122     bool lastBufferBlockMember, bool forwardReferenceOnly)
4123 {
4124     spv::Id spvType = spv::NoResult;
4125
4126     switch (type.getBasicType()) {
4127     case glslang::EbtVoid:
4128         spvType = builder.makeVoidType();
4129         assert (! type.isArray());
4130         break;
4131     case glslang::EbtBool:
4132         // "transparent" bool doesn't exist in SPIR-V.  The GLSL convention is
4133         // a 32-bit int where non-0 means true.
4134         if (explicitLayout != glslang::ElpNone)
4135             spvType = builder.makeUintType(32);
4136         else
4137             spvType = builder.makeBoolType();
4138         break;
4139     case glslang::EbtInt:
4140         spvType = builder.makeIntType(32);
4141         break;
4142     case glslang::EbtUint:
4143         spvType = builder.makeUintType(32);
4144         break;
4145     case glslang::EbtFloat:
4146         spvType = builder.makeFloatType(32);
4147         break;
4148 #ifndef GLSLANG_WEB
4149     case glslang::EbtDouble:
4150         spvType = builder.makeFloatType(64);
4151         break;
4152     case glslang::EbtFloat16:
4153         spvType = builder.makeFloatType(16);
4154         break;
4155     case glslang::EbtInt8:
4156         spvType = builder.makeIntType(8);
4157         break;
4158     case glslang::EbtUint8:
4159         spvType = builder.makeUintType(8);
4160         break;
4161     case glslang::EbtInt16:
4162         spvType = builder.makeIntType(16);
4163         break;
4164     case glslang::EbtUint16:
4165         spvType = builder.makeUintType(16);
4166         break;
4167     case glslang::EbtInt64:
4168         spvType = builder.makeIntType(64);
4169         break;
4170     case glslang::EbtUint64:
4171         spvType = builder.makeUintType(64);
4172         break;
4173     case glslang::EbtAtomicUint:
4174         builder.addCapability(spv::CapabilityAtomicStorage);
4175         spvType = builder.makeUintType(32);
4176         break;
4177     case glslang::EbtAccStruct:
4178         switch (glslangIntermediate->getStage()) {
4179         case EShLangRayGen:
4180         case EShLangIntersect:
4181         case EShLangAnyHit:
4182         case EShLangClosestHit:
4183         case EShLangMiss:
4184         case EShLangCallable:
4185             // these all should have the RayTracingNV/KHR capability already
4186             break;
4187         default:
4188             {
4189                 auto& extensions = glslangIntermediate->getRequestedExtensions();
4190                 if (extensions.find("GL_EXT_ray_query") != extensions.end()) {
4191                     builder.addExtension(spv::E_SPV_KHR_ray_query);
4192                     builder.addCapability(spv::CapabilityRayQueryKHR);
4193                 }
4194             }
4195             break;
4196         }
4197         spvType = builder.makeAccelerationStructureType();
4198         break;
4199     case glslang::EbtRayQuery:
4200         {
4201             auto& extensions = glslangIntermediate->getRequestedExtensions();
4202             if (extensions.find("GL_EXT_ray_query") != extensions.end()) {
4203                 builder.addExtension(spv::E_SPV_KHR_ray_query);
4204                 builder.addCapability(spv::CapabilityRayQueryKHR);
4205             }
4206             spvType = builder.makeRayQueryType();
4207         }
4208         break;
4209     case glslang::EbtReference:
4210         {
4211             // Make the forward pointer, then recurse to convert the structure type, then
4212             // patch up the forward pointer with a real pointer type.
4213             if (forwardPointers.find(type.getReferentType()) == forwardPointers.end()) {
4214                 spv::Id forwardId = builder.makeForwardPointer(spv::StorageClassPhysicalStorageBufferEXT);
4215                 forwardPointers[type.getReferentType()] = forwardId;
4216             }
4217             spvType = forwardPointers[type.getReferentType()];
4218             if (!forwardReferenceOnly) {
4219                 spv::Id referentType = convertGlslangToSpvType(*type.getReferentType());
4220                 builder.makePointerFromForwardPointer(spv::StorageClassPhysicalStorageBufferEXT,
4221                                                       forwardPointers[type.getReferentType()],
4222                                                       referentType);
4223             }
4224         }
4225         break;
4226 #endif
4227     case glslang::EbtSampler:
4228         {
4229             const glslang::TSampler& sampler = type.getSampler();
4230             if (sampler.isPureSampler()) {
4231                 spvType = builder.makeSamplerType();
4232             } else {
4233                 // an image is present, make its type
4234                 spvType = builder.makeImageType(getSampledType(sampler), TranslateDimensionality(sampler),
4235                                                 sampler.isShadow(), sampler.isArrayed(), sampler.isMultiSample(),
4236                                                 sampler.isImageClass() ? 2 : 1, TranslateImageFormat(type));
4237                 if (sampler.isCombined() &&
4238                     (!sampler.isBuffer() || glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_6)) {
4239                     // Already has both image and sampler, make the combined type. Only combine sampler to
4240                     // buffer if before SPIR-V 1.6.
4241                     spvType = builder.makeSampledImageType(spvType);
4242                 }
4243             }
4244         }
4245         break;
4246     case glslang::EbtStruct:
4247     case glslang::EbtBlock:
4248         {
4249             // If we've seen this struct type, return it
4250             const glslang::TTypeList* glslangMembers = type.getStruct();
4251
4252             // Try to share structs for different layouts, but not yet for other
4253             // kinds of qualification (primarily not yet including interpolant qualification).
4254             if (! HasNonLayoutQualifiers(type, qualifier))
4255                 spvType = structMap[explicitLayout][qualifier.layoutMatrix][glslangMembers];
4256             if (spvType != spv::NoResult)
4257                 break;
4258
4259             // else, we haven't seen it...
4260             if (type.getBasicType() == glslang::EbtBlock)
4261                 memberRemapper[glslangTypeToIdMap[glslangMembers]].resize(glslangMembers->size());
4262             spvType = convertGlslangStructToSpvType(type, glslangMembers, explicitLayout, qualifier);
4263         }
4264         break;
4265     case glslang::EbtString:
4266         // no type used for OpString
4267         return 0;
4268 #ifndef GLSLANG_WEB
4269     case glslang::EbtSpirvType: {
4270         // GL_EXT_spirv_intrinsics
4271         const auto& spirvType = type.getSpirvType();
4272         const auto& spirvInst = spirvType.spirvInst;
4273
4274         std::vector<spv::IdImmediate> operands;
4275         for (const auto& typeParam : spirvType.typeParams) {
4276             // Constant expression
4277             if (typeParam.constant->isLiteral()) {
4278                 if (typeParam.constant->getBasicType() == glslang::EbtFloat) {
4279                     float floatValue = static_cast<float>(typeParam.constant->getConstArray()[0].getDConst());
4280                     unsigned literal;
4281                     static_assert(sizeof(literal) == sizeof(floatValue), "sizeof(unsigned) != sizeof(float)");
4282                     memcpy(&literal, &floatValue, sizeof(literal));
4283                     operands.push_back({false, literal});
4284                 } else if (typeParam.constant->getBasicType() == glslang::EbtInt) {
4285                     unsigned literal = typeParam.constant->getConstArray()[0].getIConst();
4286                     operands.push_back({false, literal});
4287                 } else if (typeParam.constant->getBasicType() == glslang::EbtUint) {
4288                     unsigned literal = typeParam.constant->getConstArray()[0].getUConst();
4289                     operands.push_back({false, literal});
4290                 } else if (typeParam.constant->getBasicType() == glslang::EbtBool) {
4291                     unsigned literal = typeParam.constant->getConstArray()[0].getBConst();
4292                     operands.push_back({false, literal});
4293                 } else if (typeParam.constant->getBasicType() == glslang::EbtString) {
4294                     auto str = typeParam.constant->getConstArray()[0].getSConst()->c_str();
4295                     unsigned literal = 0;
4296                     char* literalPtr = reinterpret_cast<char*>(&literal);
4297                     unsigned charCount = 0;
4298                     char ch = 0;
4299                     do {
4300                         ch = *(str++);
4301                         *(literalPtr++) = ch;
4302                         ++charCount;
4303                         if (charCount == 4) {
4304                             operands.push_back({false, literal});
4305                             literalPtr = reinterpret_cast<char*>(&literal);
4306                             charCount = 0;
4307                         }
4308                     } while (ch != 0);
4309
4310                     // Partial literal is padded with 0
4311                     if (charCount > 0) {
4312                         for (; charCount < 4; ++charCount)
4313                             *(literalPtr++) = 0;
4314                         operands.push_back({false, literal});
4315                     }
4316                 } else
4317                     assert(0); // Unexpected type
4318             } else
4319                 operands.push_back({true, createSpvConstant(*typeParam.constant)});
4320         }
4321
4322         assert(spirvInst.set == ""); // Currently, couldn't be extended instructions.
4323         spvType = builder.makeGenericType(static_cast<spv::Op>(spirvInst.id), operands);
4324
4325         break;
4326     }
4327 #endif
4328     default:
4329         assert(0);
4330         break;
4331     }
4332
4333     if (type.isMatrix())
4334         spvType = builder.makeMatrixType(spvType, type.getMatrixCols(), type.getMatrixRows());
4335     else {
4336         // If this variable has a vector element count greater than 1, create a SPIR-V vector
4337         if (type.getVectorSize() > 1)
4338             spvType = builder.makeVectorType(spvType, type.getVectorSize());
4339     }
4340
4341     if (type.isCoopMat()) {
4342         builder.addCapability(spv::CapabilityCooperativeMatrixNV);
4343         builder.addExtension(spv::E_SPV_NV_cooperative_matrix);
4344         if (type.getBasicType() == glslang::EbtFloat16)
4345             builder.addCapability(spv::CapabilityFloat16);
4346         if (type.getBasicType() == glslang::EbtUint8 ||
4347             type.getBasicType() == glslang::EbtInt8) {
4348             builder.addCapability(spv::CapabilityInt8);
4349         }
4350
4351         spv::Id scope = makeArraySizeId(*type.getTypeParameters(), 1);
4352         spv::Id rows = makeArraySizeId(*type.getTypeParameters(), 2);
4353         spv::Id cols = makeArraySizeId(*type.getTypeParameters(), 3);
4354
4355         spvType = builder.makeCooperativeMatrixType(spvType, scope, rows, cols);
4356     }
4357
4358     if (type.isArray()) {
4359         int stride = 0;  // keep this 0 unless doing an explicit layout; 0 will mean no decoration, no stride
4360
4361         // Do all but the outer dimension
4362         if (type.getArraySizes()->getNumDims() > 1) {
4363             // We need to decorate array strides for types needing explicit layout, except blocks.
4364             if (explicitLayout != glslang::ElpNone && type.getBasicType() != glslang::EbtBlock) {
4365                 // Use a dummy glslang type for querying internal strides of
4366                 // arrays of arrays, but using just a one-dimensional array.
4367                 glslang::TType simpleArrayType(type, 0); // deference type of the array
4368                 while (simpleArrayType.getArraySizes()->getNumDims() > 1)
4369                     simpleArrayType.getArraySizes()->dereference();
4370
4371                 // Will compute the higher-order strides here, rather than making a whole
4372                 // pile of types and doing repetitive recursion on their contents.
4373                 stride = getArrayStride(simpleArrayType, explicitLayout, qualifier.layoutMatrix);
4374             }
4375
4376             // make the arrays
4377             for (int dim = type.getArraySizes()->getNumDims() - 1; dim > 0; --dim) {
4378                 spvType = builder.makeArrayType(spvType, makeArraySizeId(*type.getArraySizes(), dim), stride);
4379                 if (stride > 0)
4380                     builder.addDecoration(spvType, spv::DecorationArrayStride, stride);
4381                 stride *= type.getArraySizes()->getDimSize(dim);
4382             }
4383         } else {
4384             // single-dimensional array, and don't yet have stride
4385
4386             // We need to decorate array strides for types needing explicit layout, except blocks.
4387             if (explicitLayout != glslang::ElpNone && type.getBasicType() != glslang::EbtBlock)
4388                 stride = getArrayStride(type, explicitLayout, qualifier.layoutMatrix);
4389         }
4390
4391         // Do the outer dimension, which might not be known for a runtime-sized array.
4392         // (Unsized arrays that survive through linking will be runtime-sized arrays)
4393         if (type.isSizedArray())
4394             spvType = builder.makeArrayType(spvType, makeArraySizeId(*type.getArraySizes(), 0), stride);
4395         else {
4396 #ifndef GLSLANG_WEB
4397             if (!lastBufferBlockMember) {
4398                 builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
4399                 builder.addCapability(spv::CapabilityRuntimeDescriptorArrayEXT);
4400             }
4401 #endif
4402             spvType = builder.makeRuntimeArray(spvType);
4403         }
4404         if (stride > 0)
4405             builder.addDecoration(spvType, spv::DecorationArrayStride, stride);
4406     }
4407
4408     return spvType;
4409 }
4410
4411 // TODO: this functionality should exist at a higher level, in creating the AST
4412 //
4413 // Identify interface members that don't have their required extension turned on.
4414 //
4415 bool TGlslangToSpvTraverser::filterMember(const glslang::TType& member)
4416 {
4417 #ifndef GLSLANG_WEB
4418     auto& extensions = glslangIntermediate->getRequestedExtensions();
4419
4420     if (member.getFieldName() == "gl_SecondaryViewportMaskNV" &&
4421         extensions.find("GL_NV_stereo_view_rendering") == extensions.end())
4422         return true;
4423     if (member.getFieldName() == "gl_SecondaryPositionNV" &&
4424         extensions.find("GL_NV_stereo_view_rendering") == extensions.end())
4425         return true;
4426
4427     if (glslangIntermediate->getStage() != EShLangMesh) {
4428         if (member.getFieldName() == "gl_ViewportMask" &&
4429             extensions.find("GL_NV_viewport_array2") == extensions.end())
4430             return true;
4431         if (member.getFieldName() == "gl_PositionPerViewNV" &&
4432             extensions.find("GL_NVX_multiview_per_view_attributes") == extensions.end())
4433             return true;
4434         if (member.getFieldName() == "gl_ViewportMaskPerViewNV" &&
4435             extensions.find("GL_NVX_multiview_per_view_attributes") == extensions.end())
4436             return true;
4437     }
4438 #endif
4439
4440     return false;
4441 };
4442
4443 // Do full recursive conversion of a glslang structure (or block) type to a SPIR-V Id.
4444 // explicitLayout can be kept the same throughout the hierarchical recursive walk.
4445 // Mutually recursive with convertGlslangToSpvType().
4446 spv::Id TGlslangToSpvTraverser::convertGlslangStructToSpvType(const glslang::TType& type,
4447                                                               const glslang::TTypeList* glslangMembers,
4448                                                               glslang::TLayoutPacking explicitLayout,
4449                                                               const glslang::TQualifier& qualifier)
4450 {
4451     // Create a vector of struct types for SPIR-V to consume
4452     std::vector<spv::Id> spvMembers;
4453     int memberDelta = 0;  // how much the member's index changes from glslang to SPIR-V, normally 0,
4454                           // except sometimes for blocks
4455     std::vector<std::pair<glslang::TType*, glslang::TQualifier> > deferredForwardPointers;
4456     for (int i = 0; i < (int)glslangMembers->size(); i++) {
4457         glslang::TType& glslangMember = *(*glslangMembers)[i].type;
4458         if (glslangMember.hiddenMember()) {
4459             ++memberDelta;
4460             if (type.getBasicType() == glslang::EbtBlock)
4461                 memberRemapper[glslangTypeToIdMap[glslangMembers]][i] = -1;
4462         } else {
4463             if (type.getBasicType() == glslang::EbtBlock) {
4464                 if (filterMember(glslangMember)) {
4465                     memberDelta++;
4466                     memberRemapper[glslangTypeToIdMap[glslangMembers]][i] = -1;
4467                     continue;
4468                 }
4469                 memberRemapper[glslangTypeToIdMap[glslangMembers]][i] = i - memberDelta;
4470             }
4471             // modify just this child's view of the qualifier
4472             glslang::TQualifier memberQualifier = glslangMember.getQualifier();
4473             InheritQualifiers(memberQualifier, qualifier);
4474
4475             // manually inherit location
4476             if (! memberQualifier.hasLocation() && qualifier.hasLocation())
4477                 memberQualifier.layoutLocation = qualifier.layoutLocation;
4478
4479             // recurse
4480             bool lastBufferBlockMember = qualifier.storage == glslang::EvqBuffer &&
4481                                          i == (int)glslangMembers->size() - 1;
4482
4483             // Make forward pointers for any pointer members, and create a list of members to
4484             // convert to spirv types after creating the struct.
4485             if (glslangMember.isReference()) {
4486                 if (forwardPointers.find(glslangMember.getReferentType()) == forwardPointers.end()) {
4487                     deferredForwardPointers.push_back(std::make_pair(&glslangMember, memberQualifier));
4488                 }
4489                 spvMembers.push_back(
4490                     convertGlslangToSpvType(glslangMember, explicitLayout, memberQualifier, lastBufferBlockMember,
4491                         true));
4492             } else {
4493                 spvMembers.push_back(
4494                     convertGlslangToSpvType(glslangMember, explicitLayout, memberQualifier, lastBufferBlockMember,
4495                         false));
4496             }
4497         }
4498     }
4499
4500     // Make the SPIR-V type
4501     spv::Id spvType = builder.makeStructType(spvMembers, type.getTypeName().c_str());
4502     if (! HasNonLayoutQualifiers(type, qualifier))
4503         structMap[explicitLayout][qualifier.layoutMatrix][glslangMembers] = spvType;
4504
4505     // Decorate it
4506     decorateStructType(type, glslangMembers, explicitLayout, qualifier, spvType);
4507
4508     for (int i = 0; i < (int)deferredForwardPointers.size(); ++i) {
4509         auto it = deferredForwardPointers[i];
4510         convertGlslangToSpvType(*it.first, explicitLayout, it.second, false);
4511     }
4512
4513     return spvType;
4514 }
4515
4516 void TGlslangToSpvTraverser::decorateStructType(const glslang::TType& type,
4517                                                 const glslang::TTypeList* glslangMembers,
4518                                                 glslang::TLayoutPacking explicitLayout,
4519                                                 const glslang::TQualifier& qualifier,
4520                                                 spv::Id spvType)
4521 {
4522     // Name and decorate the non-hidden members
4523     int offset = -1;
4524     bool memberLocationInvalid = type.isArrayOfArrays() ||
4525         (type.isArray() && (type.getQualifier().isArrayedIo(glslangIntermediate->getStage()) == false));
4526     for (int i = 0; i < (int)glslangMembers->size(); i++) {
4527         glslang::TType& glslangMember = *(*glslangMembers)[i].type;
4528         int member = i;
4529         if (type.getBasicType() == glslang::EbtBlock) {
4530             member = memberRemapper[glslangTypeToIdMap[glslangMembers]][i];
4531             if (filterMember(glslangMember))
4532                 continue;
4533         }
4534
4535         // modify just this child's view of the qualifier
4536         glslang::TQualifier memberQualifier = glslangMember.getQualifier();
4537         InheritQualifiers(memberQualifier, qualifier);
4538
4539         // using -1 above to indicate a hidden member
4540         if (member < 0)
4541             continue;
4542
4543         builder.addMemberName(spvType, member, glslangMember.getFieldName().c_str());
4544         builder.addMemberDecoration(spvType, member,
4545                                     TranslateLayoutDecoration(glslangMember, memberQualifier.layoutMatrix));
4546         builder.addMemberDecoration(spvType, member, TranslatePrecisionDecoration(glslangMember));
4547         // Add interpolation and auxiliary storage decorations only to
4548         // top-level members of Input and Output storage classes
4549         if (type.getQualifier().storage == glslang::EvqVaryingIn ||
4550             type.getQualifier().storage == glslang::EvqVaryingOut) {
4551             if (type.getBasicType() == glslang::EbtBlock ||
4552                 glslangIntermediate->getSource() == glslang::EShSourceHlsl) {
4553                 builder.addMemberDecoration(spvType, member, TranslateInterpolationDecoration(memberQualifier));
4554                 builder.addMemberDecoration(spvType, member, TranslateAuxiliaryStorageDecoration(memberQualifier));
4555 #ifndef GLSLANG_WEB
4556                 addMeshNVDecoration(spvType, member, memberQualifier);
4557 #endif
4558             }
4559         }
4560         builder.addMemberDecoration(spvType, member, TranslateInvariantDecoration(memberQualifier));
4561
4562 #ifndef GLSLANG_WEB
4563         if (type.getBasicType() == glslang::EbtBlock &&
4564             qualifier.storage == glslang::EvqBuffer) {
4565             // Add memory decorations only to top-level members of shader storage block
4566             std::vector<spv::Decoration> memory;
4567             TranslateMemoryDecoration(memberQualifier, memory, glslangIntermediate->usingVulkanMemoryModel());
4568             for (unsigned int i = 0; i < memory.size(); ++i)
4569                 builder.addMemberDecoration(spvType, member, memory[i]);
4570         }
4571
4572 #endif
4573
4574         // Location assignment was already completed correctly by the front end,
4575         // just track whether a member needs to be decorated.
4576         // Ignore member locations if the container is an array, as that's
4577         // ill-specified and decisions have been made to not allow this.
4578         if (!memberLocationInvalid && memberQualifier.hasLocation())
4579             builder.addMemberDecoration(spvType, member, spv::DecorationLocation, memberQualifier.layoutLocation);
4580
4581         // component, XFB, others
4582         if (glslangMember.getQualifier().hasComponent())
4583             builder.addMemberDecoration(spvType, member, spv::DecorationComponent,
4584                                         glslangMember.getQualifier().layoutComponent);
4585         if (glslangMember.getQualifier().hasXfbOffset())
4586             builder.addMemberDecoration(spvType, member, spv::DecorationOffset,
4587                                         glslangMember.getQualifier().layoutXfbOffset);
4588         else if (explicitLayout != glslang::ElpNone) {
4589             // figure out what to do with offset, which is accumulating
4590             int nextOffset;
4591             updateMemberOffset(type, glslangMember, offset, nextOffset, explicitLayout, memberQualifier.layoutMatrix);
4592             if (offset >= 0)
4593                 builder.addMemberDecoration(spvType, member, spv::DecorationOffset, offset);
4594             offset = nextOffset;
4595         }
4596
4597         if (glslangMember.isMatrix() && explicitLayout != glslang::ElpNone)
4598             builder.addMemberDecoration(spvType, member, spv::DecorationMatrixStride,
4599                                         getMatrixStride(glslangMember, explicitLayout, memberQualifier.layoutMatrix));
4600
4601         // built-in variable decorations
4602         spv::BuiltIn builtIn = TranslateBuiltInDecoration(glslangMember.getQualifier().builtIn, true);
4603         if (builtIn != spv::BuiltInMax)
4604             builder.addMemberDecoration(spvType, member, spv::DecorationBuiltIn, (int)builtIn);
4605
4606 #ifndef GLSLANG_WEB
4607         // nonuniform
4608         builder.addMemberDecoration(spvType, member, TranslateNonUniformDecoration(glslangMember.getQualifier()));
4609
4610         if (glslangIntermediate->getHlslFunctionality1() && memberQualifier.semanticName != nullptr) {
4611             builder.addExtension("SPV_GOOGLE_hlsl_functionality1");
4612             builder.addMemberDecoration(spvType, member, (spv::Decoration)spv::DecorationHlslSemanticGOOGLE,
4613                                         memberQualifier.semanticName);
4614         }
4615
4616         if (builtIn == spv::BuiltInLayer) {
4617             // SPV_NV_viewport_array2 extension
4618             if (glslangMember.getQualifier().layoutViewportRelative){
4619                 builder.addMemberDecoration(spvType, member, (spv::Decoration)spv::DecorationViewportRelativeNV);
4620                 builder.addCapability(spv::CapabilityShaderViewportMaskNV);
4621                 builder.addExtension(spv::E_SPV_NV_viewport_array2);
4622             }
4623             if (glslangMember.getQualifier().layoutSecondaryViewportRelativeOffset != -2048){
4624                 builder.addMemberDecoration(spvType, member,
4625                                             (spv::Decoration)spv::DecorationSecondaryViewportRelativeNV,
4626                                             glslangMember.getQualifier().layoutSecondaryViewportRelativeOffset);
4627                 builder.addCapability(spv::CapabilityShaderStereoViewNV);
4628                 builder.addExtension(spv::E_SPV_NV_stereo_view_rendering);
4629             }
4630         }
4631         if (glslangMember.getQualifier().layoutPassthrough) {
4632             builder.addMemberDecoration(spvType, member, (spv::Decoration)spv::DecorationPassthroughNV);
4633             builder.addCapability(spv::CapabilityGeometryShaderPassthroughNV);
4634             builder.addExtension(spv::E_SPV_NV_geometry_shader_passthrough);
4635         }
4636
4637         //
4638         // Add SPIR-V decorations for members (GL_EXT_spirv_intrinsics)
4639         //
4640         if (glslangMember.getQualifier().hasSprivDecorate()) {
4641             const glslang::TSpirvDecorate& spirvDecorate = glslangMember.getQualifier().getSpirvDecorate();
4642
4643             // Add spirv_decorate
4644             for (auto& decorate : spirvDecorate.decorates) {
4645                 if (!decorate.second.empty()) {
4646                     std::vector<unsigned> literals;
4647                     TranslateLiterals(decorate.second, literals);
4648                     builder.addMemberDecoration(spvType, member, static_cast<spv::Decoration>(decorate.first), literals);
4649                 }
4650                 else
4651                     builder.addMemberDecoration(spvType, member, static_cast<spv::Decoration>(decorate.first));
4652             }
4653
4654             // spirv_decorate_id not applied to members
4655             assert(spirvDecorate.decorateIds.empty());
4656
4657             // Add spirv_decorate_string
4658             for (auto& decorateString : spirvDecorate.decorateStrings) {
4659                 std::vector<const char*> strings;
4660                 assert(!decorateString.second.empty());
4661                 for (auto extraOperand : decorateString.second) {
4662                     const char* string = extraOperand->getConstArray()[0].getSConst()->c_str();
4663                     strings.push_back(string);
4664                 }
4665                 builder.addDecoration(spvType, static_cast<spv::Decoration>(decorateString.first), strings);
4666             }
4667         }
4668 #endif
4669     }
4670
4671     // Decorate the structure
4672     builder.addDecoration(spvType, TranslateLayoutDecoration(type, qualifier.layoutMatrix));
4673     builder.addDecoration(spvType, TranslateBlockDecoration(type, glslangIntermediate->usingStorageBuffer()));
4674 }
4675
4676 // Turn the expression forming the array size into an id.
4677 // This is not quite trivial, because of specialization constants.
4678 // Sometimes, a raw constant is turned into an Id, and sometimes
4679 // a specialization constant expression is.
4680 spv::Id TGlslangToSpvTraverser::makeArraySizeId(const glslang::TArraySizes& arraySizes, int dim)
4681 {
4682     // First, see if this is sized with a node, meaning a specialization constant:
4683     glslang::TIntermTyped* specNode = arraySizes.getDimNode(dim);
4684     if (specNode != nullptr) {
4685         builder.clearAccessChain();
4686         SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder);
4687         spec_constant_op_mode_setter.turnOnSpecConstantOpMode();
4688         specNode->traverse(this);
4689         return accessChainLoad(specNode->getAsTyped()->getType());
4690     }
4691
4692     // Otherwise, need a compile-time (front end) size, get it:
4693     int size = arraySizes.getDimSize(dim);
4694     assert(size > 0);
4695     return builder.makeUintConstant(size);
4696 }
4697
4698 // Wrap the builder's accessChainLoad to:
4699 //  - localize handling of RelaxedPrecision
4700 //  - use the SPIR-V inferred type instead of another conversion of the glslang type
4701 //    (avoids unnecessary work and possible type punning for structures)
4702 //  - do conversion of concrete to abstract type
4703 spv::Id TGlslangToSpvTraverser::accessChainLoad(const glslang::TType& type)
4704 {
4705     spv::Id nominalTypeId = builder.accessChainGetInferredType();
4706
4707     spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags;
4708     coherentFlags |= TranslateCoherent(type);
4709
4710     unsigned int alignment = builder.getAccessChain().alignment;
4711     alignment |= type.getBufferReferenceAlignment();
4712
4713     spv::Id loadedId = builder.accessChainLoad(TranslatePrecisionDecoration(type),
4714         TranslateNonUniformDecoration(builder.getAccessChain().coherentFlags),
4715         TranslateNonUniformDecoration(type.getQualifier()),
4716         nominalTypeId,
4717         spv::MemoryAccessMask(TranslateMemoryAccess(coherentFlags) & ~spv::MemoryAccessMakePointerAvailableKHRMask),
4718         TranslateMemoryScope(coherentFlags),
4719         alignment);
4720
4721     // Need to convert to abstract types when necessary
4722     if (type.getBasicType() == glslang::EbtBool) {
4723         loadedId = convertLoadedBoolInUniformToUint(type, nominalTypeId, loadedId);
4724     }
4725
4726     return loadedId;
4727 }
4728
4729 // Wrap the builder's accessChainStore to:
4730 //  - do conversion of concrete to abstract type
4731 //
4732 // Implicitly uses the existing builder.accessChain as the storage target.
4733 void TGlslangToSpvTraverser::accessChainStore(const glslang::TType& type, spv::Id rvalue)
4734 {
4735     // Need to convert to abstract types when necessary
4736     if (type.getBasicType() == glslang::EbtBool) {
4737         spv::Id nominalTypeId = builder.accessChainGetInferredType();
4738
4739         if (builder.isScalarType(nominalTypeId)) {
4740             // Conversion for bool
4741             spv::Id boolType = builder.makeBoolType();
4742             if (nominalTypeId != boolType) {
4743                 // keep these outside arguments, for determinant order-of-evaluation
4744                 spv::Id one = builder.makeUintConstant(1);
4745                 spv::Id zero = builder.makeUintConstant(0);
4746                 rvalue = builder.createTriOp(spv::OpSelect, nominalTypeId, rvalue, one, zero);
4747             } else if (builder.getTypeId(rvalue) != boolType)
4748                 rvalue = builder.createBinOp(spv::OpINotEqual, boolType, rvalue, builder.makeUintConstant(0));
4749         } else if (builder.isVectorType(nominalTypeId)) {
4750             // Conversion for bvec
4751             int vecSize = builder.getNumTypeComponents(nominalTypeId);
4752             spv::Id bvecType = builder.makeVectorType(builder.makeBoolType(), vecSize);
4753             if (nominalTypeId != bvecType) {
4754                 // keep these outside arguments, for determinant order-of-evaluation
4755                 spv::Id one = makeSmearedConstant(builder.makeUintConstant(1), vecSize);
4756                 spv::Id zero = makeSmearedConstant(builder.makeUintConstant(0), vecSize);
4757                 rvalue = builder.createTriOp(spv::OpSelect, nominalTypeId, rvalue, one, zero);
4758             } else if (builder.getTypeId(rvalue) != bvecType)
4759                 rvalue = builder.createBinOp(spv::OpINotEqual, bvecType, rvalue,
4760                                              makeSmearedConstant(builder.makeUintConstant(0), vecSize));
4761         }
4762     }
4763
4764     spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags;
4765     coherentFlags |= TranslateCoherent(type);
4766
4767     unsigned int alignment = builder.getAccessChain().alignment;
4768     alignment |= type.getBufferReferenceAlignment();
4769
4770     builder.accessChainStore(rvalue, TranslateNonUniformDecoration(builder.getAccessChain().coherentFlags),
4771                              spv::MemoryAccessMask(TranslateMemoryAccess(coherentFlags) &
4772                                 ~spv::MemoryAccessMakePointerVisibleKHRMask),
4773                              TranslateMemoryScope(coherentFlags), alignment);
4774 }
4775
4776 // For storing when types match at the glslang level, but not might match at the
4777 // SPIR-V level.
4778 //
4779 // This especially happens when a single glslang type expands to multiple
4780 // SPIR-V types, like a struct that is used in a member-undecorated way as well
4781 // as in a member-decorated way.
4782 //
4783 // NOTE: This function can handle any store request; if it's not special it
4784 // simplifies to a simple OpStore.
4785 //
4786 // Implicitly uses the existing builder.accessChain as the storage target.
4787 void TGlslangToSpvTraverser::multiTypeStore(const glslang::TType& type, spv::Id rValue)
4788 {
4789     // we only do the complex path here if it's an aggregate
4790     if (! type.isStruct() && ! type.isArray()) {
4791         accessChainStore(type, rValue);
4792         return;
4793     }
4794
4795     // and, it has to be a case of type aliasing
4796     spv::Id rType = builder.getTypeId(rValue);
4797     spv::Id lValue = builder.accessChainGetLValue();
4798     spv::Id lType = builder.getContainedTypeId(builder.getTypeId(lValue));
4799     if (lType == rType) {
4800         accessChainStore(type, rValue);
4801         return;
4802     }
4803
4804     // Recursively (as needed) copy an aggregate type to a different aggregate type,
4805     // where the two types were the same type in GLSL. This requires member
4806     // by member copy, recursively.
4807
4808     // SPIR-V 1.4 added an instruction to do help do this.
4809     if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4) {
4810         // However, bool in uniform space is changed to int, so
4811         // OpCopyLogical does not work for that.
4812         // TODO: It would be more robust to do a full recursive verification of the types satisfying SPIR-V rules.
4813         bool rBool = builder.containsType(builder.getTypeId(rValue), spv::OpTypeBool, 0);
4814         bool lBool = builder.containsType(lType, spv::OpTypeBool, 0);
4815         if (lBool == rBool) {
4816             spv::Id logicalCopy = builder.createUnaryOp(spv::OpCopyLogical, lType, rValue);
4817             accessChainStore(type, logicalCopy);
4818             return;
4819         }
4820     }
4821
4822     // If an array, copy element by element.
4823     if (type.isArray()) {
4824         glslang::TType glslangElementType(type, 0);
4825         spv::Id elementRType = builder.getContainedTypeId(rType);
4826         for (int index = 0; index < type.getOuterArraySize(); ++index) {
4827             // get the source member
4828             spv::Id elementRValue = builder.createCompositeExtract(rValue, elementRType, index);
4829
4830             // set up the target storage
4831             builder.clearAccessChain();
4832             builder.setAccessChainLValue(lValue);
4833             builder.accessChainPush(builder.makeIntConstant(index), TranslateCoherent(type),
4834                 type.getBufferReferenceAlignment());
4835
4836             // store the member
4837             multiTypeStore(glslangElementType, elementRValue);
4838         }
4839     } else {
4840         assert(type.isStruct());
4841
4842         // loop over structure members
4843         const glslang::TTypeList& members = *type.getStruct();
4844         for (int m = 0; m < (int)members.size(); ++m) {
4845             const glslang::TType& glslangMemberType = *members[m].type;
4846
4847             // get the source member
4848             spv::Id memberRType = builder.getContainedTypeId(rType, m);
4849             spv::Id memberRValue = builder.createCompositeExtract(rValue, memberRType, m);
4850
4851             // set up the target storage
4852             builder.clearAccessChain();
4853             builder.setAccessChainLValue(lValue);
4854             builder.accessChainPush(builder.makeIntConstant(m), TranslateCoherent(type),
4855                 type.getBufferReferenceAlignment());
4856
4857             // store the member
4858             multiTypeStore(glslangMemberType, memberRValue);
4859         }
4860     }
4861 }
4862
4863 // Decide whether or not this type should be
4864 // decorated with offsets and strides, and if so
4865 // whether std140 or std430 rules should be applied.
4866 glslang::TLayoutPacking TGlslangToSpvTraverser::getExplicitLayout(const glslang::TType& type) const
4867 {
4868     // has to be a block
4869     if (type.getBasicType() != glslang::EbtBlock)
4870         return glslang::ElpNone;
4871
4872     // has to be a uniform or buffer block or task in/out blocks
4873     if (type.getQualifier().storage != glslang::EvqUniform &&
4874         type.getQualifier().storage != glslang::EvqBuffer &&
4875         type.getQualifier().storage != glslang::EvqShared &&
4876         !type.getQualifier().isTaskMemory())
4877         return glslang::ElpNone;
4878
4879     // return the layout to use
4880     switch (type.getQualifier().layoutPacking) {
4881     case glslang::ElpStd140:
4882     case glslang::ElpStd430:
4883     case glslang::ElpScalar:
4884         return type.getQualifier().layoutPacking;
4885     default:
4886         return glslang::ElpNone;
4887     }
4888 }
4889
4890 // Given an array type, returns the integer stride required for that array
4891 int TGlslangToSpvTraverser::getArrayStride(const glslang::TType& arrayType, glslang::TLayoutPacking explicitLayout,
4892     glslang::TLayoutMatrix matrixLayout)
4893 {
4894     int size;
4895     int stride;
4896     glslangIntermediate->getMemberAlignment(arrayType, size, stride, explicitLayout,
4897         matrixLayout == glslang::ElmRowMajor);
4898
4899     return stride;
4900 }
4901
4902 // Given a matrix type, or array (of array) of matrixes type, returns the integer stride required for that matrix
4903 // when used as a member of an interface block
4904 int TGlslangToSpvTraverser::getMatrixStride(const glslang::TType& matrixType, glslang::TLayoutPacking explicitLayout,
4905     glslang::TLayoutMatrix matrixLayout)
4906 {
4907     glslang::TType elementType;
4908     elementType.shallowCopy(matrixType);
4909     elementType.clearArraySizes();
4910
4911     int size;
4912     int stride;
4913     glslangIntermediate->getMemberAlignment(elementType, size, stride, explicitLayout,
4914         matrixLayout == glslang::ElmRowMajor);
4915
4916     return stride;
4917 }
4918
4919 // Given a member type of a struct, realign the current offset for it, and compute
4920 // the next (not yet aligned) offset for the next member, which will get aligned
4921 // on the next call.
4922 // 'currentOffset' should be passed in already initialized, ready to modify, and reflecting
4923 // the migration of data from nextOffset -> currentOffset.  It should be -1 on the first call.
4924 // -1 means a non-forced member offset (no decoration needed).
4925 void TGlslangToSpvTraverser::updateMemberOffset(const glslang::TType& structType, const glslang::TType& memberType,
4926     int& currentOffset, int& nextOffset, glslang::TLayoutPacking explicitLayout, glslang::TLayoutMatrix matrixLayout)
4927 {
4928     // this will get a positive value when deemed necessary
4929     nextOffset = -1;
4930
4931     // override anything in currentOffset with user-set offset
4932     if (memberType.getQualifier().hasOffset())
4933         currentOffset = memberType.getQualifier().layoutOffset;
4934
4935     // It could be that current linker usage in glslang updated all the layoutOffset,
4936     // in which case the following code does not matter.  But, that's not quite right
4937     // once cross-compilation unit GLSL validation is done, as the original user
4938     // settings are needed in layoutOffset, and then the following will come into play.
4939
4940     if (explicitLayout == glslang::ElpNone) {
4941         if (! memberType.getQualifier().hasOffset())
4942             currentOffset = -1;
4943
4944         return;
4945     }
4946
4947     // Getting this far means we need explicit offsets
4948     if (currentOffset < 0)
4949         currentOffset = 0;
4950
4951     // Now, currentOffset is valid (either 0, or from a previous nextOffset),
4952     // but possibly not yet correctly aligned.
4953
4954     int memberSize;
4955     int dummyStride;
4956     int memberAlignment = glslangIntermediate->getMemberAlignment(memberType, memberSize, dummyStride, explicitLayout,
4957         matrixLayout == glslang::ElmRowMajor);
4958
4959     // Adjust alignment for HLSL rules
4960     // TODO: make this consistent in early phases of code:
4961     //       adjusting this late means inconsistencies with earlier code, which for reflection is an issue
4962     // Until reflection is brought in sync with these adjustments, don't apply to $Global,
4963     // which is the most likely to rely on reflection, and least likely to rely implicit layouts
4964     if (glslangIntermediate->usingHlslOffsets() &&
4965         ! memberType.isArray() && memberType.isVector() && structType.getTypeName().compare("$Global") != 0) {
4966         int dummySize;
4967         int componentAlignment = glslangIntermediate->getBaseAlignmentScalar(memberType, dummySize);
4968         if (componentAlignment <= 4)
4969             memberAlignment = componentAlignment;
4970     }
4971
4972     // Bump up to member alignment
4973     glslang::RoundToPow2(currentOffset, memberAlignment);
4974
4975     // Bump up to vec4 if there is a bad straddle
4976     if (explicitLayout != glslang::ElpScalar && glslangIntermediate->improperStraddle(memberType, memberSize,
4977         currentOffset))
4978         glslang::RoundToPow2(currentOffset, 16);
4979
4980     nextOffset = currentOffset + memberSize;
4981 }
4982
4983 void TGlslangToSpvTraverser::declareUseOfStructMember(const glslang::TTypeList& members, int glslangMember)
4984 {
4985     const glslang::TBuiltInVariable glslangBuiltIn = members[glslangMember].type->getQualifier().builtIn;
4986     switch (glslangBuiltIn)
4987     {
4988     case glslang::EbvPointSize:
4989 #ifndef GLSLANG_WEB
4990     case glslang::EbvClipDistance:
4991     case glslang::EbvCullDistance:
4992     case glslang::EbvViewportMaskNV:
4993     case glslang::EbvSecondaryPositionNV:
4994     case glslang::EbvSecondaryViewportMaskNV:
4995     case glslang::EbvPositionPerViewNV:
4996     case glslang::EbvViewportMaskPerViewNV:
4997     case glslang::EbvTaskCountNV:
4998     case glslang::EbvPrimitiveCountNV:
4999     case glslang::EbvPrimitiveIndicesNV:
5000     case glslang::EbvClipDistancePerViewNV:
5001     case glslang::EbvCullDistancePerViewNV:
5002     case glslang::EbvLayerPerViewNV:
5003     case glslang::EbvMeshViewCountNV:
5004     case glslang::EbvMeshViewIndicesNV:
5005 #endif
5006         // Generate the associated capability.  Delegate to TranslateBuiltInDecoration.
5007         // Alternately, we could just call this for any glslang built-in, since the
5008         // capability already guards against duplicates.
5009         TranslateBuiltInDecoration(glslangBuiltIn, false);
5010         break;
5011     default:
5012         // Capabilities were already generated when the struct was declared.
5013         break;
5014     }
5015 }
5016
5017 bool TGlslangToSpvTraverser::isShaderEntryPoint(const glslang::TIntermAggregate* node)
5018 {
5019     return node->getName().compare(glslangIntermediate->getEntryPointMangledName().c_str()) == 0;
5020 }
5021
5022 // Does parameter need a place to keep writes, separate from the original?
5023 // Assumes called after originalParam(), which filters out block/buffer/opaque-based
5024 // qualifiers such that we should have only in/out/inout/constreadonly here.
5025 bool TGlslangToSpvTraverser::writableParam(glslang::TStorageQualifier qualifier) const
5026 {
5027     assert(qualifier == glslang::EvqIn ||
5028            qualifier == glslang::EvqOut ||
5029            qualifier == glslang::EvqInOut ||
5030            qualifier == glslang::EvqUniform ||
5031            qualifier == glslang::EvqConstReadOnly);
5032     return qualifier != glslang::EvqConstReadOnly &&
5033            qualifier != glslang::EvqUniform;
5034 }
5035
5036 // Is parameter pass-by-original?
5037 bool TGlslangToSpvTraverser::originalParam(glslang::TStorageQualifier qualifier, const glslang::TType& paramType,
5038                                            bool implicitThisParam)
5039 {
5040     if (implicitThisParam)                                                                     // implicit this
5041         return true;
5042     if (glslangIntermediate->getSource() == glslang::EShSourceHlsl)
5043         return paramType.getBasicType() == glslang::EbtBlock;
5044     return paramType.containsOpaque() ||                                                       // sampler, etc.
5045 #ifndef GLSLANG_WEB
5046            paramType.getQualifier().isSpirvByReference() ||                                    // spirv_by_reference
5047 #endif
5048            (paramType.getBasicType() == glslang::EbtBlock && qualifier == glslang::EvqBuffer); // SSBO
5049 }
5050
5051 // Make all the functions, skeletally, without actually visiting their bodies.
5052 void TGlslangToSpvTraverser::makeFunctions(const glslang::TIntermSequence& glslFunctions)
5053 {
5054     const auto getParamDecorations = [&](std::vector<spv::Decoration>& decorations, const glslang::TType& type,
5055         bool useVulkanMemoryModel) {
5056         spv::Decoration paramPrecision = TranslatePrecisionDecoration(type);
5057         if (paramPrecision != spv::NoPrecision)
5058             decorations.push_back(paramPrecision);
5059         TranslateMemoryDecoration(type.getQualifier(), decorations, useVulkanMemoryModel);
5060         if (type.isReference()) {
5061             // Original and non-writable params pass the pointer directly and
5062             // use restrict/aliased, others are stored to a pointer in Function
5063             // memory and use RestrictPointer/AliasedPointer.
5064             if (originalParam(type.getQualifier().storage, type, false) ||
5065                 !writableParam(type.getQualifier().storage)) {
5066                 decorations.push_back(type.getQualifier().isRestrict() ? spv::DecorationRestrict :
5067                                                                          spv::DecorationAliased);
5068             } else {
5069                 decorations.push_back(type.getQualifier().isRestrict() ? spv::DecorationRestrictPointerEXT :
5070                                                                          spv::DecorationAliasedPointerEXT);
5071             }
5072         }
5073     };
5074
5075     for (int f = 0; f < (int)glslFunctions.size(); ++f) {
5076         glslang::TIntermAggregate* glslFunction = glslFunctions[f]->getAsAggregate();
5077         if (! glslFunction || glslFunction->getOp() != glslang::EOpFunction || isShaderEntryPoint(glslFunction))
5078             continue;
5079
5080         // We're on a user function.  Set up the basic interface for the function now,
5081         // so that it's available to call.  Translating the body will happen later.
5082         //
5083         // Typically (except for a "const in" parameter), an address will be passed to the
5084         // function.  What it is an address of varies:
5085         //
5086         // - "in" parameters not marked as "const" can be written to without modifying the calling
5087         //   argument so that write needs to be to a copy, hence the address of a copy works.
5088         //
5089         // - "const in" parameters can just be the r-value, as no writes need occur.
5090         //
5091         // - "out" and "inout" arguments can't be done as pointers to the calling argument, because
5092         //   GLSL has copy-in/copy-out semantics.  They can be handled though with a pointer to a copy.
5093
5094         std::vector<spv::Id> paramTypes;
5095         std::vector<std::vector<spv::Decoration>> paramDecorations; // list of decorations per parameter
5096         glslang::TIntermSequence& parameters = glslFunction->getSequence()[0]->getAsAggregate()->getSequence();
5097
5098 #ifdef ENABLE_HLSL
5099         bool implicitThis = (int)parameters.size() > 0 && parameters[0]->getAsSymbolNode()->getName() ==
5100                                                           glslangIntermediate->implicitThisName;
5101 #else
5102         bool implicitThis = false;
5103 #endif
5104
5105         paramDecorations.resize(parameters.size());
5106         for (int p = 0; p < (int)parameters.size(); ++p) {
5107             const glslang::TType& paramType = parameters[p]->getAsTyped()->getType();
5108             spv::Id typeId = convertGlslangToSpvType(paramType);
5109             if (originalParam(paramType.getQualifier().storage, paramType, implicitThis && p == 0))
5110                 typeId = builder.makePointer(TranslateStorageClass(paramType), typeId);
5111             else if (writableParam(paramType.getQualifier().storage))
5112                 typeId = builder.makePointer(spv::StorageClassFunction, typeId);
5113             else
5114                 rValueParameters.insert(parameters[p]->getAsSymbolNode()->getId());
5115             getParamDecorations(paramDecorations[p], paramType, glslangIntermediate->usingVulkanMemoryModel());
5116             paramTypes.push_back(typeId);
5117         }
5118
5119         spv::Block* functionBlock;
5120         spv::Function *function = builder.makeFunctionEntry(TranslatePrecisionDecoration(glslFunction->getType()),
5121                                                             convertGlslangToSpvType(glslFunction->getType()),
5122                                                             glslFunction->getName().c_str(), paramTypes,
5123                                                             paramDecorations, &functionBlock);
5124         if (implicitThis)
5125             function->setImplicitThis();
5126
5127         // Track function to emit/call later
5128         functionMap[glslFunction->getName().c_str()] = function;
5129
5130         // Set the parameter id's
5131         for (int p = 0; p < (int)parameters.size(); ++p) {
5132             symbolValues[parameters[p]->getAsSymbolNode()->getId()] = function->getParamId(p);
5133             // give a name too
5134             builder.addName(function->getParamId(p), parameters[p]->getAsSymbolNode()->getName().c_str());
5135
5136             const glslang::TType& paramType = parameters[p]->getAsTyped()->getType();
5137             if (paramType.contains8BitInt())
5138                 builder.addCapability(spv::CapabilityInt8);
5139             if (paramType.contains16BitInt())
5140                 builder.addCapability(spv::CapabilityInt16);
5141             if (paramType.contains16BitFloat())
5142                 builder.addCapability(spv::CapabilityFloat16);
5143         }
5144     }
5145 }
5146
5147 // Process all the initializers, while skipping the functions and link objects
5148 void TGlslangToSpvTraverser::makeGlobalInitializers(const glslang::TIntermSequence& initializers)
5149 {
5150     builder.setBuildPoint(shaderEntry->getLastBlock());
5151     for (int i = 0; i < (int)initializers.size(); ++i) {
5152         glslang::TIntermAggregate* initializer = initializers[i]->getAsAggregate();
5153         if (initializer && initializer->getOp() != glslang::EOpFunction && initializer->getOp() !=
5154             glslang::EOpLinkerObjects) {
5155
5156             // We're on a top-level node that's not a function.  Treat as an initializer, whose
5157             // code goes into the beginning of the entry point.
5158             initializer->traverse(this);
5159         }
5160     }
5161 }
5162 // Walk over all linker objects to create a map for payload and callable data linker objects
5163 // and their location to be used during codegen for OpTraceKHR and OpExecuteCallableKHR
5164 // This is done here since it is possible that these linker objects are not be referenced in the AST
5165 void TGlslangToSpvTraverser::collectRayTracingLinkerObjects()
5166 {
5167     glslang::TIntermAggregate* linkerObjects = glslangIntermediate->findLinkerObjects();
5168     for (auto& objSeq : linkerObjects->getSequence()) {
5169         auto objNode = objSeq->getAsSymbolNode();
5170         if (objNode != nullptr) {
5171             if (objNode->getQualifier().hasLocation()) {
5172                 unsigned int location = objNode->getQualifier().layoutLocation;
5173                 auto st = objNode->getQualifier().storage;
5174                 int set;
5175                 switch (st)
5176                 {
5177                 case glslang::EvqPayload:
5178                 case glslang::EvqPayloadIn:
5179                     set = 0;
5180                     break;
5181                 case glslang::EvqCallableData:
5182                 case glslang::EvqCallableDataIn:
5183                     set = 1;
5184                     break;
5185
5186                 default:
5187                     set = -1;
5188                 }
5189                 if (set != -1)
5190                     locationToSymbol[set].insert(std::make_pair(location, objNode));
5191             }
5192         }
5193     }
5194 }
5195 // Process all the functions, while skipping initializers.
5196 void TGlslangToSpvTraverser::visitFunctions(const glslang::TIntermSequence& glslFunctions)
5197 {
5198     for (int f = 0; f < (int)glslFunctions.size(); ++f) {
5199         glslang::TIntermAggregate* node = glslFunctions[f]->getAsAggregate();
5200         if (node && (node->getOp() == glslang::EOpFunction || node->getOp() == glslang::EOpLinkerObjects))
5201             node->traverse(this);
5202     }
5203 }
5204
5205 void TGlslangToSpvTraverser::handleFunctionEntry(const glslang::TIntermAggregate* node)
5206 {
5207     // SPIR-V functions should already be in the functionMap from the prepass
5208     // that called makeFunctions().
5209     currentFunction = functionMap[node->getName().c_str()];
5210     spv::Block* functionBlock = currentFunction->getEntryBlock();
5211     builder.setBuildPoint(functionBlock);
5212 }
5213
5214 void TGlslangToSpvTraverser::translateArguments(const glslang::TIntermAggregate& node, std::vector<spv::Id>& arguments,
5215     spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags)
5216 {
5217     const glslang::TIntermSequence& glslangArguments = node.getSequence();
5218
5219     glslang::TSampler sampler = {};
5220     bool cubeCompare = false;
5221 #ifndef GLSLANG_WEB
5222     bool f16ShadowCompare = false;
5223 #endif
5224     if (node.isTexture() || node.isImage()) {
5225         sampler = glslangArguments[0]->getAsTyped()->getType().getSampler();
5226         cubeCompare = sampler.dim == glslang::EsdCube && sampler.arrayed && sampler.shadow;
5227 #ifndef GLSLANG_WEB
5228         f16ShadowCompare = sampler.shadow &&
5229             glslangArguments[1]->getAsTyped()->getType().getBasicType() == glslang::EbtFloat16;
5230 #endif
5231     }
5232
5233     for (int i = 0; i < (int)glslangArguments.size(); ++i) {
5234         builder.clearAccessChain();
5235         glslangArguments[i]->traverse(this);
5236
5237 #ifndef GLSLANG_WEB
5238         // Special case l-value operands
5239         bool lvalue = false;
5240         switch (node.getOp()) {
5241         case glslang::EOpImageAtomicAdd:
5242         case glslang::EOpImageAtomicMin:
5243         case glslang::EOpImageAtomicMax:
5244         case glslang::EOpImageAtomicAnd:
5245         case glslang::EOpImageAtomicOr:
5246         case glslang::EOpImageAtomicXor:
5247         case glslang::EOpImageAtomicExchange:
5248         case glslang::EOpImageAtomicCompSwap:
5249         case glslang::EOpImageAtomicLoad:
5250         case glslang::EOpImageAtomicStore:
5251             if (i == 0)
5252                 lvalue = true;
5253             break;
5254         case glslang::EOpSparseImageLoad:
5255             if ((sampler.ms && i == 3) || (! sampler.ms && i == 2))
5256                 lvalue = true;
5257             break;
5258         case glslang::EOpSparseTexture:
5259             if (((cubeCompare || f16ShadowCompare) && i == 3) || (! (cubeCompare || f16ShadowCompare) && i == 2))
5260                 lvalue = true;
5261             break;
5262         case glslang::EOpSparseTextureClamp:
5263             if (((cubeCompare || f16ShadowCompare) && i == 4) || (! (cubeCompare || f16ShadowCompare) && i == 3))
5264                 lvalue = true;
5265             break;
5266         case glslang::EOpSparseTextureLod:
5267         case glslang::EOpSparseTextureOffset:
5268             if  ((f16ShadowCompare && i == 4) || (! f16ShadowCompare && i == 3))
5269                 lvalue = true;
5270             break;
5271         case glslang::EOpSparseTextureFetch:
5272             if ((sampler.dim != glslang::EsdRect && i == 3) || (sampler.dim == glslang::EsdRect && i == 2))
5273                 lvalue = true;
5274             break;
5275         case glslang::EOpSparseTextureFetchOffset:
5276             if ((sampler.dim != glslang::EsdRect && i == 4) || (sampler.dim == glslang::EsdRect && i == 3))
5277                 lvalue = true;
5278             break;
5279         case glslang::EOpSparseTextureLodOffset:
5280         case glslang::EOpSparseTextureGrad:
5281         case glslang::EOpSparseTextureOffsetClamp:
5282             if ((f16ShadowCompare && i == 5) || (! f16ShadowCompare && i == 4))
5283                 lvalue = true;
5284             break;
5285         case glslang::EOpSparseTextureGradOffset:
5286         case glslang::EOpSparseTextureGradClamp:
5287             if ((f16ShadowCompare && i == 6) || (! f16ShadowCompare && i == 5))
5288                 lvalue = true;
5289             break;
5290         case glslang::EOpSparseTextureGradOffsetClamp:
5291             if ((f16ShadowCompare && i == 7) || (! f16ShadowCompare && i == 6))
5292                 lvalue = true;
5293             break;
5294         case glslang::EOpSparseTextureGather:
5295             if ((sampler.shadow && i == 3) || (! sampler.shadow && i == 2))
5296                 lvalue = true;
5297             break;
5298         case glslang::EOpSparseTextureGatherOffset:
5299         case glslang::EOpSparseTextureGatherOffsets:
5300             if ((sampler.shadow && i == 4) || (! sampler.shadow && i == 3))
5301                 lvalue = true;
5302             break;
5303         case glslang::EOpSparseTextureGatherLod:
5304             if (i == 3)
5305                 lvalue = true;
5306             break;
5307         case glslang::EOpSparseTextureGatherLodOffset:
5308         case glslang::EOpSparseTextureGatherLodOffsets:
5309             if (i == 4)
5310                 lvalue = true;
5311             break;
5312         case glslang::EOpSparseImageLoadLod:
5313             if (i == 3)
5314                 lvalue = true;
5315             break;
5316         case glslang::EOpImageSampleFootprintNV:
5317             if (i == 4)
5318                 lvalue = true;
5319             break;
5320         case glslang::EOpImageSampleFootprintClampNV:
5321         case glslang::EOpImageSampleFootprintLodNV:
5322             if (i == 5)
5323                 lvalue = true;
5324             break;
5325         case glslang::EOpImageSampleFootprintGradNV:
5326             if (i == 6)
5327                 lvalue = true;
5328             break;
5329         case glslang::EOpImageSampleFootprintGradClampNV:
5330             if (i == 7)
5331                 lvalue = true;
5332             break;
5333         default:
5334             break;
5335         }
5336
5337         if (lvalue) {
5338             spv::Id lvalue_id = builder.accessChainGetLValue();
5339             arguments.push_back(lvalue_id);
5340             lvalueCoherentFlags = builder.getAccessChain().coherentFlags;
5341             builder.addDecoration(lvalue_id, TranslateNonUniformDecoration(lvalueCoherentFlags));
5342             lvalueCoherentFlags |= TranslateCoherent(glslangArguments[i]->getAsTyped()->getType());
5343         } else
5344 #endif
5345             arguments.push_back(accessChainLoad(glslangArguments[i]->getAsTyped()->getType()));
5346     }
5347 }
5348
5349 void TGlslangToSpvTraverser::translateArguments(glslang::TIntermUnary& node, std::vector<spv::Id>& arguments)
5350 {
5351     builder.clearAccessChain();
5352     node.getOperand()->traverse(this);
5353     arguments.push_back(accessChainLoad(node.getOperand()->getType()));
5354 }
5355
5356 spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermOperator* node)
5357 {
5358     if (! node->isImage() && ! node->isTexture())
5359         return spv::NoResult;
5360
5361     builder.setLine(node->getLoc().line, node->getLoc().getFilename());
5362
5363     // Process a GLSL texturing op (will be SPV image)
5364
5365     const glslang::TType &imageType = node->getAsAggregate()
5366                                         ? node->getAsAggregate()->getSequence()[0]->getAsTyped()->getType()
5367                                         : node->getAsUnaryNode()->getOperand()->getAsTyped()->getType();
5368     const glslang::TSampler sampler = imageType.getSampler();
5369 #ifdef GLSLANG_WEB
5370     const bool f16ShadowCompare = false;
5371 #else
5372     bool f16ShadowCompare = (sampler.shadow && node->getAsAggregate())
5373             ? node->getAsAggregate()->getSequence()[1]->getAsTyped()->getType().getBasicType() == glslang::EbtFloat16
5374             : false;
5375 #endif
5376
5377     const auto signExtensionMask = [&]() {
5378         if (builder.getSpvVersion() >= spv::Spv_1_4) {
5379             if (sampler.type == glslang::EbtUint)
5380                 return spv::ImageOperandsZeroExtendMask;
5381             else if (sampler.type == glslang::EbtInt)
5382                 return spv::ImageOperandsSignExtendMask;
5383         }
5384         return spv::ImageOperandsMaskNone;
5385     };
5386
5387     spv::Builder::AccessChain::CoherentFlags lvalueCoherentFlags;
5388
5389     std::vector<spv::Id> arguments;
5390     if (node->getAsAggregate())
5391         translateArguments(*node->getAsAggregate(), arguments, lvalueCoherentFlags);
5392     else
5393         translateArguments(*node->getAsUnaryNode(), arguments);
5394     spv::Decoration precision = TranslatePrecisionDecoration(node->getType());
5395
5396     spv::Builder::TextureParameters params = { };
5397     params.sampler = arguments[0];
5398
5399     glslang::TCrackedTextureOp cracked;
5400     node->crackTexture(sampler, cracked);
5401
5402     const bool isUnsignedResult = node->getType().getBasicType() == glslang::EbtUint;
5403
5404     if (builder.isSampledImage(params.sampler) &&
5405         ((cracked.query && node->getOp() != glslang::EOpTextureQueryLod) || cracked.fragMask || cracked.fetch)) {
5406         params.sampler = builder.createUnaryOp(spv::OpImage, builder.getImageType(params.sampler), params.sampler);
5407         if (imageType.getQualifier().isNonUniform()) {
5408             builder.addDecoration(params.sampler, spv::DecorationNonUniformEXT);
5409         }
5410     }
5411     // Check for queries
5412     if (cracked.query) {
5413         switch (node->getOp()) {
5414         case glslang::EOpImageQuerySize:
5415         case glslang::EOpTextureQuerySize:
5416             if (arguments.size() > 1) {
5417                 params.lod = arguments[1];
5418                 return builder.createTextureQueryCall(spv::OpImageQuerySizeLod, params, isUnsignedResult);
5419             } else
5420                 return builder.createTextureQueryCall(spv::OpImageQuerySize, params, isUnsignedResult);
5421 #ifndef GLSLANG_WEB
5422         case glslang::EOpImageQuerySamples:
5423         case glslang::EOpTextureQuerySamples:
5424             return builder.createTextureQueryCall(spv::OpImageQuerySamples, params, isUnsignedResult);
5425         case glslang::EOpTextureQueryLod:
5426             params.coords = arguments[1];
5427             return builder.createTextureQueryCall(spv::OpImageQueryLod, params, isUnsignedResult);
5428         case glslang::EOpTextureQueryLevels:
5429             return builder.createTextureQueryCall(spv::OpImageQueryLevels, params, isUnsignedResult);
5430         case glslang::EOpSparseTexelsResident:
5431             return builder.createUnaryOp(spv::OpImageSparseTexelsResident, builder.makeBoolType(), arguments[0]);
5432 #endif
5433         default:
5434             assert(0);
5435             break;
5436         }
5437     }
5438
5439     int components = node->getType().getVectorSize();
5440
5441     if (node->getOp() == glslang::EOpImageLoad ||
5442         node->getOp() == glslang::EOpImageLoadLod ||
5443         node->getOp() == glslang::EOpTextureFetch ||
5444         node->getOp() == glslang::EOpTextureFetchOffset) {
5445         // These must produce 4 components, per SPIR-V spec.  We'll add a conversion constructor if needed.
5446         // This will only happen through the HLSL path for operator[], so we do not have to handle e.g.
5447         // the EOpTexture/Proj/Lod/etc family.  It would be harmless to do so, but would need more logic
5448         // here around e.g. which ones return scalars or other types.
5449         components = 4;
5450     }
5451
5452     glslang::TType returnType(node->getType().getBasicType(), glslang::EvqTemporary, components);
5453
5454     auto resultType = [&returnType,this]{ return convertGlslangToSpvType(returnType); };
5455
5456     // Check for image functions other than queries
5457     if (node->isImage()) {
5458         std::vector<spv::IdImmediate> operands;
5459         auto opIt = arguments.begin();
5460         spv::IdImmediate image = { true, *(opIt++) };
5461         operands.push_back(image);
5462
5463         // Handle subpass operations
5464         // TODO: GLSL should change to have the "MS" only on the type rather than the
5465         // built-in function.
5466         if (cracked.subpass) {
5467             // add on the (0,0) coordinate
5468             spv::Id zero = builder.makeIntConstant(0);
5469             std::vector<spv::Id> comps;
5470             comps.push_back(zero);
5471             comps.push_back(zero);
5472             spv::IdImmediate coord = { true,
5473                 builder.makeCompositeConstant(builder.makeVectorType(builder.makeIntType(32), 2), comps) };
5474             operands.push_back(coord);
5475             spv::IdImmediate imageOperands = { false, spv::ImageOperandsMaskNone };
5476             imageOperands.word = imageOperands.word | signExtensionMask();
5477             if (sampler.isMultiSample()) {
5478                 imageOperands.word = imageOperands.word | spv::ImageOperandsSampleMask;
5479             }
5480             if (imageOperands.word != spv::ImageOperandsMaskNone) {
5481                 operands.push_back(imageOperands);
5482                 if (sampler.isMultiSample()) {
5483                     spv::IdImmediate imageOperand = { true, *(opIt++) };
5484                     operands.push_back(imageOperand);
5485                 }
5486             }
5487             spv::Id result = builder.createOp(spv::OpImageRead, resultType(), operands);
5488             builder.setPrecision(result, precision);
5489             return result;
5490         }
5491
5492         spv::IdImmediate coord = { true, *(opIt++) };
5493         operands.push_back(coord);
5494         if (node->getOp() == glslang::EOpImageLoad || node->getOp() == glslang::EOpImageLoadLod) {
5495             spv::ImageOperandsMask mask = spv::ImageOperandsMaskNone;
5496             if (sampler.isMultiSample()) {
5497                 mask = mask | spv::ImageOperandsSampleMask;
5498             }
5499             if (cracked.lod) {
5500                 builder.addExtension(spv::E_SPV_AMD_shader_image_load_store_lod);
5501                 builder.addCapability(spv::CapabilityImageReadWriteLodAMD);
5502                 mask = mask | spv::ImageOperandsLodMask;
5503             }
5504             mask = mask | TranslateImageOperands(TranslateCoherent(imageType));
5505             mask = (spv::ImageOperandsMask)(mask & ~spv::ImageOperandsMakeTexelAvailableKHRMask);
5506             mask = mask | signExtensionMask();
5507             if (mask != spv::ImageOperandsMaskNone) {
5508                 spv::IdImmediate imageOperands = { false, (unsigned int)mask };
5509                 operands.push_back(imageOperands);
5510             }
5511             if (mask & spv::ImageOperandsSampleMask) {
5512                 spv::IdImmediate imageOperand = { true, *opIt++ };
5513                 operands.push_back(imageOperand);
5514             }
5515             if (mask & spv::ImageOperandsLodMask) {
5516                 spv::IdImmediate imageOperand = { true, *opIt++ };
5517                 operands.push_back(imageOperand);
5518             }
5519             if (mask & spv::ImageOperandsMakeTexelVisibleKHRMask) {
5520                 spv::IdImmediate imageOperand = { true,
5521                                     builder.makeUintConstant(TranslateMemoryScope(TranslateCoherent(imageType))) };
5522                 operands.push_back(imageOperand);
5523             }
5524
5525             if (builder.getImageTypeFormat(builder.getImageType(operands.front().word)) == spv::ImageFormatUnknown)
5526                 builder.addCapability(spv::CapabilityStorageImageReadWithoutFormat);
5527
5528             std::vector<spv::Id> result(1, builder.createOp(spv::OpImageRead, resultType(), operands));
5529             builder.setPrecision(result[0], precision);
5530
5531             // If needed, add a conversion constructor to the proper size.
5532             if (components != node->getType().getVectorSize())
5533                 result[0] = builder.createConstructor(precision, result, convertGlslangToSpvType(node->getType()));
5534
5535             return result[0];
5536         } else if (node->getOp() == glslang::EOpImageStore || node->getOp() == glslang::EOpImageStoreLod) {
5537
5538             // Push the texel value before the operands
5539             if (sampler.isMultiSample() || cracked.lod) {
5540                 spv::IdImmediate texel = { true, *(opIt + 1) };
5541                 operands.push_back(texel);
5542             } else {
5543                 spv::IdImmediate texel = { true, *opIt };
5544                 operands.push_back(texel);
5545             }
5546
5547             spv::ImageOperandsMask mask = spv::ImageOperandsMaskNone;
5548             if (sampler.isMultiSample()) {
5549                 mask = mask | spv::ImageOperandsSampleMask;
5550             }
5551             if (cracked.lod) {
5552                 builder.addExtension(spv::E_SPV_AMD_shader_image_load_store_lod);
5553                 builder.addCapability(spv::CapabilityImageReadWriteLodAMD);
5554                 mask = mask | spv::ImageOperandsLodMask;
5555             }
5556             mask = mask | TranslateImageOperands(TranslateCoherent(imageType));
5557             mask = (spv::ImageOperandsMask)(mask & ~spv::ImageOperandsMakeTexelVisibleKHRMask);
5558             mask = mask | signExtensionMask();
5559             if (mask != spv::ImageOperandsMaskNone) {
5560                 spv::IdImmediate imageOperands = { false, (unsigned int)mask };
5561                 operands.push_back(imageOperands);
5562             }
5563             if (mask & spv::ImageOperandsSampleMask) {
5564                 spv::IdImmediate imageOperand = { true, *opIt++ };
5565                 operands.push_back(imageOperand);
5566             }
5567             if (mask & spv::ImageOperandsLodMask) {
5568                 spv::IdImmediate imageOperand = { true, *opIt++ };
5569                 operands.push_back(imageOperand);
5570             }
5571             if (mask & spv::ImageOperandsMakeTexelAvailableKHRMask) {
5572                 spv::IdImmediate imageOperand = { true,
5573                     builder.makeUintConstant(TranslateMemoryScope(TranslateCoherent(imageType))) };
5574                 operands.push_back(imageOperand);
5575             }
5576
5577             builder.createNoResultOp(spv::OpImageWrite, operands);
5578             if (builder.getImageTypeFormat(builder.getImageType(operands.front().word)) == spv::ImageFormatUnknown)
5579                 builder.addCapability(spv::CapabilityStorageImageWriteWithoutFormat);
5580             return spv::NoResult;
5581         } else if (node->getOp() == glslang::EOpSparseImageLoad ||
5582                    node->getOp() == glslang::EOpSparseImageLoadLod) {
5583             builder.addCapability(spv::CapabilitySparseResidency);
5584             if (builder.getImageTypeFormat(builder.getImageType(operands.front().word)) == spv::ImageFormatUnknown)
5585                 builder.addCapability(spv::CapabilityStorageImageReadWithoutFormat);
5586
5587             spv::ImageOperandsMask mask = spv::ImageOperandsMaskNone;
5588             if (sampler.isMultiSample()) {
5589                 mask = mask | spv::ImageOperandsSampleMask;
5590             }
5591             if (cracked.lod) {
5592                 builder.addExtension(spv::E_SPV_AMD_shader_image_load_store_lod);
5593                 builder.addCapability(spv::CapabilityImageReadWriteLodAMD);
5594
5595                 mask = mask | spv::ImageOperandsLodMask;
5596             }
5597             mask = mask | TranslateImageOperands(TranslateCoherent(imageType));
5598             mask = (spv::ImageOperandsMask)(mask & ~spv::ImageOperandsMakeTexelAvailableKHRMask);
5599             mask = mask | signExtensionMask();
5600             if (mask != spv::ImageOperandsMaskNone) {
5601                 spv::IdImmediate imageOperands = { false, (unsigned int)mask };
5602                 operands.push_back(imageOperands);
5603             }
5604             if (mask & spv::ImageOperandsSampleMask) {
5605                 spv::IdImmediate imageOperand = { true, *opIt++ };
5606                 operands.push_back(imageOperand);
5607             }
5608             if (mask & spv::ImageOperandsLodMask) {
5609                 spv::IdImmediate imageOperand = { true, *opIt++ };
5610                 operands.push_back(imageOperand);
5611             }
5612             if (mask & spv::ImageOperandsMakeTexelVisibleKHRMask) {
5613                 spv::IdImmediate imageOperand = { true, builder.makeUintConstant(TranslateMemoryScope(
5614                     TranslateCoherent(imageType))) };
5615                 operands.push_back(imageOperand);
5616             }
5617
5618             // Create the return type that was a special structure
5619             spv::Id texelOut = *opIt;
5620             spv::Id typeId0 = resultType();
5621             spv::Id typeId1 = builder.getDerefTypeId(texelOut);
5622             spv::Id resultTypeId = builder.makeStructResultType(typeId0, typeId1);
5623
5624             spv::Id resultId = builder.createOp(spv::OpImageSparseRead, resultTypeId, operands);
5625
5626             // Decode the return type
5627             builder.createStore(builder.createCompositeExtract(resultId, typeId1, 1), texelOut);
5628             return builder.createCompositeExtract(resultId, typeId0, 0);
5629         } else {
5630             // Process image atomic operations
5631
5632             // GLSL "IMAGE_PARAMS" will involve in constructing an image texel pointer and this pointer,
5633             // as the first source operand, is required by SPIR-V atomic operations.
5634             // For non-MS, the sample value should be 0
5635             spv::IdImmediate sample = { true, sampler.isMultiSample() ? *(opIt++) : builder.makeUintConstant(0) };
5636             operands.push_back(sample);
5637
5638             spv::Id resultTypeId;
5639             glslang::TBasicType typeProxy = node->getBasicType();
5640             // imageAtomicStore has a void return type so base the pointer type on
5641             // the type of the value operand.
5642             if (node->getOp() == glslang::EOpImageAtomicStore) {
5643                 resultTypeId = builder.makePointer(spv::StorageClassImage, builder.getTypeId(*opIt));
5644                 typeProxy = node->getAsAggregate()->getSequence()[0]->getAsTyped()->getType().getSampler().type;
5645             } else {
5646                 resultTypeId = builder.makePointer(spv::StorageClassImage, resultType());
5647             }
5648             spv::Id pointer = builder.createOp(spv::OpImageTexelPointer, resultTypeId, operands);
5649             if (imageType.getQualifier().nonUniform) {
5650                 builder.addDecoration(pointer, spv::DecorationNonUniformEXT);
5651             }
5652
5653             std::vector<spv::Id> operands;
5654             operands.push_back(pointer);
5655             for (; opIt != arguments.end(); ++opIt)
5656                 operands.push_back(*opIt);
5657
5658             return createAtomicOperation(node->getOp(), precision, resultType(), operands, typeProxy,
5659                 lvalueCoherentFlags);
5660         }
5661     }
5662
5663 #ifndef GLSLANG_WEB
5664     // Check for fragment mask functions other than queries
5665     if (cracked.fragMask) {
5666         assert(sampler.ms);
5667
5668         auto opIt = arguments.begin();
5669         std::vector<spv::Id> operands;
5670
5671         operands.push_back(params.sampler);
5672         ++opIt;
5673
5674         if (sampler.isSubpass()) {
5675             // add on the (0,0) coordinate
5676             spv::Id zero = builder.makeIntConstant(0);
5677             std::vector<spv::Id> comps;
5678             comps.push_back(zero);
5679             comps.push_back(zero);
5680             operands.push_back(builder.makeCompositeConstant(
5681                 builder.makeVectorType(builder.makeIntType(32), 2), comps));
5682         }
5683
5684         for (; opIt != arguments.end(); ++opIt)
5685             operands.push_back(*opIt);
5686
5687         spv::Op fragMaskOp = spv::OpNop;
5688         if (node->getOp() == glslang::EOpFragmentMaskFetch)
5689             fragMaskOp = spv::OpFragmentMaskFetchAMD;
5690         else if (node->getOp() == glslang::EOpFragmentFetch)
5691             fragMaskOp = spv::OpFragmentFetchAMD;
5692
5693         builder.addExtension(spv::E_SPV_AMD_shader_fragment_mask);
5694         builder.addCapability(spv::CapabilityFragmentMaskAMD);
5695         return builder.createOp(fragMaskOp, resultType(), operands);
5696     }
5697 #endif
5698
5699     // Check for texture functions other than queries
5700     bool sparse = node->isSparseTexture();
5701     bool imageFootprint = node->isImageFootprint();
5702     bool cubeCompare = sampler.dim == glslang::EsdCube && sampler.isArrayed() && sampler.isShadow();
5703
5704     // check for bias argument
5705     bool bias = false;
5706     if (! cracked.lod && ! cracked.grad && ! cracked.fetch && ! cubeCompare) {
5707         int nonBiasArgCount = 2;
5708         if (cracked.gather)
5709             ++nonBiasArgCount; // comp argument should be present when bias argument is present
5710
5711         if (f16ShadowCompare)
5712             ++nonBiasArgCount;
5713         if (cracked.offset)
5714             ++nonBiasArgCount;
5715         else if (cracked.offsets)
5716             ++nonBiasArgCount;
5717         if (cracked.grad)
5718             nonBiasArgCount += 2;
5719         if (cracked.lodClamp)
5720             ++nonBiasArgCount;
5721         if (sparse)
5722             ++nonBiasArgCount;
5723         if (imageFootprint)
5724             //Following three extra arguments
5725             // int granularity, bool coarse, out gl_TextureFootprint2DNV footprint
5726             nonBiasArgCount += 3;
5727         if ((int)arguments.size() > nonBiasArgCount)
5728             bias = true;
5729     }
5730
5731 #ifndef GLSLANG_WEB
5732     if (cracked.gather) {
5733         const auto& sourceExtensions = glslangIntermediate->getRequestedExtensions();
5734         if (bias || cracked.lod ||
5735             sourceExtensions.find(glslang::E_GL_AMD_texture_gather_bias_lod) != sourceExtensions.end()) {
5736             builder.addExtension(spv::E_SPV_AMD_texture_gather_bias_lod);
5737             builder.addCapability(spv::CapabilityImageGatherBiasLodAMD);
5738         }
5739     }
5740 #endif
5741
5742     // set the rest of the arguments
5743
5744     params.coords = arguments[1];
5745     int extraArgs = 0;
5746     bool noImplicitLod = false;
5747
5748     // sort out where Dref is coming from
5749     if (cubeCompare || f16ShadowCompare) {
5750         params.Dref = arguments[2];
5751         ++extraArgs;
5752     } else if (sampler.shadow && cracked.gather) {
5753         params.Dref = arguments[2];
5754         ++extraArgs;
5755     } else if (sampler.shadow) {
5756         std::vector<spv::Id> indexes;
5757         int dRefComp;
5758         if (cracked.proj)
5759             dRefComp = 2;  // "The resulting 3rd component of P in the shadow forms is used as Dref"
5760         else
5761             dRefComp = builder.getNumComponents(params.coords) - 1;
5762         indexes.push_back(dRefComp);
5763         params.Dref = builder.createCompositeExtract(params.coords,
5764             builder.getScalarTypeId(builder.getTypeId(params.coords)), indexes);
5765     }
5766
5767     // lod
5768     if (cracked.lod) {
5769         params.lod = arguments[2 + extraArgs];
5770         ++extraArgs;
5771     } else if (glslangIntermediate->getStage() != EShLangFragment &&
5772                !(glslangIntermediate->getStage() == EShLangCompute &&
5773                  glslangIntermediate->hasLayoutDerivativeModeNone())) {
5774         // we need to invent the default lod for an explicit lod instruction for a non-fragment stage
5775         noImplicitLod = true;
5776     }
5777
5778     // multisample
5779     if (sampler.isMultiSample()) {
5780         params.sample = arguments[2 + extraArgs]; // For MS, "sample" should be specified
5781         ++extraArgs;
5782     }
5783
5784     // gradient
5785     if (cracked.grad) {
5786         params.gradX = arguments[2 + extraArgs];
5787         params.gradY = arguments[3 + extraArgs];
5788         extraArgs += 2;
5789     }
5790
5791     // offset and offsets
5792     if (cracked.offset) {
5793         params.offset = arguments[2 + extraArgs];
5794         ++extraArgs;
5795     } else if (cracked.offsets) {
5796         params.offsets = arguments[2 + extraArgs];
5797         ++extraArgs;
5798     }
5799
5800 #ifndef GLSLANG_WEB
5801     // lod clamp
5802     if (cracked.lodClamp) {
5803         params.lodClamp = arguments[2 + extraArgs];
5804         ++extraArgs;
5805     }
5806     // sparse
5807     if (sparse) {
5808         params.texelOut = arguments[2 + extraArgs];
5809         ++extraArgs;
5810     }
5811     // gather component
5812     if (cracked.gather && ! sampler.shadow) {
5813         // default component is 0, if missing, otherwise an argument
5814         if (2 + extraArgs < (int)arguments.size()) {
5815             params.component = arguments[2 + extraArgs];
5816             ++extraArgs;
5817         } else
5818             params.component = builder.makeIntConstant(0);
5819     }
5820     spv::Id  resultStruct = spv::NoResult;
5821     if (imageFootprint) {
5822         //Following three extra arguments
5823         // int granularity, bool coarse, out gl_TextureFootprint2DNV footprint
5824         params.granularity = arguments[2 + extraArgs];
5825         params.coarse = arguments[3 + extraArgs];
5826         resultStruct = arguments[4 + extraArgs];
5827         extraArgs += 3;
5828     }
5829 #endif
5830     // bias
5831     if (bias) {
5832         params.bias = arguments[2 + extraArgs];
5833         ++extraArgs;
5834     }
5835
5836 #ifndef GLSLANG_WEB
5837     if (imageFootprint) {
5838         builder.addExtension(spv::E_SPV_NV_shader_image_footprint);
5839         builder.addCapability(spv::CapabilityImageFootprintNV);
5840
5841
5842         //resultStructType(OpenGL type) contains 5 elements:
5843         //struct gl_TextureFootprint2DNV {
5844         //    uvec2 anchor;
5845         //    uvec2 offset;
5846         //    uvec2 mask;
5847         //    uint  lod;
5848         //    uint  granularity;
5849         //};
5850         //or
5851         //struct gl_TextureFootprint3DNV {
5852         //    uvec3 anchor;
5853         //    uvec3 offset;
5854         //    uvec2 mask;
5855         //    uint  lod;
5856         //    uint  granularity;
5857         //};
5858         spv::Id resultStructType = builder.getContainedTypeId(builder.getTypeId(resultStruct));
5859         assert(builder.isStructType(resultStructType));
5860
5861         //resType (SPIR-V type) contains 6 elements:
5862         //Member 0 must be a Boolean type scalar(LOD),
5863         //Member 1 must be a vector of integer type, whose Signedness operand is 0(anchor),
5864         //Member 2 must be a vector of integer type, whose Signedness operand is 0(offset),
5865         //Member 3 must be a vector of integer type, whose Signedness operand is 0(mask),
5866         //Member 4 must be a scalar of integer type, whose Signedness operand is 0(lod),
5867         //Member 5 must be a scalar of integer type, whose Signedness operand is 0(granularity).
5868         std::vector<spv::Id> members;
5869         members.push_back(resultType());
5870         for (int i = 0; i < 5; i++) {
5871             members.push_back(builder.getContainedTypeId(resultStructType, i));
5872         }
5873         spv::Id resType = builder.makeStructType(members, "ResType");
5874
5875         //call ImageFootprintNV
5876         spv::Id res = builder.createTextureCall(precision, resType, sparse, cracked.fetch, cracked.proj,
5877                                                 cracked.gather, noImplicitLod, params, signExtensionMask());
5878
5879         //copy resType (SPIR-V type) to resultStructType(OpenGL type)
5880         for (int i = 0; i < 5; i++) {
5881             builder.clearAccessChain();
5882             builder.setAccessChainLValue(resultStruct);
5883
5884             //Accessing to a struct we created, no coherent flag is set
5885             spv::Builder::AccessChain::CoherentFlags flags;
5886             flags.clear();
5887
5888             builder.accessChainPush(builder.makeIntConstant(i), flags, 0);
5889             builder.accessChainStore(builder.createCompositeExtract(res, builder.getContainedTypeId(resType, i+1),
5890                 i+1), TranslateNonUniformDecoration(imageType.getQualifier()));
5891         }
5892         return builder.createCompositeExtract(res, resultType(), 0);
5893     }
5894 #endif
5895
5896     // projective component (might not to move)
5897     // GLSL: "The texture coordinates consumed from P, not including the last component of P,
5898     //       are divided by the last component of P."
5899     // SPIR-V:  "... (u [, v] [, w], q)... It may be a vector larger than needed, but all
5900     //          unused components will appear after all used components."
5901     if (cracked.proj) {
5902         int projSourceComp = builder.getNumComponents(params.coords) - 1;
5903         int projTargetComp;
5904         switch (sampler.dim) {
5905         case glslang::Esd1D:   projTargetComp = 1;              break;
5906         case glslang::Esd2D:   projTargetComp = 2;              break;
5907         case glslang::EsdRect: projTargetComp = 2;              break;
5908         default:               projTargetComp = projSourceComp; break;
5909         }
5910         // copy the projective coordinate if we have to
5911         if (projTargetComp != projSourceComp) {
5912             spv::Id projComp = builder.createCompositeExtract(params.coords,
5913                                     builder.getScalarTypeId(builder.getTypeId(params.coords)), projSourceComp);
5914             params.coords = builder.createCompositeInsert(projComp, params.coords,
5915                                     builder.getTypeId(params.coords), projTargetComp);
5916         }
5917     }
5918
5919 #ifndef GLSLANG_WEB
5920     // nonprivate
5921     if (imageType.getQualifier().nonprivate) {
5922         params.nonprivate = true;
5923     }
5924
5925     // volatile
5926     if (imageType.getQualifier().volatil) {
5927         params.volatil = true;
5928     }
5929 #endif
5930
5931     std::vector<spv::Id> result( 1,
5932         builder.createTextureCall(precision, resultType(), sparse, cracked.fetch, cracked.proj, cracked.gather,
5933                                   noImplicitLod, params, signExtensionMask())
5934     );
5935
5936     if (components != node->getType().getVectorSize())
5937         result[0] = builder.createConstructor(precision, result, convertGlslangToSpvType(node->getType()));
5938
5939     return result[0];
5940 }
5941
5942 spv::Id TGlslangToSpvTraverser::handleUserFunctionCall(const glslang::TIntermAggregate* node)
5943 {
5944     // Grab the function's pointer from the previously created function
5945     spv::Function* function = functionMap[node->getName().c_str()];
5946     if (! function)
5947         return 0;
5948
5949     const glslang::TIntermSequence& glslangArgs = node->getSequence();
5950     const glslang::TQualifierList& qualifiers = node->getQualifierList();
5951
5952     //  See comments in makeFunctions() for details about the semantics for parameter passing.
5953     //
5954     // These imply we need a four step process:
5955     // 1. Evaluate the arguments
5956     // 2. Allocate and make copies of in, out, and inout arguments
5957     // 3. Make the call
5958     // 4. Copy back the results
5959
5960     // 1. Evaluate the arguments and their types
5961     std::vector<spv::Builder::AccessChain> lValues;
5962     std::vector<spv::Id> rValues;
5963     std::vector<const glslang::TType*> argTypes;
5964     for (int a = 0; a < (int)glslangArgs.size(); ++a) {
5965         argTypes.push_back(&glslangArgs[a]->getAsTyped()->getType());
5966         // build l-value
5967         builder.clearAccessChain();
5968         glslangArgs[a]->traverse(this);
5969         // keep outputs and pass-by-originals as l-values, evaluate others as r-values
5970         if (originalParam(qualifiers[a], *argTypes[a], function->hasImplicitThis() && a == 0) ||
5971             writableParam(qualifiers[a])) {
5972             // save l-value
5973             lValues.push_back(builder.getAccessChain());
5974         } else {
5975             // process r-value
5976             rValues.push_back(accessChainLoad(*argTypes.back()));
5977         }
5978     }
5979
5980     // 2. Allocate space for anything needing a copy, and if it's "in" or "inout"
5981     // copy the original into that space.
5982     //
5983     // Also, build up the list of actual arguments to pass in for the call
5984     int lValueCount = 0;
5985     int rValueCount = 0;
5986     std::vector<spv::Id> spvArgs;
5987     for (int a = 0; a < (int)glslangArgs.size(); ++a) {
5988         spv::Id arg;
5989         if (originalParam(qualifiers[a], *argTypes[a], function->hasImplicitThis() && a == 0)) {
5990             builder.setAccessChain(lValues[lValueCount]);
5991             arg = builder.accessChainGetLValue();
5992             ++lValueCount;
5993         } else if (writableParam(qualifiers[a])) {
5994             // need space to hold the copy
5995             arg = builder.createVariable(function->getParamPrecision(a), spv::StorageClassFunction,
5996                 builder.getContainedTypeId(function->getParamType(a)), "param");
5997             if (qualifiers[a] == glslang::EvqIn || qualifiers[a] == glslang::EvqInOut) {
5998                 // need to copy the input into output space
5999                 builder.setAccessChain(lValues[lValueCount]);
6000                 spv::Id copy = accessChainLoad(*argTypes[a]);
6001                 builder.clearAccessChain();
6002                 builder.setAccessChainLValue(arg);
6003                 multiTypeStore(*argTypes[a], copy);
6004             }
6005             ++lValueCount;
6006         } else {
6007             // process r-value, which involves a copy for a type mismatch
6008             if (function->getParamType(a) != builder.getTypeId(rValues[rValueCount]) ||
6009                 TranslatePrecisionDecoration(*argTypes[a]) != function->getParamPrecision(a))
6010             {
6011                 spv::Id argCopy = builder.createVariable(function->getParamPrecision(a), spv::StorageClassFunction, function->getParamType(a), "arg");
6012                 builder.clearAccessChain();
6013                 builder.setAccessChainLValue(argCopy);
6014                 multiTypeStore(*argTypes[a], rValues[rValueCount]);
6015                 arg = builder.createLoad(argCopy, function->getParamPrecision(a));
6016             } else
6017                 arg = rValues[rValueCount];
6018             ++rValueCount;
6019         }
6020         spvArgs.push_back(arg);
6021     }
6022
6023     // 3. Make the call.
6024     spv::Id result = builder.createFunctionCall(function, spvArgs);
6025     builder.setPrecision(result, TranslatePrecisionDecoration(node->getType()));
6026     builder.addDecoration(result, TranslateNonUniformDecoration(node->getType().getQualifier()));
6027
6028     // 4. Copy back out an "out" arguments.
6029     lValueCount = 0;
6030     for (int a = 0; a < (int)glslangArgs.size(); ++a) {
6031         if (originalParam(qualifiers[a], *argTypes[a], function->hasImplicitThis() && a == 0))
6032             ++lValueCount;
6033         else if (writableParam(qualifiers[a])) {
6034             if (qualifiers[a] == glslang::EvqOut || qualifiers[a] == glslang::EvqInOut) {
6035                 spv::Id copy = builder.createLoad(spvArgs[a], spv::NoPrecision);
6036                 builder.addDecoration(copy, TranslateNonUniformDecoration(argTypes[a]->getQualifier()));
6037                 builder.setAccessChain(lValues[lValueCount]);
6038                 multiTypeStore(*argTypes[a], copy);
6039             }
6040             ++lValueCount;
6041         }
6042     }
6043
6044     return result;
6045 }
6046
6047 // Translate AST operation to SPV operation, already having SPV-based operands/types.
6048 spv::Id TGlslangToSpvTraverser::createBinaryOperation(glslang::TOperator op, OpDecorations& decorations,
6049                                                       spv::Id typeId, spv::Id left, spv::Id right,
6050                                                       glslang::TBasicType typeProxy, bool reduceComparison)
6051 {
6052     bool isUnsigned = isTypeUnsignedInt(typeProxy);
6053     bool isFloat = isTypeFloat(typeProxy);
6054     bool isBool = typeProxy == glslang::EbtBool;
6055
6056     spv::Op binOp = spv::OpNop;
6057     bool needMatchingVectors = true;  // for non-matrix ops, would a scalar need to smear to match a vector?
6058     bool comparison = false;
6059
6060     switch (op) {
6061     case glslang::EOpAdd:
6062     case glslang::EOpAddAssign:
6063         if (isFloat)
6064             binOp = spv::OpFAdd;
6065         else
6066             binOp = spv::OpIAdd;
6067         break;
6068     case glslang::EOpSub:
6069     case glslang::EOpSubAssign:
6070         if (isFloat)
6071             binOp = spv::OpFSub;
6072         else
6073             binOp = spv::OpISub;
6074         break;
6075     case glslang::EOpMul:
6076     case glslang::EOpMulAssign:
6077         if (isFloat)
6078             binOp = spv::OpFMul;
6079         else
6080             binOp = spv::OpIMul;
6081         break;
6082     case glslang::EOpVectorTimesScalar:
6083     case glslang::EOpVectorTimesScalarAssign:
6084         if (isFloat && (builder.isVector(left) || builder.isVector(right))) {
6085             if (builder.isVector(right))
6086                 std::swap(left, right);
6087             assert(builder.isScalar(right));
6088             needMatchingVectors = false;
6089             binOp = spv::OpVectorTimesScalar;
6090         } else if (isFloat)
6091             binOp = spv::OpFMul;
6092           else
6093             binOp = spv::OpIMul;
6094         break;
6095     case glslang::EOpVectorTimesMatrix:
6096     case glslang::EOpVectorTimesMatrixAssign:
6097         binOp = spv::OpVectorTimesMatrix;
6098         break;
6099     case glslang::EOpMatrixTimesVector:
6100         binOp = spv::OpMatrixTimesVector;
6101         break;
6102     case glslang::EOpMatrixTimesScalar:
6103     case glslang::EOpMatrixTimesScalarAssign:
6104         binOp = spv::OpMatrixTimesScalar;
6105         break;
6106     case glslang::EOpMatrixTimesMatrix:
6107     case glslang::EOpMatrixTimesMatrixAssign:
6108         binOp = spv::OpMatrixTimesMatrix;
6109         break;
6110     case glslang::EOpOuterProduct:
6111         binOp = spv::OpOuterProduct;
6112         needMatchingVectors = false;
6113         break;
6114
6115     case glslang::EOpDiv:
6116     case glslang::EOpDivAssign:
6117         if (isFloat)
6118             binOp = spv::OpFDiv;
6119         else if (isUnsigned)
6120             binOp = spv::OpUDiv;
6121         else
6122             binOp = spv::OpSDiv;
6123         break;
6124     case glslang::EOpMod:
6125     case glslang::EOpModAssign:
6126         if (isFloat)
6127             binOp = spv::OpFMod;
6128         else if (isUnsigned)
6129             binOp = spv::OpUMod;
6130         else
6131             binOp = spv::OpSMod;
6132         break;
6133     case glslang::EOpRightShift:
6134     case glslang::EOpRightShiftAssign:
6135         if (isUnsigned)
6136             binOp = spv::OpShiftRightLogical;
6137         else
6138             binOp = spv::OpShiftRightArithmetic;
6139         break;
6140     case glslang::EOpLeftShift:
6141     case glslang::EOpLeftShiftAssign:
6142         binOp = spv::OpShiftLeftLogical;
6143         break;
6144     case glslang::EOpAnd:
6145     case glslang::EOpAndAssign:
6146         binOp = spv::OpBitwiseAnd;
6147         break;
6148     case glslang::EOpLogicalAnd:
6149         needMatchingVectors = false;
6150         binOp = spv::OpLogicalAnd;
6151         break;
6152     case glslang::EOpInclusiveOr:
6153     case glslang::EOpInclusiveOrAssign:
6154         binOp = spv::OpBitwiseOr;
6155         break;
6156     case glslang::EOpLogicalOr:
6157         needMatchingVectors = false;
6158         binOp = spv::OpLogicalOr;
6159         break;
6160     case glslang::EOpExclusiveOr:
6161     case glslang::EOpExclusiveOrAssign:
6162         binOp = spv::OpBitwiseXor;
6163         break;
6164     case glslang::EOpLogicalXor:
6165         needMatchingVectors = false;
6166         binOp = spv::OpLogicalNotEqual;
6167         break;
6168
6169     case glslang::EOpAbsDifference:
6170         binOp = isUnsigned ? spv::OpAbsUSubINTEL : spv::OpAbsISubINTEL;
6171         break;
6172
6173     case glslang::EOpAddSaturate:
6174         binOp = isUnsigned ? spv::OpUAddSatINTEL : spv::OpIAddSatINTEL;
6175         break;
6176
6177     case glslang::EOpSubSaturate:
6178         binOp = isUnsigned ? spv::OpUSubSatINTEL : spv::OpISubSatINTEL;
6179         break;
6180
6181     case glslang::EOpAverage:
6182         binOp = isUnsigned ? spv::OpUAverageINTEL : spv::OpIAverageINTEL;
6183         break;
6184
6185     case glslang::EOpAverageRounded:
6186         binOp = isUnsigned ? spv::OpUAverageRoundedINTEL : spv::OpIAverageRoundedINTEL;
6187         break;
6188
6189     case glslang::EOpMul32x16:
6190         binOp = isUnsigned ? spv::OpUMul32x16INTEL : spv::OpIMul32x16INTEL;
6191         break;
6192
6193     case glslang::EOpLessThan:
6194     case glslang::EOpGreaterThan:
6195     case glslang::EOpLessThanEqual:
6196     case glslang::EOpGreaterThanEqual:
6197     case glslang::EOpEqual:
6198     case glslang::EOpNotEqual:
6199     case glslang::EOpVectorEqual:
6200     case glslang::EOpVectorNotEqual:
6201         comparison = true;
6202         break;
6203     default:
6204         break;
6205     }
6206
6207     // handle mapped binary operations (should be non-comparison)
6208     if (binOp != spv::OpNop) {
6209         assert(comparison == false);
6210         if (builder.isMatrix(left) || builder.isMatrix(right) ||
6211             builder.isCooperativeMatrix(left) || builder.isCooperativeMatrix(right))
6212             return createBinaryMatrixOperation(binOp, decorations, typeId, left, right);
6213
6214         // No matrix involved; make both operands be the same number of components, if needed
6215         if (needMatchingVectors)
6216             builder.promoteScalar(decorations.precision, left, right);
6217
6218         spv::Id result = builder.createBinOp(binOp, typeId, left, right);
6219         decorations.addNoContraction(builder, result);
6220         decorations.addNonUniform(builder, result);
6221         return builder.setPrecision(result, decorations.precision);
6222     }
6223
6224     if (! comparison)
6225         return 0;
6226
6227     // Handle comparison instructions
6228
6229     if (reduceComparison && (op == glslang::EOpEqual || op == glslang::EOpNotEqual)
6230                          && (builder.isVector(left) || builder.isMatrix(left) || builder.isAggregate(left))) {
6231         spv::Id result = builder.createCompositeCompare(decorations.precision, left, right, op == glslang::EOpEqual);
6232         decorations.addNonUniform(builder, result);
6233         return result;
6234     }
6235
6236     switch (op) {
6237     case glslang::EOpLessThan:
6238         if (isFloat)
6239             binOp = spv::OpFOrdLessThan;
6240         else if (isUnsigned)
6241             binOp = spv::OpULessThan;
6242         else
6243             binOp = spv::OpSLessThan;
6244         break;
6245     case glslang::EOpGreaterThan:
6246         if (isFloat)
6247             binOp = spv::OpFOrdGreaterThan;
6248         else if (isUnsigned)
6249             binOp = spv::OpUGreaterThan;
6250         else
6251             binOp = spv::OpSGreaterThan;
6252         break;
6253     case glslang::EOpLessThanEqual:
6254         if (isFloat)
6255             binOp = spv::OpFOrdLessThanEqual;
6256         else if (isUnsigned)
6257             binOp = spv::OpULessThanEqual;
6258         else
6259             binOp = spv::OpSLessThanEqual;
6260         break;
6261     case glslang::EOpGreaterThanEqual:
6262         if (isFloat)
6263             binOp = spv::OpFOrdGreaterThanEqual;
6264         else if (isUnsigned)
6265             binOp = spv::OpUGreaterThanEqual;
6266         else
6267             binOp = spv::OpSGreaterThanEqual;
6268         break;
6269     case glslang::EOpEqual:
6270     case glslang::EOpVectorEqual:
6271         if (isFloat)
6272             binOp = spv::OpFOrdEqual;
6273         else if (isBool)
6274             binOp = spv::OpLogicalEqual;
6275         else
6276             binOp = spv::OpIEqual;
6277         break;
6278     case glslang::EOpNotEqual:
6279     case glslang::EOpVectorNotEqual:
6280         if (isFloat)
6281             binOp = spv::OpFUnordNotEqual;
6282         else if (isBool)
6283             binOp = spv::OpLogicalNotEqual;
6284         else
6285             binOp = spv::OpINotEqual;
6286         break;
6287     default:
6288         break;
6289     }
6290
6291     if (binOp != spv::OpNop) {
6292         spv::Id result = builder.createBinOp(binOp, typeId, left, right);
6293         decorations.addNoContraction(builder, result);
6294         decorations.addNonUniform(builder, result);
6295         return builder.setPrecision(result, decorations.precision);
6296     }
6297
6298     return 0;
6299 }
6300
6301 //
6302 // Translate AST matrix operation to SPV operation, already having SPV-based operands/types.
6303 // These can be any of:
6304 //
6305 //   matrix * scalar
6306 //   scalar * matrix
6307 //   matrix * matrix     linear algebraic
6308 //   matrix * vector
6309 //   vector * matrix
6310 //   matrix * matrix     componentwise
6311 //   matrix op matrix    op in {+, -, /}
6312 //   matrix op scalar    op in {+, -, /}
6313 //   scalar op matrix    op in {+, -, /}
6314 //
6315 spv::Id TGlslangToSpvTraverser::createBinaryMatrixOperation(spv::Op op, OpDecorations& decorations, spv::Id typeId,
6316                                                             spv::Id left, spv::Id right)
6317 {
6318     bool firstClass = true;
6319
6320     // First, handle first-class matrix operations (* and matrix/scalar)
6321     switch (op) {
6322     case spv::OpFDiv:
6323         if (builder.isMatrix(left) && builder.isScalar(right)) {
6324             // turn matrix / scalar into a multiply...
6325             spv::Id resultType = builder.getTypeId(right);
6326             right = builder.createBinOp(spv::OpFDiv, resultType, builder.makeFpConstant(resultType, 1.0), right);
6327             op = spv::OpMatrixTimesScalar;
6328         } else
6329             firstClass = false;
6330         break;
6331     case spv::OpMatrixTimesScalar:
6332         if (builder.isMatrix(right) || builder.isCooperativeMatrix(right))
6333             std::swap(left, right);
6334         assert(builder.isScalar(right));
6335         break;
6336     case spv::OpVectorTimesMatrix:
6337         assert(builder.isVector(left));
6338         assert(builder.isMatrix(right));
6339         break;
6340     case spv::OpMatrixTimesVector:
6341         assert(builder.isMatrix(left));
6342         assert(builder.isVector(right));
6343         break;
6344     case spv::OpMatrixTimesMatrix:
6345         assert(builder.isMatrix(left));
6346         assert(builder.isMatrix(right));
6347         break;
6348     default:
6349         firstClass = false;
6350         break;
6351     }
6352
6353     if (builder.isCooperativeMatrix(left) || builder.isCooperativeMatrix(right))
6354         firstClass = true;
6355
6356     if (firstClass) {
6357         spv::Id result = builder.createBinOp(op, typeId, left, right);
6358         decorations.addNoContraction(builder, result);
6359         decorations.addNonUniform(builder, result);
6360         return builder.setPrecision(result, decorations.precision);
6361     }
6362
6363     // Handle component-wise +, -, *, %, and / for all combinations of type.
6364     // The result type of all of them is the same type as the (a) matrix operand.
6365     // The algorithm is to:
6366     //   - break the matrix(es) into vectors
6367     //   - smear any scalar to a vector
6368     //   - do vector operations
6369     //   - make a matrix out the vector results
6370     switch (op) {
6371     case spv::OpFAdd:
6372     case spv::OpFSub:
6373     case spv::OpFDiv:
6374     case spv::OpFMod:
6375     case spv::OpFMul:
6376     {
6377         // one time set up...
6378         bool  leftMat = builder.isMatrix(left);
6379         bool rightMat = builder.isMatrix(right);
6380         unsigned int numCols = leftMat ? builder.getNumColumns(left) : builder.getNumColumns(right);
6381         int numRows = leftMat ? builder.getNumRows(left) : builder.getNumRows(right);
6382         spv::Id scalarType = builder.getScalarTypeId(typeId);
6383         spv::Id vecType = builder.makeVectorType(scalarType, numRows);
6384         std::vector<spv::Id> results;
6385         spv::Id smearVec = spv::NoResult;
6386         if (builder.isScalar(left))
6387             smearVec = builder.smearScalar(decorations.precision, left, vecType);
6388         else if (builder.isScalar(right))
6389             smearVec = builder.smearScalar(decorations.precision, right, vecType);
6390
6391         // do each vector op
6392         for (unsigned int c = 0; c < numCols; ++c) {
6393             std::vector<unsigned int> indexes;
6394             indexes.push_back(c);
6395             spv::Id  leftVec =  leftMat ? builder.createCompositeExtract( left, vecType, indexes) : smearVec;
6396             spv::Id rightVec = rightMat ? builder.createCompositeExtract(right, vecType, indexes) : smearVec;
6397             spv::Id result = builder.createBinOp(op, vecType, leftVec, rightVec);
6398             decorations.addNoContraction(builder, result);
6399             decorations.addNonUniform(builder, result);
6400             results.push_back(builder.setPrecision(result, decorations.precision));
6401         }
6402
6403         // put the pieces together
6404         spv::Id result = builder.setPrecision(builder.createCompositeConstruct(typeId, results), decorations.precision);
6405         decorations.addNonUniform(builder, result);
6406         return result;
6407     }
6408     default:
6409         assert(0);
6410         return spv::NoResult;
6411     }
6412 }
6413
6414 spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, OpDecorations& decorations, spv::Id typeId,
6415     spv::Id operand, glslang::TBasicType typeProxy, const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags)
6416 {
6417     spv::Op unaryOp = spv::OpNop;
6418     int extBuiltins = -1;
6419     int libCall = -1;
6420     bool isUnsigned = isTypeUnsignedInt(typeProxy);
6421     bool isFloat = isTypeFloat(typeProxy);
6422
6423     switch (op) {
6424     case glslang::EOpNegative:
6425         if (isFloat) {
6426             unaryOp = spv::OpFNegate;
6427             if (builder.isMatrixType(typeId))
6428                 return createUnaryMatrixOperation(unaryOp, decorations, typeId, operand, typeProxy);
6429         } else
6430             unaryOp = spv::OpSNegate;
6431         break;
6432
6433     case glslang::EOpLogicalNot:
6434     case glslang::EOpVectorLogicalNot:
6435         unaryOp = spv::OpLogicalNot;
6436         break;
6437     case glslang::EOpBitwiseNot:
6438         unaryOp = spv::OpNot;
6439         break;
6440
6441     case glslang::EOpDeterminant:
6442         libCall = spv::GLSLstd450Determinant;
6443         break;
6444     case glslang::EOpMatrixInverse:
6445         libCall = spv::GLSLstd450MatrixInverse;
6446         break;
6447     case glslang::EOpTranspose:
6448         unaryOp = spv::OpTranspose;
6449         break;
6450
6451     case glslang::EOpRadians:
6452         libCall = spv::GLSLstd450Radians;
6453         break;
6454     case glslang::EOpDegrees:
6455         libCall = spv::GLSLstd450Degrees;
6456         break;
6457     case glslang::EOpSin:
6458         libCall = spv::GLSLstd450Sin;
6459         break;
6460     case glslang::EOpCos:
6461         libCall = spv::GLSLstd450Cos;
6462         break;
6463     case glslang::EOpTan:
6464         libCall = spv::GLSLstd450Tan;
6465         break;
6466     case glslang::EOpAcos:
6467         libCall = spv::GLSLstd450Acos;
6468         break;
6469     case glslang::EOpAsin:
6470         libCall = spv::GLSLstd450Asin;
6471         break;
6472     case glslang::EOpAtan:
6473         libCall = spv::GLSLstd450Atan;
6474         break;
6475
6476     case glslang::EOpAcosh:
6477         libCall = spv::GLSLstd450Acosh;
6478         break;
6479     case glslang::EOpAsinh:
6480         libCall = spv::GLSLstd450Asinh;
6481         break;
6482     case glslang::EOpAtanh:
6483         libCall = spv::GLSLstd450Atanh;
6484         break;
6485     case glslang::EOpTanh:
6486         libCall = spv::GLSLstd450Tanh;
6487         break;
6488     case glslang::EOpCosh:
6489         libCall = spv::GLSLstd450Cosh;
6490         break;
6491     case glslang::EOpSinh:
6492         libCall = spv::GLSLstd450Sinh;
6493         break;
6494
6495     case glslang::EOpLength:
6496         libCall = spv::GLSLstd450Length;
6497         break;
6498     case glslang::EOpNormalize:
6499         libCall = spv::GLSLstd450Normalize;
6500         break;
6501
6502     case glslang::EOpExp:
6503         libCall = spv::GLSLstd450Exp;
6504         break;
6505     case glslang::EOpLog:
6506         libCall = spv::GLSLstd450Log;
6507         break;
6508     case glslang::EOpExp2:
6509         libCall = spv::GLSLstd450Exp2;
6510         break;
6511     case glslang::EOpLog2:
6512         libCall = spv::GLSLstd450Log2;
6513         break;
6514     case glslang::EOpSqrt:
6515         libCall = spv::GLSLstd450Sqrt;
6516         break;
6517     case glslang::EOpInverseSqrt:
6518         libCall = spv::GLSLstd450InverseSqrt;
6519         break;
6520
6521     case glslang::EOpFloor:
6522         libCall = spv::GLSLstd450Floor;
6523         break;
6524     case glslang::EOpTrunc:
6525         libCall = spv::GLSLstd450Trunc;
6526         break;
6527     case glslang::EOpRound:
6528         libCall = spv::GLSLstd450Round;
6529         break;
6530     case glslang::EOpRoundEven:
6531         libCall = spv::GLSLstd450RoundEven;
6532         break;
6533     case glslang::EOpCeil:
6534         libCall = spv::GLSLstd450Ceil;
6535         break;
6536     case glslang::EOpFract:
6537         libCall = spv::GLSLstd450Fract;
6538         break;
6539
6540     case glslang::EOpIsNan:
6541         unaryOp = spv::OpIsNan;
6542         break;
6543     case glslang::EOpIsInf:
6544         unaryOp = spv::OpIsInf;
6545         break;
6546     case glslang::EOpIsFinite:
6547         unaryOp = spv::OpIsFinite;
6548         break;
6549
6550     case glslang::EOpFloatBitsToInt:
6551     case glslang::EOpFloatBitsToUint:
6552     case glslang::EOpIntBitsToFloat:
6553     case glslang::EOpUintBitsToFloat:
6554     case glslang::EOpDoubleBitsToInt64:
6555     case glslang::EOpDoubleBitsToUint64:
6556     case glslang::EOpInt64BitsToDouble:
6557     case glslang::EOpUint64BitsToDouble:
6558     case glslang::EOpFloat16BitsToInt16:
6559     case glslang::EOpFloat16BitsToUint16:
6560     case glslang::EOpInt16BitsToFloat16:
6561     case glslang::EOpUint16BitsToFloat16:
6562         unaryOp = spv::OpBitcast;
6563         break;
6564
6565     case glslang::EOpPackSnorm2x16:
6566         libCall = spv::GLSLstd450PackSnorm2x16;
6567         break;
6568     case glslang::EOpUnpackSnorm2x16:
6569         libCall = spv::GLSLstd450UnpackSnorm2x16;
6570         break;
6571     case glslang::EOpPackUnorm2x16:
6572         libCall = spv::GLSLstd450PackUnorm2x16;
6573         break;
6574     case glslang::EOpUnpackUnorm2x16:
6575         libCall = spv::GLSLstd450UnpackUnorm2x16;
6576         break;
6577     case glslang::EOpPackHalf2x16:
6578         libCall = spv::GLSLstd450PackHalf2x16;
6579         break;
6580     case glslang::EOpUnpackHalf2x16:
6581         libCall = spv::GLSLstd450UnpackHalf2x16;
6582         break;
6583 #ifndef GLSLANG_WEB
6584     case glslang::EOpPackSnorm4x8:
6585         libCall = spv::GLSLstd450PackSnorm4x8;
6586         break;
6587     case glslang::EOpUnpackSnorm4x8:
6588         libCall = spv::GLSLstd450UnpackSnorm4x8;
6589         break;
6590     case glslang::EOpPackUnorm4x8:
6591         libCall = spv::GLSLstd450PackUnorm4x8;
6592         break;
6593     case glslang::EOpUnpackUnorm4x8:
6594         libCall = spv::GLSLstd450UnpackUnorm4x8;
6595         break;
6596     case glslang::EOpPackDouble2x32:
6597         libCall = spv::GLSLstd450PackDouble2x32;
6598         break;
6599     case glslang::EOpUnpackDouble2x32:
6600         libCall = spv::GLSLstd450UnpackDouble2x32;
6601         break;
6602 #endif
6603
6604     case glslang::EOpPackInt2x32:
6605     case glslang::EOpUnpackInt2x32:
6606     case glslang::EOpPackUint2x32:
6607     case glslang::EOpUnpackUint2x32:
6608     case glslang::EOpPack16:
6609     case glslang::EOpPack32:
6610     case glslang::EOpPack64:
6611     case glslang::EOpUnpack32:
6612     case glslang::EOpUnpack16:
6613     case glslang::EOpUnpack8:
6614     case glslang::EOpPackInt2x16:
6615     case glslang::EOpUnpackInt2x16:
6616     case glslang::EOpPackUint2x16:
6617     case glslang::EOpUnpackUint2x16:
6618     case glslang::EOpPackInt4x16:
6619     case glslang::EOpUnpackInt4x16:
6620     case glslang::EOpPackUint4x16:
6621     case glslang::EOpUnpackUint4x16:
6622     case glslang::EOpPackFloat2x16:
6623     case glslang::EOpUnpackFloat2x16:
6624         unaryOp = spv::OpBitcast;
6625         break;
6626
6627     case glslang::EOpDPdx:
6628         unaryOp = spv::OpDPdx;
6629         break;
6630     case glslang::EOpDPdy:
6631         unaryOp = spv::OpDPdy;
6632         break;
6633     case glslang::EOpFwidth:
6634         unaryOp = spv::OpFwidth;
6635         break;
6636
6637     case glslang::EOpAny:
6638         unaryOp = spv::OpAny;
6639         break;
6640     case glslang::EOpAll:
6641         unaryOp = spv::OpAll;
6642         break;
6643
6644     case glslang::EOpAbs:
6645         if (isFloat)
6646             libCall = spv::GLSLstd450FAbs;
6647         else
6648             libCall = spv::GLSLstd450SAbs;
6649         break;
6650     case glslang::EOpSign:
6651         if (isFloat)
6652             libCall = spv::GLSLstd450FSign;
6653         else
6654             libCall = spv::GLSLstd450SSign;
6655         break;
6656
6657 #ifndef GLSLANG_WEB
6658     case glslang::EOpDPdxFine:
6659         unaryOp = spv::OpDPdxFine;
6660         break;
6661     case glslang::EOpDPdyFine:
6662         unaryOp = spv::OpDPdyFine;
6663         break;
6664     case glslang::EOpFwidthFine:
6665         unaryOp = spv::OpFwidthFine;
6666         break;
6667     case glslang::EOpDPdxCoarse:
6668         unaryOp = spv::OpDPdxCoarse;
6669         break;
6670     case glslang::EOpDPdyCoarse:
6671         unaryOp = spv::OpDPdyCoarse;
6672         break;
6673     case glslang::EOpFwidthCoarse:
6674         unaryOp = spv::OpFwidthCoarse;
6675         break;
6676     case glslang::EOpRayQueryProceed:
6677         unaryOp = spv::OpRayQueryProceedKHR;
6678         break;
6679     case glslang::EOpRayQueryGetRayTMin:
6680         unaryOp = spv::OpRayQueryGetRayTMinKHR;
6681         break;
6682     case glslang::EOpRayQueryGetRayFlags:
6683         unaryOp = spv::OpRayQueryGetRayFlagsKHR;
6684         break;
6685     case glslang::EOpRayQueryGetWorldRayOrigin:
6686         unaryOp = spv::OpRayQueryGetWorldRayOriginKHR;
6687         break;
6688     case glslang::EOpRayQueryGetWorldRayDirection:
6689         unaryOp = spv::OpRayQueryGetWorldRayDirectionKHR;
6690         break;
6691     case glslang::EOpRayQueryGetIntersectionCandidateAABBOpaque:
6692         unaryOp = spv::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR;
6693         break;
6694     case glslang::EOpInterpolateAtCentroid:
6695         if (typeProxy == glslang::EbtFloat16)
6696             builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float);
6697         libCall = spv::GLSLstd450InterpolateAtCentroid;
6698         break;
6699     case glslang::EOpAtomicCounterIncrement:
6700     case glslang::EOpAtomicCounterDecrement:
6701     case glslang::EOpAtomicCounter:
6702     {
6703         // Handle all of the atomics in one place, in createAtomicOperation()
6704         std::vector<spv::Id> operands;
6705         operands.push_back(operand);
6706         return createAtomicOperation(op, decorations.precision, typeId, operands, typeProxy, lvalueCoherentFlags);
6707     }
6708
6709     case glslang::EOpBitFieldReverse:
6710         unaryOp = spv::OpBitReverse;
6711         break;
6712     case glslang::EOpBitCount:
6713         unaryOp = spv::OpBitCount;
6714         break;
6715     case glslang::EOpFindLSB:
6716         libCall = spv::GLSLstd450FindILsb;
6717         break;
6718     case glslang::EOpFindMSB:
6719         if (isUnsigned)
6720             libCall = spv::GLSLstd450FindUMsb;
6721         else
6722             libCall = spv::GLSLstd450FindSMsb;
6723         break;
6724
6725     case glslang::EOpCountLeadingZeros:
6726         builder.addCapability(spv::CapabilityIntegerFunctions2INTEL);
6727         builder.addExtension("SPV_INTEL_shader_integer_functions2");
6728         unaryOp = spv::OpUCountLeadingZerosINTEL;
6729         break;
6730
6731     case glslang::EOpCountTrailingZeros:
6732         builder.addCapability(spv::CapabilityIntegerFunctions2INTEL);
6733         builder.addExtension("SPV_INTEL_shader_integer_functions2");
6734         unaryOp = spv::OpUCountTrailingZerosINTEL;
6735         break;
6736
6737     case glslang::EOpBallot:
6738     case glslang::EOpReadFirstInvocation:
6739     case glslang::EOpAnyInvocation:
6740     case glslang::EOpAllInvocations:
6741     case glslang::EOpAllInvocationsEqual:
6742     case glslang::EOpMinInvocations:
6743     case glslang::EOpMaxInvocations:
6744     case glslang::EOpAddInvocations:
6745     case glslang::EOpMinInvocationsNonUniform:
6746     case glslang::EOpMaxInvocationsNonUniform:
6747     case glslang::EOpAddInvocationsNonUniform:
6748     case glslang::EOpMinInvocationsInclusiveScan:
6749     case glslang::EOpMaxInvocationsInclusiveScan:
6750     case glslang::EOpAddInvocationsInclusiveScan:
6751     case glslang::EOpMinInvocationsInclusiveScanNonUniform:
6752     case glslang::EOpMaxInvocationsInclusiveScanNonUniform:
6753     case glslang::EOpAddInvocationsInclusiveScanNonUniform:
6754     case glslang::EOpMinInvocationsExclusiveScan:
6755     case glslang::EOpMaxInvocationsExclusiveScan:
6756     case glslang::EOpAddInvocationsExclusiveScan:
6757     case glslang::EOpMinInvocationsExclusiveScanNonUniform:
6758     case glslang::EOpMaxInvocationsExclusiveScanNonUniform:
6759     case glslang::EOpAddInvocationsExclusiveScanNonUniform:
6760     {
6761         std::vector<spv::Id> operands;
6762         operands.push_back(operand);
6763         return createInvocationsOperation(op, typeId, operands, typeProxy);
6764     }
6765     case glslang::EOpSubgroupAll:
6766     case glslang::EOpSubgroupAny:
6767     case glslang::EOpSubgroupAllEqual:
6768     case glslang::EOpSubgroupBroadcastFirst:
6769     case glslang::EOpSubgroupBallot:
6770     case glslang::EOpSubgroupInverseBallot:
6771     case glslang::EOpSubgroupBallotBitCount:
6772     case glslang::EOpSubgroupBallotInclusiveBitCount:
6773     case glslang::EOpSubgroupBallotExclusiveBitCount:
6774     case glslang::EOpSubgroupBallotFindLSB:
6775     case glslang::EOpSubgroupBallotFindMSB:
6776     case glslang::EOpSubgroupAdd:
6777     case glslang::EOpSubgroupMul:
6778     case glslang::EOpSubgroupMin:
6779     case glslang::EOpSubgroupMax:
6780     case glslang::EOpSubgroupAnd:
6781     case glslang::EOpSubgroupOr:
6782     case glslang::EOpSubgroupXor:
6783     case glslang::EOpSubgroupInclusiveAdd:
6784     case glslang::EOpSubgroupInclusiveMul:
6785     case glslang::EOpSubgroupInclusiveMin:
6786     case glslang::EOpSubgroupInclusiveMax:
6787     case glslang::EOpSubgroupInclusiveAnd:
6788     case glslang::EOpSubgroupInclusiveOr:
6789     case glslang::EOpSubgroupInclusiveXor:
6790     case glslang::EOpSubgroupExclusiveAdd:
6791     case glslang::EOpSubgroupExclusiveMul:
6792     case glslang::EOpSubgroupExclusiveMin:
6793     case glslang::EOpSubgroupExclusiveMax:
6794     case glslang::EOpSubgroupExclusiveAnd:
6795     case glslang::EOpSubgroupExclusiveOr:
6796     case glslang::EOpSubgroupExclusiveXor:
6797     case glslang::EOpSubgroupQuadSwapHorizontal:
6798     case glslang::EOpSubgroupQuadSwapVertical:
6799     case glslang::EOpSubgroupQuadSwapDiagonal: {
6800         std::vector<spv::Id> operands;
6801         operands.push_back(operand);
6802         return createSubgroupOperation(op, typeId, operands, typeProxy);
6803     }
6804     case glslang::EOpMbcnt:
6805         extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_ballot);
6806         libCall = spv::MbcntAMD;
6807         break;
6808
6809     case glslang::EOpCubeFaceIndex:
6810         extBuiltins = getExtBuiltins(spv::E_SPV_AMD_gcn_shader);
6811         libCall = spv::CubeFaceIndexAMD;
6812         break;
6813
6814     case glslang::EOpCubeFaceCoord:
6815         extBuiltins = getExtBuiltins(spv::E_SPV_AMD_gcn_shader);
6816         libCall = spv::CubeFaceCoordAMD;
6817         break;
6818     case glslang::EOpSubgroupPartition:
6819         unaryOp = spv::OpGroupNonUniformPartitionNV;
6820         break;
6821     case glslang::EOpConstructReference:
6822         unaryOp = spv::OpBitcast;
6823         break;
6824
6825     case glslang::EOpConvUint64ToAccStruct:
6826     case glslang::EOpConvUvec2ToAccStruct:
6827         unaryOp = spv::OpConvertUToAccelerationStructureKHR;
6828         break;
6829 #endif
6830
6831     case glslang::EOpCopyObject:
6832         unaryOp = spv::OpCopyObject;
6833         break;
6834
6835     default:
6836         return 0;
6837     }
6838
6839     spv::Id id;
6840     if (libCall >= 0) {
6841         std::vector<spv::Id> args;
6842         args.push_back(operand);
6843         id = builder.createBuiltinCall(typeId, extBuiltins >= 0 ? extBuiltins : stdBuiltins, libCall, args);
6844     } else {
6845         id = builder.createUnaryOp(unaryOp, typeId, operand);
6846     }
6847
6848     decorations.addNoContraction(builder, id);
6849     decorations.addNonUniform(builder, id);
6850     return builder.setPrecision(id, decorations.precision);
6851 }
6852
6853 // Create a unary operation on a matrix
6854 spv::Id TGlslangToSpvTraverser::createUnaryMatrixOperation(spv::Op op, OpDecorations& decorations, spv::Id typeId,
6855                                                            spv::Id operand, glslang::TBasicType /* typeProxy */)
6856 {
6857     // Handle unary operations vector by vector.
6858     // The result type is the same type as the original type.
6859     // The algorithm is to:
6860     //   - break the matrix into vectors
6861     //   - apply the operation to each vector
6862     //   - make a matrix out the vector results
6863
6864     // get the types sorted out
6865     int numCols = builder.getNumColumns(operand);
6866     int numRows = builder.getNumRows(operand);
6867     spv::Id srcVecType  = builder.makeVectorType(builder.getScalarTypeId(builder.getTypeId(operand)), numRows);
6868     spv::Id destVecType = builder.makeVectorType(builder.getScalarTypeId(typeId), numRows);
6869     std::vector<spv::Id> results;
6870
6871     // do each vector op
6872     for (int c = 0; c < numCols; ++c) {
6873         std::vector<unsigned int> indexes;
6874         indexes.push_back(c);
6875         spv::Id srcVec  = builder.createCompositeExtract(operand, srcVecType, indexes);
6876         spv::Id destVec = builder.createUnaryOp(op, destVecType, srcVec);
6877         decorations.addNoContraction(builder, destVec);
6878         decorations.addNonUniform(builder, destVec);
6879         results.push_back(builder.setPrecision(destVec, decorations.precision));
6880     }
6881
6882     // put the pieces together
6883     spv::Id result = builder.setPrecision(builder.createCompositeConstruct(typeId, results), decorations.precision);
6884     decorations.addNonUniform(builder, result);
6885     return result;
6886 }
6887
6888 // For converting integers where both the bitwidth and the signedness could
6889 // change, but only do the width change here. The caller is still responsible
6890 // for the signedness conversion.
6891 spv::Id TGlslangToSpvTraverser::createIntWidthConversion(glslang::TOperator op, spv::Id operand, int vectorSize)
6892 {
6893     // Get the result type width, based on the type to convert to.
6894     int width = 32;
6895     switch(op) {
6896     case glslang::EOpConvInt16ToUint8:
6897     case glslang::EOpConvIntToUint8:
6898     case glslang::EOpConvInt64ToUint8:
6899     case glslang::EOpConvUint16ToInt8:
6900     case glslang::EOpConvUintToInt8:
6901     case glslang::EOpConvUint64ToInt8:
6902         width = 8;
6903         break;
6904     case glslang::EOpConvInt8ToUint16:
6905     case glslang::EOpConvIntToUint16:
6906     case glslang::EOpConvInt64ToUint16:
6907     case glslang::EOpConvUint8ToInt16:
6908     case glslang::EOpConvUintToInt16:
6909     case glslang::EOpConvUint64ToInt16:
6910         width = 16;
6911         break;
6912     case glslang::EOpConvInt8ToUint:
6913     case glslang::EOpConvInt16ToUint:
6914     case glslang::EOpConvInt64ToUint:
6915     case glslang::EOpConvUint8ToInt:
6916     case glslang::EOpConvUint16ToInt:
6917     case glslang::EOpConvUint64ToInt:
6918         width = 32;
6919         break;
6920     case glslang::EOpConvInt8ToUint64:
6921     case glslang::EOpConvInt16ToUint64:
6922     case glslang::EOpConvIntToUint64:
6923     case glslang::EOpConvUint8ToInt64:
6924     case glslang::EOpConvUint16ToInt64:
6925     case glslang::EOpConvUintToInt64:
6926         width = 64;
6927         break;
6928
6929     default:
6930         assert(false && "Default missing");
6931         break;
6932     }
6933
6934     // Get the conversion operation and result type,
6935     // based on the target width, but the source type.
6936     spv::Id type = spv::NoType;
6937     spv::Op convOp = spv::OpNop;
6938     switch(op) {
6939     case glslang::EOpConvInt8ToUint16:
6940     case glslang::EOpConvInt8ToUint:
6941     case glslang::EOpConvInt8ToUint64:
6942     case glslang::EOpConvInt16ToUint8:
6943     case glslang::EOpConvInt16ToUint:
6944     case glslang::EOpConvInt16ToUint64:
6945     case glslang::EOpConvIntToUint8:
6946     case glslang::EOpConvIntToUint16:
6947     case glslang::EOpConvIntToUint64:
6948     case glslang::EOpConvInt64ToUint8:
6949     case glslang::EOpConvInt64ToUint16:
6950     case glslang::EOpConvInt64ToUint:
6951         convOp = spv::OpSConvert;
6952         type = builder.makeIntType(width);
6953         break;
6954     default:
6955         convOp = spv::OpUConvert;
6956         type = builder.makeUintType(width);
6957         break;
6958     }
6959
6960     if (vectorSize > 0)
6961         type = builder.makeVectorType(type, vectorSize);
6962
6963     return builder.createUnaryOp(convOp, type, operand);
6964 }
6965
6966 spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, OpDecorations& decorations, spv::Id destType,
6967                                                  spv::Id operand, glslang::TBasicType typeProxy)
6968 {
6969     spv::Op convOp = spv::OpNop;
6970     spv::Id zero = 0;
6971     spv::Id one = 0;
6972
6973     int vectorSize = builder.isVectorType(destType) ? builder.getNumTypeComponents(destType) : 0;
6974
6975     switch (op) {
6976     case glslang::EOpConvIntToBool:
6977     case glslang::EOpConvUintToBool:
6978         zero = builder.makeUintConstant(0);
6979         zero = makeSmearedConstant(zero, vectorSize);
6980         return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
6981     case glslang::EOpConvFloatToBool:
6982         zero = builder.makeFloatConstant(0.0F);
6983         zero = makeSmearedConstant(zero, vectorSize);
6984         return builder.createBinOp(spv::OpFUnordNotEqual, destType, operand, zero);
6985     case glslang::EOpConvBoolToFloat:
6986         convOp = spv::OpSelect;
6987         zero = builder.makeFloatConstant(0.0F);
6988         one  = builder.makeFloatConstant(1.0F);
6989         break;
6990
6991     case glslang::EOpConvBoolToInt:
6992     case glslang::EOpConvBoolToInt64:
6993 #ifndef GLSLANG_WEB
6994         if (op == glslang::EOpConvBoolToInt64) {
6995             zero = builder.makeInt64Constant(0);
6996             one = builder.makeInt64Constant(1);
6997         } else
6998 #endif
6999         {
7000             zero = builder.makeIntConstant(0);
7001             one = builder.makeIntConstant(1);
7002         }
7003
7004         convOp = spv::OpSelect;
7005         break;
7006
7007     case glslang::EOpConvBoolToUint:
7008     case glslang::EOpConvBoolToUint64:
7009 #ifndef GLSLANG_WEB
7010         if (op == glslang::EOpConvBoolToUint64) {
7011             zero = builder.makeUint64Constant(0);
7012             one = builder.makeUint64Constant(1);
7013         } else
7014 #endif
7015         {
7016             zero = builder.makeUintConstant(0);
7017             one = builder.makeUintConstant(1);
7018         }
7019
7020         convOp = spv::OpSelect;
7021         break;
7022
7023     case glslang::EOpConvInt8ToFloat16:
7024     case glslang::EOpConvInt8ToFloat:
7025     case glslang::EOpConvInt8ToDouble:
7026     case glslang::EOpConvInt16ToFloat16:
7027     case glslang::EOpConvInt16ToFloat:
7028     case glslang::EOpConvInt16ToDouble:
7029     case glslang::EOpConvIntToFloat16:
7030     case glslang::EOpConvIntToFloat:
7031     case glslang::EOpConvIntToDouble:
7032     case glslang::EOpConvInt64ToFloat:
7033     case glslang::EOpConvInt64ToDouble:
7034     case glslang::EOpConvInt64ToFloat16:
7035         convOp = spv::OpConvertSToF;
7036         break;
7037
7038     case glslang::EOpConvUint8ToFloat16:
7039     case glslang::EOpConvUint8ToFloat:
7040     case glslang::EOpConvUint8ToDouble:
7041     case glslang::EOpConvUint16ToFloat16:
7042     case glslang::EOpConvUint16ToFloat:
7043     case glslang::EOpConvUint16ToDouble:
7044     case glslang::EOpConvUintToFloat16:
7045     case glslang::EOpConvUintToFloat:
7046     case glslang::EOpConvUintToDouble:
7047     case glslang::EOpConvUint64ToFloat:
7048     case glslang::EOpConvUint64ToDouble:
7049     case glslang::EOpConvUint64ToFloat16:
7050         convOp = spv::OpConvertUToF;
7051         break;
7052
7053     case glslang::EOpConvFloat16ToInt8:
7054     case glslang::EOpConvFloatToInt8:
7055     case glslang::EOpConvDoubleToInt8:
7056     case glslang::EOpConvFloat16ToInt16:
7057     case glslang::EOpConvFloatToInt16:
7058     case glslang::EOpConvDoubleToInt16:
7059     case glslang::EOpConvFloat16ToInt:
7060     case glslang::EOpConvFloatToInt:
7061     case glslang::EOpConvDoubleToInt:
7062     case glslang::EOpConvFloat16ToInt64:
7063     case glslang::EOpConvFloatToInt64:
7064     case glslang::EOpConvDoubleToInt64:
7065         convOp = spv::OpConvertFToS;
7066         break;
7067
7068     case glslang::EOpConvUint8ToInt8:
7069     case glslang::EOpConvInt8ToUint8:
7070     case glslang::EOpConvUint16ToInt16:
7071     case glslang::EOpConvInt16ToUint16:
7072     case glslang::EOpConvUintToInt:
7073     case glslang::EOpConvIntToUint:
7074     case glslang::EOpConvUint64ToInt64:
7075     case glslang::EOpConvInt64ToUint64:
7076         if (builder.isInSpecConstCodeGenMode()) {
7077             // Build zero scalar or vector for OpIAdd.
7078 #ifndef GLSLANG_WEB
7079             if(op == glslang::EOpConvUint8ToInt8 || op == glslang::EOpConvInt8ToUint8) {
7080                 zero = builder.makeUint8Constant(0);
7081             } else if (op == glslang::EOpConvUint16ToInt16 || op == glslang::EOpConvInt16ToUint16) {
7082                 zero = builder.makeUint16Constant(0);
7083             } else if (op == glslang::EOpConvUint64ToInt64 || op == glslang::EOpConvInt64ToUint64) {
7084                 zero = builder.makeUint64Constant(0);
7085             } else
7086 #endif
7087             {
7088                 zero = builder.makeUintConstant(0);
7089             }
7090             zero = makeSmearedConstant(zero, vectorSize);
7091             // Use OpIAdd, instead of OpBitcast to do the conversion when
7092             // generating for OpSpecConstantOp instruction.
7093             return builder.createBinOp(spv::OpIAdd, destType, operand, zero);
7094         }
7095         // For normal run-time conversion instruction, use OpBitcast.
7096         convOp = spv::OpBitcast;
7097         break;
7098
7099     case glslang::EOpConvFloat16ToUint8:
7100     case glslang::EOpConvFloatToUint8:
7101     case glslang::EOpConvDoubleToUint8:
7102     case glslang::EOpConvFloat16ToUint16:
7103     case glslang::EOpConvFloatToUint16:
7104     case glslang::EOpConvDoubleToUint16:
7105     case glslang::EOpConvFloat16ToUint:
7106     case glslang::EOpConvFloatToUint:
7107     case glslang::EOpConvDoubleToUint:
7108     case glslang::EOpConvFloatToUint64:
7109     case glslang::EOpConvDoubleToUint64:
7110     case glslang::EOpConvFloat16ToUint64:
7111         convOp = spv::OpConvertFToU;
7112         break;
7113
7114 #ifndef GLSLANG_WEB
7115     case glslang::EOpConvInt8ToBool:
7116     case glslang::EOpConvUint8ToBool:
7117         zero = builder.makeUint8Constant(0);
7118         zero = makeSmearedConstant(zero, vectorSize);
7119         return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
7120     case glslang::EOpConvInt16ToBool:
7121     case glslang::EOpConvUint16ToBool:
7122         zero = builder.makeUint16Constant(0);
7123         zero = makeSmearedConstant(zero, vectorSize);
7124         return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
7125     case glslang::EOpConvInt64ToBool:
7126     case glslang::EOpConvUint64ToBool:
7127         zero = builder.makeUint64Constant(0);
7128         zero = makeSmearedConstant(zero, vectorSize);
7129         return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
7130     case glslang::EOpConvDoubleToBool:
7131         zero = builder.makeDoubleConstant(0.0);
7132         zero = makeSmearedConstant(zero, vectorSize);
7133         return builder.createBinOp(spv::OpFUnordNotEqual, destType, operand, zero);
7134     case glslang::EOpConvFloat16ToBool:
7135         zero = builder.makeFloat16Constant(0.0F);
7136         zero = makeSmearedConstant(zero, vectorSize);
7137         return builder.createBinOp(spv::OpFUnordNotEqual, destType, operand, zero);
7138     case glslang::EOpConvBoolToDouble:
7139         convOp = spv::OpSelect;
7140         zero = builder.makeDoubleConstant(0.0);
7141         one  = builder.makeDoubleConstant(1.0);
7142         break;
7143     case glslang::EOpConvBoolToFloat16:
7144         convOp = spv::OpSelect;
7145         zero = builder.makeFloat16Constant(0.0F);
7146         one = builder.makeFloat16Constant(1.0F);
7147         break;
7148     case glslang::EOpConvBoolToInt8:
7149         zero = builder.makeInt8Constant(0);
7150         one  = builder.makeInt8Constant(1);
7151         convOp = spv::OpSelect;
7152         break;
7153     case glslang::EOpConvBoolToUint8:
7154         zero = builder.makeUint8Constant(0);
7155         one  = builder.makeUint8Constant(1);
7156         convOp = spv::OpSelect;
7157         break;
7158     case glslang::EOpConvBoolToInt16:
7159         zero = builder.makeInt16Constant(0);
7160         one  = builder.makeInt16Constant(1);
7161         convOp = spv::OpSelect;
7162         break;
7163     case glslang::EOpConvBoolToUint16:
7164         zero = builder.makeUint16Constant(0);
7165         one  = builder.makeUint16Constant(1);
7166         convOp = spv::OpSelect;
7167         break;
7168     case glslang::EOpConvDoubleToFloat:
7169     case glslang::EOpConvFloatToDouble:
7170     case glslang::EOpConvDoubleToFloat16:
7171     case glslang::EOpConvFloat16ToDouble:
7172     case glslang::EOpConvFloatToFloat16:
7173     case glslang::EOpConvFloat16ToFloat:
7174         convOp = spv::OpFConvert;
7175         if (builder.isMatrixType(destType))
7176             return createUnaryMatrixOperation(convOp, decorations, destType, operand, typeProxy);
7177         break;
7178
7179     case glslang::EOpConvInt8ToInt16:
7180     case glslang::EOpConvInt8ToInt:
7181     case glslang::EOpConvInt8ToInt64:
7182     case glslang::EOpConvInt16ToInt8:
7183     case glslang::EOpConvInt16ToInt:
7184     case glslang::EOpConvInt16ToInt64:
7185     case glslang::EOpConvIntToInt8:
7186     case glslang::EOpConvIntToInt16:
7187     case glslang::EOpConvIntToInt64:
7188     case glslang::EOpConvInt64ToInt8:
7189     case glslang::EOpConvInt64ToInt16:
7190     case glslang::EOpConvInt64ToInt:
7191         convOp = spv::OpSConvert;
7192         break;
7193
7194     case glslang::EOpConvUint8ToUint16:
7195     case glslang::EOpConvUint8ToUint:
7196     case glslang::EOpConvUint8ToUint64:
7197     case glslang::EOpConvUint16ToUint8:
7198     case glslang::EOpConvUint16ToUint:
7199     case glslang::EOpConvUint16ToUint64:
7200     case glslang::EOpConvUintToUint8:
7201     case glslang::EOpConvUintToUint16:
7202     case glslang::EOpConvUintToUint64:
7203     case glslang::EOpConvUint64ToUint8:
7204     case glslang::EOpConvUint64ToUint16:
7205     case glslang::EOpConvUint64ToUint:
7206         convOp = spv::OpUConvert;
7207         break;
7208
7209     case glslang::EOpConvInt8ToUint16:
7210     case glslang::EOpConvInt8ToUint:
7211     case glslang::EOpConvInt8ToUint64:
7212     case glslang::EOpConvInt16ToUint8:
7213     case glslang::EOpConvInt16ToUint:
7214     case glslang::EOpConvInt16ToUint64:
7215     case glslang::EOpConvIntToUint8:
7216     case glslang::EOpConvIntToUint16:
7217     case glslang::EOpConvIntToUint64:
7218     case glslang::EOpConvInt64ToUint8:
7219     case glslang::EOpConvInt64ToUint16:
7220     case glslang::EOpConvInt64ToUint:
7221     case glslang::EOpConvUint8ToInt16:
7222     case glslang::EOpConvUint8ToInt:
7223     case glslang::EOpConvUint8ToInt64:
7224     case glslang::EOpConvUint16ToInt8:
7225     case glslang::EOpConvUint16ToInt:
7226     case glslang::EOpConvUint16ToInt64:
7227     case glslang::EOpConvUintToInt8:
7228     case glslang::EOpConvUintToInt16:
7229     case glslang::EOpConvUintToInt64:
7230     case glslang::EOpConvUint64ToInt8:
7231     case glslang::EOpConvUint64ToInt16:
7232     case glslang::EOpConvUint64ToInt:
7233         // OpSConvert/OpUConvert + OpBitCast
7234         operand = createIntWidthConversion(op, operand, vectorSize);
7235
7236         if (builder.isInSpecConstCodeGenMode()) {
7237             // Build zero scalar or vector for OpIAdd.
7238             switch(op) {
7239             case glslang::EOpConvInt16ToUint8:
7240             case glslang::EOpConvIntToUint8:
7241             case glslang::EOpConvInt64ToUint8:
7242             case glslang::EOpConvUint16ToInt8:
7243             case glslang::EOpConvUintToInt8:
7244             case glslang::EOpConvUint64ToInt8:
7245                 zero = builder.makeUint8Constant(0);
7246                 break;
7247             case glslang::EOpConvInt8ToUint16:
7248             case glslang::EOpConvIntToUint16:
7249             case glslang::EOpConvInt64ToUint16:
7250             case glslang::EOpConvUint8ToInt16:
7251             case glslang::EOpConvUintToInt16:
7252             case glslang::EOpConvUint64ToInt16:
7253                 zero = builder.makeUint16Constant(0);
7254                 break;
7255             case glslang::EOpConvInt8ToUint:
7256             case glslang::EOpConvInt16ToUint:
7257             case glslang::EOpConvInt64ToUint:
7258             case glslang::EOpConvUint8ToInt:
7259             case glslang::EOpConvUint16ToInt:
7260             case glslang::EOpConvUint64ToInt:
7261                 zero = builder.makeUintConstant(0);
7262                 break;
7263             case glslang::EOpConvInt8ToUint64:
7264             case glslang::EOpConvInt16ToUint64:
7265             case glslang::EOpConvIntToUint64:
7266             case glslang::EOpConvUint8ToInt64:
7267             case glslang::EOpConvUint16ToInt64:
7268             case glslang::EOpConvUintToInt64:
7269                 zero = builder.makeUint64Constant(0);
7270                 break;
7271             default:
7272                 assert(false && "Default missing");
7273                 break;
7274             }
7275             zero = makeSmearedConstant(zero, vectorSize);
7276             // Use OpIAdd, instead of OpBitcast to do the conversion when
7277             // generating for OpSpecConstantOp instruction.
7278             return builder.createBinOp(spv::OpIAdd, destType, operand, zero);
7279         }
7280         // For normal run-time conversion instruction, use OpBitcast.
7281         convOp = spv::OpBitcast;
7282         break;
7283     case glslang::EOpConvUint64ToPtr:
7284         convOp = spv::OpConvertUToPtr;
7285         break;
7286     case glslang::EOpConvPtrToUint64:
7287         convOp = spv::OpConvertPtrToU;
7288         break;
7289     case glslang::EOpConvPtrToUvec2:
7290     case glslang::EOpConvUvec2ToPtr:
7291         convOp = spv::OpBitcast;
7292         break;
7293 #endif
7294
7295     default:
7296         break;
7297     }
7298
7299     spv::Id result = 0;
7300     if (convOp == spv::OpNop)
7301         return result;
7302
7303     if (convOp == spv::OpSelect) {
7304         zero = makeSmearedConstant(zero, vectorSize);
7305         one  = makeSmearedConstant(one, vectorSize);
7306         result = builder.createTriOp(convOp, destType, operand, one, zero);
7307     } else
7308         result = builder.createUnaryOp(convOp, destType, operand);
7309
7310     result = builder.setPrecision(result, decorations.precision);
7311     decorations.addNonUniform(builder, result);
7312     return result;
7313 }
7314
7315 spv::Id TGlslangToSpvTraverser::makeSmearedConstant(spv::Id constant, int vectorSize)
7316 {
7317     if (vectorSize == 0)
7318         return constant;
7319
7320     spv::Id vectorTypeId = builder.makeVectorType(builder.getTypeId(constant), vectorSize);
7321     std::vector<spv::Id> components;
7322     for (int c = 0; c < vectorSize; ++c)
7323         components.push_back(constant);
7324     return builder.makeCompositeConstant(vectorTypeId, components);
7325 }
7326
7327 // For glslang ops that map to SPV atomic opCodes
7328 spv::Id TGlslangToSpvTraverser::createAtomicOperation(glslang::TOperator op, spv::Decoration /*precision*/,
7329     spv::Id typeId, std::vector<spv::Id>& operands, glslang::TBasicType typeProxy,
7330     const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags)
7331 {
7332     spv::Op opCode = spv::OpNop;
7333
7334     switch (op) {
7335     case glslang::EOpAtomicAdd:
7336     case glslang::EOpImageAtomicAdd:
7337     case glslang::EOpAtomicCounterAdd:
7338         opCode = spv::OpAtomicIAdd;
7339         if (typeProxy == glslang::EbtFloat16 || typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble) {
7340             opCode = spv::OpAtomicFAddEXT;
7341             builder.addExtension(spv::E_SPV_EXT_shader_atomic_float_add);
7342             if (typeProxy == glslang::EbtFloat16) {
7343                 builder.addExtension(spv::E_SPV_EXT_shader_atomic_float16_add);
7344                 builder.addCapability(spv::CapabilityAtomicFloat16AddEXT);
7345             } else if (typeProxy == glslang::EbtFloat) {
7346                 builder.addCapability(spv::CapabilityAtomicFloat32AddEXT);
7347             } else {
7348                 builder.addCapability(spv::CapabilityAtomicFloat64AddEXT);
7349             }
7350         }
7351         break;
7352     case glslang::EOpAtomicSubtract:
7353     case glslang::EOpAtomicCounterSubtract:
7354         opCode = spv::OpAtomicISub;
7355         break;
7356     case glslang::EOpAtomicMin:
7357     case glslang::EOpImageAtomicMin:
7358     case glslang::EOpAtomicCounterMin:
7359         if (typeProxy == glslang::EbtFloat16 || typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble) {
7360             opCode = spv::OpAtomicFMinEXT;
7361             builder.addExtension(spv::E_SPV_EXT_shader_atomic_float_min_max);
7362             if (typeProxy == glslang::EbtFloat16)
7363                 builder.addCapability(spv::CapabilityAtomicFloat16MinMaxEXT);
7364             else if (typeProxy == glslang::EbtFloat)
7365                 builder.addCapability(spv::CapabilityAtomicFloat32MinMaxEXT);
7366             else
7367                 builder.addCapability(spv::CapabilityAtomicFloat64MinMaxEXT);
7368         } else if (typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64) {
7369             opCode = spv::OpAtomicUMin;
7370         } else {
7371             opCode = spv::OpAtomicSMin;
7372         }
7373         break;
7374     case glslang::EOpAtomicMax:
7375     case glslang::EOpImageAtomicMax:
7376     case glslang::EOpAtomicCounterMax:
7377         if (typeProxy == glslang::EbtFloat16 || typeProxy == glslang::EbtFloat || typeProxy == glslang::EbtDouble) {
7378             opCode = spv::OpAtomicFMaxEXT;
7379             builder.addExtension(spv::E_SPV_EXT_shader_atomic_float_min_max);
7380             if (typeProxy == glslang::EbtFloat16)
7381                 builder.addCapability(spv::CapabilityAtomicFloat16MinMaxEXT);
7382             else if (typeProxy == glslang::EbtFloat)
7383                 builder.addCapability(spv::CapabilityAtomicFloat32MinMaxEXT);
7384             else
7385                 builder.addCapability(spv::CapabilityAtomicFloat64MinMaxEXT);
7386         } else if (typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64) {
7387             opCode = spv::OpAtomicUMax;
7388         } else {
7389             opCode = spv::OpAtomicSMax;
7390         }
7391         break;
7392     case glslang::EOpAtomicAnd:
7393     case glslang::EOpImageAtomicAnd:
7394     case glslang::EOpAtomicCounterAnd:
7395         opCode = spv::OpAtomicAnd;
7396         break;
7397     case glslang::EOpAtomicOr:
7398     case glslang::EOpImageAtomicOr:
7399     case glslang::EOpAtomicCounterOr:
7400         opCode = spv::OpAtomicOr;
7401         break;
7402     case glslang::EOpAtomicXor:
7403     case glslang::EOpImageAtomicXor:
7404     case glslang::EOpAtomicCounterXor:
7405         opCode = spv::OpAtomicXor;
7406         break;
7407     case glslang::EOpAtomicExchange:
7408     case glslang::EOpImageAtomicExchange:
7409     case glslang::EOpAtomicCounterExchange:
7410         opCode = spv::OpAtomicExchange;
7411         break;
7412     case glslang::EOpAtomicCompSwap:
7413     case glslang::EOpImageAtomicCompSwap:
7414     case glslang::EOpAtomicCounterCompSwap:
7415         opCode = spv::OpAtomicCompareExchange;
7416         break;
7417     case glslang::EOpAtomicCounterIncrement:
7418         opCode = spv::OpAtomicIIncrement;
7419         break;
7420     case glslang::EOpAtomicCounterDecrement:
7421         opCode = spv::OpAtomicIDecrement;
7422         break;
7423     case glslang::EOpAtomicCounter:
7424     case glslang::EOpImageAtomicLoad:
7425     case glslang::EOpAtomicLoad:
7426         opCode = spv::OpAtomicLoad;
7427         break;
7428     case glslang::EOpAtomicStore:
7429     case glslang::EOpImageAtomicStore:
7430         opCode = spv::OpAtomicStore;
7431         break;
7432     default:
7433         assert(0);
7434         break;
7435     }
7436
7437     if (typeProxy == glslang::EbtInt64 || typeProxy == glslang::EbtUint64)
7438         builder.addCapability(spv::CapabilityInt64Atomics);
7439
7440     // Sort out the operands
7441     //  - mapping from glslang -> SPV
7442     //  - there are extra SPV operands that are optional in glslang
7443     //  - compare-exchange swaps the value and comparator
7444     //  - compare-exchange has an extra memory semantics
7445     //  - EOpAtomicCounterDecrement needs a post decrement
7446     spv::Id pointerId = 0, compareId = 0, valueId = 0;
7447     // scope defaults to Device in the old model, QueueFamilyKHR in the new model
7448     spv::Id scopeId;
7449     if (glslangIntermediate->usingVulkanMemoryModel()) {
7450         scopeId = builder.makeUintConstant(spv::ScopeQueueFamilyKHR);
7451     } else {
7452         scopeId = builder.makeUintConstant(spv::ScopeDevice);
7453     }
7454     // semantics default to relaxed
7455     spv::Id semanticsId = builder.makeUintConstant(lvalueCoherentFlags.isVolatile() &&
7456         glslangIntermediate->usingVulkanMemoryModel() ?
7457                                                     spv::MemorySemanticsVolatileMask :
7458                                                     spv::MemorySemanticsMaskNone);
7459     spv::Id semanticsId2 = semanticsId;
7460
7461     pointerId = operands[0];
7462     if (opCode == spv::OpAtomicIIncrement || opCode == spv::OpAtomicIDecrement) {
7463         // no additional operands
7464     } else if (opCode == spv::OpAtomicCompareExchange) {
7465         compareId = operands[1];
7466         valueId = operands[2];
7467         if (operands.size() > 3) {
7468             scopeId = operands[3];
7469             semanticsId = builder.makeUintConstant(
7470                 builder.getConstantScalar(operands[4]) | builder.getConstantScalar(operands[5]));
7471             semanticsId2 = builder.makeUintConstant(
7472                 builder.getConstantScalar(operands[6]) | builder.getConstantScalar(operands[7]));
7473         }
7474     } else if (opCode == spv::OpAtomicLoad) {
7475         if (operands.size() > 1) {
7476             scopeId = operands[1];
7477             semanticsId = builder.makeUintConstant(
7478                 builder.getConstantScalar(operands[2]) | builder.getConstantScalar(operands[3]));
7479         }
7480     } else {
7481         // atomic store or RMW
7482         valueId = operands[1];
7483         if (operands.size() > 2) {
7484             scopeId = operands[2];
7485             semanticsId = builder.makeUintConstant
7486                 (builder.getConstantScalar(operands[3]) | builder.getConstantScalar(operands[4]));
7487         }
7488     }
7489
7490     // Check for capabilities
7491     unsigned semanticsImmediate = builder.getConstantScalar(semanticsId) | builder.getConstantScalar(semanticsId2);
7492     if (semanticsImmediate & (spv::MemorySemanticsMakeAvailableKHRMask |
7493                               spv::MemorySemanticsMakeVisibleKHRMask |
7494                               spv::MemorySemanticsOutputMemoryKHRMask |
7495                               spv::MemorySemanticsVolatileMask)) {
7496         builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
7497     }
7498
7499     if (builder.getConstantScalar(scopeId) == spv::ScopeQueueFamily) {
7500         builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
7501     }
7502
7503     if (glslangIntermediate->usingVulkanMemoryModel() && builder.getConstantScalar(scopeId) == spv::ScopeDevice) {
7504         builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR);
7505     }
7506
7507     std::vector<spv::Id> spvAtomicOperands;  // hold the spv operands
7508     spvAtomicOperands.push_back(pointerId);
7509     spvAtomicOperands.push_back(scopeId);
7510     spvAtomicOperands.push_back(semanticsId);
7511     if (opCode == spv::OpAtomicCompareExchange) {
7512         spvAtomicOperands.push_back(semanticsId2);
7513         spvAtomicOperands.push_back(valueId);
7514         spvAtomicOperands.push_back(compareId);
7515     } else if (opCode != spv::OpAtomicLoad && opCode != spv::OpAtomicIIncrement && opCode != spv::OpAtomicIDecrement) {
7516         spvAtomicOperands.push_back(valueId);
7517     }
7518
7519     if (opCode == spv::OpAtomicStore) {
7520         builder.createNoResultOp(opCode, spvAtomicOperands);
7521         return 0;
7522     } else {
7523         spv::Id resultId = builder.createOp(opCode, typeId, spvAtomicOperands);
7524
7525         // GLSL and HLSL atomic-counter decrement return post-decrement value,
7526         // while SPIR-V returns pre-decrement value. Translate between these semantics.
7527         if (op == glslang::EOpAtomicCounterDecrement)
7528             resultId = builder.createBinOp(spv::OpISub, typeId, resultId, builder.makeIntConstant(1));
7529
7530         return resultId;
7531     }
7532 }
7533
7534 // Create group invocation operations.
7535 spv::Id TGlslangToSpvTraverser::createInvocationsOperation(glslang::TOperator op, spv::Id typeId,
7536     std::vector<spv::Id>& operands, glslang::TBasicType typeProxy)
7537 {
7538     bool isUnsigned = isTypeUnsignedInt(typeProxy);
7539     bool isFloat = isTypeFloat(typeProxy);
7540
7541     spv::Op opCode = spv::OpNop;
7542     std::vector<spv::IdImmediate> spvGroupOperands;
7543     spv::GroupOperation groupOperation = spv::GroupOperationMax;
7544
7545     if (op == glslang::EOpBallot || op == glslang::EOpReadFirstInvocation ||
7546         op == glslang::EOpReadInvocation) {
7547         builder.addExtension(spv::E_SPV_KHR_shader_ballot);
7548         builder.addCapability(spv::CapabilitySubgroupBallotKHR);
7549     } else if (op == glslang::EOpAnyInvocation ||
7550         op == glslang::EOpAllInvocations ||
7551         op == glslang::EOpAllInvocationsEqual) {
7552         builder.addExtension(spv::E_SPV_KHR_subgroup_vote);
7553         builder.addCapability(spv::CapabilitySubgroupVoteKHR);
7554     } else {
7555         builder.addCapability(spv::CapabilityGroups);
7556         if (op == glslang::EOpMinInvocationsNonUniform ||
7557             op == glslang::EOpMaxInvocationsNonUniform ||
7558             op == glslang::EOpAddInvocationsNonUniform ||
7559             op == glslang::EOpMinInvocationsInclusiveScanNonUniform ||
7560             op == glslang::EOpMaxInvocationsInclusiveScanNonUniform ||
7561             op == glslang::EOpAddInvocationsInclusiveScanNonUniform ||
7562             op == glslang::EOpMinInvocationsExclusiveScanNonUniform ||
7563             op == glslang::EOpMaxInvocationsExclusiveScanNonUniform ||
7564             op == glslang::EOpAddInvocationsExclusiveScanNonUniform)
7565             builder.addExtension(spv::E_SPV_AMD_shader_ballot);
7566
7567         switch (op) {
7568         case glslang::EOpMinInvocations:
7569         case glslang::EOpMaxInvocations:
7570         case glslang::EOpAddInvocations:
7571         case glslang::EOpMinInvocationsNonUniform:
7572         case glslang::EOpMaxInvocationsNonUniform:
7573         case glslang::EOpAddInvocationsNonUniform:
7574             groupOperation = spv::GroupOperationReduce;
7575             break;
7576         case glslang::EOpMinInvocationsInclusiveScan:
7577         case glslang::EOpMaxInvocationsInclusiveScan:
7578         case glslang::EOpAddInvocationsInclusiveScan:
7579         case glslang::EOpMinInvocationsInclusiveScanNonUniform:
7580         case glslang::EOpMaxInvocationsInclusiveScanNonUniform:
7581         case glslang::EOpAddInvocationsInclusiveScanNonUniform:
7582             groupOperation = spv::GroupOperationInclusiveScan;
7583             break;
7584         case glslang::EOpMinInvocationsExclusiveScan:
7585         case glslang::EOpMaxInvocationsExclusiveScan:
7586         case glslang::EOpAddInvocationsExclusiveScan:
7587         case glslang::EOpMinInvocationsExclusiveScanNonUniform:
7588         case glslang::EOpMaxInvocationsExclusiveScanNonUniform:
7589         case glslang::EOpAddInvocationsExclusiveScanNonUniform:
7590             groupOperation = spv::GroupOperationExclusiveScan;
7591             break;
7592         default:
7593             break;
7594         }
7595         spv::IdImmediate scope = { true, builder.makeUintConstant(spv::ScopeSubgroup) };
7596         spvGroupOperands.push_back(scope);
7597         if (groupOperation != spv::GroupOperationMax) {
7598             spv::IdImmediate groupOp = { false, (unsigned)groupOperation };
7599             spvGroupOperands.push_back(groupOp);
7600         }
7601     }
7602
7603     for (auto opIt = operands.begin(); opIt != operands.end(); ++opIt) {
7604         spv::IdImmediate op = { true, *opIt };
7605         spvGroupOperands.push_back(op);
7606     }
7607
7608     switch (op) {
7609     case glslang::EOpAnyInvocation:
7610         opCode = spv::OpSubgroupAnyKHR;
7611         break;
7612     case glslang::EOpAllInvocations:
7613         opCode = spv::OpSubgroupAllKHR;
7614         break;
7615     case glslang::EOpAllInvocationsEqual:
7616         opCode = spv::OpSubgroupAllEqualKHR;
7617         break;
7618     case glslang::EOpReadInvocation:
7619         opCode = spv::OpSubgroupReadInvocationKHR;
7620         if (builder.isVectorType(typeId))
7621             return CreateInvocationsVectorOperation(opCode, groupOperation, typeId, operands);
7622         break;
7623     case glslang::EOpReadFirstInvocation:
7624         opCode = spv::OpSubgroupFirstInvocationKHR;
7625         if (builder.isVectorType(typeId))
7626             return CreateInvocationsVectorOperation(opCode, groupOperation, typeId, operands);
7627         break;
7628     case glslang::EOpBallot:
7629     {
7630         // NOTE: According to the spec, the result type of "OpSubgroupBallotKHR" must be a 4 component vector of 32
7631         // bit integer types. The GLSL built-in function "ballotARB()" assumes the maximum number of invocations in
7632         // a subgroup is 64. Thus, we have to convert uvec4.xy to uint64_t as follow:
7633         //
7634         //     result = Bitcast(SubgroupBallotKHR(Predicate).xy)
7635         //
7636         spv::Id uintType  = builder.makeUintType(32);
7637         spv::Id uvec4Type = builder.makeVectorType(uintType, 4);
7638         spv::Id result = builder.createOp(spv::OpSubgroupBallotKHR, uvec4Type, spvGroupOperands);
7639
7640         std::vector<spv::Id> components;
7641         components.push_back(builder.createCompositeExtract(result, uintType, 0));
7642         components.push_back(builder.createCompositeExtract(result, uintType, 1));
7643
7644         spv::Id uvec2Type = builder.makeVectorType(uintType, 2);
7645         return builder.createUnaryOp(spv::OpBitcast, typeId,
7646                                      builder.createCompositeConstruct(uvec2Type, components));
7647     }
7648
7649     case glslang::EOpMinInvocations:
7650     case glslang::EOpMaxInvocations:
7651     case glslang::EOpAddInvocations:
7652     case glslang::EOpMinInvocationsInclusiveScan:
7653     case glslang::EOpMaxInvocationsInclusiveScan:
7654     case glslang::EOpAddInvocationsInclusiveScan:
7655     case glslang::EOpMinInvocationsExclusiveScan:
7656     case glslang::EOpMaxInvocationsExclusiveScan:
7657     case glslang::EOpAddInvocationsExclusiveScan:
7658         if (op == glslang::EOpMinInvocations ||
7659             op == glslang::EOpMinInvocationsInclusiveScan ||
7660             op == glslang::EOpMinInvocationsExclusiveScan) {
7661             if (isFloat)
7662                 opCode = spv::OpGroupFMin;
7663             else {
7664                 if (isUnsigned)
7665                     opCode = spv::OpGroupUMin;
7666                 else
7667                     opCode = spv::OpGroupSMin;
7668             }
7669         } else if (op == glslang::EOpMaxInvocations ||
7670                    op == glslang::EOpMaxInvocationsInclusiveScan ||
7671                    op == glslang::EOpMaxInvocationsExclusiveScan) {
7672             if (isFloat)
7673                 opCode = spv::OpGroupFMax;
7674             else {
7675                 if (isUnsigned)
7676                     opCode = spv::OpGroupUMax;
7677                 else
7678                     opCode = spv::OpGroupSMax;
7679             }
7680         } else {
7681             if (isFloat)
7682                 opCode = spv::OpGroupFAdd;
7683             else
7684                 opCode = spv::OpGroupIAdd;
7685         }
7686
7687         if (builder.isVectorType(typeId))
7688             return CreateInvocationsVectorOperation(opCode, groupOperation, typeId, operands);
7689
7690         break;
7691     case glslang::EOpMinInvocationsNonUniform:
7692     case glslang::EOpMaxInvocationsNonUniform:
7693     case glslang::EOpAddInvocationsNonUniform:
7694     case glslang::EOpMinInvocationsInclusiveScanNonUniform:
7695     case glslang::EOpMaxInvocationsInclusiveScanNonUniform:
7696     case glslang::EOpAddInvocationsInclusiveScanNonUniform:
7697     case glslang::EOpMinInvocationsExclusiveScanNonUniform:
7698     case glslang::EOpMaxInvocationsExclusiveScanNonUniform:
7699     case glslang::EOpAddInvocationsExclusiveScanNonUniform:
7700         if (op == glslang::EOpMinInvocationsNonUniform ||
7701             op == glslang::EOpMinInvocationsInclusiveScanNonUniform ||
7702             op == glslang::EOpMinInvocationsExclusiveScanNonUniform) {
7703             if (isFloat)
7704                 opCode = spv::OpGroupFMinNonUniformAMD;
7705             else {
7706                 if (isUnsigned)
7707                     opCode = spv::OpGroupUMinNonUniformAMD;
7708                 else
7709                     opCode = spv::OpGroupSMinNonUniformAMD;
7710             }
7711         }
7712         else if (op == glslang::EOpMaxInvocationsNonUniform ||
7713                  op == glslang::EOpMaxInvocationsInclusiveScanNonUniform ||
7714                  op == glslang::EOpMaxInvocationsExclusiveScanNonUniform) {
7715             if (isFloat)
7716                 opCode = spv::OpGroupFMaxNonUniformAMD;
7717             else {
7718                 if (isUnsigned)
7719                     opCode = spv::OpGroupUMaxNonUniformAMD;
7720                 else
7721                     opCode = spv::OpGroupSMaxNonUniformAMD;
7722             }
7723         }
7724         else {
7725             if (isFloat)
7726                 opCode = spv::OpGroupFAddNonUniformAMD;
7727             else
7728                 opCode = spv::OpGroupIAddNonUniformAMD;
7729         }
7730
7731         if (builder.isVectorType(typeId))
7732             return CreateInvocationsVectorOperation(opCode, groupOperation, typeId, operands);
7733
7734         break;
7735     default:
7736         logger->missingFunctionality("invocation operation");
7737         return spv::NoResult;
7738     }
7739
7740     assert(opCode != spv::OpNop);
7741     return builder.createOp(opCode, typeId, spvGroupOperands);
7742 }
7743
7744 // Create group invocation operations on a vector
7745 spv::Id TGlslangToSpvTraverser::CreateInvocationsVectorOperation(spv::Op op, spv::GroupOperation groupOperation,
7746     spv::Id typeId, std::vector<spv::Id>& operands)
7747 {
7748     assert(op == spv::OpGroupFMin || op == spv::OpGroupUMin || op == spv::OpGroupSMin ||
7749            op == spv::OpGroupFMax || op == spv::OpGroupUMax || op == spv::OpGroupSMax ||
7750            op == spv::OpGroupFAdd || op == spv::OpGroupIAdd || op == spv::OpGroupBroadcast ||
7751            op == spv::OpSubgroupReadInvocationKHR || op == spv::OpSubgroupFirstInvocationKHR ||
7752            op == spv::OpGroupFMinNonUniformAMD || op == spv::OpGroupUMinNonUniformAMD ||
7753            op == spv::OpGroupSMinNonUniformAMD ||
7754            op == spv::OpGroupFMaxNonUniformAMD || op == spv::OpGroupUMaxNonUniformAMD ||
7755            op == spv::OpGroupSMaxNonUniformAMD ||
7756            op == spv::OpGroupFAddNonUniformAMD || op == spv::OpGroupIAddNonUniformAMD);
7757
7758     // Handle group invocation operations scalar by scalar.
7759     // The result type is the same type as the original type.
7760     // The algorithm is to:
7761     //   - break the vector into scalars
7762     //   - apply the operation to each scalar
7763     //   - make a vector out the scalar results
7764
7765     // get the types sorted out
7766     int numComponents = builder.getNumComponents(operands[0]);
7767     spv::Id scalarType = builder.getScalarTypeId(builder.getTypeId(operands[0]));
7768     std::vector<spv::Id> results;
7769
7770     // do each scalar op
7771     for (int comp = 0; comp < numComponents; ++comp) {
7772         std::vector<unsigned int> indexes;
7773         indexes.push_back(comp);
7774         spv::IdImmediate scalar = { true, builder.createCompositeExtract(operands[0], scalarType, indexes) };
7775         std::vector<spv::IdImmediate> spvGroupOperands;
7776         if (op == spv::OpSubgroupReadInvocationKHR) {
7777             spvGroupOperands.push_back(scalar);
7778             spv::IdImmediate operand = { true, operands[1] };
7779             spvGroupOperands.push_back(operand);
7780         } else if (op == spv::OpSubgroupFirstInvocationKHR) {
7781             spvGroupOperands.push_back(scalar);
7782         } else if (op == spv::OpGroupBroadcast) {
7783             spv::IdImmediate scope = { true, builder.makeUintConstant(spv::ScopeSubgroup) };
7784             spvGroupOperands.push_back(scope);
7785             spvGroupOperands.push_back(scalar);
7786             spv::IdImmediate operand = { true, operands[1] };
7787             spvGroupOperands.push_back(operand);
7788         } else {
7789             spv::IdImmediate scope = { true, builder.makeUintConstant(spv::ScopeSubgroup) };
7790             spvGroupOperands.push_back(scope);
7791             spv::IdImmediate groupOp = { false, (unsigned)groupOperation };
7792             spvGroupOperands.push_back(groupOp);
7793             spvGroupOperands.push_back(scalar);
7794         }
7795
7796         results.push_back(builder.createOp(op, scalarType, spvGroupOperands));
7797     }
7798
7799     // put the pieces together
7800     return builder.createCompositeConstruct(typeId, results);
7801 }
7802
7803 // Create subgroup invocation operations.
7804 spv::Id TGlslangToSpvTraverser::createSubgroupOperation(glslang::TOperator op, spv::Id typeId,
7805     std::vector<spv::Id>& operands, glslang::TBasicType typeProxy)
7806 {
7807     // Add the required capabilities.
7808     switch (op) {
7809     case glslang::EOpSubgroupElect:
7810         builder.addCapability(spv::CapabilityGroupNonUniform);
7811         break;
7812     case glslang::EOpSubgroupAll:
7813     case glslang::EOpSubgroupAny:
7814     case glslang::EOpSubgroupAllEqual:
7815         builder.addCapability(spv::CapabilityGroupNonUniform);
7816         builder.addCapability(spv::CapabilityGroupNonUniformVote);
7817         break;
7818     case glslang::EOpSubgroupBroadcast:
7819     case glslang::EOpSubgroupBroadcastFirst:
7820     case glslang::EOpSubgroupBallot:
7821     case glslang::EOpSubgroupInverseBallot:
7822     case glslang::EOpSubgroupBallotBitExtract:
7823     case glslang::EOpSubgroupBallotBitCount:
7824     case glslang::EOpSubgroupBallotInclusiveBitCount:
7825     case glslang::EOpSubgroupBallotExclusiveBitCount:
7826     case glslang::EOpSubgroupBallotFindLSB:
7827     case glslang::EOpSubgroupBallotFindMSB:
7828         builder.addCapability(spv::CapabilityGroupNonUniform);
7829         builder.addCapability(spv::CapabilityGroupNonUniformBallot);
7830         break;
7831     case glslang::EOpSubgroupShuffle:
7832     case glslang::EOpSubgroupShuffleXor:
7833         builder.addCapability(spv::CapabilityGroupNonUniform);
7834         builder.addCapability(spv::CapabilityGroupNonUniformShuffle);
7835         break;
7836     case glslang::EOpSubgroupShuffleUp:
7837     case glslang::EOpSubgroupShuffleDown:
7838         builder.addCapability(spv::CapabilityGroupNonUniform);
7839         builder.addCapability(spv::CapabilityGroupNonUniformShuffleRelative);
7840         break;
7841     case glslang::EOpSubgroupAdd:
7842     case glslang::EOpSubgroupMul:
7843     case glslang::EOpSubgroupMin:
7844     case glslang::EOpSubgroupMax:
7845     case glslang::EOpSubgroupAnd:
7846     case glslang::EOpSubgroupOr:
7847     case glslang::EOpSubgroupXor:
7848     case glslang::EOpSubgroupInclusiveAdd:
7849     case glslang::EOpSubgroupInclusiveMul:
7850     case glslang::EOpSubgroupInclusiveMin:
7851     case glslang::EOpSubgroupInclusiveMax:
7852     case glslang::EOpSubgroupInclusiveAnd:
7853     case glslang::EOpSubgroupInclusiveOr:
7854     case glslang::EOpSubgroupInclusiveXor:
7855     case glslang::EOpSubgroupExclusiveAdd:
7856     case glslang::EOpSubgroupExclusiveMul:
7857     case glslang::EOpSubgroupExclusiveMin:
7858     case glslang::EOpSubgroupExclusiveMax:
7859     case glslang::EOpSubgroupExclusiveAnd:
7860     case glslang::EOpSubgroupExclusiveOr:
7861     case glslang::EOpSubgroupExclusiveXor:
7862         builder.addCapability(spv::CapabilityGroupNonUniform);
7863         builder.addCapability(spv::CapabilityGroupNonUniformArithmetic);
7864         break;
7865     case glslang::EOpSubgroupClusteredAdd:
7866     case glslang::EOpSubgroupClusteredMul:
7867     case glslang::EOpSubgroupClusteredMin:
7868     case glslang::EOpSubgroupClusteredMax:
7869     case glslang::EOpSubgroupClusteredAnd:
7870     case glslang::EOpSubgroupClusteredOr:
7871     case glslang::EOpSubgroupClusteredXor:
7872         builder.addCapability(spv::CapabilityGroupNonUniform);
7873         builder.addCapability(spv::CapabilityGroupNonUniformClustered);
7874         break;
7875     case glslang::EOpSubgroupQuadBroadcast:
7876     case glslang::EOpSubgroupQuadSwapHorizontal:
7877     case glslang::EOpSubgroupQuadSwapVertical:
7878     case glslang::EOpSubgroupQuadSwapDiagonal:
7879         builder.addCapability(spv::CapabilityGroupNonUniform);
7880         builder.addCapability(spv::CapabilityGroupNonUniformQuad);
7881         break;
7882     case glslang::EOpSubgroupPartitionedAdd:
7883     case glslang::EOpSubgroupPartitionedMul:
7884     case glslang::EOpSubgroupPartitionedMin:
7885     case glslang::EOpSubgroupPartitionedMax:
7886     case glslang::EOpSubgroupPartitionedAnd:
7887     case glslang::EOpSubgroupPartitionedOr:
7888     case glslang::EOpSubgroupPartitionedXor:
7889     case glslang::EOpSubgroupPartitionedInclusiveAdd:
7890     case glslang::EOpSubgroupPartitionedInclusiveMul:
7891     case glslang::EOpSubgroupPartitionedInclusiveMin:
7892     case glslang::EOpSubgroupPartitionedInclusiveMax:
7893     case glslang::EOpSubgroupPartitionedInclusiveAnd:
7894     case glslang::EOpSubgroupPartitionedInclusiveOr:
7895     case glslang::EOpSubgroupPartitionedInclusiveXor:
7896     case glslang::EOpSubgroupPartitionedExclusiveAdd:
7897     case glslang::EOpSubgroupPartitionedExclusiveMul:
7898     case glslang::EOpSubgroupPartitionedExclusiveMin:
7899     case glslang::EOpSubgroupPartitionedExclusiveMax:
7900     case glslang::EOpSubgroupPartitionedExclusiveAnd:
7901     case glslang::EOpSubgroupPartitionedExclusiveOr:
7902     case glslang::EOpSubgroupPartitionedExclusiveXor:
7903         builder.addExtension(spv::E_SPV_NV_shader_subgroup_partitioned);
7904         builder.addCapability(spv::CapabilityGroupNonUniformPartitionedNV);
7905         break;
7906     default: assert(0 && "Unhandled subgroup operation!");
7907     }
7908
7909
7910     const bool isUnsigned = isTypeUnsignedInt(typeProxy);
7911     const bool isFloat = isTypeFloat(typeProxy);
7912     const bool isBool = typeProxy == glslang::EbtBool;
7913
7914     spv::Op opCode = spv::OpNop;
7915
7916     // Figure out which opcode to use.
7917     switch (op) {
7918     case glslang::EOpSubgroupElect:                   opCode = spv::OpGroupNonUniformElect; break;
7919     case glslang::EOpSubgroupAll:                     opCode = spv::OpGroupNonUniformAll; break;
7920     case glslang::EOpSubgroupAny:                     opCode = spv::OpGroupNonUniformAny; break;
7921     case glslang::EOpSubgroupAllEqual:                opCode = spv::OpGroupNonUniformAllEqual; break;
7922     case glslang::EOpSubgroupBroadcast:               opCode = spv::OpGroupNonUniformBroadcast; break;
7923     case glslang::EOpSubgroupBroadcastFirst:          opCode = spv::OpGroupNonUniformBroadcastFirst; break;
7924     case glslang::EOpSubgroupBallot:                  opCode = spv::OpGroupNonUniformBallot; break;
7925     case glslang::EOpSubgroupInverseBallot:           opCode = spv::OpGroupNonUniformInverseBallot; break;
7926     case glslang::EOpSubgroupBallotBitExtract:        opCode = spv::OpGroupNonUniformBallotBitExtract; break;
7927     case glslang::EOpSubgroupBallotBitCount:
7928     case glslang::EOpSubgroupBallotInclusiveBitCount:
7929     case glslang::EOpSubgroupBallotExclusiveBitCount: opCode = spv::OpGroupNonUniformBallotBitCount; break;
7930     case glslang::EOpSubgroupBallotFindLSB:           opCode = spv::OpGroupNonUniformBallotFindLSB; break;
7931     case glslang::EOpSubgroupBallotFindMSB:           opCode = spv::OpGroupNonUniformBallotFindMSB; break;
7932     case glslang::EOpSubgroupShuffle:                 opCode = spv::OpGroupNonUniformShuffle; break;
7933     case glslang::EOpSubgroupShuffleXor:              opCode = spv::OpGroupNonUniformShuffleXor; break;
7934     case glslang::EOpSubgroupShuffleUp:               opCode = spv::OpGroupNonUniformShuffleUp; break;
7935     case glslang::EOpSubgroupShuffleDown:             opCode = spv::OpGroupNonUniformShuffleDown; break;
7936     case glslang::EOpSubgroupAdd:
7937     case glslang::EOpSubgroupInclusiveAdd:
7938     case glslang::EOpSubgroupExclusiveAdd:
7939     case glslang::EOpSubgroupClusteredAdd:
7940     case glslang::EOpSubgroupPartitionedAdd:
7941     case glslang::EOpSubgroupPartitionedInclusiveAdd:
7942     case glslang::EOpSubgroupPartitionedExclusiveAdd:
7943         if (isFloat) {
7944             opCode = spv::OpGroupNonUniformFAdd;
7945         } else {
7946             opCode = spv::OpGroupNonUniformIAdd;
7947         }
7948         break;
7949     case glslang::EOpSubgroupMul:
7950     case glslang::EOpSubgroupInclusiveMul:
7951     case glslang::EOpSubgroupExclusiveMul:
7952     case glslang::EOpSubgroupClusteredMul:
7953     case glslang::EOpSubgroupPartitionedMul:
7954     case glslang::EOpSubgroupPartitionedInclusiveMul:
7955     case glslang::EOpSubgroupPartitionedExclusiveMul:
7956         if (isFloat) {
7957             opCode = spv::OpGroupNonUniformFMul;
7958         } else {
7959             opCode = spv::OpGroupNonUniformIMul;
7960         }
7961         break;
7962     case glslang::EOpSubgroupMin:
7963     case glslang::EOpSubgroupInclusiveMin:
7964     case glslang::EOpSubgroupExclusiveMin:
7965     case glslang::EOpSubgroupClusteredMin:
7966     case glslang::EOpSubgroupPartitionedMin:
7967     case glslang::EOpSubgroupPartitionedInclusiveMin:
7968     case glslang::EOpSubgroupPartitionedExclusiveMin:
7969         if (isFloat) {
7970             opCode = spv::OpGroupNonUniformFMin;
7971         } else if (isUnsigned) {
7972             opCode = spv::OpGroupNonUniformUMin;
7973         } else {
7974             opCode = spv::OpGroupNonUniformSMin;
7975         }
7976         break;
7977     case glslang::EOpSubgroupMax:
7978     case glslang::EOpSubgroupInclusiveMax:
7979     case glslang::EOpSubgroupExclusiveMax:
7980     case glslang::EOpSubgroupClusteredMax:
7981     case glslang::EOpSubgroupPartitionedMax:
7982     case glslang::EOpSubgroupPartitionedInclusiveMax:
7983     case glslang::EOpSubgroupPartitionedExclusiveMax:
7984         if (isFloat) {
7985             opCode = spv::OpGroupNonUniformFMax;
7986         } else if (isUnsigned) {
7987             opCode = spv::OpGroupNonUniformUMax;
7988         } else {
7989             opCode = spv::OpGroupNonUniformSMax;
7990         }
7991         break;
7992     case glslang::EOpSubgroupAnd:
7993     case glslang::EOpSubgroupInclusiveAnd:
7994     case glslang::EOpSubgroupExclusiveAnd:
7995     case glslang::EOpSubgroupClusteredAnd:
7996     case glslang::EOpSubgroupPartitionedAnd:
7997     case glslang::EOpSubgroupPartitionedInclusiveAnd:
7998     case glslang::EOpSubgroupPartitionedExclusiveAnd:
7999         if (isBool) {
8000             opCode = spv::OpGroupNonUniformLogicalAnd;
8001         } else {
8002             opCode = spv::OpGroupNonUniformBitwiseAnd;
8003         }
8004         break;
8005     case glslang::EOpSubgroupOr:
8006     case glslang::EOpSubgroupInclusiveOr:
8007     case glslang::EOpSubgroupExclusiveOr:
8008     case glslang::EOpSubgroupClusteredOr:
8009     case glslang::EOpSubgroupPartitionedOr:
8010     case glslang::EOpSubgroupPartitionedInclusiveOr:
8011     case glslang::EOpSubgroupPartitionedExclusiveOr:
8012         if (isBool) {
8013             opCode = spv::OpGroupNonUniformLogicalOr;
8014         } else {
8015             opCode = spv::OpGroupNonUniformBitwiseOr;
8016         }
8017         break;
8018     case glslang::EOpSubgroupXor:
8019     case glslang::EOpSubgroupInclusiveXor:
8020     case glslang::EOpSubgroupExclusiveXor:
8021     case glslang::EOpSubgroupClusteredXor:
8022     case glslang::EOpSubgroupPartitionedXor:
8023     case glslang::EOpSubgroupPartitionedInclusiveXor:
8024     case glslang::EOpSubgroupPartitionedExclusiveXor:
8025         if (isBool) {
8026             opCode = spv::OpGroupNonUniformLogicalXor;
8027         } else {
8028             opCode = spv::OpGroupNonUniformBitwiseXor;
8029         }
8030         break;
8031     case glslang::EOpSubgroupQuadBroadcast:      opCode = spv::OpGroupNonUniformQuadBroadcast; break;
8032     case glslang::EOpSubgroupQuadSwapHorizontal:
8033     case glslang::EOpSubgroupQuadSwapVertical:
8034     case glslang::EOpSubgroupQuadSwapDiagonal:   opCode = spv::OpGroupNonUniformQuadSwap; break;
8035     default: assert(0 && "Unhandled subgroup operation!");
8036     }
8037
8038     // get the right Group Operation
8039     spv::GroupOperation groupOperation = spv::GroupOperationMax;
8040     switch (op) {
8041     default:
8042         break;
8043     case glslang::EOpSubgroupBallotBitCount:
8044     case glslang::EOpSubgroupAdd:
8045     case glslang::EOpSubgroupMul:
8046     case glslang::EOpSubgroupMin:
8047     case glslang::EOpSubgroupMax:
8048     case glslang::EOpSubgroupAnd:
8049     case glslang::EOpSubgroupOr:
8050     case glslang::EOpSubgroupXor:
8051         groupOperation = spv::GroupOperationReduce;
8052         break;
8053     case glslang::EOpSubgroupBallotInclusiveBitCount:
8054     case glslang::EOpSubgroupInclusiveAdd:
8055     case glslang::EOpSubgroupInclusiveMul:
8056     case glslang::EOpSubgroupInclusiveMin:
8057     case glslang::EOpSubgroupInclusiveMax:
8058     case glslang::EOpSubgroupInclusiveAnd:
8059     case glslang::EOpSubgroupInclusiveOr:
8060     case glslang::EOpSubgroupInclusiveXor:
8061         groupOperation = spv::GroupOperationInclusiveScan;
8062         break;
8063     case glslang::EOpSubgroupBallotExclusiveBitCount:
8064     case glslang::EOpSubgroupExclusiveAdd:
8065     case glslang::EOpSubgroupExclusiveMul:
8066     case glslang::EOpSubgroupExclusiveMin:
8067     case glslang::EOpSubgroupExclusiveMax:
8068     case glslang::EOpSubgroupExclusiveAnd:
8069     case glslang::EOpSubgroupExclusiveOr:
8070     case glslang::EOpSubgroupExclusiveXor:
8071         groupOperation = spv::GroupOperationExclusiveScan;
8072         break;
8073     case glslang::EOpSubgroupClusteredAdd:
8074     case glslang::EOpSubgroupClusteredMul:
8075     case glslang::EOpSubgroupClusteredMin:
8076     case glslang::EOpSubgroupClusteredMax:
8077     case glslang::EOpSubgroupClusteredAnd:
8078     case glslang::EOpSubgroupClusteredOr:
8079     case glslang::EOpSubgroupClusteredXor:
8080         groupOperation = spv::GroupOperationClusteredReduce;
8081         break;
8082     case glslang::EOpSubgroupPartitionedAdd:
8083     case glslang::EOpSubgroupPartitionedMul:
8084     case glslang::EOpSubgroupPartitionedMin:
8085     case glslang::EOpSubgroupPartitionedMax:
8086     case glslang::EOpSubgroupPartitionedAnd:
8087     case glslang::EOpSubgroupPartitionedOr:
8088     case glslang::EOpSubgroupPartitionedXor:
8089         groupOperation = spv::GroupOperationPartitionedReduceNV;
8090         break;
8091     case glslang::EOpSubgroupPartitionedInclusiveAdd:
8092     case glslang::EOpSubgroupPartitionedInclusiveMul:
8093     case glslang::EOpSubgroupPartitionedInclusiveMin:
8094     case glslang::EOpSubgroupPartitionedInclusiveMax:
8095     case glslang::EOpSubgroupPartitionedInclusiveAnd:
8096     case glslang::EOpSubgroupPartitionedInclusiveOr:
8097     case glslang::EOpSubgroupPartitionedInclusiveXor:
8098         groupOperation = spv::GroupOperationPartitionedInclusiveScanNV;
8099         break;
8100     case glslang::EOpSubgroupPartitionedExclusiveAdd:
8101     case glslang::EOpSubgroupPartitionedExclusiveMul:
8102     case glslang::EOpSubgroupPartitionedExclusiveMin:
8103     case glslang::EOpSubgroupPartitionedExclusiveMax:
8104     case glslang::EOpSubgroupPartitionedExclusiveAnd:
8105     case glslang::EOpSubgroupPartitionedExclusiveOr:
8106     case glslang::EOpSubgroupPartitionedExclusiveXor:
8107         groupOperation = spv::GroupOperationPartitionedExclusiveScanNV;
8108         break;
8109     }
8110
8111     // build the instruction
8112     std::vector<spv::IdImmediate> spvGroupOperands;
8113
8114     // Every operation begins with the Execution Scope operand.
8115     spv::IdImmediate executionScope = { true, builder.makeUintConstant(spv::ScopeSubgroup) };
8116     spvGroupOperands.push_back(executionScope);
8117
8118     // Next, for all operations that use a Group Operation, push that as an operand.
8119     if (groupOperation != spv::GroupOperationMax) {
8120         spv::IdImmediate groupOperand = { false, (unsigned)groupOperation };
8121         spvGroupOperands.push_back(groupOperand);
8122     }
8123
8124     // Push back the operands next.
8125     for (auto opIt = operands.cbegin(); opIt != operands.cend(); ++opIt) {
8126         spv::IdImmediate operand = { true, *opIt };
8127         spvGroupOperands.push_back(operand);
8128     }
8129
8130     // Some opcodes have additional operands.
8131     spv::Id directionId = spv::NoResult;
8132     switch (op) {
8133     default: break;
8134     case glslang::EOpSubgroupQuadSwapHorizontal: directionId = builder.makeUintConstant(0); break;
8135     case glslang::EOpSubgroupQuadSwapVertical:   directionId = builder.makeUintConstant(1); break;
8136     case glslang::EOpSubgroupQuadSwapDiagonal:   directionId = builder.makeUintConstant(2); break;
8137     }
8138     if (directionId != spv::NoResult) {
8139         spv::IdImmediate direction = { true, directionId };
8140         spvGroupOperands.push_back(direction);
8141     }
8142
8143     return builder.createOp(opCode, typeId, spvGroupOperands);
8144 }
8145
8146 spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::Decoration precision,
8147     spv::Id typeId, std::vector<spv::Id>& operands, glslang::TBasicType typeProxy)
8148 {
8149     bool isUnsigned = isTypeUnsignedInt(typeProxy);
8150     bool isFloat = isTypeFloat(typeProxy);
8151
8152     spv::Op opCode = spv::OpNop;
8153     int extBuiltins = -1;
8154     int libCall = -1;
8155     size_t consumedOperands = operands.size();
8156     spv::Id typeId0 = 0;
8157     if (consumedOperands > 0)
8158         typeId0 = builder.getTypeId(operands[0]);
8159     spv::Id typeId1 = 0;
8160     if (consumedOperands > 1)
8161         typeId1 = builder.getTypeId(operands[1]);
8162     spv::Id frexpIntType = 0;
8163
8164     switch (op) {
8165     case glslang::EOpMin:
8166         if (isFloat)
8167             libCall = nanMinMaxClamp ? spv::GLSLstd450NMin : spv::GLSLstd450FMin;
8168         else if (isUnsigned)
8169             libCall = spv::GLSLstd450UMin;
8170         else
8171             libCall = spv::GLSLstd450SMin;
8172         builder.promoteScalar(precision, operands.front(), operands.back());
8173         break;
8174     case glslang::EOpModf:
8175         libCall = spv::GLSLstd450Modf;
8176         break;
8177     case glslang::EOpMax:
8178         if (isFloat)
8179             libCall = nanMinMaxClamp ? spv::GLSLstd450NMax : spv::GLSLstd450FMax;
8180         else if (isUnsigned)
8181             libCall = spv::GLSLstd450UMax;
8182         else
8183             libCall = spv::GLSLstd450SMax;
8184         builder.promoteScalar(precision, operands.front(), operands.back());
8185         break;
8186     case glslang::EOpPow:
8187         libCall = spv::GLSLstd450Pow;
8188         break;
8189     case glslang::EOpDot:
8190         opCode = spv::OpDot;
8191         break;
8192     case glslang::EOpAtan:
8193         libCall = spv::GLSLstd450Atan2;
8194         break;
8195
8196     case glslang::EOpClamp:
8197         if (isFloat)
8198             libCall = nanMinMaxClamp ? spv::GLSLstd450NClamp : spv::GLSLstd450FClamp;
8199         else if (isUnsigned)
8200             libCall = spv::GLSLstd450UClamp;
8201         else
8202             libCall = spv::GLSLstd450SClamp;
8203         builder.promoteScalar(precision, operands.front(), operands[1]);
8204         builder.promoteScalar(precision, operands.front(), operands[2]);
8205         break;
8206     case glslang::EOpMix:
8207         if (! builder.isBoolType(builder.getScalarTypeId(builder.getTypeId(operands.back())))) {
8208             assert(isFloat);
8209             libCall = spv::GLSLstd450FMix;
8210         } else {
8211             opCode = spv::OpSelect;
8212             std::swap(operands.front(), operands.back());
8213         }
8214         builder.promoteScalar(precision, operands.front(), operands.back());
8215         break;
8216     case glslang::EOpStep:
8217         libCall = spv::GLSLstd450Step;
8218         builder.promoteScalar(precision, operands.front(), operands.back());
8219         break;
8220     case glslang::EOpSmoothStep:
8221         libCall = spv::GLSLstd450SmoothStep;
8222         builder.promoteScalar(precision, operands[0], operands[2]);
8223         builder.promoteScalar(precision, operands[1], operands[2]);
8224         break;
8225
8226     case glslang::EOpDistance:
8227         libCall = spv::GLSLstd450Distance;
8228         break;
8229     case glslang::EOpCross:
8230         libCall = spv::GLSLstd450Cross;
8231         break;
8232     case glslang::EOpFaceForward:
8233         libCall = spv::GLSLstd450FaceForward;
8234         break;
8235     case glslang::EOpReflect:
8236         libCall = spv::GLSLstd450Reflect;
8237         break;
8238     case glslang::EOpRefract:
8239         libCall = spv::GLSLstd450Refract;
8240         break;
8241     case glslang::EOpBarrier:
8242         {
8243             // This is for the extended controlBarrier function, with four operands.
8244             // The unextended barrier() goes through createNoArgOperation.
8245             assert(operands.size() == 4);
8246             unsigned int executionScope = builder.getConstantScalar(operands[0]);
8247             unsigned int memoryScope = builder.getConstantScalar(operands[1]);
8248             unsigned int semantics = builder.getConstantScalar(operands[2]) | builder.getConstantScalar(operands[3]);
8249             builder.createControlBarrier((spv::Scope)executionScope, (spv::Scope)memoryScope,
8250                 (spv::MemorySemanticsMask)semantics);
8251             if (semantics & (spv::MemorySemanticsMakeAvailableKHRMask |
8252                              spv::MemorySemanticsMakeVisibleKHRMask |
8253                              spv::MemorySemanticsOutputMemoryKHRMask |
8254                              spv::MemorySemanticsVolatileMask)) {
8255                 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
8256             }
8257             if (glslangIntermediate->usingVulkanMemoryModel() && (executionScope == spv::ScopeDevice ||
8258                 memoryScope == spv::ScopeDevice)) {
8259                 builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR);
8260             }
8261             return 0;
8262         }
8263         break;
8264     case glslang::EOpMemoryBarrier:
8265         {
8266             // This is for the extended memoryBarrier function, with three operands.
8267             // The unextended memoryBarrier() goes through createNoArgOperation.
8268             assert(operands.size() == 3);
8269             unsigned int memoryScope = builder.getConstantScalar(operands[0]);
8270             unsigned int semantics = builder.getConstantScalar(operands[1]) | builder.getConstantScalar(operands[2]);
8271             builder.createMemoryBarrier((spv::Scope)memoryScope, (spv::MemorySemanticsMask)semantics);
8272             if (semantics & (spv::MemorySemanticsMakeAvailableKHRMask |
8273                              spv::MemorySemanticsMakeVisibleKHRMask |
8274                              spv::MemorySemanticsOutputMemoryKHRMask |
8275                              spv::MemorySemanticsVolatileMask)) {
8276                 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
8277             }
8278             if (glslangIntermediate->usingVulkanMemoryModel() && memoryScope == spv::ScopeDevice) {
8279                 builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR);
8280             }
8281             return 0;
8282         }
8283         break;
8284
8285 #ifndef GLSLANG_WEB
8286     case glslang::EOpInterpolateAtSample:
8287         if (typeProxy == glslang::EbtFloat16)
8288             builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float);
8289         libCall = spv::GLSLstd450InterpolateAtSample;
8290         break;
8291     case glslang::EOpInterpolateAtOffset:
8292         if (typeProxy == glslang::EbtFloat16)
8293             builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float);
8294         libCall = spv::GLSLstd450InterpolateAtOffset;
8295         break;
8296     case glslang::EOpAddCarry:
8297         opCode = spv::OpIAddCarry;
8298         typeId = builder.makeStructResultType(typeId0, typeId0);
8299         consumedOperands = 2;
8300         break;
8301     case glslang::EOpSubBorrow:
8302         opCode = spv::OpISubBorrow;
8303         typeId = builder.makeStructResultType(typeId0, typeId0);
8304         consumedOperands = 2;
8305         break;
8306     case glslang::EOpUMulExtended:
8307         opCode = spv::OpUMulExtended;
8308         typeId = builder.makeStructResultType(typeId0, typeId0);
8309         consumedOperands = 2;
8310         break;
8311     case glslang::EOpIMulExtended:
8312         opCode = spv::OpSMulExtended;
8313         typeId = builder.makeStructResultType(typeId0, typeId0);
8314         consumedOperands = 2;
8315         break;
8316     case glslang::EOpBitfieldExtract:
8317         if (isUnsigned)
8318             opCode = spv::OpBitFieldUExtract;
8319         else
8320             opCode = spv::OpBitFieldSExtract;
8321         break;
8322     case glslang::EOpBitfieldInsert:
8323         opCode = spv::OpBitFieldInsert;
8324         break;
8325
8326     case glslang::EOpFma:
8327         libCall = spv::GLSLstd450Fma;
8328         break;
8329     case glslang::EOpFrexp:
8330         {
8331             libCall = spv::GLSLstd450FrexpStruct;
8332             assert(builder.isPointerType(typeId1));
8333             typeId1 = builder.getContainedTypeId(typeId1);
8334             int width = builder.getScalarTypeWidth(typeId1);
8335             if (width == 16)
8336                 // Using 16-bit exp operand, enable extension SPV_AMD_gpu_shader_int16
8337                 builder.addExtension(spv::E_SPV_AMD_gpu_shader_int16);
8338             if (builder.getNumComponents(operands[0]) == 1)
8339                 frexpIntType = builder.makeIntegerType(width, true);
8340             else
8341                 frexpIntType = builder.makeVectorType(builder.makeIntegerType(width, true),
8342                     builder.getNumComponents(operands[0]));
8343             typeId = builder.makeStructResultType(typeId0, frexpIntType);
8344             consumedOperands = 1;
8345         }
8346         break;
8347     case glslang::EOpLdexp:
8348         libCall = spv::GLSLstd450Ldexp;
8349         break;
8350
8351     case glslang::EOpReadInvocation:
8352         return createInvocationsOperation(op, typeId, operands, typeProxy);
8353
8354     case glslang::EOpSubgroupBroadcast:
8355     case glslang::EOpSubgroupBallotBitExtract:
8356     case glslang::EOpSubgroupShuffle:
8357     case glslang::EOpSubgroupShuffleXor:
8358     case glslang::EOpSubgroupShuffleUp:
8359     case glslang::EOpSubgroupShuffleDown:
8360     case glslang::EOpSubgroupClusteredAdd:
8361     case glslang::EOpSubgroupClusteredMul:
8362     case glslang::EOpSubgroupClusteredMin:
8363     case glslang::EOpSubgroupClusteredMax:
8364     case glslang::EOpSubgroupClusteredAnd:
8365     case glslang::EOpSubgroupClusteredOr:
8366     case glslang::EOpSubgroupClusteredXor:
8367     case glslang::EOpSubgroupQuadBroadcast:
8368     case glslang::EOpSubgroupPartitionedAdd:
8369     case glslang::EOpSubgroupPartitionedMul:
8370     case glslang::EOpSubgroupPartitionedMin:
8371     case glslang::EOpSubgroupPartitionedMax:
8372     case glslang::EOpSubgroupPartitionedAnd:
8373     case glslang::EOpSubgroupPartitionedOr:
8374     case glslang::EOpSubgroupPartitionedXor:
8375     case glslang::EOpSubgroupPartitionedInclusiveAdd:
8376     case glslang::EOpSubgroupPartitionedInclusiveMul:
8377     case glslang::EOpSubgroupPartitionedInclusiveMin:
8378     case glslang::EOpSubgroupPartitionedInclusiveMax:
8379     case glslang::EOpSubgroupPartitionedInclusiveAnd:
8380     case glslang::EOpSubgroupPartitionedInclusiveOr:
8381     case glslang::EOpSubgroupPartitionedInclusiveXor:
8382     case glslang::EOpSubgroupPartitionedExclusiveAdd:
8383     case glslang::EOpSubgroupPartitionedExclusiveMul:
8384     case glslang::EOpSubgroupPartitionedExclusiveMin:
8385     case glslang::EOpSubgroupPartitionedExclusiveMax:
8386     case glslang::EOpSubgroupPartitionedExclusiveAnd:
8387     case glslang::EOpSubgroupPartitionedExclusiveOr:
8388     case glslang::EOpSubgroupPartitionedExclusiveXor:
8389         return createSubgroupOperation(op, typeId, operands, typeProxy);
8390
8391     case glslang::EOpSwizzleInvocations:
8392         extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_ballot);
8393         libCall = spv::SwizzleInvocationsAMD;
8394         break;
8395     case glslang::EOpSwizzleInvocationsMasked:
8396         extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_ballot);
8397         libCall = spv::SwizzleInvocationsMaskedAMD;
8398         break;
8399     case glslang::EOpWriteInvocation:
8400         extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_ballot);
8401         libCall = spv::WriteInvocationAMD;
8402         break;
8403
8404     case glslang::EOpMin3:
8405         extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_trinary_minmax);
8406         if (isFloat)
8407             libCall = spv::FMin3AMD;
8408         else {
8409             if (isUnsigned)
8410                 libCall = spv::UMin3AMD;
8411             else
8412                 libCall = spv::SMin3AMD;
8413         }
8414         break;
8415     case glslang::EOpMax3:
8416         extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_trinary_minmax);
8417         if (isFloat)
8418             libCall = spv::FMax3AMD;
8419         else {
8420             if (isUnsigned)
8421                 libCall = spv::UMax3AMD;
8422             else
8423                 libCall = spv::SMax3AMD;
8424         }
8425         break;
8426     case glslang::EOpMid3:
8427         extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_trinary_minmax);
8428         if (isFloat)
8429             libCall = spv::FMid3AMD;
8430         else {
8431             if (isUnsigned)
8432                 libCall = spv::UMid3AMD;
8433             else
8434                 libCall = spv::SMid3AMD;
8435         }
8436         break;
8437
8438     case glslang::EOpInterpolateAtVertex:
8439         if (typeProxy == glslang::EbtFloat16)
8440             builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float);
8441         extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
8442         libCall = spv::InterpolateAtVertexAMD;
8443         break;
8444
8445     case glslang::EOpReportIntersection:
8446         typeId = builder.makeBoolType();
8447         opCode = spv::OpReportIntersectionKHR;
8448         break;
8449     case glslang::EOpTraceNV:
8450         builder.createNoResultOp(spv::OpTraceNV, operands);
8451         return 0;
8452     case glslang::EOpTraceRayMotionNV:
8453         builder.addExtension(spv::E_SPV_NV_ray_tracing_motion_blur);
8454         builder.addCapability(spv::CapabilityRayTracingMotionBlurNV);
8455         builder.createNoResultOp(spv::OpTraceRayMotionNV, operands);
8456         return 0;
8457     case glslang::EOpTraceKHR:
8458         builder.createNoResultOp(spv::OpTraceRayKHR, operands);
8459         return 0;
8460     case glslang::EOpExecuteCallableNV:
8461         builder.createNoResultOp(spv::OpExecuteCallableNV, operands);
8462         return 0;
8463     case glslang::EOpExecuteCallableKHR:
8464         builder.createNoResultOp(spv::OpExecuteCallableKHR, operands);
8465         return 0;
8466
8467     case glslang::EOpRayQueryInitialize:
8468         builder.createNoResultOp(spv::OpRayQueryInitializeKHR, operands);
8469         return 0;
8470     case glslang::EOpRayQueryTerminate:
8471         builder.createNoResultOp(spv::OpRayQueryTerminateKHR, operands);
8472         return 0;
8473     case glslang::EOpRayQueryGenerateIntersection:
8474         builder.createNoResultOp(spv::OpRayQueryGenerateIntersectionKHR, operands);
8475         return 0;
8476     case glslang::EOpRayQueryConfirmIntersection:
8477         builder.createNoResultOp(spv::OpRayQueryConfirmIntersectionKHR, operands);
8478         return 0;
8479     case glslang::EOpRayQueryProceed:
8480         typeId = builder.makeBoolType();
8481         opCode = spv::OpRayQueryProceedKHR;
8482         break;
8483     case glslang::EOpRayQueryGetIntersectionType:
8484         typeId = builder.makeUintType(32);
8485         opCode = spv::OpRayQueryGetIntersectionTypeKHR;
8486         break;
8487     case glslang::EOpRayQueryGetRayTMin:
8488         typeId = builder.makeFloatType(32);
8489         opCode = spv::OpRayQueryGetRayTMinKHR;
8490         break;
8491     case glslang::EOpRayQueryGetRayFlags:
8492         typeId = builder.makeIntType(32);
8493         opCode = spv::OpRayQueryGetRayFlagsKHR;
8494         break;
8495     case glslang::EOpRayQueryGetIntersectionT:
8496         typeId = builder.makeFloatType(32);
8497         opCode = spv::OpRayQueryGetIntersectionTKHR;
8498         break;
8499     case glslang::EOpRayQueryGetIntersectionInstanceCustomIndex:
8500         typeId = builder.makeIntType(32);
8501         opCode = spv::OpRayQueryGetIntersectionInstanceCustomIndexKHR;
8502         break;
8503     case glslang::EOpRayQueryGetIntersectionInstanceId:
8504         typeId = builder.makeIntType(32);
8505         opCode = spv::OpRayQueryGetIntersectionInstanceIdKHR;
8506         break;
8507     case glslang::EOpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffset:
8508         typeId = builder.makeUintType(32);
8509         opCode = spv::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR;
8510         break;
8511     case glslang::EOpRayQueryGetIntersectionGeometryIndex:
8512         typeId = builder.makeIntType(32);
8513         opCode = spv::OpRayQueryGetIntersectionGeometryIndexKHR;
8514         break;
8515     case glslang::EOpRayQueryGetIntersectionPrimitiveIndex:
8516         typeId = builder.makeIntType(32);
8517         opCode = spv::OpRayQueryGetIntersectionPrimitiveIndexKHR;
8518         break;
8519     case glslang::EOpRayQueryGetIntersectionBarycentrics:
8520         typeId = builder.makeVectorType(builder.makeFloatType(32), 2);
8521         opCode = spv::OpRayQueryGetIntersectionBarycentricsKHR;
8522         break;
8523     case glslang::EOpRayQueryGetIntersectionFrontFace:
8524         typeId = builder.makeBoolType();
8525         opCode = spv::OpRayQueryGetIntersectionFrontFaceKHR;
8526         break;
8527     case glslang::EOpRayQueryGetIntersectionCandidateAABBOpaque:
8528         typeId = builder.makeBoolType();
8529         opCode = spv::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR;
8530         break;
8531     case glslang::EOpRayQueryGetIntersectionObjectRayDirection:
8532         typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
8533         opCode = spv::OpRayQueryGetIntersectionObjectRayDirectionKHR;
8534         break;
8535     case glslang::EOpRayQueryGetIntersectionObjectRayOrigin:
8536         typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
8537         opCode = spv::OpRayQueryGetIntersectionObjectRayOriginKHR;
8538         break;
8539     case glslang::EOpRayQueryGetWorldRayDirection:
8540         typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
8541         opCode = spv::OpRayQueryGetWorldRayDirectionKHR;
8542         break;
8543     case glslang::EOpRayQueryGetWorldRayOrigin:
8544         typeId = builder.makeVectorType(builder.makeFloatType(32), 3);
8545         opCode = spv::OpRayQueryGetWorldRayOriginKHR;
8546         break;
8547     case glslang::EOpRayQueryGetIntersectionObjectToWorld:
8548         typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
8549         opCode = spv::OpRayQueryGetIntersectionObjectToWorldKHR;
8550         break;
8551     case glslang::EOpRayQueryGetIntersectionWorldToObject:
8552         typeId = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
8553         opCode = spv::OpRayQueryGetIntersectionWorldToObjectKHR;
8554         break;
8555     case glslang::EOpWritePackedPrimitiveIndices4x8NV:
8556         builder.createNoResultOp(spv::OpWritePackedPrimitiveIndices4x8NV, operands);
8557         return 0;
8558     case glslang::EOpEmitMeshTasksEXT:
8559         if(taskPayloadID)
8560             operands.push_back(taskPayloadID);
8561         builder.createNoResultOp(spv::OpEmitMeshTasksEXT, operands);
8562         // Make it a terminating instruction in the current block
8563         builder.createAndSetNoPredecessorBlock("post-OpEmitMeshTasksEXT");
8564         return 0;
8565     case glslang::EOpSetMeshOutputsEXT:
8566         builder.createNoResultOp(spv::OpSetMeshOutputsEXT, operands);
8567         return 0;
8568     case glslang::EOpCooperativeMatrixMulAdd:
8569         opCode = spv::OpCooperativeMatrixMulAddNV;
8570         break;
8571 #endif // GLSLANG_WEB
8572     default:
8573         return 0;
8574     }
8575
8576     spv::Id id = 0;
8577     if (libCall >= 0) {
8578         // Use an extended instruction from the standard library.
8579         // Construct the call arguments, without modifying the original operands vector.
8580         // We might need the remaining arguments, e.g. in the EOpFrexp case.
8581         std::vector<spv::Id> callArguments(operands.begin(), operands.begin() + consumedOperands);
8582         id = builder.createBuiltinCall(typeId, extBuiltins >= 0 ? extBuiltins : stdBuiltins, libCall, callArguments);
8583     } else if (opCode == spv::OpDot && !isFloat) {
8584         // int dot(int, int)
8585         // NOTE: never called for scalar/vector1, this is turned into simple mul before this can be reached
8586         const int componentCount = builder.getNumComponents(operands[0]);
8587         spv::Id mulOp = builder.createBinOp(spv::OpIMul, builder.getTypeId(operands[0]), operands[0], operands[1]);
8588         builder.setPrecision(mulOp, precision);
8589         id = builder.createCompositeExtract(mulOp, typeId, 0);
8590         for (int i = 1; i < componentCount; ++i) {
8591             builder.setPrecision(id, precision);
8592             id = builder.createBinOp(spv::OpIAdd, typeId, id, builder.createCompositeExtract(mulOp, typeId, i));
8593         }
8594     } else {
8595         switch (consumedOperands) {
8596         case 0:
8597             // should all be handled by visitAggregate and createNoArgOperation
8598             assert(0);
8599             return 0;
8600         case 1:
8601             // should all be handled by createUnaryOperation
8602             assert(0);
8603             return 0;
8604         case 2:
8605             id = builder.createBinOp(opCode, typeId, operands[0], operands[1]);
8606             break;
8607         default:
8608             // anything 3 or over doesn't have l-value operands, so all should be consumed
8609             assert(consumedOperands == operands.size());
8610             id = builder.createOp(opCode, typeId, operands);
8611             break;
8612         }
8613     }
8614
8615 #ifndef GLSLANG_WEB
8616     // Decode the return types that were structures
8617     switch (op) {
8618     case glslang::EOpAddCarry:
8619     case glslang::EOpSubBorrow:
8620         builder.createStore(builder.createCompositeExtract(id, typeId0, 1), operands[2]);
8621         id = builder.createCompositeExtract(id, typeId0, 0);
8622         break;
8623     case glslang::EOpUMulExtended:
8624     case glslang::EOpIMulExtended:
8625         builder.createStore(builder.createCompositeExtract(id, typeId0, 0), operands[3]);
8626         builder.createStore(builder.createCompositeExtract(id, typeId0, 1), operands[2]);
8627         break;
8628     case glslang::EOpFrexp:
8629         {
8630             assert(operands.size() == 2);
8631             if (builder.isFloatType(builder.getScalarTypeId(typeId1))) {
8632                 // "exp" is floating-point type (from HLSL intrinsic)
8633                 spv::Id member1 = builder.createCompositeExtract(id, frexpIntType, 1);
8634                 member1 = builder.createUnaryOp(spv::OpConvertSToF, typeId1, member1);
8635                 builder.createStore(member1, operands[1]);
8636             } else
8637                 // "exp" is integer type (from GLSL built-in function)
8638                 builder.createStore(builder.createCompositeExtract(id, frexpIntType, 1), operands[1]);
8639             id = builder.createCompositeExtract(id, typeId0, 0);
8640         }
8641         break;
8642     default:
8643         break;
8644     }
8645 #endif
8646
8647     return builder.setPrecision(id, precision);
8648 }
8649
8650 // Intrinsics with no arguments (or no return value, and no precision).
8651 spv::Id TGlslangToSpvTraverser::createNoArgOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId)
8652 {
8653     // GLSL memory barriers use queuefamily scope in new model, device scope in old model
8654     spv::Scope memoryBarrierScope = glslangIntermediate->usingVulkanMemoryModel() ?
8655         spv::ScopeQueueFamilyKHR : spv::ScopeDevice;
8656
8657     switch (op) {
8658     case glslang::EOpBarrier:
8659         if (glslangIntermediate->getStage() == EShLangTessControl) {
8660             if (glslangIntermediate->usingVulkanMemoryModel()) {
8661                 builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup,
8662                                              spv::MemorySemanticsOutputMemoryKHRMask |
8663                                              spv::MemorySemanticsAcquireReleaseMask);
8664                 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
8665             } else {
8666                 builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeInvocation, spv::MemorySemanticsMaskNone);
8667             }
8668         } else {
8669             builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup,
8670                                             spv::MemorySemanticsWorkgroupMemoryMask |
8671                                             spv::MemorySemanticsAcquireReleaseMask);
8672         }
8673         return 0;
8674     case glslang::EOpMemoryBarrier:
8675         builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsAllMemory |
8676                                                         spv::MemorySemanticsAcquireReleaseMask);
8677         return 0;
8678     case glslang::EOpMemoryBarrierBuffer:
8679         builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsUniformMemoryMask |
8680                                                         spv::MemorySemanticsAcquireReleaseMask);
8681         return 0;
8682     case glslang::EOpMemoryBarrierShared:
8683         builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsWorkgroupMemoryMask |
8684                                                         spv::MemorySemanticsAcquireReleaseMask);
8685         return 0;
8686     case glslang::EOpGroupMemoryBarrier:
8687         builder.createMemoryBarrier(spv::ScopeWorkgroup, spv::MemorySemanticsAllMemory |
8688                                                          spv::MemorySemanticsAcquireReleaseMask);
8689         return 0;
8690 #ifndef GLSLANG_WEB
8691     case glslang::EOpMemoryBarrierAtomicCounter:
8692         builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsAtomicCounterMemoryMask |
8693                                                         spv::MemorySemanticsAcquireReleaseMask);
8694         return 0;
8695     case glslang::EOpMemoryBarrierImage:
8696         builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsImageMemoryMask |
8697                                                         spv::MemorySemanticsAcquireReleaseMask);
8698         return 0;
8699     case glslang::EOpAllMemoryBarrierWithGroupSync:
8700         builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeDevice,
8701                                         spv::MemorySemanticsAllMemory |
8702                                         spv::MemorySemanticsAcquireReleaseMask);
8703         return 0;
8704     case glslang::EOpDeviceMemoryBarrier:
8705         builder.createMemoryBarrier(spv::ScopeDevice, spv::MemorySemanticsUniformMemoryMask |
8706                                                       spv::MemorySemanticsImageMemoryMask |
8707                                                       spv::MemorySemanticsAcquireReleaseMask);
8708         return 0;
8709     case glslang::EOpDeviceMemoryBarrierWithGroupSync:
8710         builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeDevice, spv::MemorySemanticsUniformMemoryMask |
8711                                                                             spv::MemorySemanticsImageMemoryMask |
8712                                                                             spv::MemorySemanticsAcquireReleaseMask);
8713         return 0;
8714     case glslang::EOpWorkgroupMemoryBarrier:
8715         builder.createMemoryBarrier(spv::ScopeWorkgroup, spv::MemorySemanticsWorkgroupMemoryMask |
8716                                                          spv::MemorySemanticsAcquireReleaseMask);
8717         return 0;
8718     case glslang::EOpWorkgroupMemoryBarrierWithGroupSync:
8719         builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup,
8720                                         spv::MemorySemanticsWorkgroupMemoryMask |
8721                                         spv::MemorySemanticsAcquireReleaseMask);
8722         return 0;
8723     case glslang::EOpSubgroupBarrier:
8724         builder.createControlBarrier(spv::ScopeSubgroup, spv::ScopeSubgroup, spv::MemorySemanticsAllMemory |
8725                                                                              spv::MemorySemanticsAcquireReleaseMask);
8726         return spv::NoResult;
8727     case glslang::EOpSubgroupMemoryBarrier:
8728         builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsAllMemory |
8729                                                         spv::MemorySemanticsAcquireReleaseMask);
8730         return spv::NoResult;
8731     case glslang::EOpSubgroupMemoryBarrierBuffer:
8732         builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsUniformMemoryMask |
8733                                                         spv::MemorySemanticsAcquireReleaseMask);
8734         return spv::NoResult;
8735     case glslang::EOpSubgroupMemoryBarrierImage:
8736         builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsImageMemoryMask |
8737                                                         spv::MemorySemanticsAcquireReleaseMask);
8738         return spv::NoResult;
8739     case glslang::EOpSubgroupMemoryBarrierShared:
8740         builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsWorkgroupMemoryMask |
8741                                                         spv::MemorySemanticsAcquireReleaseMask);
8742         return spv::NoResult;
8743
8744     case glslang::EOpEmitVertex:
8745         builder.createNoResultOp(spv::OpEmitVertex);
8746         return 0;
8747     case glslang::EOpEndPrimitive:
8748         builder.createNoResultOp(spv::OpEndPrimitive);
8749         return 0;
8750
8751     case glslang::EOpSubgroupElect: {
8752         std::vector<spv::Id> operands;
8753         return createSubgroupOperation(op, typeId, operands, glslang::EbtVoid);
8754     }
8755     case glslang::EOpTime:
8756     {
8757         std::vector<spv::Id> args; // Dummy arguments
8758         spv::Id id = builder.createBuiltinCall(typeId, getExtBuiltins(spv::E_SPV_AMD_gcn_shader), spv::TimeAMD, args);
8759         return builder.setPrecision(id, precision);
8760     }
8761     case glslang::EOpIgnoreIntersectionNV:
8762         builder.createNoResultOp(spv::OpIgnoreIntersectionNV);
8763         return 0;
8764     case glslang::EOpTerminateRayNV:
8765         builder.createNoResultOp(spv::OpTerminateRayNV);
8766         return 0;
8767     case glslang::EOpRayQueryInitialize:
8768         builder.createNoResultOp(spv::OpRayQueryInitializeKHR);
8769         return 0;
8770     case glslang::EOpRayQueryTerminate:
8771         builder.createNoResultOp(spv::OpRayQueryTerminateKHR);
8772         return 0;
8773     case glslang::EOpRayQueryGenerateIntersection:
8774         builder.createNoResultOp(spv::OpRayQueryGenerateIntersectionKHR);
8775         return 0;
8776     case glslang::EOpRayQueryConfirmIntersection:
8777         builder.createNoResultOp(spv::OpRayQueryConfirmIntersectionKHR);
8778         return 0;
8779     case glslang::EOpBeginInvocationInterlock:
8780         builder.createNoResultOp(spv::OpBeginInvocationInterlockEXT);
8781         return 0;
8782     case glslang::EOpEndInvocationInterlock:
8783         builder.createNoResultOp(spv::OpEndInvocationInterlockEXT);
8784         return 0;
8785
8786     case glslang::EOpIsHelperInvocation:
8787     {
8788         std::vector<spv::Id> args; // Dummy arguments
8789         builder.addExtension(spv::E_SPV_EXT_demote_to_helper_invocation);
8790         builder.addCapability(spv::CapabilityDemoteToHelperInvocationEXT);
8791         return builder.createOp(spv::OpIsHelperInvocationEXT, typeId, args);
8792     }
8793
8794     case glslang::EOpReadClockSubgroupKHR: {
8795         std::vector<spv::Id> args;
8796         args.push_back(builder.makeUintConstant(spv::ScopeSubgroup));
8797         builder.addExtension(spv::E_SPV_KHR_shader_clock);
8798         builder.addCapability(spv::CapabilityShaderClockKHR);
8799         return builder.createOp(spv::OpReadClockKHR, typeId, args);
8800     }
8801
8802     case glslang::EOpReadClockDeviceKHR: {
8803         std::vector<spv::Id> args;
8804         args.push_back(builder.makeUintConstant(spv::ScopeDevice));
8805         builder.addExtension(spv::E_SPV_KHR_shader_clock);
8806         builder.addCapability(spv::CapabilityShaderClockKHR);
8807         return builder.createOp(spv::OpReadClockKHR, typeId, args);
8808     }
8809 #endif
8810     default:
8811         break;
8812     }
8813
8814     logger->missingFunctionality("unknown operation with no arguments");
8815
8816     return 0;
8817 }
8818
8819 spv::Id TGlslangToSpvTraverser::getSymbolId(const glslang::TIntermSymbol* symbol)
8820 {
8821     auto iter = symbolValues.find(symbol->getId());
8822     spv::Id id;
8823     if (symbolValues.end() != iter) {
8824         id = iter->second;
8825         return id;
8826     }
8827
8828     // it was not found, create it
8829     spv::BuiltIn builtIn = TranslateBuiltInDecoration(symbol->getQualifier().builtIn, false);
8830     auto forcedType = getForcedType(symbol->getQualifier().builtIn, symbol->getType());
8831
8832     // There are pairs of symbols that map to the same SPIR-V built-in:
8833     // gl_ObjectToWorldEXT and gl_ObjectToWorld3x4EXT, and gl_WorldToObjectEXT
8834     // and gl_WorldToObject3x4EXT. SPIR-V forbids having two OpVariables
8835     // with the same BuiltIn in the same storage class, so we must re-use one.
8836     const bool mayNeedToReuseBuiltIn =
8837         builtIn == spv::BuiltInObjectToWorldKHR ||
8838         builtIn == spv::BuiltInWorldToObjectKHR;
8839
8840     if (mayNeedToReuseBuiltIn) {
8841         auto iter = builtInVariableIds.find(uint32_t(builtIn));
8842         if (builtInVariableIds.end() != iter) {
8843             id = iter->second;
8844             symbolValues[symbol->getId()] = id;
8845             if (forcedType.second != spv::NoType)
8846                 forceType[id] = forcedType.second;
8847             return id;
8848         }
8849     }
8850
8851     id = createSpvVariable(symbol, forcedType.first);
8852
8853     if (mayNeedToReuseBuiltIn) {
8854         builtInVariableIds.insert({uint32_t(builtIn), id});
8855     }
8856
8857     symbolValues[symbol->getId()] = id;
8858     if (forcedType.second != spv::NoType)
8859         forceType[id] = forcedType.second;
8860
8861     if (symbol->getBasicType() != glslang::EbtBlock) {
8862         builder.addDecoration(id, TranslatePrecisionDecoration(symbol->getType()));
8863         builder.addDecoration(id, TranslateInterpolationDecoration(symbol->getType().getQualifier()));
8864         builder.addDecoration(id, TranslateAuxiliaryStorageDecoration(symbol->getType().getQualifier()));
8865 #ifndef GLSLANG_WEB
8866         addMeshNVDecoration(id, /*member*/ -1, symbol->getType().getQualifier());
8867         if (symbol->getQualifier().hasComponent())
8868             builder.addDecoration(id, spv::DecorationComponent, symbol->getQualifier().layoutComponent);
8869         if (symbol->getQualifier().hasIndex())
8870             builder.addDecoration(id, spv::DecorationIndex, symbol->getQualifier().layoutIndex);
8871 #endif
8872         if (symbol->getType().getQualifier().hasSpecConstantId())
8873             builder.addDecoration(id, spv::DecorationSpecId, symbol->getType().getQualifier().layoutSpecConstantId);
8874         // atomic counters use this:
8875         if (symbol->getQualifier().hasOffset())
8876             builder.addDecoration(id, spv::DecorationOffset, symbol->getQualifier().layoutOffset);
8877     }
8878
8879     if (symbol->getQualifier().hasLocation()) {
8880         if (!(glslangIntermediate->isRayTracingStage() && glslangIntermediate->IsRequestedExtension(glslang::E_GL_EXT_ray_tracing)
8881               && (builder.getStorageClass(id) == spv::StorageClassRayPayloadKHR ||
8882                   builder.getStorageClass(id) == spv::StorageClassIncomingRayPayloadKHR ||
8883                   builder.getStorageClass(id) == spv::StorageClassCallableDataKHR ||
8884                   builder.getStorageClass(id) == spv::StorageClassIncomingCallableDataKHR))) {
8885             // Location values are used to link TraceRayKHR and ExecuteCallableKHR to corresponding variables
8886             // but are not valid in SPIRV since they are supported only for Input/Output Storage classes.
8887             builder.addDecoration(id, spv::DecorationLocation, symbol->getQualifier().layoutLocation);
8888         }
8889     }
8890
8891     builder.addDecoration(id, TranslateInvariantDecoration(symbol->getType().getQualifier()));
8892     if (symbol->getQualifier().hasStream() && glslangIntermediate->isMultiStream()) {
8893         builder.addCapability(spv::CapabilityGeometryStreams);
8894         builder.addDecoration(id, spv::DecorationStream, symbol->getQualifier().layoutStream);
8895     }
8896     if (symbol->getQualifier().hasSet())
8897         builder.addDecoration(id, spv::DecorationDescriptorSet, symbol->getQualifier().layoutSet);
8898     else if (IsDescriptorResource(symbol->getType())) {
8899         // default to 0
8900         builder.addDecoration(id, spv::DecorationDescriptorSet, 0);
8901     }
8902     if (symbol->getQualifier().hasBinding())
8903         builder.addDecoration(id, spv::DecorationBinding, symbol->getQualifier().layoutBinding);
8904     else if (IsDescriptorResource(symbol->getType())) {
8905         // default to 0
8906         builder.addDecoration(id, spv::DecorationBinding, 0);
8907     }
8908     if (symbol->getQualifier().hasAttachment())
8909         builder.addDecoration(id, spv::DecorationInputAttachmentIndex, symbol->getQualifier().layoutAttachment);
8910     if (glslangIntermediate->getXfbMode()) {
8911         builder.addCapability(spv::CapabilityTransformFeedback);
8912         if (symbol->getQualifier().hasXfbBuffer()) {
8913             builder.addDecoration(id, spv::DecorationXfbBuffer, symbol->getQualifier().layoutXfbBuffer);
8914             unsigned stride = glslangIntermediate->getXfbStride(symbol->getQualifier().layoutXfbBuffer);
8915             if (stride != glslang::TQualifier::layoutXfbStrideEnd)
8916                 builder.addDecoration(id, spv::DecorationXfbStride, stride);
8917         }
8918         if (symbol->getQualifier().hasXfbOffset())
8919             builder.addDecoration(id, spv::DecorationOffset, symbol->getQualifier().layoutXfbOffset);
8920     }
8921
8922     // add built-in variable decoration
8923     if (builtIn != spv::BuiltInMax) {
8924         // WorkgroupSize deprecated in spirv1.6
8925         if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_6 ||
8926             builtIn != spv::BuiltInWorkgroupSize)
8927             builder.addDecoration(id, spv::DecorationBuiltIn, (int)builtIn);
8928     }
8929
8930     // Add volatile decoration to HelperInvocation for spirv1.6 and beyond
8931     if (builtIn == spv::BuiltInHelperInvocation &&
8932         glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
8933         builder.addDecoration(id, spv::DecorationVolatile);
8934     }
8935
8936 #ifndef GLSLANG_WEB
8937     // Subgroup builtins which have input storage class are volatile for ray tracing stages.
8938     if (symbol->getType().isImage() || symbol->getQualifier().isPipeInput()) {
8939         std::vector<spv::Decoration> memory;
8940         TranslateMemoryDecoration(symbol->getType().getQualifier(), memory,
8941             glslangIntermediate->usingVulkanMemoryModel());
8942         for (unsigned int i = 0; i < memory.size(); ++i)
8943             builder.addDecoration(id, memory[i]);
8944     }
8945
8946     if (builtIn == spv::BuiltInSampleMask) {
8947           spv::Decoration decoration;
8948           // GL_NV_sample_mask_override_coverage extension
8949           if (glslangIntermediate->getLayoutOverrideCoverage())
8950               decoration = (spv::Decoration)spv::DecorationOverrideCoverageNV;
8951           else
8952               decoration = (spv::Decoration)spv::DecorationMax;
8953         builder.addDecoration(id, decoration);
8954         if (decoration != spv::DecorationMax) {
8955             builder.addCapability(spv::CapabilitySampleMaskOverrideCoverageNV);
8956             builder.addExtension(spv::E_SPV_NV_sample_mask_override_coverage);
8957         }
8958     }
8959     else if (builtIn == spv::BuiltInLayer) {
8960         // SPV_NV_viewport_array2 extension
8961         if (symbol->getQualifier().layoutViewportRelative) {
8962             builder.addDecoration(id, (spv::Decoration)spv::DecorationViewportRelativeNV);
8963             builder.addCapability(spv::CapabilityShaderViewportMaskNV);
8964             builder.addExtension(spv::E_SPV_NV_viewport_array2);
8965         }
8966         if (symbol->getQualifier().layoutSecondaryViewportRelativeOffset != -2048) {
8967             builder.addDecoration(id, (spv::Decoration)spv::DecorationSecondaryViewportRelativeNV,
8968                                   symbol->getQualifier().layoutSecondaryViewportRelativeOffset);
8969             builder.addCapability(spv::CapabilityShaderStereoViewNV);
8970             builder.addExtension(spv::E_SPV_NV_stereo_view_rendering);
8971         }
8972     }
8973
8974     if (symbol->getQualifier().layoutPassthrough) {
8975         builder.addDecoration(id, spv::DecorationPassthroughNV);
8976         builder.addCapability(spv::CapabilityGeometryShaderPassthroughNV);
8977         builder.addExtension(spv::E_SPV_NV_geometry_shader_passthrough);
8978     }
8979     if (symbol->getQualifier().pervertexNV) {
8980         builder.addDecoration(id, spv::DecorationPerVertexNV);
8981         builder.addCapability(spv::CapabilityFragmentBarycentricNV);
8982         builder.addExtension(spv::E_SPV_NV_fragment_shader_barycentric);
8983     }
8984
8985     if (symbol->getQualifier().pervertexEXT) {
8986         builder.addDecoration(id, spv::DecorationPerVertexKHR);
8987         builder.addCapability(spv::CapabilityFragmentBarycentricKHR);
8988         builder.addExtension(spv::E_SPV_KHR_fragment_shader_barycentric);
8989     }
8990
8991     if (glslangIntermediate->getHlslFunctionality1() && symbol->getType().getQualifier().semanticName != nullptr) {
8992         builder.addExtension("SPV_GOOGLE_hlsl_functionality1");
8993         builder.addDecoration(id, (spv::Decoration)spv::DecorationHlslSemanticGOOGLE,
8994                               symbol->getType().getQualifier().semanticName);
8995     }
8996
8997     if (symbol->isReference()) {
8998         builder.addDecoration(id, symbol->getType().getQualifier().restrict ?
8999             spv::DecorationRestrictPointerEXT : spv::DecorationAliasedPointerEXT);
9000     }
9001
9002     //
9003     // Add SPIR-V decorations for structure (GL_EXT_spirv_intrinsics)
9004     //
9005     if (symbol->getType().getQualifier().hasSprivDecorate()) {
9006         const glslang::TSpirvDecorate& spirvDecorate = symbol->getType().getQualifier().getSpirvDecorate();
9007
9008         // Add spirv_decorate
9009         for (auto& decorate : spirvDecorate.decorates) {
9010             if (!decorate.second.empty()) {
9011                 std::vector<unsigned> literals;
9012                 TranslateLiterals(decorate.second, literals);
9013                 builder.addDecoration(id, static_cast<spv::Decoration>(decorate.first), literals);
9014             }
9015             else
9016                 builder.addDecoration(id, static_cast<spv::Decoration>(decorate.first));
9017         }
9018
9019         // Add spirv_decorate_id
9020         for (auto& decorateId : spirvDecorate.decorateIds) {
9021             std::vector<spv::Id> operandIds;
9022             assert(!decorateId.second.empty());
9023             for (auto extraOperand : decorateId.second) {
9024                 if (extraOperand->getQualifier().isSpecConstant())
9025                     operandIds.push_back(getSymbolId(extraOperand->getAsSymbolNode()));
9026                 else
9027                     operandIds.push_back(createSpvConstant(*extraOperand));
9028             }
9029             builder.addDecorationId(id, static_cast<spv::Decoration>(decorateId.first), operandIds);
9030         }
9031
9032         // Add spirv_decorate_string
9033         for (auto& decorateString : spirvDecorate.decorateStrings) {
9034             std::vector<const char*> strings;
9035             assert(!decorateString.second.empty());
9036             for (auto extraOperand : decorateString.second) {
9037                 const char* string = extraOperand->getConstArray()[0].getSConst()->c_str();
9038                 strings.push_back(string);
9039             }
9040             builder.addDecoration(id, static_cast<spv::Decoration>(decorateString.first), strings);
9041         }
9042     }
9043 #endif
9044
9045     return id;
9046 }
9047
9048 #ifndef GLSLANG_WEB
9049 // add per-primitive, per-view. per-task decorations to a struct member (member >= 0) or an object
9050 void TGlslangToSpvTraverser::addMeshNVDecoration(spv::Id id, int member, const glslang::TQualifier& qualifier)
9051 {
9052     bool isMeshShaderExt = (glslangIntermediate->getRequestedExtensions().find(glslang::E_GL_EXT_mesh_shader) !=
9053                             glslangIntermediate->getRequestedExtensions().end());
9054
9055     if (member >= 0) {
9056         if (qualifier.perPrimitiveNV) {
9057             // Need to add capability/extension for fragment shader.
9058             // Mesh shader already adds this by default.
9059             if (glslangIntermediate->getStage() == EShLangFragment) {
9060                 if(isMeshShaderExt) {
9061                     builder.addCapability(spv::CapabilityMeshShadingEXT);
9062                     builder.addExtension(spv::E_SPV_EXT_mesh_shader);
9063                 } else {
9064                     builder.addCapability(spv::CapabilityMeshShadingNV);
9065                     builder.addExtension(spv::E_SPV_NV_mesh_shader);
9066                 }
9067             }
9068             builder.addMemberDecoration(id, (unsigned)member, spv::DecorationPerPrimitiveNV);
9069         }
9070         if (qualifier.perViewNV)
9071             builder.addMemberDecoration(id, (unsigned)member, spv::DecorationPerViewNV);
9072         if (qualifier.perTaskNV)
9073             builder.addMemberDecoration(id, (unsigned)member, spv::DecorationPerTaskNV);
9074     } else {
9075         if (qualifier.perPrimitiveNV) {
9076             // Need to add capability/extension for fragment shader.
9077             // Mesh shader already adds this by default.
9078             if (glslangIntermediate->getStage() == EShLangFragment) {
9079                 if(isMeshShaderExt) {
9080                     builder.addCapability(spv::CapabilityMeshShadingEXT);
9081                     builder.addExtension(spv::E_SPV_EXT_mesh_shader);
9082                 } else {
9083                     builder.addCapability(spv::CapabilityMeshShadingNV);
9084                     builder.addExtension(spv::E_SPV_NV_mesh_shader);
9085                 }
9086             }
9087             builder.addDecoration(id, spv::DecorationPerPrimitiveNV);
9088         }
9089         if (qualifier.perViewNV)
9090             builder.addDecoration(id, spv::DecorationPerViewNV);
9091         if (qualifier.perTaskNV)
9092             builder.addDecoration(id, spv::DecorationPerTaskNV);
9093     }
9094 }
9095 #endif
9096
9097 // Make a full tree of instructions to build a SPIR-V specialization constant,
9098 // or regular constant if possible.
9099 //
9100 // TBD: this is not yet done, nor verified to be the best design, it does do the leaf symbols though
9101 //
9102 // Recursively walk the nodes.  The nodes form a tree whose leaves are
9103 // regular constants, which themselves are trees that createSpvConstant()
9104 // recursively walks.  So, this function walks the "top" of the tree:
9105 //  - emit specialization constant-building instructions for specConstant
9106 //  - when running into a non-spec-constant, switch to createSpvConstant()
9107 spv::Id TGlslangToSpvTraverser::createSpvConstant(const glslang::TIntermTyped& node)
9108 {
9109     assert(node.getQualifier().isConstant());
9110
9111     // Handle front-end constants first (non-specialization constants).
9112     if (! node.getQualifier().specConstant) {
9113         // hand off to the non-spec-constant path
9114         assert(node.getAsConstantUnion() != nullptr || node.getAsSymbolNode() != nullptr);
9115         int nextConst = 0;
9116         return createSpvConstantFromConstUnionArray(node.getType(), node.getAsConstantUnion() ?
9117             node.getAsConstantUnion()->getConstArray() : node.getAsSymbolNode()->getConstArray(),
9118             nextConst, false);
9119     }
9120
9121     // We now know we have a specialization constant to build
9122
9123     // Extra capabilities may be needed.
9124     if (node.getType().contains8BitInt())
9125         builder.addCapability(spv::CapabilityInt8);
9126     if (node.getType().contains16BitFloat())
9127         builder.addCapability(spv::CapabilityFloat16);
9128     if (node.getType().contains16BitInt())
9129         builder.addCapability(spv::CapabilityInt16);
9130     if (node.getType().contains64BitInt())
9131         builder.addCapability(spv::CapabilityInt64);
9132     if (node.getType().containsDouble())
9133         builder.addCapability(spv::CapabilityFloat64);
9134
9135     // gl_WorkGroupSize is a special case until the front-end handles hierarchical specialization constants,
9136     // even then, it's specialization ids are handled by special case syntax in GLSL: layout(local_size_x = ...
9137     if (node.getType().getQualifier().builtIn == glslang::EbvWorkGroupSize) {
9138         std::vector<spv::Id> dimConstId;
9139         for (int dim = 0; dim < 3; ++dim) {
9140             bool specConst = (glslangIntermediate->getLocalSizeSpecId(dim) != glslang::TQualifier::layoutNotSet);
9141             dimConstId.push_back(builder.makeUintConstant(glslangIntermediate->getLocalSize(dim), specConst));
9142             if (specConst) {
9143                 builder.addDecoration(dimConstId.back(), spv::DecorationSpecId,
9144                                       glslangIntermediate->getLocalSizeSpecId(dim));
9145             }
9146         }
9147         return builder.makeCompositeConstant(builder.makeVectorType(builder.makeUintType(32), 3), dimConstId, true);
9148     }
9149
9150     // An AST node labelled as specialization constant should be a symbol node.
9151     // Its initializer should either be a sub tree with constant nodes, or a constant union array.
9152     if (auto* sn = node.getAsSymbolNode()) {
9153         spv::Id result;
9154         if (auto* sub_tree = sn->getConstSubtree()) {
9155             // Traverse the constant constructor sub tree like generating normal run-time instructions.
9156             // During the AST traversal, if the node is marked as 'specConstant', SpecConstantOpModeGuard
9157             // will set the builder into spec constant op instruction generating mode.
9158             sub_tree->traverse(this);
9159             result = accessChainLoad(sub_tree->getType());
9160         } else if (auto* const_union_array = &sn->getConstArray()) {
9161             int nextConst = 0;
9162             result = createSpvConstantFromConstUnionArray(sn->getType(), *const_union_array, nextConst, true);
9163         } else {
9164             logger->missingFunctionality("Invalid initializer for spec onstant.");
9165             return spv::NoResult;
9166         }
9167         builder.addName(result, sn->getName().c_str());
9168         return result;
9169     }
9170
9171     // Neither a front-end constant node, nor a specialization constant node with constant union array or
9172     // constant sub tree as initializer.
9173     logger->missingFunctionality("Neither a front-end constant nor a spec constant.");
9174     return spv::NoResult;
9175 }
9176
9177 // Use 'consts' as the flattened glslang source of scalar constants to recursively
9178 // build the aggregate SPIR-V constant.
9179 //
9180 // If there are not enough elements present in 'consts', 0 will be substituted;
9181 // an empty 'consts' can be used to create a fully zeroed SPIR-V constant.
9182 //
9183 spv::Id TGlslangToSpvTraverser::createSpvConstantFromConstUnionArray(const glslang::TType& glslangType,
9184     const glslang::TConstUnionArray& consts, int& nextConst, bool specConstant)
9185 {
9186     // vector of constants for SPIR-V
9187     std::vector<spv::Id> spvConsts;
9188
9189     // Type is used for struct and array constants
9190     spv::Id typeId = convertGlslangToSpvType(glslangType);
9191
9192     if (glslangType.isArray()) {
9193         glslang::TType elementType(glslangType, 0);
9194         for (int i = 0; i < glslangType.getOuterArraySize(); ++i)
9195             spvConsts.push_back(createSpvConstantFromConstUnionArray(elementType, consts, nextConst, false));
9196     } else if (glslangType.isMatrix()) {
9197         glslang::TType vectorType(glslangType, 0);
9198         for (int col = 0; col < glslangType.getMatrixCols(); ++col)
9199             spvConsts.push_back(createSpvConstantFromConstUnionArray(vectorType, consts, nextConst, false));
9200     } else if (glslangType.isCoopMat()) {
9201         glslang::TType componentType(glslangType.getBasicType());
9202         spvConsts.push_back(createSpvConstantFromConstUnionArray(componentType, consts, nextConst, false));
9203     } else if (glslangType.isStruct()) {
9204         glslang::TVector<glslang::TTypeLoc>::const_iterator iter;
9205         for (iter = glslangType.getStruct()->begin(); iter != glslangType.getStruct()->end(); ++iter)
9206             spvConsts.push_back(createSpvConstantFromConstUnionArray(*iter->type, consts, nextConst, false));
9207     } else if (glslangType.getVectorSize() > 1) {
9208         for (unsigned int i = 0; i < (unsigned int)glslangType.getVectorSize(); ++i) {
9209             bool zero = nextConst >= consts.size();
9210             switch (glslangType.getBasicType()) {
9211             case glslang::EbtInt:
9212                 spvConsts.push_back(builder.makeIntConstant(zero ? 0 : consts[nextConst].getIConst()));
9213                 break;
9214             case glslang::EbtUint:
9215                 spvConsts.push_back(builder.makeUintConstant(zero ? 0 : consts[nextConst].getUConst()));
9216                 break;
9217             case glslang::EbtFloat:
9218                 spvConsts.push_back(builder.makeFloatConstant(zero ? 0.0F : (float)consts[nextConst].getDConst()));
9219                 break;
9220             case glslang::EbtBool:
9221                 spvConsts.push_back(builder.makeBoolConstant(zero ? false : consts[nextConst].getBConst()));
9222                 break;
9223 #ifndef GLSLANG_WEB
9224             case glslang::EbtInt8:
9225                 builder.addCapability(spv::CapabilityInt8);
9226                 spvConsts.push_back(builder.makeInt8Constant(zero ? 0 : consts[nextConst].getI8Const()));
9227                 break;
9228             case glslang::EbtUint8:
9229                 builder.addCapability(spv::CapabilityInt8);
9230                 spvConsts.push_back(builder.makeUint8Constant(zero ? 0 : consts[nextConst].getU8Const()));
9231                 break;
9232             case glslang::EbtInt16:
9233                 builder.addCapability(spv::CapabilityInt16);
9234                 spvConsts.push_back(builder.makeInt16Constant(zero ? 0 : consts[nextConst].getI16Const()));
9235                 break;
9236             case glslang::EbtUint16:
9237                 builder.addCapability(spv::CapabilityInt16);
9238                 spvConsts.push_back(builder.makeUint16Constant(zero ? 0 : consts[nextConst].getU16Const()));
9239                 break;
9240             case glslang::EbtInt64:
9241                 spvConsts.push_back(builder.makeInt64Constant(zero ? 0 : consts[nextConst].getI64Const()));
9242                 break;
9243             case glslang::EbtUint64:
9244                 spvConsts.push_back(builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const()));
9245                 break;
9246             case glslang::EbtDouble:
9247                 spvConsts.push_back(builder.makeDoubleConstant(zero ? 0.0 : consts[nextConst].getDConst()));
9248                 break;
9249             case glslang::EbtFloat16:
9250                 builder.addCapability(spv::CapabilityFloat16);
9251                 spvConsts.push_back(builder.makeFloat16Constant(zero ? 0.0F : (float)consts[nextConst].getDConst()));
9252                 break;
9253 #endif
9254             default:
9255                 assert(0);
9256                 break;
9257             }
9258             ++nextConst;
9259         }
9260     } else {
9261         // we have a non-aggregate (scalar) constant
9262         bool zero = nextConst >= consts.size();
9263         spv::Id scalar = 0;
9264         switch (glslangType.getBasicType()) {
9265         case glslang::EbtInt:
9266             scalar = builder.makeIntConstant(zero ? 0 : consts[nextConst].getIConst(), specConstant);
9267             break;
9268         case glslang::EbtUint:
9269             scalar = builder.makeUintConstant(zero ? 0 : consts[nextConst].getUConst(), specConstant);
9270             break;
9271         case glslang::EbtFloat:
9272             scalar = builder.makeFloatConstant(zero ? 0.0F : (float)consts[nextConst].getDConst(), specConstant);
9273             break;
9274         case glslang::EbtBool:
9275             scalar = builder.makeBoolConstant(zero ? false : consts[nextConst].getBConst(), specConstant);
9276             break;
9277 #ifndef GLSLANG_WEB
9278         case glslang::EbtInt8:
9279             builder.addCapability(spv::CapabilityInt8);
9280             scalar = builder.makeInt8Constant(zero ? 0 : consts[nextConst].getI8Const(), specConstant);
9281             break;
9282         case glslang::EbtUint8:
9283             builder.addCapability(spv::CapabilityInt8);
9284             scalar = builder.makeUint8Constant(zero ? 0 : consts[nextConst].getU8Const(), specConstant);
9285             break;
9286         case glslang::EbtInt16:
9287             builder.addCapability(spv::CapabilityInt16);
9288             scalar = builder.makeInt16Constant(zero ? 0 : consts[nextConst].getI16Const(), specConstant);
9289             break;
9290         case glslang::EbtUint16:
9291             builder.addCapability(spv::CapabilityInt16);
9292             scalar = builder.makeUint16Constant(zero ? 0 : consts[nextConst].getU16Const(), specConstant);
9293             break;
9294         case glslang::EbtInt64:
9295             scalar = builder.makeInt64Constant(zero ? 0 : consts[nextConst].getI64Const(), specConstant);
9296             break;
9297         case glslang::EbtUint64:
9298             scalar = builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const(), specConstant);
9299             break;
9300         case glslang::EbtDouble:
9301             scalar = builder.makeDoubleConstant(zero ? 0.0 : consts[nextConst].getDConst(), specConstant);
9302             break;
9303         case glslang::EbtFloat16:
9304             builder.addCapability(spv::CapabilityFloat16);
9305             scalar = builder.makeFloat16Constant(zero ? 0.0F : (float)consts[nextConst].getDConst(), specConstant);
9306             break;
9307         case glslang::EbtReference:
9308             scalar = builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const(), specConstant);
9309             scalar = builder.createUnaryOp(spv::OpBitcast, typeId, scalar);
9310             break;
9311 #endif
9312         case glslang::EbtString:
9313             scalar = builder.getStringId(consts[nextConst].getSConst()->c_str());
9314             break;
9315         default:
9316             assert(0);
9317             break;
9318         }
9319         ++nextConst;
9320         return scalar;
9321     }
9322
9323     return builder.makeCompositeConstant(typeId, spvConsts);
9324 }
9325
9326 // Return true if the node is a constant or symbol whose reading has no
9327 // non-trivial observable cost or effect.
9328 bool TGlslangToSpvTraverser::isTrivialLeaf(const glslang::TIntermTyped* node)
9329 {
9330     // don't know what this is
9331     if (node == nullptr)
9332         return false;
9333
9334     // a constant is safe
9335     if (node->getAsConstantUnion() != nullptr)
9336         return true;
9337
9338     // not a symbol means non-trivial
9339     if (node->getAsSymbolNode() == nullptr)
9340         return false;
9341
9342     // a symbol, depends on what's being read
9343     switch (node->getType().getQualifier().storage) {
9344     case glslang::EvqTemporary:
9345     case glslang::EvqGlobal:
9346     case glslang::EvqIn:
9347     case glslang::EvqInOut:
9348     case glslang::EvqConst:
9349     case glslang::EvqConstReadOnly:
9350     case glslang::EvqUniform:
9351         return true;
9352     default:
9353         return false;
9354     }
9355 }
9356
9357 // A node is trivial if it is a single operation with no side effects.
9358 // HLSL (and/or vectors) are always trivial, as it does not short circuit.
9359 // Otherwise, error on the side of saying non-trivial.
9360 // Return true if trivial.
9361 bool TGlslangToSpvTraverser::isTrivial(const glslang::TIntermTyped* node)
9362 {
9363     if (node == nullptr)
9364         return false;
9365
9366     // count non scalars as trivial, as well as anything coming from HLSL
9367     if (! node->getType().isScalarOrVec1() || glslangIntermediate->getSource() == glslang::EShSourceHlsl)
9368         return true;
9369
9370     // symbols and constants are trivial
9371     if (isTrivialLeaf(node))
9372         return true;
9373
9374     // otherwise, it needs to be a simple operation or one or two leaf nodes
9375
9376     // not a simple operation
9377     const glslang::TIntermBinary* binaryNode = node->getAsBinaryNode();
9378     const glslang::TIntermUnary* unaryNode = node->getAsUnaryNode();
9379     if (binaryNode == nullptr && unaryNode == nullptr)
9380         return false;
9381
9382     // not on leaf nodes
9383     if (binaryNode && (! isTrivialLeaf(binaryNode->getLeft()) || ! isTrivialLeaf(binaryNode->getRight())))
9384         return false;
9385
9386     if (unaryNode && ! isTrivialLeaf(unaryNode->getOperand())) {
9387         return false;
9388     }
9389
9390     switch (node->getAsOperator()->getOp()) {
9391     case glslang::EOpLogicalNot:
9392     case glslang::EOpConvIntToBool:
9393     case glslang::EOpConvUintToBool:
9394     case glslang::EOpConvFloatToBool:
9395     case glslang::EOpConvDoubleToBool:
9396     case glslang::EOpEqual:
9397     case glslang::EOpNotEqual:
9398     case glslang::EOpLessThan:
9399     case glslang::EOpGreaterThan:
9400     case glslang::EOpLessThanEqual:
9401     case glslang::EOpGreaterThanEqual:
9402     case glslang::EOpIndexDirect:
9403     case glslang::EOpIndexDirectStruct:
9404     case glslang::EOpLogicalXor:
9405     case glslang::EOpAny:
9406     case glslang::EOpAll:
9407         return true;
9408     default:
9409         return false;
9410     }
9411 }
9412
9413 // Emit short-circuiting code, where 'right' is never evaluated unless
9414 // the left side is true (for &&) or false (for ||).
9415 spv::Id TGlslangToSpvTraverser::createShortCircuit(glslang::TOperator op, glslang::TIntermTyped& left,
9416     glslang::TIntermTyped& right)
9417 {
9418     spv::Id boolTypeId = builder.makeBoolType();
9419
9420     // emit left operand
9421     builder.clearAccessChain();
9422     left.traverse(this);
9423     spv::Id leftId = accessChainLoad(left.getType());
9424
9425     // Operands to accumulate OpPhi operands
9426     std::vector<spv::Id> phiOperands;
9427     // accumulate left operand's phi information
9428     phiOperands.push_back(leftId);
9429     phiOperands.push_back(builder.getBuildPoint()->getId());
9430
9431     // Make the two kinds of operation symmetric with a "!"
9432     //   || => emit "if (! left) result = right"
9433     //   && => emit "if (  left) result = right"
9434     //
9435     // TODO: this runtime "not" for || could be avoided by adding functionality
9436     // to 'builder' to have an "else" without an "then"
9437     if (op == glslang::EOpLogicalOr)
9438         leftId = builder.createUnaryOp(spv::OpLogicalNot, boolTypeId, leftId);
9439
9440     // make an "if" based on the left value
9441     spv::Builder::If ifBuilder(leftId, spv::SelectionControlMaskNone, builder);
9442
9443     // emit right operand as the "then" part of the "if"
9444     builder.clearAccessChain();
9445     right.traverse(this);
9446     spv::Id rightId = accessChainLoad(right.getType());
9447
9448     // accumulate left operand's phi information
9449     phiOperands.push_back(rightId);
9450     phiOperands.push_back(builder.getBuildPoint()->getId());
9451
9452     // finish the "if"
9453     ifBuilder.makeEndIf();
9454
9455     // phi together the two results
9456     return builder.createOp(spv::OpPhi, boolTypeId, phiOperands);
9457 }
9458
9459 #ifndef GLSLANG_WEB
9460 // Return type Id of the imported set of extended instructions corresponds to the name.
9461 // Import this set if it has not been imported yet.
9462 spv::Id TGlslangToSpvTraverser::getExtBuiltins(const char* name)
9463 {
9464     if (extBuiltinMap.find(name) != extBuiltinMap.end())
9465         return extBuiltinMap[name];
9466     else {
9467         builder.addExtension(name);
9468         spv::Id extBuiltins = builder.import(name);
9469         extBuiltinMap[name] = extBuiltins;
9470         return extBuiltins;
9471     }
9472 }
9473 #endif
9474
9475 };  // end anonymous namespace
9476
9477 namespace glslang {
9478
9479 void GetSpirvVersion(std::string& version)
9480 {
9481     const int bufSize = 100;
9482     char buf[bufSize];
9483     snprintf(buf, bufSize, "0x%08x, Revision %d", spv::Version, spv::Revision);
9484     version = buf;
9485 }
9486
9487 // For low-order part of the generator's magic number. Bump up
9488 // when there is a change in the style (e.g., if SSA form changes,
9489 // or a different instruction sequence to do something gets used).
9490 int GetSpirvGeneratorVersion()
9491 {
9492     // return 1; // start
9493     // return 2; // EOpAtomicCounterDecrement gets a post decrement, to map between GLSL -> SPIR-V
9494     // return 3; // change/correct barrier-instruction operands, to match memory model group decisions
9495     // return 4; // some deeper access chains: for dynamic vector component, and local Boolean component
9496     // return 5; // make OpArrayLength result type be an int with signedness of 0
9497     // return 6; // revert version 5 change, which makes a different (new) kind of incorrect code,
9498                  // versions 4 and 6 each generate OpArrayLength as it has long been done
9499     // return 7; // GLSL volatile keyword maps to both SPIR-V decorations Volatile and Coherent
9500     // return 8; // switch to new dead block eliminator; use OpUnreachable
9501     // return 9; // don't include opaque function parameters in OpEntryPoint global's operand list
9502     return 10; // Generate OpFUnordNotEqual for != comparisons
9503 }
9504
9505 // Write SPIR-V out to a binary file
9506 void OutputSpvBin(const std::vector<unsigned int>& spirv, const char* baseName)
9507 {
9508     std::ofstream out;
9509     out.open(baseName, std::ios::binary | std::ios::out);
9510     if (out.fail())
9511         printf("ERROR: Failed to open file: %s\n", baseName);
9512     for (int i = 0; i < (int)spirv.size(); ++i) {
9513         unsigned int word = spirv[i];
9514         out.write((const char*)&word, 4);
9515     }
9516     out.close();
9517 }
9518
9519 // Write SPIR-V out to a text file with 32-bit hexadecimal words
9520 void OutputSpvHex(const std::vector<unsigned int>& spirv, const char* baseName, const char* varName)
9521 {
9522 #if !defined(GLSLANG_WEB) && !defined(GLSLANG_ANGLE)
9523     std::ofstream out;
9524     out.open(baseName, std::ios::binary | std::ios::out);
9525     if (out.fail())
9526         printf("ERROR: Failed to open file: %s\n", baseName);
9527     out << "\t// " <<
9528         GetSpirvGeneratorVersion() <<
9529         GLSLANG_VERSION_MAJOR << "." << GLSLANG_VERSION_MINOR << "." << GLSLANG_VERSION_PATCH <<
9530         GLSLANG_VERSION_FLAVOR << std::endl;
9531     if (varName != nullptr) {
9532         out << "\t #pragma once" << std::endl;
9533         out << "const uint32_t " << varName << "[] = {" << std::endl;
9534     }
9535     const int WORDS_PER_LINE = 8;
9536     for (int i = 0; i < (int)spirv.size(); i += WORDS_PER_LINE) {
9537         out << "\t";
9538         for (int j = 0; j < WORDS_PER_LINE && i + j < (int)spirv.size(); ++j) {
9539             const unsigned int word = spirv[i + j];
9540             out << "0x" << std::hex << std::setw(8) << std::setfill('0') << word;
9541             if (i + j + 1 < (int)spirv.size()) {
9542                 out << ",";
9543             }
9544         }
9545         out << std::endl;
9546     }
9547     if (varName != nullptr) {
9548         out << "};";
9549         out << std::endl;
9550     }
9551     out.close();
9552 #endif
9553 }
9554
9555 //
9556 // Set up the glslang traversal
9557 //
9558 void GlslangToSpv(const TIntermediate& intermediate, std::vector<unsigned int>& spirv, SpvOptions* options)
9559 {
9560     spv::SpvBuildLogger logger;
9561     GlslangToSpv(intermediate, spirv, &logger, options);
9562 }
9563
9564 void GlslangToSpv(const TIntermediate& intermediate, std::vector<unsigned int>& spirv,
9565                   spv::SpvBuildLogger* logger, SpvOptions* options)
9566 {
9567     TIntermNode* root = intermediate.getTreeRoot();
9568
9569     if (root == 0)
9570         return;
9571
9572     SpvOptions defaultOptions;
9573     if (options == nullptr)
9574         options = &defaultOptions;
9575
9576     GetThreadPoolAllocator().push();
9577
9578     TGlslangToSpvTraverser it(intermediate.getSpv().spv, &intermediate, logger, *options);
9579     root->traverse(&it);
9580     it.finishSpv();
9581     it.dumpSpv(spirv);
9582
9583 #if ENABLE_OPT
9584     // If from HLSL, run spirv-opt to "legalize" the SPIR-V for Vulkan
9585     // eg. forward and remove memory writes of opaque types.
9586     bool prelegalization = intermediate.getSource() == EShSourceHlsl;
9587     if ((prelegalization || options->optimizeSize) && !options->disableOptimizer) {
9588         SpirvToolsTransform(intermediate, spirv, logger, options);
9589         prelegalization = false;
9590     }
9591     else if (options->stripDebugInfo) {
9592         // Strip debug info even if optimization is disabled.
9593         SpirvToolsStripDebugInfo(intermediate, spirv, logger);
9594     }
9595
9596     if (options->validate)
9597         SpirvToolsValidate(intermediate, spirv, logger, prelegalization);
9598
9599     if (options->disassemble)
9600         SpirvToolsDisassemble(std::cout, spirv);
9601
9602 #endif
9603
9604     GetThreadPoolAllocator().pop();
9605 }
9606
9607 }; // end namespace glslang