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