// // Copyright (C) 2014-2016 LunarG, Inc. // Copyright (C) 2015-2018 Google, Inc. // Copyright (C) 2017 ARM Limited. // // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions // are met: // // Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // // Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following // disclaimer in the documentation and/or other materials provided // with the distribution. // // Neither the name of 3Dlabs Inc. Ltd. nor the names of its // contributors may be used to endorse or promote products derived // from this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE // COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE // POSSIBILITY OF SUCH DAMAGE. // // Visit the nodes in the glslang intermediate tree representation to // translate them to SPIR-V. // #include "spirv.hpp" #include "GlslangToSpv.h" #include "SpvBuilder.h" namespace spv { #include "GLSL.std.450.h" #include "GLSL.ext.KHR.h" #include "GLSL.ext.EXT.h" #include "GLSL.ext.AMD.h" #include "GLSL.ext.NV.h" } // Glslang includes #include "../glslang/MachineIndependent/localintermediate.h" #include "../glslang/MachineIndependent/SymbolTable.h" #include "../glslang/Include/Common.h" #include "../glslang/Include/revision.h" #include #include #include #include #include #include #include namespace { namespace { class SpecConstantOpModeGuard { public: SpecConstantOpModeGuard(spv::Builder* builder) : builder_(builder) { previous_flag_ = builder->isInSpecConstCodeGenMode(); } ~SpecConstantOpModeGuard() { previous_flag_ ? builder_->setToSpecConstCodeGenMode() : builder_->setToNormalCodeGenMode(); } void turnOnSpecConstantOpMode() { builder_->setToSpecConstCodeGenMode(); } private: spv::Builder* builder_; bool previous_flag_; }; struct OpDecorations { public: OpDecorations(spv::Decoration precision, spv::Decoration noContraction, spv::Decoration nonUniform) : precision(precision) #ifndef GLSLANG_WEB , noContraction(noContraction), nonUniform(nonUniform) #endif { } spv::Decoration precision; #ifdef GLSLANG_WEB void addNoContraction(spv::Builder&, spv::Id) const { } void addNonUniform(spv::Builder&, spv::Id) const { } #else void addNoContraction(spv::Builder& builder, spv::Id t) { builder.addDecoration(t, noContraction); } void addNonUniform(spv::Builder& builder, spv::Id t) { builder.addDecoration(t, nonUniform); } protected: spv::Decoration noContraction; spv::Decoration nonUniform; #endif }; } // namespace // // The main holder of information for translating glslang to SPIR-V. // // Derives from the AST walking base class. // class TGlslangToSpvTraverser : public glslang::TIntermTraverser { public: TGlslangToSpvTraverser(unsigned int spvVersion, const glslang::TIntermediate*, spv::SpvBuildLogger* logger, glslang::SpvOptions& options); virtual ~TGlslangToSpvTraverser() { } bool visitAggregate(glslang::TVisit, glslang::TIntermAggregate*); bool visitBinary(glslang::TVisit, glslang::TIntermBinary*); void visitConstantUnion(glslang::TIntermConstantUnion*); bool visitSelection(glslang::TVisit, glslang::TIntermSelection*); bool visitSwitch(glslang::TVisit, glslang::TIntermSwitch*); void visitSymbol(glslang::TIntermSymbol* symbol); bool visitUnary(glslang::TVisit, glslang::TIntermUnary*); bool visitLoop(glslang::TVisit, glslang::TIntermLoop*); bool visitBranch(glslang::TVisit visit, glslang::TIntermBranch*); void finishSpv(); void dumpSpv(std::vector& out); protected: TGlslangToSpvTraverser(TGlslangToSpvTraverser&); TGlslangToSpvTraverser& operator=(TGlslangToSpvTraverser&); spv::Decoration TranslateInterpolationDecoration(const glslang::TQualifier& qualifier); spv::Decoration TranslateAuxiliaryStorageDecoration(const glslang::TQualifier& qualifier); spv::Decoration TranslateNonUniformDecoration(const glslang::TQualifier& qualifier); spv::Builder::AccessChain::CoherentFlags TranslateCoherent(const glslang::TType& type); spv::MemoryAccessMask TranslateMemoryAccess(const spv::Builder::AccessChain::CoherentFlags &coherentFlags); spv::ImageOperandsMask TranslateImageOperands(const spv::Builder::AccessChain::CoherentFlags &coherentFlags); spv::Scope TranslateMemoryScope(const spv::Builder::AccessChain::CoherentFlags &coherentFlags); spv::BuiltIn TranslateBuiltInDecoration(glslang::TBuiltInVariable, bool memberDeclaration); spv::ImageFormat TranslateImageFormat(const glslang::TType& type); spv::SelectionControlMask TranslateSelectionControl(const glslang::TIntermSelection&) const; spv::SelectionControlMask TranslateSwitchControl(const glslang::TIntermSwitch&) const; spv::LoopControlMask TranslateLoopControl(const glslang::TIntermLoop&, std::vector& operands) const; spv::StorageClass TranslateStorageClass(const glslang::TType&); void addIndirectionIndexCapabilities(const glslang::TType& baseType, const glslang::TType& indexType); spv::Id createSpvVariable(const glslang::TIntermSymbol*, spv::Id forcedType); spv::Id getSampledType(const glslang::TSampler&); spv::Id getInvertedSwizzleType(const glslang::TIntermTyped&); spv::Id createInvertedSwizzle(spv::Decoration precision, const glslang::TIntermTyped&, spv::Id parentResult); void convertSwizzle(const glslang::TIntermAggregate&, std::vector& swizzle); spv::Id convertGlslangToSpvType(const glslang::TType& type, bool forwardReferenceOnly = false); spv::Id convertGlslangToSpvType(const glslang::TType& type, glslang::TLayoutPacking, const glslang::TQualifier&, bool lastBufferBlockMember, bool forwardReferenceOnly = false); bool filterMember(const glslang::TType& member); spv::Id convertGlslangStructToSpvType(const glslang::TType&, const glslang::TTypeList* glslangStruct, glslang::TLayoutPacking, const glslang::TQualifier&); void decorateStructType(const glslang::TType&, const glslang::TTypeList* glslangStruct, glslang::TLayoutPacking, const glslang::TQualifier&, spv::Id); spv::Id makeArraySizeId(const glslang::TArraySizes&, int dim); spv::Id accessChainLoad(const glslang::TType& type); void accessChainStore(const glslang::TType& type, spv::Id rvalue); void multiTypeStore(const glslang::TType&, spv::Id rValue); glslang::TLayoutPacking getExplicitLayout(const glslang::TType& type) const; int getArrayStride(const glslang::TType& arrayType, glslang::TLayoutPacking, glslang::TLayoutMatrix); int getMatrixStride(const glslang::TType& matrixType, glslang::TLayoutPacking, glslang::TLayoutMatrix); void updateMemberOffset(const glslang::TType& structType, const glslang::TType& memberType, int& currentOffset, int& nextOffset, glslang::TLayoutPacking, glslang::TLayoutMatrix); void declareUseOfStructMember(const glslang::TTypeList& members, int glslangMember); bool isShaderEntryPoint(const glslang::TIntermAggregate* node); bool writableParam(glslang::TStorageQualifier) const; bool originalParam(glslang::TStorageQualifier, const glslang::TType&, bool implicitThisParam); void makeFunctions(const glslang::TIntermSequence&); void makeGlobalInitializers(const glslang::TIntermSequence&); void visitFunctions(const glslang::TIntermSequence&); void handleFunctionEntry(const glslang::TIntermAggregate* node); void translateArguments(const glslang::TIntermAggregate& node, std::vector& arguments, spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags); void translateArguments(glslang::TIntermUnary& node, std::vector& arguments); spv::Id createImageTextureFunctionCall(glslang::TIntermOperator* node); spv::Id handleUserFunctionCall(const glslang::TIntermAggregate*); spv::Id createBinaryOperation(glslang::TOperator op, OpDecorations&, spv::Id typeId, spv::Id left, spv::Id right, glslang::TBasicType typeProxy, bool reduceComparison = true); spv::Id createBinaryMatrixOperation(spv::Op, OpDecorations&, spv::Id typeId, spv::Id left, spv::Id right); spv::Id createUnaryOperation(glslang::TOperator op, OpDecorations&, spv::Id typeId, spv::Id operand, glslang::TBasicType typeProxy, const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags); spv::Id createUnaryMatrixOperation(spv::Op op, OpDecorations&, spv::Id typeId, spv::Id operand, glslang::TBasicType typeProxy); spv::Id createConversion(glslang::TOperator op, OpDecorations&, spv::Id destTypeId, spv::Id operand, glslang::TBasicType typeProxy); spv::Id createIntWidthConversion(glslang::TOperator op, spv::Id operand, int vectorSize); spv::Id makeSmearedConstant(spv::Id constant, int vectorSize); spv::Id createAtomicOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId, std::vector& operands, glslang::TBasicType typeProxy, const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags); spv::Id createInvocationsOperation(glslang::TOperator op, spv::Id typeId, std::vector& operands, glslang::TBasicType typeProxy); spv::Id CreateInvocationsVectorOperation(spv::Op op, spv::GroupOperation groupOperation, spv::Id typeId, std::vector& operands); spv::Id createSubgroupOperation(glslang::TOperator op, spv::Id typeId, std::vector& operands, glslang::TBasicType typeProxy); spv::Id createMiscOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId, std::vector& operands, glslang::TBasicType typeProxy); spv::Id createNoArgOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId); spv::Id getSymbolId(const glslang::TIntermSymbol* node); void addMeshNVDecoration(spv::Id id, int member, const glslang::TQualifier & qualifier); spv::Id createSpvConstant(const glslang::TIntermTyped&); spv::Id createSpvConstantFromConstUnionArray(const glslang::TType& type, const glslang::TConstUnionArray&, int& nextConst, bool specConstant); bool isTrivialLeaf(const glslang::TIntermTyped* node); bool isTrivial(const glslang::TIntermTyped* node); spv::Id createShortCircuit(glslang::TOperator, glslang::TIntermTyped& left, glslang::TIntermTyped& right); spv::Id getExtBuiltins(const char* name); std::pair getForcedType(spv::BuiltIn, const glslang::TType&); spv::Id translateForcedType(spv::Id object); spv::Id createCompositeConstruct(spv::Id typeId, std::vector constituents); glslang::SpvOptions& options; spv::Function* shaderEntry; spv::Function* currentFunction; spv::Instruction* entryPoint; int sequenceDepth; spv::SpvBuildLogger* logger; // There is a 1:1 mapping between a spv builder and a module; this is thread safe spv::Builder builder; bool inEntryPoint; bool entryPointTerminated; bool linkageOnly; // true when visiting the set of objects in the AST present only for establishing interface, whether or not they were statically used std::set iOSet; // all input/output variables from either static use or declaration of interface const glslang::TIntermediate* glslangIntermediate; bool nanMinMaxClamp; // true if use NMin/NMax/NClamp instead of FMin/FMax/FClamp spv::Id stdBuiltins; std::unordered_map extBuiltinMap; std::unordered_map symbolValues; std::unordered_set rValueParameters; // set of formal function parameters passed as rValues, rather than a pointer std::unordered_map functionMap; std::unordered_map structMap[glslang::ElpCount][glslang::ElmCount]; // for mapping glslang block indices to spv indices (e.g., due to hidden members): std::unordered_map > memberRemapper; std::stack breakForLoop; // false means break for switch std::unordered_map counterOriginator; // Map pointee types for EbtReference to their forward pointers std::map forwardPointers; // Type forcing, for when SPIR-V wants a different type than the AST, // requiring local translation to and from SPIR-V type on every access. // Maps AST-required-type-id> std::unordered_map forceType; }; // // Helper functions for translating glslang representations to SPIR-V enumerants. // // Translate glslang profile to SPIR-V source language. spv::SourceLanguage TranslateSourceLanguage(glslang::EShSource source, EProfile profile) { #ifdef GLSLANG_WEB return spv::SourceLanguageESSL; #endif switch (source) { case glslang::EShSourceGlsl: switch (profile) { case ENoProfile: case ECoreProfile: case ECompatibilityProfile: return spv::SourceLanguageGLSL; case EEsProfile: return spv::SourceLanguageESSL; default: return spv::SourceLanguageUnknown; } case glslang::EShSourceHlsl: return spv::SourceLanguageHLSL; default: return spv::SourceLanguageUnknown; } } // Translate glslang language (stage) to SPIR-V execution model. spv::ExecutionModel TranslateExecutionModel(EShLanguage stage) { switch (stage) { case EShLangVertex: return spv::ExecutionModelVertex; case EShLangFragment: return spv::ExecutionModelFragment; case EShLangCompute: return spv::ExecutionModelGLCompute; #ifndef GLSLANG_WEB case EShLangTessControl: return spv::ExecutionModelTessellationControl; case EShLangTessEvaluation: return spv::ExecutionModelTessellationEvaluation; case EShLangGeometry: return spv::ExecutionModelGeometry; case EShLangRayGenNV: return spv::ExecutionModelRayGenerationNV; case EShLangIntersectNV: return spv::ExecutionModelIntersectionNV; case EShLangAnyHitNV: return spv::ExecutionModelAnyHitNV; case EShLangClosestHitNV: return spv::ExecutionModelClosestHitNV; case EShLangMissNV: return spv::ExecutionModelMissNV; case EShLangCallableNV: return spv::ExecutionModelCallableNV; case EShLangTaskNV: return spv::ExecutionModelTaskNV; case EShLangMeshNV: return spv::ExecutionModelMeshNV; #endif default: assert(0); return spv::ExecutionModelFragment; } } // Translate glslang sampler type to SPIR-V dimensionality. spv::Dim TranslateDimensionality(const glslang::TSampler& sampler) { switch (sampler.dim) { case glslang::Esd1D: return spv::Dim1D; case glslang::Esd2D: return spv::Dim2D; case glslang::Esd3D: return spv::Dim3D; case glslang::EsdCube: return spv::DimCube; case glslang::EsdRect: return spv::DimRect; case glslang::EsdBuffer: return spv::DimBuffer; case glslang::EsdSubpass: return spv::DimSubpassData; default: assert(0); return spv::Dim2D; } } // Translate glslang precision to SPIR-V precision decorations. spv::Decoration TranslatePrecisionDecoration(glslang::TPrecisionQualifier glslangPrecision) { switch (glslangPrecision) { case glslang::EpqLow: return spv::DecorationRelaxedPrecision; case glslang::EpqMedium: return spv::DecorationRelaxedPrecision; default: return spv::NoPrecision; } } // Translate glslang type to SPIR-V precision decorations. spv::Decoration TranslatePrecisionDecoration(const glslang::TType& type) { return TranslatePrecisionDecoration(type.getQualifier().precision); } // Translate glslang type to SPIR-V block decorations. spv::Decoration TranslateBlockDecoration(const glslang::TType& type, bool useStorageBuffer) { if (type.getBasicType() == glslang::EbtBlock) { switch (type.getQualifier().storage) { case glslang::EvqUniform: return spv::DecorationBlock; case glslang::EvqBuffer: return useStorageBuffer ? spv::DecorationBlock : spv::DecorationBufferBlock; case glslang::EvqVaryingIn: return spv::DecorationBlock; case glslang::EvqVaryingOut: return spv::DecorationBlock; #ifndef GLSLANG_WEB case glslang::EvqPayloadNV: return spv::DecorationBlock; case glslang::EvqPayloadInNV: return spv::DecorationBlock; case glslang::EvqHitAttrNV: return spv::DecorationBlock; case glslang::EvqCallableDataNV: return spv::DecorationBlock; case glslang::EvqCallableDataInNV: return spv::DecorationBlock; #endif default: assert(0); break; } } return spv::DecorationMax; } // Translate glslang type to SPIR-V memory decorations. void TranslateMemoryDecoration(const glslang::TQualifier& qualifier, std::vector& memory, bool useVulkanMemoryModel) { if (!useVulkanMemoryModel) { if (qualifier.isCoherent()) memory.push_back(spv::DecorationCoherent); if (qualifier.isVolatile()) { memory.push_back(spv::DecorationVolatile); memory.push_back(spv::DecorationCoherent); } } if (qualifier.isRestrict()) memory.push_back(spv::DecorationRestrict); if (qualifier.isReadOnly()) memory.push_back(spv::DecorationNonWritable); if (qualifier.isWriteOnly()) memory.push_back(spv::DecorationNonReadable); } // Translate glslang type to SPIR-V layout decorations. spv::Decoration TranslateLayoutDecoration(const glslang::TType& type, glslang::TLayoutMatrix matrixLayout) { if (type.isMatrix()) { switch (matrixLayout) { case glslang::ElmRowMajor: return spv::DecorationRowMajor; case glslang::ElmColumnMajor: return spv::DecorationColMajor; default: // opaque layouts don't need a majorness return spv::DecorationMax; } } else { switch (type.getBasicType()) { default: return spv::DecorationMax; break; case glslang::EbtBlock: switch (type.getQualifier().storage) { case glslang::EvqUniform: case glslang::EvqBuffer: switch (type.getQualifier().layoutPacking) { case glslang::ElpShared: return spv::DecorationGLSLShared; case glslang::ElpPacked: return spv::DecorationGLSLPacked; default: return spv::DecorationMax; } case glslang::EvqVaryingIn: case glslang::EvqVaryingOut: if (type.getQualifier().isTaskMemory()) { switch (type.getQualifier().layoutPacking) { case glslang::ElpShared: return spv::DecorationGLSLShared; case glslang::ElpPacked: return spv::DecorationGLSLPacked; default: break; } } else { assert(type.getQualifier().layoutPacking == glslang::ElpNone); } return spv::DecorationMax; #ifndef GLSLANG_WEB case glslang::EvqPayloadNV: case glslang::EvqPayloadInNV: case glslang::EvqHitAttrNV: case glslang::EvqCallableDataNV: case glslang::EvqCallableDataInNV: return spv::DecorationMax; #endif default: assert(0); return spv::DecorationMax; } } } } // Translate glslang type to SPIR-V interpolation decorations. // Returns spv::DecorationMax when no decoration // should be applied. spv::Decoration TGlslangToSpvTraverser::TranslateInterpolationDecoration(const glslang::TQualifier& qualifier) { if (qualifier.smooth) // Smooth decoration doesn't exist in SPIR-V 1.0 return spv::DecorationMax; else if (qualifier.isNonPerspective()) return spv::DecorationNoPerspective; else if (qualifier.flat) return spv::DecorationFlat; else if (qualifier.isExplicitInterpolation()) { builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter); return spv::DecorationExplicitInterpAMD; } else return spv::DecorationMax; } // Translate glslang type to SPIR-V auxiliary storage decorations. // Returns spv::DecorationMax when no decoration // should be applied. spv::Decoration TGlslangToSpvTraverser::TranslateAuxiliaryStorageDecoration(const glslang::TQualifier& qualifier) { if (qualifier.centroid) return spv::DecorationCentroid; #ifndef GLSLANG_WEB else if (qualifier.patch) return spv::DecorationPatch; else if (qualifier.sample) { builder.addCapability(spv::CapabilitySampleRateShading); return spv::DecorationSample; } #endif return spv::DecorationMax; } // If glslang type is invariant, return SPIR-V invariant decoration. spv::Decoration TranslateInvariantDecoration(const glslang::TQualifier& qualifier) { if (qualifier.invariant) return spv::DecorationInvariant; else return spv::DecorationMax; } // If glslang type is noContraction, return SPIR-V NoContraction decoration. spv::Decoration TranslateNoContractionDecoration(const glslang::TQualifier& qualifier) { #ifndef GLSLANG_WEB if (qualifier.isNoContraction()) return spv::DecorationNoContraction; else #endif return spv::DecorationMax; } // If glslang type is nonUniform, return SPIR-V NonUniform decoration. spv::Decoration TGlslangToSpvTraverser::TranslateNonUniformDecoration(const glslang::TQualifier& qualifier) { #ifndef GLSLANG_WEB if (qualifier.isNonUniform()) { builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5); builder.addCapability(spv::CapabilityShaderNonUniformEXT); return spv::DecorationNonUniformEXT; } else #endif return spv::DecorationMax; } spv::MemoryAccessMask TGlslangToSpvTraverser::TranslateMemoryAccess( const spv::Builder::AccessChain::CoherentFlags &coherentFlags) { spv::MemoryAccessMask mask = spv::MemoryAccessMaskNone; #ifndef GLSLANG_WEB if (!glslangIntermediate->usingVulkanMemoryModel() || coherentFlags.isImage) return mask; if (coherentFlags.volatil || coherentFlags.coherent || coherentFlags.devicecoherent || coherentFlags.queuefamilycoherent || coherentFlags.workgroupcoherent || coherentFlags.subgroupcoherent) { mask = mask | spv::MemoryAccessMakePointerAvailableKHRMask | spv::MemoryAccessMakePointerVisibleKHRMask; } if (coherentFlags.nonprivate) { mask = mask | spv::MemoryAccessNonPrivatePointerKHRMask; } if (coherentFlags.volatil) { mask = mask | spv::MemoryAccessVolatileMask; } if (mask != spv::MemoryAccessMaskNone) { builder.addCapability(spv::CapabilityVulkanMemoryModelKHR); } #endif return mask; } spv::ImageOperandsMask TGlslangToSpvTraverser::TranslateImageOperands( const spv::Builder::AccessChain::CoherentFlags &coherentFlags) { spv::ImageOperandsMask mask = spv::ImageOperandsMaskNone; #ifndef GLSLANG_WEB if (!glslangIntermediate->usingVulkanMemoryModel()) return mask; if (coherentFlags.volatil || coherentFlags.coherent || coherentFlags.devicecoherent || coherentFlags.queuefamilycoherent || coherentFlags.workgroupcoherent || coherentFlags.subgroupcoherent) { mask = mask | spv::ImageOperandsMakeTexelAvailableKHRMask | spv::ImageOperandsMakeTexelVisibleKHRMask; } if (coherentFlags.nonprivate) { mask = mask | spv::ImageOperandsNonPrivateTexelKHRMask; } if (coherentFlags.volatil) { mask = mask | spv::ImageOperandsVolatileTexelKHRMask; } if (mask != spv::ImageOperandsMaskNone) { builder.addCapability(spv::CapabilityVulkanMemoryModelKHR); } #endif return mask; } spv::Builder::AccessChain::CoherentFlags TGlslangToSpvTraverser::TranslateCoherent(const glslang::TType& type) { spv::Builder::AccessChain::CoherentFlags flags = {}; #ifndef GLSLANG_WEB flags.coherent = type.getQualifier().coherent; flags.devicecoherent = type.getQualifier().devicecoherent; flags.queuefamilycoherent = type.getQualifier().queuefamilycoherent; // shared variables are implicitly workgroupcoherent in GLSL. flags.workgroupcoherent = type.getQualifier().workgroupcoherent || type.getQualifier().storage == glslang::EvqShared; flags.subgroupcoherent = type.getQualifier().subgroupcoherent; flags.volatil = type.getQualifier().volatil; // *coherent variables are implicitly nonprivate in GLSL flags.nonprivate = type.getQualifier().nonprivate || flags.subgroupcoherent || flags.workgroupcoherent || flags.queuefamilycoherent || flags.devicecoherent || flags.coherent || flags.volatil; flags.isImage = type.getBasicType() == glslang::EbtSampler; #endif return flags; } spv::Scope TGlslangToSpvTraverser::TranslateMemoryScope( const spv::Builder::AccessChain::CoherentFlags &coherentFlags) { spv::Scope scope = spv::ScopeMax; #ifndef GLSLANG_WEB if (coherentFlags.volatil || coherentFlags.coherent) { // coherent defaults to Device scope in the old model, QueueFamilyKHR scope in the new model scope = glslangIntermediate->usingVulkanMemoryModel() ? spv::ScopeQueueFamilyKHR : spv::ScopeDevice; } else if (coherentFlags.devicecoherent) { scope = spv::ScopeDevice; } else if (coherentFlags.queuefamilycoherent) { scope = spv::ScopeQueueFamilyKHR; } else if (coherentFlags.workgroupcoherent) { scope = spv::ScopeWorkgroup; } else if (coherentFlags.subgroupcoherent) { scope = spv::ScopeSubgroup; } if (glslangIntermediate->usingVulkanMemoryModel() && scope == spv::ScopeDevice) { builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR); } #endif return scope; } // Translate a glslang built-in variable to a SPIR-V built in decoration. Also generate // associated capabilities when required. For some built-in variables, a capability // is generated only when using the variable in an executable instruction, but not when // just declaring a struct member variable with it. This is true for PointSize, // ClipDistance, and CullDistance. spv::BuiltIn TGlslangToSpvTraverser::TranslateBuiltInDecoration(glslang::TBuiltInVariable builtIn, bool memberDeclaration) { switch (builtIn) { case glslang::EbvPointSize: #ifndef GLSLANG_WEB // Defer adding the capability until the built-in is actually used. if (! memberDeclaration) { switch (glslangIntermediate->getStage()) { case EShLangGeometry: builder.addCapability(spv::CapabilityGeometryPointSize); break; case EShLangTessControl: case EShLangTessEvaluation: builder.addCapability(spv::CapabilityTessellationPointSize); break; default: break; } } #endif return spv::BuiltInPointSize; case glslang::EbvPosition: return spv::BuiltInPosition; case glslang::EbvVertexId: return spv::BuiltInVertexId; case glslang::EbvInstanceId: return spv::BuiltInInstanceId; case glslang::EbvVertexIndex: return spv::BuiltInVertexIndex; case glslang::EbvInstanceIndex: return spv::BuiltInInstanceIndex; case glslang::EbvFragCoord: return spv::BuiltInFragCoord; case glslang::EbvPointCoord: return spv::BuiltInPointCoord; case glslang::EbvFace: return spv::BuiltInFrontFacing; case glslang::EbvFragDepth: return spv::BuiltInFragDepth; case glslang::EbvNumWorkGroups: return spv::BuiltInNumWorkgroups; case glslang::EbvWorkGroupSize: return spv::BuiltInWorkgroupSize; case glslang::EbvWorkGroupId: return spv::BuiltInWorkgroupId; case glslang::EbvLocalInvocationId: return spv::BuiltInLocalInvocationId; case glslang::EbvLocalInvocationIndex: return spv::BuiltInLocalInvocationIndex; case glslang::EbvGlobalInvocationId: return spv::BuiltInGlobalInvocationId; #ifndef GLSLANG_WEB // These *Distance capabilities logically belong here, but if the member is declared and // then never used, consumers of SPIR-V prefer the capability not be declared. // They are now generated when used, rather than here when declared. // Potentially, the specification should be more clear what the minimum // use needed is to trigger the capability. // case glslang::EbvClipDistance: if (!memberDeclaration) builder.addCapability(spv::CapabilityClipDistance); return spv::BuiltInClipDistance; case glslang::EbvCullDistance: if (!memberDeclaration) builder.addCapability(spv::CapabilityCullDistance); return spv::BuiltInCullDistance; case glslang::EbvViewportIndex: builder.addCapability(spv::CapabilityMultiViewport); if (glslangIntermediate->getStage() == EShLangVertex || glslangIntermediate->getStage() == EShLangTessControl || glslangIntermediate->getStage() == EShLangTessEvaluation) { builder.addIncorporatedExtension(spv::E_SPV_EXT_shader_viewport_index_layer, spv::Spv_1_5); builder.addCapability(spv::CapabilityShaderViewportIndexLayerEXT); } return spv::BuiltInViewportIndex; case glslang::EbvSampleId: builder.addCapability(spv::CapabilitySampleRateShading); return spv::BuiltInSampleId; case glslang::EbvSamplePosition: builder.addCapability(spv::CapabilitySampleRateShading); return spv::BuiltInSamplePosition; case glslang::EbvSampleMask: return spv::BuiltInSampleMask; case glslang::EbvLayer: if (glslangIntermediate->getStage() == EShLangMeshNV) { return spv::BuiltInLayer; } builder.addCapability(spv::CapabilityGeometry); if (glslangIntermediate->getStage() == EShLangVertex || glslangIntermediate->getStage() == EShLangTessControl || glslangIntermediate->getStage() == EShLangTessEvaluation) { builder.addIncorporatedExtension(spv::E_SPV_EXT_shader_viewport_index_layer, spv::Spv_1_5); builder.addCapability(spv::CapabilityShaderViewportIndexLayerEXT); } return spv::BuiltInLayer; case glslang::EbvBaseVertex: builder.addIncorporatedExtension(spv::E_SPV_KHR_shader_draw_parameters, spv::Spv_1_3); builder.addCapability(spv::CapabilityDrawParameters); return spv::BuiltInBaseVertex; case glslang::EbvBaseInstance: builder.addIncorporatedExtension(spv::E_SPV_KHR_shader_draw_parameters, spv::Spv_1_3); builder.addCapability(spv::CapabilityDrawParameters); return spv::BuiltInBaseInstance; case glslang::EbvDrawId: builder.addIncorporatedExtension(spv::E_SPV_KHR_shader_draw_parameters, spv::Spv_1_3); builder.addCapability(spv::CapabilityDrawParameters); return spv::BuiltInDrawIndex; case glslang::EbvPrimitiveId: if (glslangIntermediate->getStage() == EShLangFragment) builder.addCapability(spv::CapabilityGeometry); return spv::BuiltInPrimitiveId; case glslang::EbvFragStencilRef: builder.addExtension(spv::E_SPV_EXT_shader_stencil_export); builder.addCapability(spv::CapabilityStencilExportEXT); return spv::BuiltInFragStencilRefEXT; case glslang::EbvInvocationId: return spv::BuiltInInvocationId; case glslang::EbvTessLevelInner: return spv::BuiltInTessLevelInner; case glslang::EbvTessLevelOuter: return spv::BuiltInTessLevelOuter; case glslang::EbvTessCoord: return spv::BuiltInTessCoord; case glslang::EbvPatchVertices: return spv::BuiltInPatchVertices; case glslang::EbvHelperInvocation: return spv::BuiltInHelperInvocation; case glslang::EbvSubGroupSize: builder.addExtension(spv::E_SPV_KHR_shader_ballot); builder.addCapability(spv::CapabilitySubgroupBallotKHR); return spv::BuiltInSubgroupSize; case glslang::EbvSubGroupInvocation: builder.addExtension(spv::E_SPV_KHR_shader_ballot); builder.addCapability(spv::CapabilitySubgroupBallotKHR); return spv::BuiltInSubgroupLocalInvocationId; case glslang::EbvSubGroupEqMask: builder.addExtension(spv::E_SPV_KHR_shader_ballot); builder.addCapability(spv::CapabilitySubgroupBallotKHR); return spv::BuiltInSubgroupEqMask; case glslang::EbvSubGroupGeMask: builder.addExtension(spv::E_SPV_KHR_shader_ballot); builder.addCapability(spv::CapabilitySubgroupBallotKHR); return spv::BuiltInSubgroupGeMask; case glslang::EbvSubGroupGtMask: builder.addExtension(spv::E_SPV_KHR_shader_ballot); builder.addCapability(spv::CapabilitySubgroupBallotKHR); return spv::BuiltInSubgroupGtMask; case glslang::EbvSubGroupLeMask: builder.addExtension(spv::E_SPV_KHR_shader_ballot); builder.addCapability(spv::CapabilitySubgroupBallotKHR); return spv::BuiltInSubgroupLeMask; case glslang::EbvSubGroupLtMask: builder.addExtension(spv::E_SPV_KHR_shader_ballot); builder.addCapability(spv::CapabilitySubgroupBallotKHR); return spv::BuiltInSubgroupLtMask; case glslang::EbvNumSubgroups: builder.addCapability(spv::CapabilityGroupNonUniform); return spv::BuiltInNumSubgroups; case glslang::EbvSubgroupID: builder.addCapability(spv::CapabilityGroupNonUniform); return spv::BuiltInSubgroupId; case glslang::EbvSubgroupSize2: builder.addCapability(spv::CapabilityGroupNonUniform); return spv::BuiltInSubgroupSize; case glslang::EbvSubgroupInvocation2: builder.addCapability(spv::CapabilityGroupNonUniform); return spv::BuiltInSubgroupLocalInvocationId; case glslang::EbvSubgroupEqMask2: builder.addCapability(spv::CapabilityGroupNonUniform); builder.addCapability(spv::CapabilityGroupNonUniformBallot); return spv::BuiltInSubgroupEqMask; case glslang::EbvSubgroupGeMask2: builder.addCapability(spv::CapabilityGroupNonUniform); builder.addCapability(spv::CapabilityGroupNonUniformBallot); return spv::BuiltInSubgroupGeMask; case glslang::EbvSubgroupGtMask2: builder.addCapability(spv::CapabilityGroupNonUniform); builder.addCapability(spv::CapabilityGroupNonUniformBallot); return spv::BuiltInSubgroupGtMask; case glslang::EbvSubgroupLeMask2: builder.addCapability(spv::CapabilityGroupNonUniform); builder.addCapability(spv::CapabilityGroupNonUniformBallot); return spv::BuiltInSubgroupLeMask; case glslang::EbvSubgroupLtMask2: builder.addCapability(spv::CapabilityGroupNonUniform); builder.addCapability(spv::CapabilityGroupNonUniformBallot); return spv::BuiltInSubgroupLtMask; case glslang::EbvBaryCoordNoPersp: builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter); return spv::BuiltInBaryCoordNoPerspAMD; case glslang::EbvBaryCoordNoPerspCentroid: builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter); return spv::BuiltInBaryCoordNoPerspCentroidAMD; case glslang::EbvBaryCoordNoPerspSample: builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter); return spv::BuiltInBaryCoordNoPerspSampleAMD; case glslang::EbvBaryCoordSmooth: builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter); return spv::BuiltInBaryCoordSmoothAMD; case glslang::EbvBaryCoordSmoothCentroid: builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter); return spv::BuiltInBaryCoordSmoothCentroidAMD; case glslang::EbvBaryCoordSmoothSample: builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter); return spv::BuiltInBaryCoordSmoothSampleAMD; case glslang::EbvBaryCoordPullModel: builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter); return spv::BuiltInBaryCoordPullModelAMD; case glslang::EbvDeviceIndex: builder.addIncorporatedExtension(spv::E_SPV_KHR_device_group, spv::Spv_1_3); builder.addCapability(spv::CapabilityDeviceGroup); return spv::BuiltInDeviceIndex; case glslang::EbvViewIndex: builder.addIncorporatedExtension(spv::E_SPV_KHR_multiview, spv::Spv_1_3); builder.addCapability(spv::CapabilityMultiView); return spv::BuiltInViewIndex; case glslang::EbvFragSizeEXT: builder.addExtension(spv::E_SPV_EXT_fragment_invocation_density); builder.addCapability(spv::CapabilityFragmentDensityEXT); return spv::BuiltInFragSizeEXT; case glslang::EbvFragInvocationCountEXT: builder.addExtension(spv::E_SPV_EXT_fragment_invocation_density); builder.addCapability(spv::CapabilityFragmentDensityEXT); return spv::BuiltInFragInvocationCountEXT; case glslang::EbvViewportMaskNV: if (!memberDeclaration) { builder.addExtension(spv::E_SPV_NV_viewport_array2); builder.addCapability(spv::CapabilityShaderViewportMaskNV); } return spv::BuiltInViewportMaskNV; case glslang::EbvSecondaryPositionNV: if (!memberDeclaration) { builder.addExtension(spv::E_SPV_NV_stereo_view_rendering); builder.addCapability(spv::CapabilityShaderStereoViewNV); } return spv::BuiltInSecondaryPositionNV; case glslang::EbvSecondaryViewportMaskNV: if (!memberDeclaration) { builder.addExtension(spv::E_SPV_NV_stereo_view_rendering); builder.addCapability(spv::CapabilityShaderStereoViewNV); } return spv::BuiltInSecondaryViewportMaskNV; case glslang::EbvPositionPerViewNV: if (!memberDeclaration) { builder.addExtension(spv::E_SPV_NVX_multiview_per_view_attributes); builder.addCapability(spv::CapabilityPerViewAttributesNV); } return spv::BuiltInPositionPerViewNV; case glslang::EbvViewportMaskPerViewNV: if (!memberDeclaration) { builder.addExtension(spv::E_SPV_NVX_multiview_per_view_attributes); builder.addCapability(spv::CapabilityPerViewAttributesNV); } return spv::BuiltInViewportMaskPerViewNV; case glslang::EbvFragFullyCoveredNV: builder.addExtension(spv::E_SPV_EXT_fragment_fully_covered); builder.addCapability(spv::CapabilityFragmentFullyCoveredEXT); return spv::BuiltInFullyCoveredEXT; case glslang::EbvFragmentSizeNV: builder.addExtension(spv::E_SPV_NV_shading_rate); builder.addCapability(spv::CapabilityShadingRateNV); return spv::BuiltInFragmentSizeNV; case glslang::EbvInvocationsPerPixelNV: builder.addExtension(spv::E_SPV_NV_shading_rate); builder.addCapability(spv::CapabilityShadingRateNV); return spv::BuiltInInvocationsPerPixelNV; // ray tracing case glslang::EbvLaunchIdNV: return spv::BuiltInLaunchIdNV; case glslang::EbvLaunchSizeNV: return spv::BuiltInLaunchSizeNV; case glslang::EbvWorldRayOriginNV: return spv::BuiltInWorldRayOriginNV; case glslang::EbvWorldRayDirectionNV: return spv::BuiltInWorldRayDirectionNV; case glslang::EbvObjectRayOriginNV: return spv::BuiltInObjectRayOriginNV; case glslang::EbvObjectRayDirectionNV: return spv::BuiltInObjectRayDirectionNV; case glslang::EbvRayTminNV: return spv::BuiltInRayTminNV; case glslang::EbvRayTmaxNV: return spv::BuiltInRayTmaxNV; case glslang::EbvInstanceCustomIndexNV: return spv::BuiltInInstanceCustomIndexNV; case glslang::EbvHitTNV: return spv::BuiltInHitTNV; case glslang::EbvHitKindNV: return spv::BuiltInHitKindNV; case glslang::EbvObjectToWorldNV: return spv::BuiltInObjectToWorldNV; case glslang::EbvWorldToObjectNV: return spv::BuiltInWorldToObjectNV; case glslang::EbvIncomingRayFlagsNV: return spv::BuiltInIncomingRayFlagsNV; // barycentrics case glslang::EbvBaryCoordNV: builder.addExtension(spv::E_SPV_NV_fragment_shader_barycentric); builder.addCapability(spv::CapabilityFragmentBarycentricNV); return spv::BuiltInBaryCoordNV; case glslang::EbvBaryCoordNoPerspNV: builder.addExtension(spv::E_SPV_NV_fragment_shader_barycentric); builder.addCapability(spv::CapabilityFragmentBarycentricNV); return spv::BuiltInBaryCoordNoPerspNV; // mesh shaders case glslang::EbvTaskCountNV: return spv::BuiltInTaskCountNV; case glslang::EbvPrimitiveCountNV: return spv::BuiltInPrimitiveCountNV; case glslang::EbvPrimitiveIndicesNV: return spv::BuiltInPrimitiveIndicesNV; case glslang::EbvClipDistancePerViewNV: return spv::BuiltInClipDistancePerViewNV; case glslang::EbvCullDistancePerViewNV: return spv::BuiltInCullDistancePerViewNV; case glslang::EbvLayerPerViewNV: return spv::BuiltInLayerPerViewNV; case glslang::EbvMeshViewCountNV: return spv::BuiltInMeshViewCountNV; case glslang::EbvMeshViewIndicesNV: return spv::BuiltInMeshViewIndicesNV; // sm builtins case glslang::EbvWarpsPerSM: builder.addExtension(spv::E_SPV_NV_shader_sm_builtins); builder.addCapability(spv::CapabilityShaderSMBuiltinsNV); return spv::BuiltInWarpsPerSMNV; case glslang::EbvSMCount: builder.addExtension(spv::E_SPV_NV_shader_sm_builtins); builder.addCapability(spv::CapabilityShaderSMBuiltinsNV); return spv::BuiltInSMCountNV; case glslang::EbvWarpID: builder.addExtension(spv::E_SPV_NV_shader_sm_builtins); builder.addCapability(spv::CapabilityShaderSMBuiltinsNV); return spv::BuiltInWarpIDNV; case glslang::EbvSMID: builder.addExtension(spv::E_SPV_NV_shader_sm_builtins); builder.addCapability(spv::CapabilityShaderSMBuiltinsNV); return spv::BuiltInSMIDNV; #endif default: return spv::BuiltInMax; } } // Translate glslang image layout format to SPIR-V image format. spv::ImageFormat TGlslangToSpvTraverser::TranslateImageFormat(const glslang::TType& type) { assert(type.getBasicType() == glslang::EbtSampler); #ifdef GLSLANG_WEB return spv::ImageFormatUnknown; #endif // Check for capabilities switch (type.getQualifier().getFormat()) { case glslang::ElfRg32f: case glslang::ElfRg16f: case glslang::ElfR11fG11fB10f: case glslang::ElfR16f: case glslang::ElfRgba16: case glslang::ElfRgb10A2: case glslang::ElfRg16: case glslang::ElfRg8: case glslang::ElfR16: case glslang::ElfR8: case glslang::ElfRgba16Snorm: case glslang::ElfRg16Snorm: case glslang::ElfRg8Snorm: case glslang::ElfR16Snorm: case glslang::ElfR8Snorm: case glslang::ElfRg32i: case glslang::ElfRg16i: case glslang::ElfRg8i: case glslang::ElfR16i: case glslang::ElfR8i: case glslang::ElfRgb10a2ui: case glslang::ElfRg32ui: case glslang::ElfRg16ui: case glslang::ElfRg8ui: case glslang::ElfR16ui: case glslang::ElfR8ui: builder.addCapability(spv::CapabilityStorageImageExtendedFormats); break; default: break; } // do the translation switch (type.getQualifier().getFormat()) { case glslang::ElfNone: return spv::ImageFormatUnknown; case glslang::ElfRgba32f: return spv::ImageFormatRgba32f; case glslang::ElfRgba16f: return spv::ImageFormatRgba16f; case glslang::ElfR32f: return spv::ImageFormatR32f; case glslang::ElfRgba8: return spv::ImageFormatRgba8; case glslang::ElfRgba8Snorm: return spv::ImageFormatRgba8Snorm; case glslang::ElfRg32f: return spv::ImageFormatRg32f; case glslang::ElfRg16f: return spv::ImageFormatRg16f; case glslang::ElfR11fG11fB10f: return spv::ImageFormatR11fG11fB10f; case glslang::ElfR16f: return spv::ImageFormatR16f; case glslang::ElfRgba16: return spv::ImageFormatRgba16; case glslang::ElfRgb10A2: return spv::ImageFormatRgb10A2; case glslang::ElfRg16: return spv::ImageFormatRg16; case glslang::ElfRg8: return spv::ImageFormatRg8; case glslang::ElfR16: return spv::ImageFormatR16; case glslang::ElfR8: return spv::ImageFormatR8; case glslang::ElfRgba16Snorm: return spv::ImageFormatRgba16Snorm; case glslang::ElfRg16Snorm: return spv::ImageFormatRg16Snorm; case glslang::ElfRg8Snorm: return spv::ImageFormatRg8Snorm; case glslang::ElfR16Snorm: return spv::ImageFormatR16Snorm; case glslang::ElfR8Snorm: return spv::ImageFormatR8Snorm; case glslang::ElfRgba32i: return spv::ImageFormatRgba32i; case glslang::ElfRgba16i: return spv::ImageFormatRgba16i; case glslang::ElfRgba8i: return spv::ImageFormatRgba8i; case glslang::ElfR32i: return spv::ImageFormatR32i; case glslang::ElfRg32i: return spv::ImageFormatRg32i; case glslang::ElfRg16i: return spv::ImageFormatRg16i; case glslang::ElfRg8i: return spv::ImageFormatRg8i; case glslang::ElfR16i: return spv::ImageFormatR16i; case glslang::ElfR8i: return spv::ImageFormatR8i; case glslang::ElfRgba32ui: return spv::ImageFormatRgba32ui; case glslang::ElfRgba16ui: return spv::ImageFormatRgba16ui; case glslang::ElfRgba8ui: return spv::ImageFormatRgba8ui; case glslang::ElfR32ui: return spv::ImageFormatR32ui; case glslang::ElfRg32ui: return spv::ImageFormatRg32ui; case glslang::ElfRg16ui: return spv::ImageFormatRg16ui; case glslang::ElfRgb10a2ui: return spv::ImageFormatRgb10a2ui; case glslang::ElfRg8ui: return spv::ImageFormatRg8ui; case glslang::ElfR16ui: return spv::ImageFormatR16ui; case glslang::ElfR8ui: return spv::ImageFormatR8ui; default: return spv::ImageFormatMax; } } spv::SelectionControlMask TGlslangToSpvTraverser::TranslateSelectionControl(const glslang::TIntermSelection& selectionNode) const { if (selectionNode.getFlatten()) return spv::SelectionControlFlattenMask; if (selectionNode.getDontFlatten()) return spv::SelectionControlDontFlattenMask; return spv::SelectionControlMaskNone; } spv::SelectionControlMask TGlslangToSpvTraverser::TranslateSwitchControl(const glslang::TIntermSwitch& switchNode) const { if (switchNode.getFlatten()) return spv::SelectionControlFlattenMask; if (switchNode.getDontFlatten()) return spv::SelectionControlDontFlattenMask; return spv::SelectionControlMaskNone; } // return a non-0 dependency if the dependency argument must be set spv::LoopControlMask TGlslangToSpvTraverser::TranslateLoopControl(const glslang::TIntermLoop& loopNode, std::vector& operands) const { spv::LoopControlMask control = spv::LoopControlMaskNone; if (loopNode.getDontUnroll()) control = control | spv::LoopControlDontUnrollMask; if (loopNode.getUnroll()) control = control | spv::LoopControlUnrollMask; if (unsigned(loopNode.getLoopDependency()) == glslang::TIntermLoop::dependencyInfinite) control = control | spv::LoopControlDependencyInfiniteMask; else if (loopNode.getLoopDependency() > 0) { control = control | spv::LoopControlDependencyLengthMask; operands.push_back((unsigned int)loopNode.getLoopDependency()); } if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4) { if (loopNode.getMinIterations() > 0) { control = control | spv::LoopControlMinIterationsMask; operands.push_back(loopNode.getMinIterations()); } if (loopNode.getMaxIterations() < glslang::TIntermLoop::iterationsInfinite) { control = control | spv::LoopControlMaxIterationsMask; operands.push_back(loopNode.getMaxIterations()); } if (loopNode.getIterationMultiple() > 1) { control = control | spv::LoopControlIterationMultipleMask; operands.push_back(loopNode.getIterationMultiple()); } if (loopNode.getPeelCount() > 0) { control = control | spv::LoopControlPeelCountMask; operands.push_back(loopNode.getPeelCount()); } if (loopNode.getPartialCount() > 0) { control = control | spv::LoopControlPartialCountMask; operands.push_back(loopNode.getPartialCount()); } } return control; } // Translate glslang type to SPIR-V storage class. spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::TType& type) { if (type.getQualifier().isPipeInput()) return spv::StorageClassInput; if (type.getQualifier().isPipeOutput()) return spv::StorageClassOutput; if (glslangIntermediate->getSource() != glslang::EShSourceHlsl || type.getQualifier().storage == glslang::EvqUniform) { if (type.isAtomic()) return spv::StorageClassAtomicCounter; if (type.containsOpaque()) return spv::StorageClassUniformConstant; } if (type.getQualifier().isUniformOrBuffer() && type.getQualifier().isShaderRecordNV()) { return spv::StorageClassShaderRecordBufferNV; } if (glslangIntermediate->usingStorageBuffer() && type.getQualifier().storage == glslang::EvqBuffer) { builder.addIncorporatedExtension(spv::E_SPV_KHR_storage_buffer_storage_class, spv::Spv_1_3); return spv::StorageClassStorageBuffer; } if (type.getQualifier().isUniformOrBuffer()) { if (type.getQualifier().isPushConstant()) return spv::StorageClassPushConstant; if (type.getBasicType() == glslang::EbtBlock) return spv::StorageClassUniform; return spv::StorageClassUniformConstant; } switch (type.getQualifier().storage) { case glslang::EvqGlobal: return spv::StorageClassPrivate; case glslang::EvqConstReadOnly: return spv::StorageClassFunction; case glslang::EvqTemporary: return spv::StorageClassFunction; case glslang::EvqShared: return spv::StorageClassWorkgroup; #ifndef GLSLANG_WEB case glslang::EvqPayloadNV: return spv::StorageClassRayPayloadNV; case glslang::EvqPayloadInNV: return spv::StorageClassIncomingRayPayloadNV; case glslang::EvqHitAttrNV: return spv::StorageClassHitAttributeNV; case glslang::EvqCallableDataNV: return spv::StorageClassCallableDataNV; case glslang::EvqCallableDataInNV: return spv::StorageClassIncomingCallableDataNV; #endif default: assert(0); break; } return spv::StorageClassFunction; } // Add capabilities pertaining to how an array is indexed. void TGlslangToSpvTraverser::addIndirectionIndexCapabilities(const glslang::TType& baseType, const glslang::TType& indexType) { #ifndef GLSLANG_WEB if (indexType.getQualifier().isNonUniform()) { // deal with an asserted non-uniform index // SPV_EXT_descriptor_indexing already added in TranslateNonUniformDecoration if (baseType.getBasicType() == glslang::EbtSampler) { if (baseType.getQualifier().hasAttachment()) builder.addCapability(spv::CapabilityInputAttachmentArrayNonUniformIndexingEXT); else if (baseType.isImage() && baseType.getSampler().isBuffer()) builder.addCapability(spv::CapabilityStorageTexelBufferArrayNonUniformIndexingEXT); else if (baseType.isTexture() && baseType.getSampler().isBuffer()) builder.addCapability(spv::CapabilityUniformTexelBufferArrayNonUniformIndexingEXT); else if (baseType.isImage()) builder.addCapability(spv::CapabilityStorageImageArrayNonUniformIndexingEXT); else if (baseType.isTexture()) builder.addCapability(spv::CapabilitySampledImageArrayNonUniformIndexingEXT); } else if (baseType.getBasicType() == glslang::EbtBlock) { if (baseType.getQualifier().storage == glslang::EvqBuffer) builder.addCapability(spv::CapabilityStorageBufferArrayNonUniformIndexingEXT); else if (baseType.getQualifier().storage == glslang::EvqUniform) builder.addCapability(spv::CapabilityUniformBufferArrayNonUniformIndexingEXT); } } else { // assume a dynamically uniform index if (baseType.getBasicType() == glslang::EbtSampler) { if (baseType.getQualifier().hasAttachment()) { builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5); builder.addCapability(spv::CapabilityInputAttachmentArrayDynamicIndexingEXT); } else if (baseType.isImage() && baseType.getSampler().isBuffer()) { builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5); builder.addCapability(spv::CapabilityStorageTexelBufferArrayDynamicIndexingEXT); } else if (baseType.isTexture() && baseType.getSampler().isBuffer()) { builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5); builder.addCapability(spv::CapabilityUniformTexelBufferArrayDynamicIndexingEXT); } } } #endif } // Return whether or not the given type is something that should be tied to a // descriptor set. bool IsDescriptorResource(const glslang::TType& type) { // uniform and buffer blocks are included, unless it is a push_constant if (type.getBasicType() == glslang::EbtBlock) return type.getQualifier().isUniformOrBuffer() && ! type.getQualifier().isShaderRecordNV() && ! type.getQualifier().isPushConstant(); // non block... // basically samplerXXX/subpass/sampler/texture are all included // if they are the global-scope-class, not the function parameter // (or local, if they ever exist) class. if (type.getBasicType() == glslang::EbtSampler) return type.getQualifier().isUniformOrBuffer(); // None of the above. return false; } void InheritQualifiers(glslang::TQualifier& child, const glslang::TQualifier& parent) { if (child.layoutMatrix == glslang::ElmNone) child.layoutMatrix = parent.layoutMatrix; if (parent.invariant) child.invariant = true; if (parent.flat) child.flat = true; if (parent.centroid) child.centroid = true; #ifndef GLSLANG_WEB if (parent.nopersp) child.nopersp = true; if (parent.explicitInterp) child.explicitInterp = true; if (parent.perPrimitiveNV) child.perPrimitiveNV = true; if (parent.perViewNV) child.perViewNV = true; if (parent.perTaskNV) child.perTaskNV = true; if (parent.patch) child.patch = true; if (parent.sample) child.sample = true; if (parent.coherent) child.coherent = true; if (parent.devicecoherent) child.devicecoherent = true; if (parent.queuefamilycoherent) child.queuefamilycoherent = true; if (parent.workgroupcoherent) child.workgroupcoherent = true; if (parent.subgroupcoherent) child.subgroupcoherent = true; if (parent.nonprivate) child.nonprivate = true; if (parent.volatil) child.volatil = true; if (parent.restrict) child.restrict = true; if (parent.readonly) child.readonly = true; if (parent.writeonly) child.writeonly = true; #endif } bool HasNonLayoutQualifiers(const glslang::TType& type, const glslang::TQualifier& qualifier) { // This should list qualifiers that simultaneous satisfy: // - struct members might inherit from a struct declaration // (note that non-block structs don't explicitly inherit, // only implicitly, meaning no decoration involved) // - affect decorations on the struct members // (note smooth does not, and expecting something like volatile // to effect the whole object) // - are not part of the offset/st430/etc or row/column-major layout return qualifier.invariant || (qualifier.hasLocation() && type.getBasicType() == glslang::EbtBlock); } // // Implement the TGlslangToSpvTraverser class. // TGlslangToSpvTraverser::TGlslangToSpvTraverser(unsigned int spvVersion, const glslang::TIntermediate* glslangIntermediate, spv::SpvBuildLogger* buildLogger, glslang::SpvOptions& options) : TIntermTraverser(true, false, true), options(options), shaderEntry(nullptr), currentFunction(nullptr), sequenceDepth(0), logger(buildLogger), builder(spvVersion, (glslang::GetKhronosToolId() << 16) | glslang::GetSpirvGeneratorVersion(), logger), inEntryPoint(false), entryPointTerminated(false), linkageOnly(false), glslangIntermediate(glslangIntermediate), nanMinMaxClamp(glslangIntermediate->getNanMinMaxClamp()) { spv::ExecutionModel executionModel = TranslateExecutionModel(glslangIntermediate->getStage()); builder.clearAccessChain(); builder.setSource(TranslateSourceLanguage(glslangIntermediate->getSource(), glslangIntermediate->getProfile()), glslangIntermediate->getVersion()); if (options.generateDebugInfo) { builder.setEmitOpLines(); builder.setSourceFile(glslangIntermediate->getSourceFile()); // Set the source shader's text. If for SPV version 1.0, include // a preamble in comments stating the OpModuleProcessed instructions. // Otherwise, emit those as actual instructions. std::string text; const std::vector& processes = glslangIntermediate->getProcesses(); for (int p = 0; p < (int)processes.size(); ++p) { if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_1) { text.append("// OpModuleProcessed "); text.append(processes[p]); text.append("\n"); } else builder.addModuleProcessed(processes[p]); } if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_1 && (int)processes.size() > 0) text.append("#line 1\n"); text.append(glslangIntermediate->getSourceText()); builder.setSourceText(text); // Pass name and text for all included files const std::map& include_txt = glslangIntermediate->getIncludeText(); for (auto iItr = include_txt.begin(); iItr != include_txt.end(); ++iItr) builder.addInclude(iItr->first, iItr->second); } stdBuiltins = builder.import("GLSL.std.450"); spv::AddressingModel addressingModel = spv::AddressingModelLogical; spv::MemoryModel memoryModel = spv::MemoryModelGLSL450; if (glslangIntermediate->usingPhysicalStorageBuffer()) { addressingModel = spv::AddressingModelPhysicalStorageBuffer64EXT; builder.addIncorporatedExtension(spv::E_SPV_EXT_physical_storage_buffer, spv::Spv_1_5); builder.addCapability(spv::CapabilityPhysicalStorageBufferAddressesEXT); }; if (glslangIntermediate->usingVulkanMemoryModel()) { memoryModel = spv::MemoryModelVulkanKHR; builder.addCapability(spv::CapabilityVulkanMemoryModelKHR); builder.addIncorporatedExtension(spv::E_SPV_KHR_vulkan_memory_model, spv::Spv_1_5); } builder.setMemoryModel(addressingModel, memoryModel); if (glslangIntermediate->usingVariablePointers()) { builder.addCapability(spv::CapabilityVariablePointers); } shaderEntry = builder.makeEntryPoint(glslangIntermediate->getEntryPointName().c_str()); entryPoint = builder.addEntryPoint(executionModel, shaderEntry, glslangIntermediate->getEntryPointName().c_str()); // Add the source extensions const auto& sourceExtensions = glslangIntermediate->getRequestedExtensions(); for (auto it = sourceExtensions.begin(); it != sourceExtensions.end(); ++it) builder.addSourceExtension(it->c_str()); // Add the top-level modes for this shader. if (glslangIntermediate->getXfbMode()) { builder.addCapability(spv::CapabilityTransformFeedback); builder.addExecutionMode(shaderEntry, spv::ExecutionModeXfb); } unsigned int mode; switch (glslangIntermediate->getStage()) { case EShLangVertex: builder.addCapability(spv::CapabilityShader); break; case EShLangFragment: builder.addCapability(spv::CapabilityShader); if (glslangIntermediate->getPixelCenterInteger()) builder.addExecutionMode(shaderEntry, spv::ExecutionModePixelCenterInteger); if (glslangIntermediate->getOriginUpperLeft()) builder.addExecutionMode(shaderEntry, spv::ExecutionModeOriginUpperLeft); else builder.addExecutionMode(shaderEntry, spv::ExecutionModeOriginLowerLeft); if (glslangIntermediate->getEarlyFragmentTests()) builder.addExecutionMode(shaderEntry, spv::ExecutionModeEarlyFragmentTests); if (glslangIntermediate->getPostDepthCoverage()) { builder.addCapability(spv::CapabilitySampleMaskPostDepthCoverage); builder.addExecutionMode(shaderEntry, spv::ExecutionModePostDepthCoverage); builder.addExtension(spv::E_SPV_KHR_post_depth_coverage); } if (glslangIntermediate->getDepth() != glslang::EldUnchanged && glslangIntermediate->isDepthReplacing()) builder.addExecutionMode(shaderEntry, spv::ExecutionModeDepthReplacing); #ifndef GLSLANG_WEB switch(glslangIntermediate->getDepth()) { case glslang::EldGreater: mode = spv::ExecutionModeDepthGreater; break; case glslang::EldLess: mode = spv::ExecutionModeDepthLess; break; default: mode = spv::ExecutionModeMax; break; } if (mode != spv::ExecutionModeMax) builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode); switch (glslangIntermediate->getInterlockOrdering()) { case glslang::EioPixelInterlockOrdered: mode = spv::ExecutionModePixelInterlockOrderedEXT; break; case glslang::EioPixelInterlockUnordered: mode = spv::ExecutionModePixelInterlockUnorderedEXT; break; case glslang::EioSampleInterlockOrdered: mode = spv::ExecutionModeSampleInterlockOrderedEXT; break; case glslang::EioSampleInterlockUnordered: mode = spv::ExecutionModeSampleInterlockUnorderedEXT; break; case glslang::EioShadingRateInterlockOrdered: mode = spv::ExecutionModeShadingRateInterlockOrderedEXT; break; case glslang::EioShadingRateInterlockUnordered: mode = spv::ExecutionModeShadingRateInterlockUnorderedEXT; break; default: mode = spv::ExecutionModeMax; break; } if (mode != spv::ExecutionModeMax) { builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode); if (mode == spv::ExecutionModeShadingRateInterlockOrderedEXT || mode == spv::ExecutionModeShadingRateInterlockUnorderedEXT) { builder.addCapability(spv::CapabilityFragmentShaderShadingRateInterlockEXT); } else if (mode == spv::ExecutionModePixelInterlockOrderedEXT || mode == spv::ExecutionModePixelInterlockUnorderedEXT) { builder.addCapability(spv::CapabilityFragmentShaderPixelInterlockEXT); } else { builder.addCapability(spv::CapabilityFragmentShaderSampleInterlockEXT); } builder.addExtension(spv::E_SPV_EXT_fragment_shader_interlock); } #endif break; case EShLangCompute: builder.addCapability(spv::CapabilityShader); builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0), glslangIntermediate->getLocalSize(1), glslangIntermediate->getLocalSize(2)); if (glslangIntermediate->getLayoutDerivativeModeNone() == glslang::LayoutDerivativeGroupQuads) { builder.addCapability(spv::CapabilityComputeDerivativeGroupQuadsNV); builder.addExecutionMode(shaderEntry, spv::ExecutionModeDerivativeGroupQuadsNV); builder.addExtension(spv::E_SPV_NV_compute_shader_derivatives); } else if (glslangIntermediate->getLayoutDerivativeModeNone() == glslang::LayoutDerivativeGroupLinear) { builder.addCapability(spv::CapabilityComputeDerivativeGroupLinearNV); builder.addExecutionMode(shaderEntry, spv::ExecutionModeDerivativeGroupLinearNV); builder.addExtension(spv::E_SPV_NV_compute_shader_derivatives); } break; #ifndef GLSLANG_WEB case EShLangTessEvaluation: case EShLangTessControl: builder.addCapability(spv::CapabilityTessellation); glslang::TLayoutGeometry primitive; if (glslangIntermediate->getStage() == EShLangTessControl) { builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputVertices, glslangIntermediate->getVertices()); primitive = glslangIntermediate->getOutputPrimitive(); } else { primitive = glslangIntermediate->getInputPrimitive(); } switch (primitive) { case glslang::ElgTriangles: mode = spv::ExecutionModeTriangles; break; case glslang::ElgQuads: mode = spv::ExecutionModeQuads; break; case glslang::ElgIsolines: mode = spv::ExecutionModeIsolines; break; default: mode = spv::ExecutionModeMax; break; } if (mode != spv::ExecutionModeMax) builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode); switch (glslangIntermediate->getVertexSpacing()) { case glslang::EvsEqual: mode = spv::ExecutionModeSpacingEqual; break; case glslang::EvsFractionalEven: mode = spv::ExecutionModeSpacingFractionalEven; break; case glslang::EvsFractionalOdd: mode = spv::ExecutionModeSpacingFractionalOdd; break; default: mode = spv::ExecutionModeMax; break; } if (mode != spv::ExecutionModeMax) builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode); switch (glslangIntermediate->getVertexOrder()) { case glslang::EvoCw: mode = spv::ExecutionModeVertexOrderCw; break; case glslang::EvoCcw: mode = spv::ExecutionModeVertexOrderCcw; break; default: mode = spv::ExecutionModeMax; break; } if (mode != spv::ExecutionModeMax) builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode); if (glslangIntermediate->getPointMode()) builder.addExecutionMode(shaderEntry, spv::ExecutionModePointMode); break; case EShLangGeometry: builder.addCapability(spv::CapabilityGeometry); switch (glslangIntermediate->getInputPrimitive()) { case glslang::ElgPoints: mode = spv::ExecutionModeInputPoints; break; case glslang::ElgLines: mode = spv::ExecutionModeInputLines; break; case glslang::ElgLinesAdjacency: mode = spv::ExecutionModeInputLinesAdjacency; break; case glslang::ElgTriangles: mode = spv::ExecutionModeTriangles; break; case glslang::ElgTrianglesAdjacency: mode = spv::ExecutionModeInputTrianglesAdjacency; break; default: mode = spv::ExecutionModeMax; break; } if (mode != spv::ExecutionModeMax) builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode); builder.addExecutionMode(shaderEntry, spv::ExecutionModeInvocations, glslangIntermediate->getInvocations()); switch (glslangIntermediate->getOutputPrimitive()) { case glslang::ElgPoints: mode = spv::ExecutionModeOutputPoints; break; case glslang::ElgLineStrip: mode = spv::ExecutionModeOutputLineStrip; break; case glslang::ElgTriangleStrip: mode = spv::ExecutionModeOutputTriangleStrip; break; default: mode = spv::ExecutionModeMax; break; } if (mode != spv::ExecutionModeMax) builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode); builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputVertices, glslangIntermediate->getVertices()); break; case EShLangRayGenNV: case EShLangIntersectNV: case EShLangAnyHitNV: case EShLangClosestHitNV: case EShLangMissNV: case EShLangCallableNV: builder.addCapability(spv::CapabilityRayTracingNV); builder.addExtension("SPV_NV_ray_tracing"); break; case EShLangTaskNV: case EShLangMeshNV: builder.addCapability(spv::CapabilityMeshShadingNV); builder.addExtension(spv::E_SPV_NV_mesh_shader); builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0), glslangIntermediate->getLocalSize(1), glslangIntermediate->getLocalSize(2)); if (glslangIntermediate->getStage() == EShLangMeshNV) { builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputVertices, glslangIntermediate->getVertices()); builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputPrimitivesNV, glslangIntermediate->getPrimitives()); switch (glslangIntermediate->getOutputPrimitive()) { case glslang::ElgPoints: mode = spv::ExecutionModeOutputPoints; break; case glslang::ElgLines: mode = spv::ExecutionModeOutputLinesNV; break; case glslang::ElgTriangles: mode = spv::ExecutionModeOutputTrianglesNV; break; default: mode = spv::ExecutionModeMax; break; } if (mode != spv::ExecutionModeMax) builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode); } break; #endif default: break; } } // Finish creating SPV, after the traversal is complete. void TGlslangToSpvTraverser::finishSpv() { // Finish the entry point function if (! entryPointTerminated) { builder.setBuildPoint(shaderEntry->getLastBlock()); builder.leaveFunction(); } // finish off the entry-point SPV instruction by adding the Input/Output for (auto it = iOSet.cbegin(); it != iOSet.cend(); ++it) entryPoint->addIdOperand(*it); // Add capabilities, extensions, remove unneeded decorations, etc., // based on the resulting SPIR-V. // Note: WebGPU code generation must have the opportunity to aggressively // prune unreachable merge blocks and continue targets. builder.postProcess(); } // Write the SPV into 'out'. void TGlslangToSpvTraverser::dumpSpv(std::vector& out) { builder.dump(out); } // // Implement the traversal functions. // // Return true from interior nodes to have the external traversal // continue on to children. Return false if children were // already processed. // // // Symbols can turn into // - uniform/input reads // - output writes // - complex lvalue base setups: foo.bar[3].... , where we see foo and start up an access chain // - something simple that degenerates into the last bullet // void TGlslangToSpvTraverser::visitSymbol(glslang::TIntermSymbol* symbol) { SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder); if (symbol->getType().getQualifier().isSpecConstant()) spec_constant_op_mode_setter.turnOnSpecConstantOpMode(); // getSymbolId() will set up all the IO decorations on the first call. // Formal function parameters were mapped during makeFunctions(). spv::Id id = getSymbolId(symbol); if (builder.isPointer(id)) { // Include all "static use" and "linkage only" interface variables on the OpEntryPoint instruction // Consider adding to the OpEntryPoint interface list. // Only looking at structures if they have at least one member. if (!symbol->getType().isStruct() || symbol->getType().getStruct()->size() > 0) { spv::StorageClass sc = builder.getStorageClass(id); // Before SPIR-V 1.4, we only want to include Input and Output. // Starting with SPIR-V 1.4, we want all globals. if ((glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4 && sc != spv::StorageClassFunction) || (sc == spv::StorageClassInput || sc == spv::StorageClassOutput)) { iOSet.insert(id); } } // If the SPIR-V type is required to be different than the AST type, // translate now from the SPIR-V type to the AST type, for the consuming // operation. // Note this turns it from an l-value to an r-value. // Currently, all symbols needing this are inputs; avoid the map lookup when non-input. if (symbol->getType().getQualifier().storage == glslang::EvqVaryingIn) id = translateForcedType(id); } // Only process non-linkage-only nodes for generating actual static uses if (! linkageOnly || symbol->getQualifier().isSpecConstant()) { // Prepare to generate code for the access // L-value chains will be computed left to right. We're on the symbol now, // which is the left-most part of the access chain, so now is "clear" time, // followed by setting the base. builder.clearAccessChain(); // For now, we consider all user variables as being in memory, so they are pointers, // except for // A) R-Value arguments to a function, which are an intermediate object. // See comments in handleUserFunctionCall(). // B) Specialization constants (normal constants don't even come in as a variable), // These are also pure R-values. // C) R-Values from type translation, see above call to translateForcedType() glslang::TQualifier qualifier = symbol->getQualifier(); if (qualifier.isSpecConstant() || rValueParameters.find(symbol->getId()) != rValueParameters.end() || !builder.isPointerType(builder.getTypeId(id))) builder.setAccessChainRValue(id); else builder.setAccessChainLValue(id); } #ifdef ENABLE_HLSL // Process linkage-only nodes for any special additional interface work. if (linkageOnly) { if (glslangIntermediate->getHlslFunctionality1()) { // Map implicit counter buffers to their originating buffers, which should have been // seen by now, given earlier pruning of unused counters, and preservation of order // of declaration. if (symbol->getType().getQualifier().isUniformOrBuffer()) { if (!glslangIntermediate->hasCounterBufferName(symbol->getName())) { // Save possible originating buffers for counter buffers, keyed by // making the potential counter-buffer name. std::string keyName = symbol->getName().c_str(); keyName = glslangIntermediate->addCounterBufferName(keyName); counterOriginator[keyName] = symbol; } else { // Handle a counter buffer, by finding the saved originating buffer. std::string keyName = symbol->getName().c_str(); auto it = counterOriginator.find(keyName); if (it != counterOriginator.end()) { id = getSymbolId(it->second); if (id != spv::NoResult) { spv::Id counterId = getSymbolId(symbol); if (counterId != spv::NoResult) { builder.addExtension("SPV_GOOGLE_hlsl_functionality1"); builder.addDecorationId(id, spv::DecorationHlslCounterBufferGOOGLE, counterId); } } } } } } } #endif } bool TGlslangToSpvTraverser::visitBinary(glslang::TVisit /* visit */, glslang::TIntermBinary* node) { builder.setLine(node->getLoc().line, node->getLoc().getFilename()); SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder); if (node->getType().getQualifier().isSpecConstant()) spec_constant_op_mode_setter.turnOnSpecConstantOpMode(); // First, handle special cases switch (node->getOp()) { case glslang::EOpAssign: case glslang::EOpAddAssign: case glslang::EOpSubAssign: case glslang::EOpMulAssign: case glslang::EOpVectorTimesMatrixAssign: case glslang::EOpVectorTimesScalarAssign: case glslang::EOpMatrixTimesScalarAssign: case glslang::EOpMatrixTimesMatrixAssign: case glslang::EOpDivAssign: case glslang::EOpModAssign: case glslang::EOpAndAssign: case glslang::EOpInclusiveOrAssign: case glslang::EOpExclusiveOrAssign: case glslang::EOpLeftShiftAssign: case glslang::EOpRightShiftAssign: // A bin-op assign "a += b" means the same thing as "a = a + b" // where a is evaluated before b. For a simple assignment, GLSL // says to evaluate the left before the right. So, always, left // node then right node. { // get the left l-value, save it away builder.clearAccessChain(); node->getLeft()->traverse(this); spv::Builder::AccessChain lValue = builder.getAccessChain(); // evaluate the right builder.clearAccessChain(); node->getRight()->traverse(this); spv::Id rValue = accessChainLoad(node->getRight()->getType()); if (node->getOp() != glslang::EOpAssign) { // the left is also an r-value builder.setAccessChain(lValue); spv::Id leftRValue = accessChainLoad(node->getLeft()->getType()); // do the operation OpDecorations decorations = { TranslatePrecisionDecoration(node->getOperationPrecision()), TranslateNoContractionDecoration(node->getType().getQualifier()), TranslateNonUniformDecoration(node->getType().getQualifier()) }; rValue = createBinaryOperation(node->getOp(), decorations, convertGlslangToSpvType(node->getType()), leftRValue, rValue, node->getType().getBasicType()); // these all need their counterparts in createBinaryOperation() assert(rValue != spv::NoResult); } // store the result builder.setAccessChain(lValue); multiTypeStore(node->getLeft()->getType(), rValue); // assignments are expressions having an rValue after they are evaluated... builder.clearAccessChain(); builder.setAccessChainRValue(rValue); } return false; case glslang::EOpIndexDirect: case glslang::EOpIndexDirectStruct: { // Structure, array, matrix, or vector indirection with statically known index. // Get the left part of the access chain. node->getLeft()->traverse(this); // Add the next element in the chain const int glslangIndex = node->getRight()->getAsConstantUnion()->getConstArray()[0].getIConst(); if (! node->getLeft()->getType().isArray() && node->getLeft()->getType().isVector() && node->getOp() == glslang::EOpIndexDirect) { // This is essentially a hard-coded vector swizzle of size 1, // so short circuit the access-chain stuff with a swizzle. std::vector swizzle; swizzle.push_back(glslangIndex); int dummySize; builder.accessChainPushSwizzle(swizzle, convertGlslangToSpvType(node->getLeft()->getType()), TranslateCoherent(node->getLeft()->getType()), glslangIntermediate->getBaseAlignmentScalar(node->getLeft()->getType(), dummySize)); } else { // Load through a block reference is performed with a dot operator that // is mapped to EOpIndexDirectStruct. When we get to the actual reference, // do a load and reset the access chain. if (node->getLeft()->isReference() && !node->getLeft()->getType().isArray() && node->getOp() == glslang::EOpIndexDirectStruct) { spv::Id left = accessChainLoad(node->getLeft()->getType()); builder.clearAccessChain(); builder.setAccessChainLValue(left); } int spvIndex = glslangIndex; if (node->getLeft()->getBasicType() == glslang::EbtBlock && node->getOp() == glslang::EOpIndexDirectStruct) { // This may be, e.g., an anonymous block-member selection, which generally need // index remapping due to hidden members in anonymous blocks. std::vector& remapper = memberRemapper[node->getLeft()->getType().getStruct()]; assert(remapper.size() > 0); spvIndex = remapper[glslangIndex]; } // normal case for indexing array or structure or block builder.accessChainPush(builder.makeIntConstant(spvIndex), TranslateCoherent(node->getLeft()->getType()), node->getLeft()->getType().getBufferReferenceAlignment()); // Add capabilities here for accessing PointSize and clip/cull distance. // We have deferred generation of associated capabilities until now. if (node->getLeft()->getType().isStruct() && ! node->getLeft()->getType().isArray()) declareUseOfStructMember(*(node->getLeft()->getType().getStruct()), glslangIndex); } } return false; case glslang::EOpIndexIndirect: { // Array, matrix, or vector indirection with variable index. // Will use native SPIR-V access-chain for and array indirection; // matrices are arrays of vectors, so will also work for a matrix. // Will use the access chain's 'component' for variable index into a vector. // This adapter is building access chains left to right. // Set up the access chain to the left. node->getLeft()->traverse(this); // save it so that computing the right side doesn't trash it spv::Builder::AccessChain partial = builder.getAccessChain(); // compute the next index in the chain builder.clearAccessChain(); node->getRight()->traverse(this); spv::Id index = accessChainLoad(node->getRight()->getType()); addIndirectionIndexCapabilities(node->getLeft()->getType(), node->getRight()->getType()); // restore the saved access chain builder.setAccessChain(partial); if (! node->getLeft()->getType().isArray() && node->getLeft()->getType().isVector()) { int dummySize; builder.accessChainPushComponent(index, convertGlslangToSpvType(node->getLeft()->getType()), TranslateCoherent(node->getLeft()->getType()), glslangIntermediate->getBaseAlignmentScalar(node->getLeft()->getType(), dummySize)); } else builder.accessChainPush(index, TranslateCoherent(node->getLeft()->getType()), node->getLeft()->getType().getBufferReferenceAlignment()); } return false; case glslang::EOpVectorSwizzle: { node->getLeft()->traverse(this); std::vector swizzle; convertSwizzle(*node->getRight()->getAsAggregate(), swizzle); int dummySize; builder.accessChainPushSwizzle(swizzle, convertGlslangToSpvType(node->getLeft()->getType()), TranslateCoherent(node->getLeft()->getType()), glslangIntermediate->getBaseAlignmentScalar(node->getLeft()->getType(), dummySize)); } return false; case glslang::EOpMatrixSwizzle: logger->missingFunctionality("matrix swizzle"); return true; case glslang::EOpLogicalOr: case glslang::EOpLogicalAnd: { // These may require short circuiting, but can sometimes be done as straight // binary operations. The right operand must be short circuited if it has // side effects, and should probably be if it is complex. if (isTrivial(node->getRight()->getAsTyped())) break; // handle below as a normal binary operation // otherwise, we need to do dynamic short circuiting on the right operand spv::Id result = createShortCircuit(node->getOp(), *node->getLeft()->getAsTyped(), *node->getRight()->getAsTyped()); builder.clearAccessChain(); builder.setAccessChainRValue(result); } return false; default: break; } // Assume generic binary op... // get right operand builder.clearAccessChain(); node->getLeft()->traverse(this); spv::Id left = accessChainLoad(node->getLeft()->getType()); // get left operand builder.clearAccessChain(); node->getRight()->traverse(this); spv::Id right = accessChainLoad(node->getRight()->getType()); // get result OpDecorations decorations = { TranslatePrecisionDecoration(node->getOperationPrecision()), TranslateNoContractionDecoration(node->getType().getQualifier()), TranslateNonUniformDecoration(node->getType().getQualifier()) }; spv::Id result = createBinaryOperation(node->getOp(), decorations, convertGlslangToSpvType(node->getType()), left, right, node->getLeft()->getType().getBasicType()); builder.clearAccessChain(); if (! result) { logger->missingFunctionality("unknown glslang binary operation"); return true; // pick up a child as the place-holder result } else { builder.setAccessChainRValue(result); return false; } } // Figure out what, if any, type changes are needed when accessing a specific built-in. // Returns . // Also see comment for 'forceType', regarding tracking SPIR-V-required types. std::pair TGlslangToSpvTraverser::getForcedType(spv::BuiltIn builtIn, const glslang::TType& glslangType) { switch(builtIn) { case spv::BuiltInSubgroupEqMask: case spv::BuiltInSubgroupGeMask: case spv::BuiltInSubgroupGtMask: case spv::BuiltInSubgroupLeMask: case spv::BuiltInSubgroupLtMask: { // these require changing a 64-bit scaler -> a vector of 32-bit components if (glslangType.isVector()) break; std::pair ret(builder.makeVectorType(builder.makeUintType(32), 4), builder.makeUintType(64)); return ret; } default: break; } std::pair ret(spv::NoType, spv::NoType); return ret; } // For an object previously identified (see getForcedType() and forceType) // as needing type translations, do the translation needed for a load, turning // an L-value into in R-value. spv::Id TGlslangToSpvTraverser::translateForcedType(spv::Id object) { const auto forceIt = forceType.find(object); if (forceIt == forceType.end()) return object; spv::Id desiredTypeId = forceIt->second; spv::Id objectTypeId = builder.getTypeId(object); assert(builder.isPointerType(objectTypeId)); objectTypeId = builder.getContainedTypeId(objectTypeId); if (builder.isVectorType(objectTypeId) && builder.getScalarTypeWidth(builder.getContainedTypeId(objectTypeId)) == 32) { if (builder.getScalarTypeWidth(desiredTypeId) == 64) { // handle 32-bit v.xy* -> 64-bit builder.clearAccessChain(); builder.setAccessChainLValue(object); object = builder.accessChainLoad(spv::NoPrecision, spv::DecorationMax, objectTypeId); std::vector components; components.push_back(builder.createCompositeExtract(object, builder.getContainedTypeId(objectTypeId), 0)); components.push_back(builder.createCompositeExtract(object, builder.getContainedTypeId(objectTypeId), 1)); spv::Id vecType = builder.makeVectorType(builder.getContainedTypeId(objectTypeId), 2); return builder.createUnaryOp(spv::OpBitcast, desiredTypeId, builder.createCompositeConstruct(vecType, components)); } else { logger->missingFunctionality("forcing 32-bit vector type to non 64-bit scalar"); } } else { logger->missingFunctionality("forcing non 32-bit vector type"); } return object; } bool TGlslangToSpvTraverser::visitUnary(glslang::TVisit /* visit */, glslang::TIntermUnary* node) { builder.setLine(node->getLoc().line, node->getLoc().getFilename()); SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder); if (node->getType().getQualifier().isSpecConstant()) spec_constant_op_mode_setter.turnOnSpecConstantOpMode(); spv::Id result = spv::NoResult; // try texturing first result = createImageTextureFunctionCall(node); if (result != spv::NoResult) { builder.clearAccessChain(); builder.setAccessChainRValue(result); return false; // done with this node } // Non-texturing. if (node->getOp() == glslang::EOpArrayLength) { // Quite special; won't want to evaluate the operand. // Currently, the front-end does not allow .length() on an array until it is sized, // except for the last block membeor of an SSBO. // TODO: If this changes, link-time sized arrays might show up here, and need their // size extracted. // Normal .length() would have been constant folded by the front-end. // So, this has to be block.lastMember.length(). // SPV wants "block" and member number as the operands, go get them. spv::Id length; if (node->getOperand()->getType().isCoopMat()) { spec_constant_op_mode_setter.turnOnSpecConstantOpMode(); spv::Id typeId = convertGlslangToSpvType(node->getOperand()->getType()); assert(builder.isCooperativeMatrixType(typeId)); length = builder.createCooperativeMatrixLength(typeId); } else { glslang::TIntermTyped* block = node->getOperand()->getAsBinaryNode()->getLeft(); block->traverse(this); unsigned int member = node->getOperand()->getAsBinaryNode()->getRight()->getAsConstantUnion()->getConstArray()[0].getUConst(); length = builder.createArrayLength(builder.accessChainGetLValue(), member); } // GLSL semantics say the result of .length() is an int, while SPIR-V says // signedness must be 0. So, convert from SPIR-V unsigned back to GLSL's // AST expectation of a signed result. if (glslangIntermediate->getSource() == glslang::EShSourceGlsl) { if (builder.isInSpecConstCodeGenMode()) { length = builder.createBinOp(spv::OpIAdd, builder.makeIntType(32), length, builder.makeIntConstant(0)); } else { length = builder.createUnaryOp(spv::OpBitcast, builder.makeIntType(32), length); } } builder.clearAccessChain(); builder.setAccessChainRValue(length); return false; } // Start by evaluating the operand // Does it need a swizzle inversion? If so, evaluation is inverted; // operate first on the swizzle base, then apply the swizzle. spv::Id invertedType = spv::NoType; auto resultType = [&invertedType, &node, this](){ return invertedType != spv::NoType ? invertedType : convertGlslangToSpvType(node->getType()); }; if (node->getOp() == glslang::EOpInterpolateAtCentroid) invertedType = getInvertedSwizzleType(*node->getOperand()); builder.clearAccessChain(); TIntermNode *operandNode; if (invertedType != spv::NoType) operandNode = node->getOperand()->getAsBinaryNode()->getLeft(); else operandNode = node->getOperand(); operandNode->traverse(this); spv::Id operand = spv::NoResult; spv::Builder::AccessChain::CoherentFlags lvalueCoherentFlags; #ifndef GLSLANG_WEB if (node->getOp() == glslang::EOpAtomicCounterIncrement || node->getOp() == glslang::EOpAtomicCounterDecrement || node->getOp() == glslang::EOpAtomicCounter || node->getOp() == glslang::EOpInterpolateAtCentroid) { operand = builder.accessChainGetLValue(); // Special case l-value operands lvalueCoherentFlags = builder.getAccessChain().coherentFlags; lvalueCoherentFlags |= TranslateCoherent(operandNode->getAsTyped()->getType()); } else #endif { operand = accessChainLoad(node->getOperand()->getType()); } OpDecorations decorations = { TranslatePrecisionDecoration(node->getOperationPrecision()), TranslateNoContractionDecoration(node->getType().getQualifier()), TranslateNonUniformDecoration(node->getType().getQualifier()) }; // it could be a conversion if (! result) result = createConversion(node->getOp(), decorations, resultType(), operand, node->getOperand()->getBasicType()); // if not, then possibly an operation if (! result) result = createUnaryOperation(node->getOp(), decorations, resultType(), operand, node->getOperand()->getBasicType(), lvalueCoherentFlags); if (result) { if (invertedType) { result = createInvertedSwizzle(decorations.precision, *node->getOperand(), result); decorations.addNonUniform(builder, result); } builder.clearAccessChain(); builder.setAccessChainRValue(result); return false; // done with this node } // it must be a special case, check... switch (node->getOp()) { case glslang::EOpPostIncrement: case glslang::EOpPostDecrement: case glslang::EOpPreIncrement: case glslang::EOpPreDecrement: { // we need the integer value "1" or the floating point "1.0" to add/subtract spv::Id one = 0; if (node->getBasicType() == glslang::EbtFloat) one = builder.makeFloatConstant(1.0F); #ifndef GLSLANG_WEB else if (node->getBasicType() == glslang::EbtDouble) one = builder.makeDoubleConstant(1.0); else if (node->getBasicType() == glslang::EbtFloat16) one = builder.makeFloat16Constant(1.0F); else if (node->getBasicType() == glslang::EbtInt8 || node->getBasicType() == glslang::EbtUint8) one = builder.makeInt8Constant(1); else if (node->getBasicType() == glslang::EbtInt16 || node->getBasicType() == glslang::EbtUint16) one = builder.makeInt16Constant(1); else if (node->getBasicType() == glslang::EbtInt64 || node->getBasicType() == glslang::EbtUint64) one = builder.makeInt64Constant(1); #endif else one = builder.makeIntConstant(1); glslang::TOperator op; if (node->getOp() == glslang::EOpPreIncrement || node->getOp() == glslang::EOpPostIncrement) op = glslang::EOpAdd; else op = glslang::EOpSub; spv::Id result = createBinaryOperation(op, decorations, convertGlslangToSpvType(node->getType()), operand, one, node->getType().getBasicType()); assert(result != spv::NoResult); // The result of operation is always stored, but conditionally the // consumed result. The consumed result is always an r-value. builder.accessChainStore(result); builder.clearAccessChain(); if (node->getOp() == glslang::EOpPreIncrement || node->getOp() == glslang::EOpPreDecrement) builder.setAccessChainRValue(result); else builder.setAccessChainRValue(operand); } return false; #ifndef GLSLANG_WEB case glslang::EOpEmitStreamVertex: builder.createNoResultOp(spv::OpEmitStreamVertex, operand); return false; case glslang::EOpEndStreamPrimitive: builder.createNoResultOp(spv::OpEndStreamPrimitive, operand); return false; #endif default: logger->missingFunctionality("unknown glslang unary"); return true; // pick up operand as placeholder result } } // Construct a composite object, recursively copying members if their types don't match spv::Id TGlslangToSpvTraverser::createCompositeConstruct(spv::Id resultTypeId, std::vector constituents) { for (int c = 0; c < (int)constituents.size(); ++c) { spv::Id& constituent = constituents[c]; spv::Id lType = builder.getContainedTypeId(resultTypeId, c); spv::Id rType = builder.getTypeId(constituent); if (lType != rType) { if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4) { constituent = builder.createUnaryOp(spv::OpCopyLogical, lType, constituent); } else if (builder.isStructType(rType)) { std::vector rTypeConstituents; int numrTypeConstituents = builder.getNumTypeConstituents(rType); for (int i = 0; i < numrTypeConstituents; ++i) { rTypeConstituents.push_back(builder.createCompositeExtract(constituent, builder.getContainedTypeId(rType, i), i)); } constituents[c] = createCompositeConstruct(lType, rTypeConstituents); } else { assert(builder.isArrayType(rType)); std::vector rTypeConstituents; int numrTypeConstituents = builder.getNumTypeConstituents(rType); spv::Id elementRType = builder.getContainedTypeId(rType); for (int i = 0; i < numrTypeConstituents; ++i) { rTypeConstituents.push_back(builder.createCompositeExtract(constituent, elementRType, i)); } constituents[c] = createCompositeConstruct(lType, rTypeConstituents); } } } return builder.createCompositeConstruct(resultTypeId, constituents); } bool TGlslangToSpvTraverser::visitAggregate(glslang::TVisit visit, glslang::TIntermAggregate* node) { SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder); if (node->getType().getQualifier().isSpecConstant()) spec_constant_op_mode_setter.turnOnSpecConstantOpMode(); spv::Id result = spv::NoResult; spv::Id invertedType = spv::NoType; // to use to override the natural type of the node auto resultType = [&invertedType, &node, this](){ return invertedType != spv::NoType ? invertedType : convertGlslangToSpvType(node->getType()); }; // try texturing result = createImageTextureFunctionCall(node); if (result != spv::NoResult) { builder.clearAccessChain(); builder.setAccessChainRValue(result); return false; } #ifndef GLSLANG_WEB else if (node->getOp() == glslang::EOpImageStore || node->getOp() == glslang::EOpImageStoreLod || node->getOp() == glslang::EOpImageAtomicStore) { // "imageStore" is a special case, which has no result return false; } #endif glslang::TOperator binOp = glslang::EOpNull; bool reduceComparison = true; bool isMatrix = false; bool noReturnValue = false; bool atomic = false; spv::Builder::AccessChain::CoherentFlags lvalueCoherentFlags; assert(node->getOp()); spv::Decoration precision = TranslatePrecisionDecoration(node->getOperationPrecision()); switch (node->getOp()) { case glslang::EOpSequence: { if (preVisit) ++sequenceDepth; else --sequenceDepth; if (sequenceDepth == 1) { // If this is the parent node of all the functions, we want to see them // early, so all call points have actual SPIR-V functions to reference. // In all cases, still let the traverser visit the children for us. makeFunctions(node->getAsAggregate()->getSequence()); // Also, we want all globals initializers to go into the beginning of the entry point, before // anything else gets there, so visit out of order, doing them all now. makeGlobalInitializers(node->getAsAggregate()->getSequence()); // Initializers are done, don't want to visit again, but functions and link objects need to be processed, // so do them manually. visitFunctions(node->getAsAggregate()->getSequence()); return false; } return true; } case glslang::EOpLinkerObjects: { if (visit == glslang::EvPreVisit) linkageOnly = true; else linkageOnly = false; return true; } case glslang::EOpComma: { // processing from left to right naturally leaves the right-most // lying around in the access chain glslang::TIntermSequence& glslangOperands = node->getSequence(); for (int i = 0; i < (int)glslangOperands.size(); ++i) glslangOperands[i]->traverse(this); return false; } case glslang::EOpFunction: if (visit == glslang::EvPreVisit) { if (isShaderEntryPoint(node)) { inEntryPoint = true; builder.setBuildPoint(shaderEntry->getLastBlock()); currentFunction = shaderEntry; } else { handleFunctionEntry(node); } } else { if (inEntryPoint) entryPointTerminated = true; builder.leaveFunction(); inEntryPoint = false; } return true; case glslang::EOpParameters: // Parameters will have been consumed by EOpFunction processing, but not // the body, so we still visited the function node's children, making this // child redundant. return false; case glslang::EOpFunctionCall: { builder.setLine(node->getLoc().line, node->getLoc().getFilename()); if (node->isUserDefined()) result = handleUserFunctionCall(node); // assert(result); // this can happen for bad shaders because the call graph completeness checking is not yet done if (result) { builder.clearAccessChain(); builder.setAccessChainRValue(result); } else logger->missingFunctionality("missing user function; linker needs to catch that"); return false; } case glslang::EOpConstructMat2x2: case glslang::EOpConstructMat2x3: case glslang::EOpConstructMat2x4: case glslang::EOpConstructMat3x2: case glslang::EOpConstructMat3x3: case glslang::EOpConstructMat3x4: case glslang::EOpConstructMat4x2: case glslang::EOpConstructMat4x3: case glslang::EOpConstructMat4x4: case glslang::EOpConstructDMat2x2: case glslang::EOpConstructDMat2x3: case glslang::EOpConstructDMat2x4: case glslang::EOpConstructDMat3x2: case glslang::EOpConstructDMat3x3: case glslang::EOpConstructDMat3x4: case glslang::EOpConstructDMat4x2: case glslang::EOpConstructDMat4x3: case glslang::EOpConstructDMat4x4: case glslang::EOpConstructIMat2x2: case glslang::EOpConstructIMat2x3: case glslang::EOpConstructIMat2x4: case glslang::EOpConstructIMat3x2: case glslang::EOpConstructIMat3x3: case glslang::EOpConstructIMat3x4: case glslang::EOpConstructIMat4x2: case glslang::EOpConstructIMat4x3: case glslang::EOpConstructIMat4x4: case glslang::EOpConstructUMat2x2: case glslang::EOpConstructUMat2x3: case glslang::EOpConstructUMat2x4: case glslang::EOpConstructUMat3x2: case glslang::EOpConstructUMat3x3: case glslang::EOpConstructUMat3x4: case glslang::EOpConstructUMat4x2: case glslang::EOpConstructUMat4x3: case glslang::EOpConstructUMat4x4: case glslang::EOpConstructBMat2x2: case glslang::EOpConstructBMat2x3: case glslang::EOpConstructBMat2x4: case glslang::EOpConstructBMat3x2: case glslang::EOpConstructBMat3x3: case glslang::EOpConstructBMat3x4: case glslang::EOpConstructBMat4x2: case glslang::EOpConstructBMat4x3: case glslang::EOpConstructBMat4x4: case glslang::EOpConstructF16Mat2x2: case glslang::EOpConstructF16Mat2x3: case glslang::EOpConstructF16Mat2x4: case glslang::EOpConstructF16Mat3x2: case glslang::EOpConstructF16Mat3x3: case glslang::EOpConstructF16Mat3x4: case glslang::EOpConstructF16Mat4x2: case glslang::EOpConstructF16Mat4x3: case glslang::EOpConstructF16Mat4x4: isMatrix = true; // fall through case glslang::EOpConstructFloat: case glslang::EOpConstructVec2: case glslang::EOpConstructVec3: case glslang::EOpConstructVec4: case glslang::EOpConstructDouble: case glslang::EOpConstructDVec2: case glslang::EOpConstructDVec3: case glslang::EOpConstructDVec4: case glslang::EOpConstructFloat16: case glslang::EOpConstructF16Vec2: case glslang::EOpConstructF16Vec3: case glslang::EOpConstructF16Vec4: case glslang::EOpConstructBool: case glslang::EOpConstructBVec2: case glslang::EOpConstructBVec3: case glslang::EOpConstructBVec4: case glslang::EOpConstructInt8: case glslang::EOpConstructI8Vec2: case glslang::EOpConstructI8Vec3: case glslang::EOpConstructI8Vec4: case glslang::EOpConstructUint8: case glslang::EOpConstructU8Vec2: case glslang::EOpConstructU8Vec3: case glslang::EOpConstructU8Vec4: case glslang::EOpConstructInt16: case glslang::EOpConstructI16Vec2: case glslang::EOpConstructI16Vec3: case glslang::EOpConstructI16Vec4: case glslang::EOpConstructUint16: case glslang::EOpConstructU16Vec2: case glslang::EOpConstructU16Vec3: case glslang::EOpConstructU16Vec4: case glslang::EOpConstructInt: case glslang::EOpConstructIVec2: case glslang::EOpConstructIVec3: case glslang::EOpConstructIVec4: case glslang::EOpConstructUint: case glslang::EOpConstructUVec2: case glslang::EOpConstructUVec3: case glslang::EOpConstructUVec4: case glslang::EOpConstructInt64: case glslang::EOpConstructI64Vec2: case glslang::EOpConstructI64Vec3: case glslang::EOpConstructI64Vec4: case glslang::EOpConstructUint64: case glslang::EOpConstructU64Vec2: case glslang::EOpConstructU64Vec3: case glslang::EOpConstructU64Vec4: case glslang::EOpConstructStruct: case glslang::EOpConstructTextureSampler: case glslang::EOpConstructReference: case glslang::EOpConstructCooperativeMatrix: { builder.setLine(node->getLoc().line, node->getLoc().getFilename()); std::vector arguments; translateArguments(*node, arguments, lvalueCoherentFlags); spv::Id constructed; if (node->getOp() == glslang::EOpConstructTextureSampler) constructed = builder.createOp(spv::OpSampledImage, resultType(), arguments); else if (node->getOp() == glslang::EOpConstructStruct || node->getOp() == glslang::EOpConstructCooperativeMatrix || node->getType().isArray()) { std::vector constituents; for (int c = 0; c < (int)arguments.size(); ++c) constituents.push_back(arguments[c]); constructed = createCompositeConstruct(resultType(), constituents); } else if (isMatrix) constructed = builder.createMatrixConstructor(precision, arguments, resultType()); else constructed = builder.createConstructor(precision, arguments, resultType()); builder.clearAccessChain(); builder.setAccessChainRValue(constructed); return false; } // These six are component-wise compares with component-wise results. // Forward on to createBinaryOperation(), requesting a vector result. case glslang::EOpLessThan: case glslang::EOpGreaterThan: case glslang::EOpLessThanEqual: case glslang::EOpGreaterThanEqual: case glslang::EOpVectorEqual: case glslang::EOpVectorNotEqual: { // Map the operation to a binary binOp = node->getOp(); reduceComparison = false; switch (node->getOp()) { case glslang::EOpVectorEqual: binOp = glslang::EOpVectorEqual; break; case glslang::EOpVectorNotEqual: binOp = glslang::EOpVectorNotEqual; break; default: binOp = node->getOp(); break; } break; } case glslang::EOpMul: // component-wise matrix multiply binOp = glslang::EOpMul; break; case glslang::EOpOuterProduct: // two vectors multiplied to make a matrix binOp = glslang::EOpOuterProduct; break; case glslang::EOpDot: { // for scalar dot product, use multiply glslang::TIntermSequence& glslangOperands = node->getSequence(); if (glslangOperands[0]->getAsTyped()->getVectorSize() == 1) binOp = glslang::EOpMul; break; } case glslang::EOpMod: // when an aggregate, this is the floating-point mod built-in function, // which can be emitted by the one in createBinaryOperation() binOp = glslang::EOpMod; break; case glslang::EOpEmitVertex: case glslang::EOpEndPrimitive: case glslang::EOpBarrier: case glslang::EOpMemoryBarrier: case glslang::EOpMemoryBarrierAtomicCounter: case glslang::EOpMemoryBarrierBuffer: case glslang::EOpMemoryBarrierImage: case glslang::EOpMemoryBarrierShared: case glslang::EOpGroupMemoryBarrier: case glslang::EOpDeviceMemoryBarrier: case glslang::EOpAllMemoryBarrierWithGroupSync: case glslang::EOpDeviceMemoryBarrierWithGroupSync: case glslang::EOpWorkgroupMemoryBarrier: case glslang::EOpWorkgroupMemoryBarrierWithGroupSync: case glslang::EOpSubgroupBarrier: case glslang::EOpSubgroupMemoryBarrier: case glslang::EOpSubgroupMemoryBarrierBuffer: case glslang::EOpSubgroupMemoryBarrierImage: case glslang::EOpSubgroupMemoryBarrierShared: noReturnValue = true; // These all have 0 operands and will naturally finish up in the code below for 0 operands break; case glslang::EOpAtomicAdd: case glslang::EOpAtomicMin: case glslang::EOpAtomicMax: case glslang::EOpAtomicAnd: case glslang::EOpAtomicOr: case glslang::EOpAtomicXor: case glslang::EOpAtomicExchange: case glslang::EOpAtomicCompSwap: atomic = true; break; #ifndef GLSLANG_WEB case glslang::EOpAtomicStore: noReturnValue = true; // fallthrough case glslang::EOpAtomicLoad: atomic = true; break; case glslang::EOpAtomicCounterAdd: case glslang::EOpAtomicCounterSubtract: case glslang::EOpAtomicCounterMin: case glslang::EOpAtomicCounterMax: case glslang::EOpAtomicCounterAnd: case glslang::EOpAtomicCounterOr: case glslang::EOpAtomicCounterXor: case glslang::EOpAtomicCounterExchange: case glslang::EOpAtomicCounterCompSwap: builder.addExtension("SPV_KHR_shader_atomic_counter_ops"); builder.addCapability(spv::CapabilityAtomicStorageOps); atomic = true; break; case glslang::EOpAbsDifference: case glslang::EOpAddSaturate: case glslang::EOpSubSaturate: case glslang::EOpAverage: case glslang::EOpAverageRounded: case glslang::EOpMul32x16: builder.addCapability(spv::CapabilityIntegerFunctions2INTEL); builder.addExtension("SPV_INTEL_shader_integer_functions2"); binOp = node->getOp(); break; case glslang::EOpIgnoreIntersectionNV: case glslang::EOpTerminateRayNV: case glslang::EOpTraceNV: case glslang::EOpExecuteCallableNV: case glslang::EOpWritePackedPrimitiveIndices4x8NV: noReturnValue = true; break; case glslang::EOpCooperativeMatrixLoad: case glslang::EOpCooperativeMatrixStore: noReturnValue = true; break; case glslang::EOpBeginInvocationInterlock: case glslang::EOpEndInvocationInterlock: builder.addExtension(spv::E_SPV_EXT_fragment_shader_interlock); noReturnValue = true; break; #endif default: break; } // // See if it maps to a regular operation. // if (binOp != glslang::EOpNull) { glslang::TIntermTyped* left = node->getSequence()[0]->getAsTyped(); glslang::TIntermTyped* right = node->getSequence()[1]->getAsTyped(); assert(left && right); builder.clearAccessChain(); left->traverse(this); spv::Id leftId = accessChainLoad(left->getType()); builder.clearAccessChain(); right->traverse(this); spv::Id rightId = accessChainLoad(right->getType()); builder.setLine(node->getLoc().line, node->getLoc().getFilename()); OpDecorations decorations = { precision, TranslateNoContractionDecoration(node->getType().getQualifier()), TranslateNonUniformDecoration(node->getType().getQualifier()) }; result = createBinaryOperation(binOp, decorations, resultType(), leftId, rightId, left->getType().getBasicType(), reduceComparison); // code above should only make binOp that exists in createBinaryOperation assert(result != spv::NoResult); builder.clearAccessChain(); builder.setAccessChainRValue(result); return false; } // // Create the list of operands. // glslang::TIntermSequence& glslangOperands = node->getSequence(); std::vector operands; std::vector memoryAccessOperands; for (int arg = 0; arg < (int)glslangOperands.size(); ++arg) { // special case l-value operands; there are just a few bool lvalue = false; switch (node->getOp()) { case glslang::EOpModf: if (arg == 1) lvalue = true; break; case glslang::EOpAtomicAdd: case glslang::EOpAtomicMin: case glslang::EOpAtomicMax: case glslang::EOpAtomicAnd: case glslang::EOpAtomicOr: case glslang::EOpAtomicXor: case glslang::EOpAtomicExchange: case glslang::EOpAtomicCompSwap: if (arg == 0) lvalue = true; break; #ifndef GLSLANG_WEB case glslang::EOpFrexp: if (arg == 1) lvalue = true; break; case glslang::EOpInterpolateAtSample: case glslang::EOpInterpolateAtOffset: case glslang::EOpInterpolateAtVertex: if (arg == 0) { lvalue = true; // Does it need a swizzle inversion? If so, evaluation is inverted; // operate first on the swizzle base, then apply the swizzle. if (glslangOperands[0]->getAsOperator() && glslangOperands[0]->getAsOperator()->getOp() == glslang::EOpVectorSwizzle) invertedType = convertGlslangToSpvType(glslangOperands[0]->getAsBinaryNode()->getLeft()->getType()); } break; case glslang::EOpAtomicLoad: case glslang::EOpAtomicStore: case glslang::EOpAtomicCounterAdd: case glslang::EOpAtomicCounterSubtract: case glslang::EOpAtomicCounterMin: case glslang::EOpAtomicCounterMax: case glslang::EOpAtomicCounterAnd: case glslang::EOpAtomicCounterOr: case glslang::EOpAtomicCounterXor: case glslang::EOpAtomicCounterExchange: case glslang::EOpAtomicCounterCompSwap: if (arg == 0) lvalue = true; break; case glslang::EOpAddCarry: case glslang::EOpSubBorrow: if (arg == 2) lvalue = true; break; case glslang::EOpUMulExtended: case glslang::EOpIMulExtended: if (arg >= 2) lvalue = true; break; case glslang::EOpCooperativeMatrixLoad: if (arg == 0 || arg == 1) lvalue = true; break; case glslang::EOpCooperativeMatrixStore: if (arg == 1) lvalue = true; break; #endif default: break; } builder.clearAccessChain(); if (invertedType != spv::NoType && arg == 0) glslangOperands[0]->getAsBinaryNode()->getLeft()->traverse(this); else glslangOperands[arg]->traverse(this); #ifndef GLSLANG_WEB if (node->getOp() == glslang::EOpCooperativeMatrixLoad || node->getOp() == glslang::EOpCooperativeMatrixStore) { if (arg == 1) { // fold "element" parameter into the access chain spv::Builder::AccessChain save = builder.getAccessChain(); builder.clearAccessChain(); glslangOperands[2]->traverse(this); spv::Id elementId = accessChainLoad(glslangOperands[2]->getAsTyped()->getType()); builder.setAccessChain(save); // Point to the first element of the array. builder.accessChainPush(elementId, TranslateCoherent(glslangOperands[arg]->getAsTyped()->getType()), glslangOperands[arg]->getAsTyped()->getType().getBufferReferenceAlignment()); spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags; unsigned int alignment = builder.getAccessChain().alignment; int memoryAccess = TranslateMemoryAccess(coherentFlags); if (node->getOp() == glslang::EOpCooperativeMatrixLoad) memoryAccess &= ~spv::MemoryAccessMakePointerAvailableKHRMask; if (node->getOp() == glslang::EOpCooperativeMatrixStore) memoryAccess &= ~spv::MemoryAccessMakePointerVisibleKHRMask; if (builder.getStorageClass(builder.getAccessChain().base) == spv::StorageClassPhysicalStorageBufferEXT) { memoryAccess = (spv::MemoryAccessMask)(memoryAccess | spv::MemoryAccessAlignedMask); } memoryAccessOperands.push_back(spv::IdImmediate(false, memoryAccess)); if (memoryAccess & spv::MemoryAccessAlignedMask) { memoryAccessOperands.push_back(spv::IdImmediate(false, alignment)); } if (memoryAccess & (spv::MemoryAccessMakePointerAvailableKHRMask | spv::MemoryAccessMakePointerVisibleKHRMask)) { memoryAccessOperands.push_back(spv::IdImmediate(true, builder.makeUintConstant(TranslateMemoryScope(coherentFlags)))); } } else if (arg == 2) { continue; } } #endif if (lvalue) { operands.push_back(builder.accessChainGetLValue()); lvalueCoherentFlags = builder.getAccessChain().coherentFlags; lvalueCoherentFlags |= TranslateCoherent(glslangOperands[arg]->getAsTyped()->getType()); } else { builder.setLine(node->getLoc().line, node->getLoc().getFilename()); operands.push_back(accessChainLoad(glslangOperands[arg]->getAsTyped()->getType())); } } builder.setLine(node->getLoc().line, node->getLoc().getFilename()); #ifndef GLSLANG_WEB if (node->getOp() == glslang::EOpCooperativeMatrixLoad) { std::vector idImmOps; idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride idImmOps.push_back(spv::IdImmediate(true, operands[3])); // colMajor idImmOps.insert(idImmOps.end(), memoryAccessOperands.begin(), memoryAccessOperands.end()); // get the pointee type spv::Id typeId = builder.getContainedTypeId(builder.getTypeId(operands[0])); assert(builder.isCooperativeMatrixType(typeId)); // do the op spv::Id result = builder.createOp(spv::OpCooperativeMatrixLoadNV, typeId, idImmOps); // store the result to the pointer (out param 'm') builder.createStore(result, operands[0]); result = 0; } else if (node->getOp() == glslang::EOpCooperativeMatrixStore) { std::vector idImmOps; idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf idImmOps.push_back(spv::IdImmediate(true, operands[0])); // object idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride idImmOps.push_back(spv::IdImmediate(true, operands[3])); // colMajor idImmOps.insert(idImmOps.end(), memoryAccessOperands.begin(), memoryAccessOperands.end()); builder.createNoResultOp(spv::OpCooperativeMatrixStoreNV, idImmOps); result = 0; } else #endif if (atomic) { // Handle all atomics result = createAtomicOperation(node->getOp(), precision, resultType(), operands, node->getBasicType(), lvalueCoherentFlags); } else { // Pass through to generic operations. switch (glslangOperands.size()) { case 0: result = createNoArgOperation(node->getOp(), precision, resultType()); break; case 1: { OpDecorations decorations = { precision, TranslateNoContractionDecoration(node->getType().getQualifier()), TranslateNonUniformDecoration(node->getType().getQualifier()) }; result = createUnaryOperation( node->getOp(), decorations, resultType(), operands.front(), glslangOperands[0]->getAsTyped()->getBasicType(), lvalueCoherentFlags); } break; default: result = createMiscOperation(node->getOp(), precision, resultType(), operands, node->getBasicType()); break; } if (invertedType) result = createInvertedSwizzle(precision, *glslangOperands[0]->getAsBinaryNode(), result); } if (noReturnValue) return false; if (! result) { logger->missingFunctionality("unknown glslang aggregate"); return true; // pick up a child as a placeholder operand } else { builder.clearAccessChain(); builder.setAccessChainRValue(result); return false; } } // This path handles both if-then-else and ?: // The if-then-else has a node type of void, while // ?: has either a void or a non-void node type // // Leaving the result, when not void: // GLSL only has r-values as the result of a :?, but // if we have an l-value, that can be more efficient if it will // become the base of a complex r-value expression, because the // next layer copies r-values into memory to use the access-chain mechanism bool TGlslangToSpvTraverser::visitSelection(glslang::TVisit /* visit */, glslang::TIntermSelection* node) { // see if OpSelect can handle it const auto isOpSelectable = [&]() { if (node->getBasicType() == glslang::EbtVoid) return false; // OpSelect can do all other types starting with SPV 1.4 if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_4) { // pre-1.4, only scalars and vectors can be handled if ((!node->getType().isScalar() && !node->getType().isVector())) return false; } return true; }; // See if it simple and safe, or required, to execute both sides. // Crucially, side effects must be either semantically required or avoided, // and there are performance trade-offs. // Return true if required or a good idea (and safe) to execute both sides, // false otherwise. const auto bothSidesPolicy = [&]() -> bool { // do we have both sides? if (node->getTrueBlock() == nullptr || node->getFalseBlock() == nullptr) return false; // required? (unless we write additional code to look for side effects // and make performance trade-offs if none are present) if (!node->getShortCircuit()) return true; // if not required to execute both, decide based on performance/practicality... if (!isOpSelectable()) return false; assert(node->getType() == node->getTrueBlock() ->getAsTyped()->getType() && node->getType() == node->getFalseBlock()->getAsTyped()->getType()); // return true if a single operand to ? : is okay for OpSelect const auto operandOkay = [](glslang::TIntermTyped* node) { return node->getAsSymbolNode() || node->getType().getQualifier().isConstant(); }; return operandOkay(node->getTrueBlock() ->getAsTyped()) && operandOkay(node->getFalseBlock()->getAsTyped()); }; spv::Id result = spv::NoResult; // upcoming result selecting between trueValue and falseValue // emit the condition before doing anything with selection node->getCondition()->traverse(this); spv::Id condition = accessChainLoad(node->getCondition()->getType()); // Find a way of executing both sides and selecting the right result. const auto executeBothSides = [&]() -> void { // execute both sides node->getTrueBlock()->traverse(this); spv::Id trueValue = accessChainLoad(node->getTrueBlock()->getAsTyped()->getType()); node->getFalseBlock()->traverse(this); spv::Id falseValue = accessChainLoad(node->getTrueBlock()->getAsTyped()->getType()); builder.setLine(node->getLoc().line, node->getLoc().getFilename()); // done if void if (node->getBasicType() == glslang::EbtVoid) return; // emit code to select between trueValue and falseValue // see if OpSelect can handle it if (isOpSelectable()) { // Emit OpSelect for this selection. // smear condition to vector, if necessary (AST is always scalar) // Before 1.4, smear like for mix(), starting with 1.4, keep it scalar if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_4 && builder.isVector(trueValue)) { condition = builder.smearScalar(spv::NoPrecision, condition, builder.makeVectorType(builder.makeBoolType(), builder.getNumComponents(trueValue))); } // OpSelect result = builder.createTriOp(spv::OpSelect, convertGlslangToSpvType(node->getType()), condition, trueValue, falseValue); builder.clearAccessChain(); builder.setAccessChainRValue(result); } else { // We need control flow to select the result. // TODO: Once SPIR-V OpSelect allows arbitrary types, eliminate this path. result = builder.createVariable(spv::StorageClassFunction, convertGlslangToSpvType(node->getType())); // Selection control: const spv::SelectionControlMask control = TranslateSelectionControl(*node); // make an "if" based on the value created by the condition spv::Builder::If ifBuilder(condition, control, builder); // emit the "then" statement builder.createStore(trueValue, result); ifBuilder.makeBeginElse(); // emit the "else" statement builder.createStore(falseValue, result); // finish off the control flow ifBuilder.makeEndIf(); builder.clearAccessChain(); builder.setAccessChainLValue(result); } }; // Execute the one side needed, as per the condition const auto executeOneSide = [&]() { // Always emit control flow. if (node->getBasicType() != glslang::EbtVoid) result = builder.createVariable(spv::StorageClassFunction, convertGlslangToSpvType(node->getType())); // Selection control: const spv::SelectionControlMask control = TranslateSelectionControl(*node); // make an "if" based on the value created by the condition spv::Builder::If ifBuilder(condition, control, builder); // emit the "then" statement if (node->getTrueBlock() != nullptr) { node->getTrueBlock()->traverse(this); if (result != spv::NoResult) builder.createStore(accessChainLoad(node->getTrueBlock()->getAsTyped()->getType()), result); } if (node->getFalseBlock() != nullptr) { ifBuilder.makeBeginElse(); // emit the "else" statement node->getFalseBlock()->traverse(this); if (result != spv::NoResult) builder.createStore(accessChainLoad(node->getFalseBlock()->getAsTyped()->getType()), result); } // finish off the control flow ifBuilder.makeEndIf(); if (result != spv::NoResult) { builder.clearAccessChain(); builder.setAccessChainLValue(result); } }; // Try for OpSelect (or a requirement to execute both sides) if (bothSidesPolicy()) { SpecConstantOpModeGuard spec_constant_op_mode_setter(&builder); if (node->getType().getQualifier().isSpecConstant()) spec_constant_op_mode_setter.turnOnSpecConstantOpMode(); executeBothSides(); } else executeOneSide(); return false; } bool TGlslangToSpvTraverser::visitSwitch(glslang::TVisit /* visit */, glslang::TIntermSwitch* node) { // emit and get the condition before doing anything with switch node->getCondition()->traverse(this); spv::Id selector = accessChainLoad(node->getCondition()->getAsTyped()->getType()); // Selection control: const spv::SelectionControlMask control = TranslateSwitchControl(*node); // browse the children to sort out code segments int defaultSegment = -1; std::vector codeSegments; glslang::TIntermSequence& sequence = node->getBody()->getSequence(); std::vector caseValues; std::vector valueIndexToSegment(sequence.size()); // note: probably not all are used, it is an overestimate for (glslang::TIntermSequence::iterator c = sequence.begin(); c != sequence.end(); ++c) { TIntermNode* child = *c; if (child->getAsBranchNode() && child->getAsBranchNode()->getFlowOp() == glslang::EOpDefault) defaultSegment = (int)codeSegments.size(); else if (child->getAsBranchNode() && child->getAsBranchNode()->getFlowOp() == glslang::EOpCase) { valueIndexToSegment[caseValues.size()] = (int)codeSegments.size(); caseValues.push_back(child->getAsBranchNode()->getExpression()->getAsConstantUnion()->getConstArray()[0].getIConst()); } else codeSegments.push_back(child); } // handle the case where the last code segment is missing, due to no code // statements between the last case and the end of the switch statement if ((caseValues.size() && (int)codeSegments.size() == valueIndexToSegment[caseValues.size() - 1]) || (int)codeSegments.size() == defaultSegment) codeSegments.push_back(nullptr); // make the switch statement std::vector segmentBlocks; // returned, as the blocks allocated in the call builder.makeSwitch(selector, control, (int)codeSegments.size(), caseValues, valueIndexToSegment, defaultSegment, segmentBlocks); // emit all the code in the segments breakForLoop.push(false); for (unsigned int s = 0; s < codeSegments.size(); ++s) { builder.nextSwitchSegment(segmentBlocks, s); if (codeSegments[s]) codeSegments[s]->traverse(this); else builder.addSwitchBreak(); } breakForLoop.pop(); builder.endSwitch(segmentBlocks); return false; } void TGlslangToSpvTraverser::visitConstantUnion(glslang::TIntermConstantUnion* node) { int nextConst = 0; spv::Id constant = createSpvConstantFromConstUnionArray(node->getType(), node->getConstArray(), nextConst, false); builder.clearAccessChain(); builder.setAccessChainRValue(constant); } bool TGlslangToSpvTraverser::visitLoop(glslang::TVisit /* visit */, glslang::TIntermLoop* node) { auto blocks = builder.makeNewLoop(); builder.createBranch(&blocks.head); // Loop control: std::vector operands; const spv::LoopControlMask control = TranslateLoopControl(*node, operands); // Spec requires back edges to target header blocks, and every header block // must dominate its merge block. Make a header block first to ensure these // conditions are met. By definition, it will contain OpLoopMerge, followed // by a block-ending branch. But we don't want to put any other body/test // instructions in it, since the body/test may have arbitrary instructions, // including merges of its own. builder.setLine(node->getLoc().line, node->getLoc().getFilename()); builder.setBuildPoint(&blocks.head); builder.createLoopMerge(&blocks.merge, &blocks.continue_target, control, operands); if (node->testFirst() && node->getTest()) { spv::Block& test = builder.makeNewBlock(); builder.createBranch(&test); builder.setBuildPoint(&test); node->getTest()->traverse(this); spv::Id condition = accessChainLoad(node->getTest()->getType()); builder.createConditionalBranch(condition, &blocks.body, &blocks.merge); builder.setBuildPoint(&blocks.body); breakForLoop.push(true); if (node->getBody()) node->getBody()->traverse(this); builder.createBranch(&blocks.continue_target); breakForLoop.pop(); builder.setBuildPoint(&blocks.continue_target); if (node->getTerminal()) node->getTerminal()->traverse(this); builder.createBranch(&blocks.head); } else { builder.setLine(node->getLoc().line, node->getLoc().getFilename()); builder.createBranch(&blocks.body); breakForLoop.push(true); builder.setBuildPoint(&blocks.body); if (node->getBody()) node->getBody()->traverse(this); builder.createBranch(&blocks.continue_target); breakForLoop.pop(); builder.setBuildPoint(&blocks.continue_target); if (node->getTerminal()) node->getTerminal()->traverse(this); if (node->getTest()) { node->getTest()->traverse(this); spv::Id condition = accessChainLoad(node->getTest()->getType()); builder.createConditionalBranch(condition, &blocks.head, &blocks.merge); } else { // TODO: unless there was a break/return/discard instruction // somewhere in the body, this is an infinite loop, so we should // issue a warning. builder.createBranch(&blocks.head); } } builder.setBuildPoint(&blocks.merge); builder.closeLoop(); return false; } bool TGlslangToSpvTraverser::visitBranch(glslang::TVisit /* visit */, glslang::TIntermBranch* node) { if (node->getExpression()) node->getExpression()->traverse(this); builder.setLine(node->getLoc().line, node->getLoc().getFilename()); switch (node->getFlowOp()) { case glslang::EOpKill: builder.makeDiscard(); break; case glslang::EOpBreak: if (breakForLoop.top()) builder.createLoopExit(); else builder.addSwitchBreak(); break; case glslang::EOpContinue: builder.createLoopContinue(); break; case glslang::EOpReturn: if (node->getExpression()) { const glslang::TType& glslangReturnType = node->getExpression()->getType(); spv::Id returnId = accessChainLoad(glslangReturnType); if (builder.getTypeId(returnId) != currentFunction->getReturnType()) { builder.clearAccessChain(); spv::Id copyId = builder.createVariable(spv::StorageClassFunction, currentFunction->getReturnType()); builder.setAccessChainLValue(copyId); multiTypeStore(glslangReturnType, returnId); returnId = builder.createLoad(copyId); } builder.makeReturn(false, returnId); } else builder.makeReturn(false); builder.clearAccessChain(); break; #ifndef GLSLANG_WEB case glslang::EOpDemote: builder.createNoResultOp(spv::OpDemoteToHelperInvocationEXT); builder.addExtension(spv::E_SPV_EXT_demote_to_helper_invocation); builder.addCapability(spv::CapabilityDemoteToHelperInvocationEXT); break; #endif default: assert(0); break; } return false; } spv::Id TGlslangToSpvTraverser::createSpvVariable(const glslang::TIntermSymbol* node, spv::Id forcedType) { // First, steer off constants, which are not SPIR-V variables, but // can still have a mapping to a SPIR-V Id. // This includes specialization constants. if (node->getQualifier().isConstant()) { spv::Id result = createSpvConstant(*node); if (result != spv::NoResult) return result; } // Now, handle actual variables spv::StorageClass storageClass = TranslateStorageClass(node->getType()); spv::Id spvType = forcedType == spv::NoType ? convertGlslangToSpvType(node->getType()) : forcedType; const bool contains16BitType = node->getType().contains16BitFloat() || node->getType().contains16BitInt(); if (contains16BitType) { switch (storageClass) { case spv::StorageClassInput: case spv::StorageClassOutput: builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3); builder.addCapability(spv::CapabilityStorageInputOutput16); break; case spv::StorageClassUniform: builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3); if (node->getType().getQualifier().storage == glslang::EvqBuffer) builder.addCapability(spv::CapabilityStorageUniformBufferBlock16); else builder.addCapability(spv::CapabilityStorageUniform16); break; #ifndef GLSLANG_WEB case spv::StorageClassPushConstant: builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3); builder.addCapability(spv::CapabilityStoragePushConstant16); break; case spv::StorageClassStorageBuffer: case spv::StorageClassPhysicalStorageBufferEXT: builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3); builder.addCapability(spv::CapabilityStorageUniformBufferBlock16); break; #endif default: if (node->getType().contains16BitFloat()) builder.addCapability(spv::CapabilityFloat16); if (node->getType().contains16BitInt()) builder.addCapability(spv::CapabilityInt16); break; } } if (node->getType().contains8BitInt()) { if (storageClass == spv::StorageClassPushConstant) { builder.addIncorporatedExtension(spv::E_SPV_KHR_8bit_storage, spv::Spv_1_5); builder.addCapability(spv::CapabilityStoragePushConstant8); } else if (storageClass == spv::StorageClassUniform) { builder.addIncorporatedExtension(spv::E_SPV_KHR_8bit_storage, spv::Spv_1_5); builder.addCapability(spv::CapabilityUniformAndStorageBuffer8BitAccess); } else if (storageClass == spv::StorageClassStorageBuffer) { builder.addIncorporatedExtension(spv::E_SPV_KHR_8bit_storage, spv::Spv_1_5); builder.addCapability(spv::CapabilityStorageBuffer8BitAccess); } else { builder.addCapability(spv::CapabilityInt8); } } const char* name = node->getName().c_str(); if (glslang::IsAnonymous(name)) name = ""; return builder.createVariable(storageClass, spvType, name); } // Return type Id of the sampled type. spv::Id TGlslangToSpvTraverser::getSampledType(const glslang::TSampler& sampler) { switch (sampler.type) { case glslang::EbtInt: return builder.makeIntType(32); case glslang::EbtUint: return builder.makeUintType(32); case glslang::EbtFloat: return builder.makeFloatType(32); #ifndef GLSLANG_WEB case glslang::EbtFloat16: builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float_fetch); builder.addCapability(spv::CapabilityFloat16ImageAMD); return builder.makeFloatType(16); #endif default: assert(0); return builder.makeFloatType(32); } } // If node is a swizzle operation, return the type that should be used if // the swizzle base is first consumed by another operation, before the swizzle // is applied. spv::Id TGlslangToSpvTraverser::getInvertedSwizzleType(const glslang::TIntermTyped& node) { if (node.getAsOperator() && node.getAsOperator()->getOp() == glslang::EOpVectorSwizzle) return convertGlslangToSpvType(node.getAsBinaryNode()->getLeft()->getType()); else return spv::NoType; } // When inverting a swizzle with a parent op, this function // will apply the swizzle operation to a completed parent operation. spv::Id TGlslangToSpvTraverser::createInvertedSwizzle(spv::Decoration precision, const glslang::TIntermTyped& node, spv::Id parentResult) { std::vector swizzle; convertSwizzle(*node.getAsBinaryNode()->getRight()->getAsAggregate(), swizzle); return builder.createRvalueSwizzle(precision, convertGlslangToSpvType(node.getType()), parentResult, swizzle); } // Convert a glslang AST swizzle node to a swizzle vector for building SPIR-V. void TGlslangToSpvTraverser::convertSwizzle(const glslang::TIntermAggregate& node, std::vector& swizzle) { const glslang::TIntermSequence& swizzleSequence = node.getSequence(); for (int i = 0; i < (int)swizzleSequence.size(); ++i) swizzle.push_back(swizzleSequence[i]->getAsConstantUnion()->getConstArray()[0].getIConst()); } // Convert from a glslang type to an SPV type, by calling into a // recursive version of this function. This establishes the inherited // layout state rooted from the top-level type. spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& type, bool forwardReferenceOnly) { return convertGlslangToSpvType(type, getExplicitLayout(type), type.getQualifier(), false, forwardReferenceOnly); } // Do full recursive conversion of an arbitrary glslang type to a SPIR-V Id. // explicitLayout can be kept the same throughout the hierarchical recursive walk. // Mutually recursive with convertGlslangStructToSpvType(). spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& type, glslang::TLayoutPacking explicitLayout, const glslang::TQualifier& qualifier, bool lastBufferBlockMember, bool forwardReferenceOnly) { spv::Id spvType = spv::NoResult; switch (type.getBasicType()) { case glslang::EbtVoid: spvType = builder.makeVoidType(); assert (! type.isArray()); break; case glslang::EbtBool: // "transparent" bool doesn't exist in SPIR-V. The GLSL convention is // a 32-bit int where non-0 means true. if (explicitLayout != glslang::ElpNone) spvType = builder.makeUintType(32); else spvType = builder.makeBoolType(); break; case glslang::EbtInt: spvType = builder.makeIntType(32); break; case glslang::EbtUint: spvType = builder.makeUintType(32); break; case glslang::EbtFloat: spvType = builder.makeFloatType(32); break; #ifndef GLSLANG_WEB case glslang::EbtDouble: spvType = builder.makeFloatType(64); break; case glslang::EbtFloat16: spvType = builder.makeFloatType(16); break; case glslang::EbtInt8: spvType = builder.makeIntType(8); break; case glslang::EbtUint8: spvType = builder.makeUintType(8); break; case glslang::EbtInt16: spvType = builder.makeIntType(16); break; case glslang::EbtUint16: spvType = builder.makeUintType(16); break; case glslang::EbtInt64: spvType = builder.makeIntType(64); break; case glslang::EbtUint64: spvType = builder.makeUintType(64); break; case glslang::EbtAtomicUint: builder.addCapability(spv::CapabilityAtomicStorage); spvType = builder.makeUintType(32); break; case glslang::EbtAccStructNV: spvType = builder.makeAccelerationStructureNVType(); break; case glslang::EbtReference: { // Make the forward pointer, then recurse to convert the structure type, then // patch up the forward pointer with a real pointer type. if (forwardPointers.find(type.getReferentType()) == forwardPointers.end()) { spv::Id forwardId = builder.makeForwardPointer(spv::StorageClassPhysicalStorageBufferEXT); forwardPointers[type.getReferentType()] = forwardId; } spvType = forwardPointers[type.getReferentType()]; if (!forwardReferenceOnly) { spv::Id referentType = convertGlslangToSpvType(*type.getReferentType()); builder.makePointerFromForwardPointer(spv::StorageClassPhysicalStorageBufferEXT, forwardPointers[type.getReferentType()], referentType); } } break; #endif case glslang::EbtSampler: { const glslang::TSampler& sampler = type.getSampler(); if (sampler.isPureSampler()) { spvType = builder.makeSamplerType(); } else { // an image is present, make its type spvType = builder.makeImageType(getSampledType(sampler), TranslateDimensionality(sampler), sampler.isShadow(), sampler.isArrayed(), sampler.isMultiSample(), sampler.isImageClass() ? 2 : 1, TranslateImageFormat(type)); if (sampler.isCombined()) { // already has both image and sampler, make the combined type spvType = builder.makeSampledImageType(spvType); } } } break; case glslang::EbtStruct: case glslang::EbtBlock: { // If we've seen this struct type, return it const glslang::TTypeList* glslangMembers = type.getStruct(); // Try to share structs for different layouts, but not yet for other // kinds of qualification (primarily not yet including interpolant qualification). if (! HasNonLayoutQualifiers(type, qualifier)) spvType = structMap[explicitLayout][qualifier.layoutMatrix][glslangMembers]; if (spvType != spv::NoResult) break; // else, we haven't seen it... if (type.getBasicType() == glslang::EbtBlock) memberRemapper[glslangMembers].resize(glslangMembers->size()); spvType = convertGlslangStructToSpvType(type, glslangMembers, explicitLayout, qualifier); } break; default: assert(0); break; } if (type.isMatrix()) spvType = builder.makeMatrixType(spvType, type.getMatrixCols(), type.getMatrixRows()); else { // If this variable has a vector element count greater than 1, create a SPIR-V vector if (type.getVectorSize() > 1) spvType = builder.makeVectorType(spvType, type.getVectorSize()); } if (type.isCoopMat()) { builder.addCapability(spv::CapabilityCooperativeMatrixNV); builder.addExtension(spv::E_SPV_NV_cooperative_matrix); if (type.getBasicType() == glslang::EbtFloat16) builder.addCapability(spv::CapabilityFloat16); if (type.getBasicType() == glslang::EbtUint8 || type.getBasicType() == glslang::EbtInt8) { builder.addCapability(spv::CapabilityInt8); } spv::Id scope = makeArraySizeId(*type.getTypeParameters(), 1); spv::Id rows = makeArraySizeId(*type.getTypeParameters(), 2); spv::Id cols = makeArraySizeId(*type.getTypeParameters(), 3); spvType = builder.makeCooperativeMatrixType(spvType, scope, rows, cols); } if (type.isArray()) { int stride = 0; // keep this 0 unless doing an explicit layout; 0 will mean no decoration, no stride // Do all but the outer dimension if (type.getArraySizes()->getNumDims() > 1) { // We need to decorate array strides for types needing explicit layout, except blocks. if (explicitLayout != glslang::ElpNone && type.getBasicType() != glslang::EbtBlock) { // Use a dummy glslang type for querying internal strides of // arrays of arrays, but using just a one-dimensional array. glslang::TType simpleArrayType(type, 0); // deference type of the array while (simpleArrayType.getArraySizes()->getNumDims() > 1) simpleArrayType.getArraySizes()->dereference(); // Will compute the higher-order strides here, rather than making a whole // pile of types and doing repetitive recursion on their contents. stride = getArrayStride(simpleArrayType, explicitLayout, qualifier.layoutMatrix); } // make the arrays for (int dim = type.getArraySizes()->getNumDims() - 1; dim > 0; --dim) { spvType = builder.makeArrayType(spvType, makeArraySizeId(*type.getArraySizes(), dim), stride); if (stride > 0) builder.addDecoration(spvType, spv::DecorationArrayStride, stride); stride *= type.getArraySizes()->getDimSize(dim); } } else { // single-dimensional array, and don't yet have stride // We need to decorate array strides for types needing explicit layout, except blocks. if (explicitLayout != glslang::ElpNone && type.getBasicType() != glslang::EbtBlock) stride = getArrayStride(type, explicitLayout, qualifier.layoutMatrix); } // Do the outer dimension, which might not be known for a runtime-sized array. // (Unsized arrays that survive through linking will be runtime-sized arrays) if (type.isSizedArray()) spvType = builder.makeArrayType(spvType, makeArraySizeId(*type.getArraySizes(), 0), stride); else { #ifndef GLSLANG_WEB if (!lastBufferBlockMember) { builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5); builder.addCapability(spv::CapabilityRuntimeDescriptorArrayEXT); } #endif spvType = builder.makeRuntimeArray(spvType); } if (stride > 0) builder.addDecoration(spvType, spv::DecorationArrayStride, stride); } return spvType; } // TODO: this functionality should exist at a higher level, in creating the AST // // Identify interface members that don't have their required extension turned on. // bool TGlslangToSpvTraverser::filterMember(const glslang::TType& member) { #ifndef GLSLANG_WEB auto& extensions = glslangIntermediate->getRequestedExtensions(); if (member.getFieldName() == "gl_SecondaryViewportMaskNV" && extensions.find("GL_NV_stereo_view_rendering") == extensions.end()) return true; if (member.getFieldName() == "gl_SecondaryPositionNV" && extensions.find("GL_NV_stereo_view_rendering") == extensions.end()) return true; if (glslangIntermediate->getStage() != EShLangMeshNV) { if (member.getFieldName() == "gl_ViewportMask" && extensions.find("GL_NV_viewport_array2") == extensions.end()) return true; if (member.getFieldName() == "gl_PositionPerViewNV" && extensions.find("GL_NVX_multiview_per_view_attributes") == extensions.end()) return true; if (member.getFieldName() == "gl_ViewportMaskPerViewNV" && extensions.find("GL_NVX_multiview_per_view_attributes") == extensions.end()) return true; } #endif return false; }; // Do full recursive conversion of a glslang structure (or block) type to a SPIR-V Id. // explicitLayout can be kept the same throughout the hierarchical recursive walk. // Mutually recursive with convertGlslangToSpvType(). spv::Id TGlslangToSpvTraverser::convertGlslangStructToSpvType(const glslang::TType& type, const glslang::TTypeList* glslangMembers, glslang::TLayoutPacking explicitLayout, const glslang::TQualifier& qualifier) { // Create a vector of struct types for SPIR-V to consume std::vector spvMembers; int memberDelta = 0; // how much the member's index changes from glslang to SPIR-V, normally 0, except sometimes for blocks std::vector > deferredForwardPointers; for (int i = 0; i < (int)glslangMembers->size(); i++) { glslang::TType& glslangMember = *(*glslangMembers)[i].type; if (glslangMember.hiddenMember()) { ++memberDelta; if (type.getBasicType() == glslang::EbtBlock) memberRemapper[glslangMembers][i] = -1; } else { if (type.getBasicType() == glslang::EbtBlock) { if (filterMember(glslangMember)) { memberDelta++; memberRemapper[glslangMembers][i] = -1; continue; } memberRemapper[glslangMembers][i] = i - memberDelta; } // modify just this child's view of the qualifier glslang::TQualifier memberQualifier = glslangMember.getQualifier(); InheritQualifiers(memberQualifier, qualifier); // manually inherit location if (! memberQualifier.hasLocation() && qualifier.hasLocation()) memberQualifier.layoutLocation = qualifier.layoutLocation; // recurse bool lastBufferBlockMember = qualifier.storage == glslang::EvqBuffer && i == (int)glslangMembers->size() - 1; // Make forward pointers for any pointer members, and create a list of members to // convert to spirv types after creating the struct. if (glslangMember.isReference()) { if (forwardPointers.find(glslangMember.getReferentType()) == forwardPointers.end()) { deferredForwardPointers.push_back(std::make_pair(&glslangMember, memberQualifier)); } spvMembers.push_back( convertGlslangToSpvType(glslangMember, explicitLayout, memberQualifier, lastBufferBlockMember, true)); } else { spvMembers.push_back( convertGlslangToSpvType(glslangMember, explicitLayout, memberQualifier, lastBufferBlockMember, false)); } } } // Make the SPIR-V type spv::Id spvType = builder.makeStructType(spvMembers, type.getTypeName().c_str()); if (! HasNonLayoutQualifiers(type, qualifier)) structMap[explicitLayout][qualifier.layoutMatrix][glslangMembers] = spvType; // Decorate it decorateStructType(type, glslangMembers, explicitLayout, qualifier, spvType); for (int i = 0; i < (int)deferredForwardPointers.size(); ++i) { auto it = deferredForwardPointers[i]; convertGlslangToSpvType(*it.first, explicitLayout, it.second, false); } return spvType; } void TGlslangToSpvTraverser::decorateStructType(const glslang::TType& type, const glslang::TTypeList* glslangMembers, glslang::TLayoutPacking explicitLayout, const glslang::TQualifier& qualifier, spv::Id spvType) { // Name and decorate the non-hidden members int offset = -1; int locationOffset = 0; // for use within the members of this struct for (int i = 0; i < (int)glslangMembers->size(); i++) { glslang::TType& glslangMember = *(*glslangMembers)[i].type; int member = i; if (type.getBasicType() == glslang::EbtBlock) { member = memberRemapper[glslangMembers][i]; if (filterMember(glslangMember)) continue; } // modify just this child's view of the qualifier glslang::TQualifier memberQualifier = glslangMember.getQualifier(); InheritQualifiers(memberQualifier, qualifier); // using -1 above to indicate a hidden member if (member < 0) continue; builder.addMemberName(spvType, member, glslangMember.getFieldName().c_str()); builder.addMemberDecoration(spvType, member, TranslateLayoutDecoration(glslangMember, memberQualifier.layoutMatrix)); builder.addMemberDecoration(spvType, member, TranslatePrecisionDecoration(glslangMember)); // Add interpolation and auxiliary storage decorations only to // top-level members of Input and Output storage classes if (type.getQualifier().storage == glslang::EvqVaryingIn || type.getQualifier().storage == glslang::EvqVaryingOut) { if (type.getBasicType() == glslang::EbtBlock || glslangIntermediate->getSource() == glslang::EShSourceHlsl) { builder.addMemberDecoration(spvType, member, TranslateInterpolationDecoration(memberQualifier)); builder.addMemberDecoration(spvType, member, TranslateAuxiliaryStorageDecoration(memberQualifier)); #ifndef GLSLANG_WEB addMeshNVDecoration(spvType, member, memberQualifier); #endif } } builder.addMemberDecoration(spvType, member, TranslateInvariantDecoration(memberQualifier)); #ifndef GLSLANG_WEB if (type.getBasicType() == glslang::EbtBlock && qualifier.storage == glslang::EvqBuffer) { // Add memory decorations only to top-level members of shader storage block std::vector memory; TranslateMemoryDecoration(memberQualifier, memory, glslangIntermediate->usingVulkanMemoryModel()); for (unsigned int i = 0; i < memory.size(); ++i) builder.addMemberDecoration(spvType, member, memory[i]); } #endif // Location assignment was already completed correctly by the front end, // just track whether a member needs to be decorated. // Ignore member locations if the container is an array, as that's // ill-specified and decisions have been made to not allow this. if (! type.isArray() && memberQualifier.hasLocation()) builder.addMemberDecoration(spvType, member, spv::DecorationLocation, memberQualifier.layoutLocation); if (qualifier.hasLocation()) // track for upcoming inheritance locationOffset += glslangIntermediate->computeTypeLocationSize( glslangMember, glslangIntermediate->getStage()); // component, XFB, others if (glslangMember.getQualifier().hasComponent()) builder.addMemberDecoration(spvType, member, spv::DecorationComponent, glslangMember.getQualifier().layoutComponent); if (glslangMember.getQualifier().hasXfbOffset()) builder.addMemberDecoration(spvType, member, spv::DecorationOffset, glslangMember.getQualifier().layoutXfbOffset); else if (explicitLayout != glslang::ElpNone) { // figure out what to do with offset, which is accumulating int nextOffset; updateMemberOffset(type, glslangMember, offset, nextOffset, explicitLayout, memberQualifier.layoutMatrix); if (offset >= 0) builder.addMemberDecoration(spvType, member, spv::DecorationOffset, offset); offset = nextOffset; } if (glslangMember.isMatrix() && explicitLayout != glslang::ElpNone) builder.addMemberDecoration(spvType, member, spv::DecorationMatrixStride, getMatrixStride(glslangMember, explicitLayout, memberQualifier.layoutMatrix)); // built-in variable decorations spv::BuiltIn builtIn = TranslateBuiltInDecoration(glslangMember.getQualifier().builtIn, true); if (builtIn != spv::BuiltInMax) builder.addMemberDecoration(spvType, member, spv::DecorationBuiltIn, (int)builtIn); #ifndef GLSLANG_WEB // nonuniform builder.addMemberDecoration(spvType, member, TranslateNonUniformDecoration(glslangMember.getQualifier())); if (glslangIntermediate->getHlslFunctionality1() && memberQualifier.semanticName != nullptr) { builder.addExtension("SPV_GOOGLE_hlsl_functionality1"); builder.addMemberDecoration(spvType, member, (spv::Decoration)spv::DecorationHlslSemanticGOOGLE, memberQualifier.semanticName); } if (builtIn == spv::BuiltInLayer) { // SPV_NV_viewport_array2 extension if (glslangMember.getQualifier().layoutViewportRelative){ builder.addMemberDecoration(spvType, member, (spv::Decoration)spv::DecorationViewportRelativeNV); builder.addCapability(spv::CapabilityShaderViewportMaskNV); builder.addExtension(spv::E_SPV_NV_viewport_array2); } if (glslangMember.getQualifier().layoutSecondaryViewportRelativeOffset != -2048){ builder.addMemberDecoration(spvType, member, (spv::Decoration)spv::DecorationSecondaryViewportRelativeNV, glslangMember.getQualifier().layoutSecondaryViewportRelativeOffset); builder.addCapability(spv::CapabilityShaderStereoViewNV); builder.addExtension(spv::E_SPV_NV_stereo_view_rendering); } } if (glslangMember.getQualifier().layoutPassthrough) { builder.addMemberDecoration(spvType, member, (spv::Decoration)spv::DecorationPassthroughNV); builder.addCapability(spv::CapabilityGeometryShaderPassthroughNV); builder.addExtension(spv::E_SPV_NV_geometry_shader_passthrough); } #endif } // Decorate the structure builder.addDecoration(spvType, TranslateLayoutDecoration(type, qualifier.layoutMatrix)); builder.addDecoration(spvType, TranslateBlockDecoration(type, glslangIntermediate->usingStorageBuffer())); } // Turn the expression forming the array size into an id. // This is not quite trivial, because of specialization constants. // Sometimes, a raw constant is turned into an Id, and sometimes // a specialization constant expression is. spv::Id TGlslangToSpvTraverser::makeArraySizeId(const glslang::TArraySizes& arraySizes, int dim) { // First, see if this is sized with a node, meaning a specialization constant: glslang::TIntermTyped* specNode = arraySizes.getDimNode(dim); if (specNode != nullptr) { builder.clearAccessChain(); specNode->traverse(this); return accessChainLoad(specNode->getAsTyped()->getType()); } // Otherwise, need a compile-time (front end) size, get it: int size = arraySizes.getDimSize(dim); assert(size > 0); return builder.makeUintConstant(size); } // Wrap the builder's accessChainLoad to: // - localize handling of RelaxedPrecision // - use the SPIR-V inferred type instead of another conversion of the glslang type // (avoids unnecessary work and possible type punning for structures) // - do conversion of concrete to abstract type spv::Id TGlslangToSpvTraverser::accessChainLoad(const glslang::TType& type) { spv::Id nominalTypeId = builder.accessChainGetInferredType(); spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags; coherentFlags |= TranslateCoherent(type); unsigned int alignment = builder.getAccessChain().alignment; alignment |= type.getBufferReferenceAlignment(); spv::Id loadedId = builder.accessChainLoad(TranslatePrecisionDecoration(type), TranslateNonUniformDecoration(type.getQualifier()), nominalTypeId, spv::MemoryAccessMask(TranslateMemoryAccess(coherentFlags) & ~spv::MemoryAccessMakePointerAvailableKHRMask), TranslateMemoryScope(coherentFlags), alignment); // Need to convert to abstract types when necessary if (type.getBasicType() == glslang::EbtBool) { if (builder.isScalarType(nominalTypeId)) { // Conversion for bool spv::Id boolType = builder.makeBoolType(); if (nominalTypeId != boolType) loadedId = builder.createBinOp(spv::OpINotEqual, boolType, loadedId, builder.makeUintConstant(0)); } else if (builder.isVectorType(nominalTypeId)) { // Conversion for bvec int vecSize = builder.getNumTypeComponents(nominalTypeId); spv::Id bvecType = builder.makeVectorType(builder.makeBoolType(), vecSize); if (nominalTypeId != bvecType) loadedId = builder.createBinOp(spv::OpINotEqual, bvecType, loadedId, makeSmearedConstant(builder.makeUintConstant(0), vecSize)); } } return loadedId; } // Wrap the builder's accessChainStore to: // - do conversion of concrete to abstract type // // Implicitly uses the existing builder.accessChain as the storage target. void TGlslangToSpvTraverser::accessChainStore(const glslang::TType& type, spv::Id rvalue) { // Need to convert to abstract types when necessary if (type.getBasicType() == glslang::EbtBool) { spv::Id nominalTypeId = builder.accessChainGetInferredType(); if (builder.isScalarType(nominalTypeId)) { // Conversion for bool spv::Id boolType = builder.makeBoolType(); if (nominalTypeId != boolType) { // keep these outside arguments, for determinant order-of-evaluation spv::Id one = builder.makeUintConstant(1); spv::Id zero = builder.makeUintConstant(0); rvalue = builder.createTriOp(spv::OpSelect, nominalTypeId, rvalue, one, zero); } else if (builder.getTypeId(rvalue) != boolType) rvalue = builder.createBinOp(spv::OpINotEqual, boolType, rvalue, builder.makeUintConstant(0)); } else if (builder.isVectorType(nominalTypeId)) { // Conversion for bvec int vecSize = builder.getNumTypeComponents(nominalTypeId); spv::Id bvecType = builder.makeVectorType(builder.makeBoolType(), vecSize); if (nominalTypeId != bvecType) { // keep these outside arguments, for determinant order-of-evaluation spv::Id one = makeSmearedConstant(builder.makeUintConstant(1), vecSize); spv::Id zero = makeSmearedConstant(builder.makeUintConstant(0), vecSize); rvalue = builder.createTriOp(spv::OpSelect, nominalTypeId, rvalue, one, zero); } else if (builder.getTypeId(rvalue) != bvecType) rvalue = builder.createBinOp(spv::OpINotEqual, bvecType, rvalue, makeSmearedConstant(builder.makeUintConstant(0), vecSize)); } } spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags; coherentFlags |= TranslateCoherent(type); unsigned int alignment = builder.getAccessChain().alignment; alignment |= type.getBufferReferenceAlignment(); builder.accessChainStore(rvalue, spv::MemoryAccessMask(TranslateMemoryAccess(coherentFlags) & ~spv::MemoryAccessMakePointerVisibleKHRMask), TranslateMemoryScope(coherentFlags), alignment); } // For storing when types match at the glslang level, but not might match at the // SPIR-V level. // // This especially happens when a single glslang type expands to multiple // SPIR-V types, like a struct that is used in a member-undecorated way as well // as in a member-decorated way. // // NOTE: This function can handle any store request; if it's not special it // simplifies to a simple OpStore. // // Implicitly uses the existing builder.accessChain as the storage target. void TGlslangToSpvTraverser::multiTypeStore(const glslang::TType& type, spv::Id rValue) { // we only do the complex path here if it's an aggregate if (! type.isStruct() && ! type.isArray()) { accessChainStore(type, rValue); return; } // and, it has to be a case of type aliasing spv::Id rType = builder.getTypeId(rValue); spv::Id lValue = builder.accessChainGetLValue(); spv::Id lType = builder.getContainedTypeId(builder.getTypeId(lValue)); if (lType == rType) { accessChainStore(type, rValue); return; } // Recursively (as needed) copy an aggregate type to a different aggregate type, // where the two types were the same type in GLSL. This requires member // by member copy, recursively. // SPIR-V 1.4 added an instruction to do help do this. if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4) { // However, bool in uniform space is changed to int, so // OpCopyLogical does not work for that. // TODO: It would be more robust to do a full recursive verification of the types satisfying SPIR-V rules. bool rBool = builder.containsType(builder.getTypeId(rValue), spv::OpTypeBool, 0); bool lBool = builder.containsType(lType, spv::OpTypeBool, 0); if (lBool == rBool) { spv::Id logicalCopy = builder.createUnaryOp(spv::OpCopyLogical, lType, rValue); accessChainStore(type, logicalCopy); return; } } // If an array, copy element by element. if (type.isArray()) { glslang::TType glslangElementType(type, 0); spv::Id elementRType = builder.getContainedTypeId(rType); for (int index = 0; index < type.getOuterArraySize(); ++index) { // get the source member spv::Id elementRValue = builder.createCompositeExtract(rValue, elementRType, index); // set up the target storage builder.clearAccessChain(); builder.setAccessChainLValue(lValue); builder.accessChainPush(builder.makeIntConstant(index), TranslateCoherent(type), type.getBufferReferenceAlignment()); // store the member multiTypeStore(glslangElementType, elementRValue); } } else { assert(type.isStruct()); // loop over structure members const glslang::TTypeList& members = *type.getStruct(); for (int m = 0; m < (int)members.size(); ++m) { const glslang::TType& glslangMemberType = *members[m].type; // get the source member spv::Id memberRType = builder.getContainedTypeId(rType, m); spv::Id memberRValue = builder.createCompositeExtract(rValue, memberRType, m); // set up the target storage builder.clearAccessChain(); builder.setAccessChainLValue(lValue); builder.accessChainPush(builder.makeIntConstant(m), TranslateCoherent(type), type.getBufferReferenceAlignment()); // store the member multiTypeStore(glslangMemberType, memberRValue); } } } // Decide whether or not this type should be // decorated with offsets and strides, and if so // whether std140 or std430 rules should be applied. glslang::TLayoutPacking TGlslangToSpvTraverser::getExplicitLayout(const glslang::TType& type) const { // has to be a block if (type.getBasicType() != glslang::EbtBlock) return glslang::ElpNone; // has to be a uniform or buffer block or task in/out blocks if (type.getQualifier().storage != glslang::EvqUniform && type.getQualifier().storage != glslang::EvqBuffer && !type.getQualifier().isTaskMemory()) return glslang::ElpNone; // return the layout to use switch (type.getQualifier().layoutPacking) { case glslang::ElpStd140: case glslang::ElpStd430: case glslang::ElpScalar: return type.getQualifier().layoutPacking; default: return glslang::ElpNone; } } // Given an array type, returns the integer stride required for that array int TGlslangToSpvTraverser::getArrayStride(const glslang::TType& arrayType, glslang::TLayoutPacking explicitLayout, glslang::TLayoutMatrix matrixLayout) { int size; int stride; glslangIntermediate->getMemberAlignment(arrayType, size, stride, explicitLayout, matrixLayout == glslang::ElmRowMajor); return stride; } // Given a matrix type, or array (of array) of matrixes type, returns the integer stride required for that matrix // when used as a member of an interface block int TGlslangToSpvTraverser::getMatrixStride(const glslang::TType& matrixType, glslang::TLayoutPacking explicitLayout, glslang::TLayoutMatrix matrixLayout) { glslang::TType elementType; elementType.shallowCopy(matrixType); elementType.clearArraySizes(); int size; int stride; glslangIntermediate->getMemberAlignment(elementType, size, stride, explicitLayout, matrixLayout == glslang::ElmRowMajor); return stride; } // Given a member type of a struct, realign the current offset for it, and compute // the next (not yet aligned) offset for the next member, which will get aligned // on the next call. // 'currentOffset' should be passed in already initialized, ready to modify, and reflecting // the migration of data from nextOffset -> currentOffset. It should be -1 on the first call. // -1 means a non-forced member offset (no decoration needed). void TGlslangToSpvTraverser::updateMemberOffset(const glslang::TType& structType, const glslang::TType& memberType, int& currentOffset, int& nextOffset, glslang::TLayoutPacking explicitLayout, glslang::TLayoutMatrix matrixLayout) { // this will get a positive value when deemed necessary nextOffset = -1; // override anything in currentOffset with user-set offset if (memberType.getQualifier().hasOffset()) currentOffset = memberType.getQualifier().layoutOffset; // It could be that current linker usage in glslang updated all the layoutOffset, // in which case the following code does not matter. But, that's not quite right // once cross-compilation unit GLSL validation is done, as the original user // settings are needed in layoutOffset, and then the following will come into play. if (explicitLayout == glslang::ElpNone) { if (! memberType.getQualifier().hasOffset()) currentOffset = -1; return; } // Getting this far means we need explicit offsets if (currentOffset < 0) currentOffset = 0; // Now, currentOffset is valid (either 0, or from a previous nextOffset), // but possibly not yet correctly aligned. int memberSize; int dummyStride; int memberAlignment = glslangIntermediate->getMemberAlignment(memberType, memberSize, dummyStride, explicitLayout, matrixLayout == glslang::ElmRowMajor); // Adjust alignment for HLSL rules // TODO: make this consistent in early phases of code: // adjusting this late means inconsistencies with earlier code, which for reflection is an issue // Until reflection is brought in sync with these adjustments, don't apply to $Global, // which is the most likely to rely on reflection, and least likely to rely implicit layouts if (glslangIntermediate->usingHlslOffsets() && ! memberType.isArray() && memberType.isVector() && structType.getTypeName().compare("$Global") != 0) { int dummySize; int componentAlignment = glslangIntermediate->getBaseAlignmentScalar(memberType, dummySize); if (componentAlignment <= 4) memberAlignment = componentAlignment; } // Bump up to member alignment glslang::RoundToPow2(currentOffset, memberAlignment); // Bump up to vec4 if there is a bad straddle if (explicitLayout != glslang::ElpScalar && glslangIntermediate->improperStraddle(memberType, memberSize, currentOffset)) glslang::RoundToPow2(currentOffset, 16); nextOffset = currentOffset + memberSize; } void TGlslangToSpvTraverser::declareUseOfStructMember(const glslang::TTypeList& members, int glslangMember) { const glslang::TBuiltInVariable glslangBuiltIn = members[glslangMember].type->getQualifier().builtIn; switch (glslangBuiltIn) { case glslang::EbvPointSize: #ifndef GLSLANG_WEB case glslang::EbvClipDistance: case glslang::EbvCullDistance: case glslang::EbvViewportMaskNV: case glslang::EbvSecondaryPositionNV: case glslang::EbvSecondaryViewportMaskNV: case glslang::EbvPositionPerViewNV: case glslang::EbvViewportMaskPerViewNV: case glslang::EbvTaskCountNV: case glslang::EbvPrimitiveCountNV: case glslang::EbvPrimitiveIndicesNV: case glslang::EbvClipDistancePerViewNV: case glslang::EbvCullDistancePerViewNV: case glslang::EbvLayerPerViewNV: case glslang::EbvMeshViewCountNV: case glslang::EbvMeshViewIndicesNV: #endif // Generate the associated capability. Delegate to TranslateBuiltInDecoration. // Alternately, we could just call this for any glslang built-in, since the // capability already guards against duplicates. TranslateBuiltInDecoration(glslangBuiltIn, false); break; default: // Capabilities were already generated when the struct was declared. break; } } bool TGlslangToSpvTraverser::isShaderEntryPoint(const glslang::TIntermAggregate* node) { return node->getName().compare(glslangIntermediate->getEntryPointMangledName().c_str()) == 0; } // Does parameter need a place to keep writes, separate from the original? // Assumes called after originalParam(), which filters out block/buffer/opaque-based // qualifiers such that we should have only in/out/inout/constreadonly here. bool TGlslangToSpvTraverser::writableParam(glslang::TStorageQualifier qualifier) const { assert(qualifier == glslang::EvqIn || qualifier == glslang::EvqOut || qualifier == glslang::EvqInOut || qualifier == glslang::EvqConstReadOnly); return qualifier != glslang::EvqConstReadOnly; } // Is parameter pass-by-original? bool TGlslangToSpvTraverser::originalParam(glslang::TStorageQualifier qualifier, const glslang::TType& paramType, bool implicitThisParam) { if (implicitThisParam) // implicit this return true; if (glslangIntermediate->getSource() == glslang::EShSourceHlsl) return paramType.getBasicType() == glslang::EbtBlock; return paramType.containsOpaque() || // sampler, etc. (paramType.getBasicType() == glslang::EbtBlock && qualifier == glslang::EvqBuffer); // SSBO } // Make all the functions, skeletally, without actually visiting their bodies. void TGlslangToSpvTraverser::makeFunctions(const glslang::TIntermSequence& glslFunctions) { const auto getParamDecorations = [&](std::vector& decorations, const glslang::TType& type, bool useVulkanMemoryModel) { spv::Decoration paramPrecision = TranslatePrecisionDecoration(type); if (paramPrecision != spv::NoPrecision) decorations.push_back(paramPrecision); TranslateMemoryDecoration(type.getQualifier(), decorations, useVulkanMemoryModel); if (type.isReference()) { // Original and non-writable params pass the pointer directly and // use restrict/aliased, others are stored to a pointer in Function // memory and use RestrictPointer/AliasedPointer. if (originalParam(type.getQualifier().storage, type, false) || !writableParam(type.getQualifier().storage)) { decorations.push_back(type.getQualifier().isRestrict() ? spv::DecorationRestrict : spv::DecorationAliased); } else { decorations.push_back(type.getQualifier().isRestrict() ? spv::DecorationRestrictPointerEXT : spv::DecorationAliasedPointerEXT); } } }; for (int f = 0; f < (int)glslFunctions.size(); ++f) { glslang::TIntermAggregate* glslFunction = glslFunctions[f]->getAsAggregate(); if (! glslFunction || glslFunction->getOp() != glslang::EOpFunction || isShaderEntryPoint(glslFunction)) continue; // We're on a user function. Set up the basic interface for the function now, // so that it's available to call. Translating the body will happen later. // // Typically (except for a "const in" parameter), an address will be passed to the // function. What it is an address of varies: // // - "in" parameters not marked as "const" can be written to without modifying the calling // argument so that write needs to be to a copy, hence the address of a copy works. // // - "const in" parameters can just be the r-value, as no writes need occur. // // - "out" and "inout" arguments can't be done as pointers to the calling argument, because // GLSL has copy-in/copy-out semantics. They can be handled though with a pointer to a copy. std::vector paramTypes; std::vector> paramDecorations; // list of decorations per parameter glslang::TIntermSequence& parameters = glslFunction->getSequence()[0]->getAsAggregate()->getSequence(); #ifdef ENABLE_HLSL bool implicitThis = (int)parameters.size() > 0 && parameters[0]->getAsSymbolNode()->getName() == glslangIntermediate->implicitThisName; #else bool implicitThis = false; #endif paramDecorations.resize(parameters.size()); for (int p = 0; p < (int)parameters.size(); ++p) { const glslang::TType& paramType = parameters[p]->getAsTyped()->getType(); spv::Id typeId = convertGlslangToSpvType(paramType); if (originalParam(paramType.getQualifier().storage, paramType, implicitThis && p == 0)) typeId = builder.makePointer(TranslateStorageClass(paramType), typeId); else if (writableParam(paramType.getQualifier().storage)) typeId = builder.makePointer(spv::StorageClassFunction, typeId); else rValueParameters.insert(parameters[p]->getAsSymbolNode()->getId()); getParamDecorations(paramDecorations[p], paramType, glslangIntermediate->usingVulkanMemoryModel()); paramTypes.push_back(typeId); } spv::Block* functionBlock; spv::Function *function = builder.makeFunctionEntry(TranslatePrecisionDecoration(glslFunction->getType()), convertGlslangToSpvType(glslFunction->getType()), glslFunction->getName().c_str(), paramTypes, paramDecorations, &functionBlock); if (implicitThis) function->setImplicitThis(); // Track function to emit/call later functionMap[glslFunction->getName().c_str()] = function; // Set the parameter id's for (int p = 0; p < (int)parameters.size(); ++p) { symbolValues[parameters[p]->getAsSymbolNode()->getId()] = function->getParamId(p); // give a name too builder.addName(function->getParamId(p), parameters[p]->getAsSymbolNode()->getName().c_str()); const glslang::TType& paramType = parameters[p]->getAsTyped()->getType(); if (paramType.contains8BitInt()) builder.addCapability(spv::CapabilityInt8); if (paramType.contains16BitInt()) builder.addCapability(spv::CapabilityInt16); if (paramType.contains16BitFloat()) builder.addCapability(spv::CapabilityFloat16); } } } // Process all the initializers, while skipping the functions and link objects void TGlslangToSpvTraverser::makeGlobalInitializers(const glslang::TIntermSequence& initializers) { builder.setBuildPoint(shaderEntry->getLastBlock()); for (int i = 0; i < (int)initializers.size(); ++i) { glslang::TIntermAggregate* initializer = initializers[i]->getAsAggregate(); if (initializer && initializer->getOp() != glslang::EOpFunction && initializer->getOp() != glslang::EOpLinkerObjects) { // We're on a top-level node that's not a function. Treat as an initializer, whose // code goes into the beginning of the entry point. initializer->traverse(this); } } } // Process all the functions, while skipping initializers. void TGlslangToSpvTraverser::visitFunctions(const glslang::TIntermSequence& glslFunctions) { for (int f = 0; f < (int)glslFunctions.size(); ++f) { glslang::TIntermAggregate* node = glslFunctions[f]->getAsAggregate(); if (node && (node->getOp() == glslang::EOpFunction || node->getOp() == glslang::EOpLinkerObjects)) node->traverse(this); } } void TGlslangToSpvTraverser::handleFunctionEntry(const glslang::TIntermAggregate* node) { // SPIR-V functions should already be in the functionMap from the prepass // that called makeFunctions(). currentFunction = functionMap[node->getName().c_str()]; spv::Block* functionBlock = currentFunction->getEntryBlock(); builder.setBuildPoint(functionBlock); } void TGlslangToSpvTraverser::translateArguments(const glslang::TIntermAggregate& node, std::vector& arguments, spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags) { const glslang::TIntermSequence& glslangArguments = node.getSequence(); glslang::TSampler sampler = {}; bool cubeCompare = false; #ifndef GLSLANG_WEB bool f16ShadowCompare = false; #endif if (node.isTexture() || node.isImage()) { sampler = glslangArguments[0]->getAsTyped()->getType().getSampler(); cubeCompare = sampler.dim == glslang::EsdCube && sampler.arrayed && sampler.shadow; #ifndef GLSLANG_WEB f16ShadowCompare = sampler.shadow && glslangArguments[1]->getAsTyped()->getType().getBasicType() == glslang::EbtFloat16; #endif } for (int i = 0; i < (int)glslangArguments.size(); ++i) { builder.clearAccessChain(); glslangArguments[i]->traverse(this); #ifndef GLSLANG_WEB // Special case l-value operands bool lvalue = false; switch (node.getOp()) { case glslang::EOpImageAtomicAdd: case glslang::EOpImageAtomicMin: case glslang::EOpImageAtomicMax: case glslang::EOpImageAtomicAnd: case glslang::EOpImageAtomicOr: case glslang::EOpImageAtomicXor: case glslang::EOpImageAtomicExchange: case glslang::EOpImageAtomicCompSwap: case glslang::EOpImageAtomicLoad: case glslang::EOpImageAtomicStore: if (i == 0) lvalue = true; break; case glslang::EOpSparseImageLoad: if ((sampler.ms && i == 3) || (! sampler.ms && i == 2)) lvalue = true; break; case glslang::EOpSparseTexture: if (((cubeCompare || f16ShadowCompare) && i == 3) || (! (cubeCompare || f16ShadowCompare) && i == 2)) lvalue = true; break; case glslang::EOpSparseTextureClamp: if (((cubeCompare || f16ShadowCompare) && i == 4) || (! (cubeCompare || f16ShadowCompare) && i == 3)) lvalue = true; break; case glslang::EOpSparseTextureLod: case glslang::EOpSparseTextureOffset: if ((f16ShadowCompare && i == 4) || (! f16ShadowCompare && i == 3)) lvalue = true; break; case glslang::EOpSparseTextureFetch: if ((sampler.dim != glslang::EsdRect && i == 3) || (sampler.dim == glslang::EsdRect && i == 2)) lvalue = true; break; case glslang::EOpSparseTextureFetchOffset: if ((sampler.dim != glslang::EsdRect && i == 4) || (sampler.dim == glslang::EsdRect && i == 3)) lvalue = true; break; case glslang::EOpSparseTextureLodOffset: case glslang::EOpSparseTextureGrad: case glslang::EOpSparseTextureOffsetClamp: if ((f16ShadowCompare && i == 5) || (! f16ShadowCompare && i == 4)) lvalue = true; break; case glslang::EOpSparseTextureGradOffset: case glslang::EOpSparseTextureGradClamp: if ((f16ShadowCompare && i == 6) || (! f16ShadowCompare && i == 5)) lvalue = true; break; case glslang::EOpSparseTextureGradOffsetClamp: if ((f16ShadowCompare && i == 7) || (! f16ShadowCompare && i == 6)) lvalue = true; break; case glslang::EOpSparseTextureGather: if ((sampler.shadow && i == 3) || (! sampler.shadow && i == 2)) lvalue = true; break; case glslang::EOpSparseTextureGatherOffset: case glslang::EOpSparseTextureGatherOffsets: if ((sampler.shadow && i == 4) || (! sampler.shadow && i == 3)) lvalue = true; break; case glslang::EOpSparseTextureGatherLod: if (i == 3) lvalue = true; break; case glslang::EOpSparseTextureGatherLodOffset: case glslang::EOpSparseTextureGatherLodOffsets: if (i == 4) lvalue = true; break; case glslang::EOpSparseImageLoadLod: if (i == 3) lvalue = true; break; case glslang::EOpImageSampleFootprintNV: if (i == 4) lvalue = true; break; case glslang::EOpImageSampleFootprintClampNV: case glslang::EOpImageSampleFootprintLodNV: if (i == 5) lvalue = true; break; case glslang::EOpImageSampleFootprintGradNV: if (i == 6) lvalue = true; break; case glslang::EOpImageSampleFootprintGradClampNV: if (i == 7) lvalue = true; break; default: break; } if (lvalue) { arguments.push_back(builder.accessChainGetLValue()); lvalueCoherentFlags = builder.getAccessChain().coherentFlags; lvalueCoherentFlags |= TranslateCoherent(glslangArguments[i]->getAsTyped()->getType()); } else #endif arguments.push_back(accessChainLoad(glslangArguments[i]->getAsTyped()->getType())); } } void TGlslangToSpvTraverser::translateArguments(glslang::TIntermUnary& node, std::vector& arguments) { builder.clearAccessChain(); node.getOperand()->traverse(this); arguments.push_back(accessChainLoad(node.getOperand()->getType())); } spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermOperator* node) { if (! node->isImage() && ! node->isTexture()) return spv::NoResult; builder.setLine(node->getLoc().line, node->getLoc().getFilename()); // Process a GLSL texturing op (will be SPV image) const glslang::TType &imageType = node->getAsAggregate() ? node->getAsAggregate()->getSequence()[0]->getAsTyped()->getType() : node->getAsUnaryNode()->getOperand()->getAsTyped()->getType(); const glslang::TSampler sampler = imageType.getSampler(); #ifdef GLSLANG_WEB const bool f16ShadowCompare = false; #else bool f16ShadowCompare = (sampler.shadow && node->getAsAggregate()) ? node->getAsAggregate()->getSequence()[1]->getAsTyped()->getType().getBasicType() == glslang::EbtFloat16 : false; #endif const auto signExtensionMask = [&]() { if (builder.getSpvVersion() >= spv::Spv_1_4) { if (sampler.type == glslang::EbtUint) return spv::ImageOperandsZeroExtendMask; else if (sampler.type == glslang::EbtInt) return spv::ImageOperandsSignExtendMask; } return spv::ImageOperandsMaskNone; }; spv::Builder::AccessChain::CoherentFlags lvalueCoherentFlags; std::vector arguments; if (node->getAsAggregate()) translateArguments(*node->getAsAggregate(), arguments, lvalueCoherentFlags); else translateArguments(*node->getAsUnaryNode(), arguments); spv::Decoration precision = TranslatePrecisionDecoration(node->getOperationPrecision()); spv::Builder::TextureParameters params = { }; params.sampler = arguments[0]; glslang::TCrackedTextureOp cracked; node->crackTexture(sampler, cracked); const bool isUnsignedResult = node->getType().getBasicType() == glslang::EbtUint; // Check for queries if (cracked.query) { // OpImageQueryLod works on a sampled image, for other queries the image has to be extracted first if (node->getOp() != glslang::EOpTextureQueryLod && builder.isSampledImage(params.sampler)) params.sampler = builder.createUnaryOp(spv::OpImage, builder.getImageType(params.sampler), params.sampler); switch (node->getOp()) { case glslang::EOpImageQuerySize: case glslang::EOpTextureQuerySize: if (arguments.size() > 1) { params.lod = arguments[1]; return builder.createTextureQueryCall(spv::OpImageQuerySizeLod, params, isUnsignedResult); } else return builder.createTextureQueryCall(spv::OpImageQuerySize, params, isUnsignedResult); #ifndef GLSLANG_WEB case glslang::EOpImageQuerySamples: case glslang::EOpTextureQuerySamples: return builder.createTextureQueryCall(spv::OpImageQuerySamples, params, isUnsignedResult); case glslang::EOpTextureQueryLod: params.coords = arguments[1]; return builder.createTextureQueryCall(spv::OpImageQueryLod, params, isUnsignedResult); case glslang::EOpTextureQueryLevels: return builder.createTextureQueryCall(spv::OpImageQueryLevels, params, isUnsignedResult); case glslang::EOpSparseTexelsResident: return builder.createUnaryOp(spv::OpImageSparseTexelsResident, builder.makeBoolType(), arguments[0]); #endif default: assert(0); break; } } int components = node->getType().getVectorSize(); if (node->getOp() == glslang::EOpTextureFetch) { // These must produce 4 components, per SPIR-V spec. We'll add a conversion constructor if needed. // This will only happen through the HLSL path for operator[], so we do not have to handle e.g. // the EOpTexture/Proj/Lod/etc family. It would be harmless to do so, but would need more logic // here around e.g. which ones return scalars or other types. components = 4; } glslang::TType returnType(node->getType().getBasicType(), glslang::EvqTemporary, components); auto resultType = [&returnType,this]{ return convertGlslangToSpvType(returnType); }; // Check for image functions other than queries if (node->isImage()) { std::vector operands; auto opIt = arguments.begin(); spv::IdImmediate image = { true, *(opIt++) }; operands.push_back(image); // Handle subpass operations // TODO: GLSL should change to have the "MS" only on the type rather than the // built-in function. if (cracked.subpass) { // add on the (0,0) coordinate spv::Id zero = builder.makeIntConstant(0); std::vector comps; comps.push_back(zero); comps.push_back(zero); spv::IdImmediate coord = { true, builder.makeCompositeConstant(builder.makeVectorType(builder.makeIntType(32), 2), comps) }; operands.push_back(coord); spv::IdImmediate imageOperands = { false, spv::ImageOperandsMaskNone }; imageOperands.word = imageOperands.word | signExtensionMask(); if (sampler.isMultiSample()) { imageOperands.word = imageOperands.word | spv::ImageOperandsSampleMask; } if (imageOperands.word != spv::ImageOperandsMaskNone) { operands.push_back(imageOperands); if (sampler.isMultiSample()) { spv::IdImmediate imageOperand = { true, *(opIt++) }; operands.push_back(imageOperand); } } spv::Id result = builder.createOp(spv::OpImageRead, resultType(), operands); builder.setPrecision(result, precision); return result; } spv::IdImmediate coord = { true, *(opIt++) }; operands.push_back(coord); if (node->getOp() == glslang::EOpImageLoad || node->getOp() == glslang::EOpImageLoadLod) { spv::ImageOperandsMask mask = spv::ImageOperandsMaskNone; if (sampler.isMultiSample()) { mask = mask | spv::ImageOperandsSampleMask; } if (cracked.lod) { builder.addExtension(spv::E_SPV_AMD_shader_image_load_store_lod); builder.addCapability(spv::CapabilityImageReadWriteLodAMD); mask = mask | spv::ImageOperandsLodMask; } mask = mask | TranslateImageOperands(TranslateCoherent(imageType)); mask = (spv::ImageOperandsMask)(mask & ~spv::ImageOperandsMakeTexelAvailableKHRMask); mask = mask | signExtensionMask(); if (mask != spv::ImageOperandsMaskNone) { spv::IdImmediate imageOperands = { false, (unsigned int)mask }; operands.push_back(imageOperands); } if (mask & spv::ImageOperandsSampleMask) { spv::IdImmediate imageOperand = { true, *opIt++ }; operands.push_back(imageOperand); } if (mask & spv::ImageOperandsLodMask) { spv::IdImmediate imageOperand = { true, *opIt++ }; operands.push_back(imageOperand); } if (mask & spv::ImageOperandsMakeTexelVisibleKHRMask) { spv::IdImmediate imageOperand = { true, builder.makeUintConstant(TranslateMemoryScope(TranslateCoherent(imageType))) }; operands.push_back(imageOperand); } if (builder.getImageTypeFormat(builder.getImageType(operands.front().word)) == spv::ImageFormatUnknown) builder.addCapability(spv::CapabilityStorageImageReadWithoutFormat); std::vector result(1, builder.createOp(spv::OpImageRead, resultType(), operands)); builder.setPrecision(result[0], precision); // If needed, add a conversion constructor to the proper size. if (components != node->getType().getVectorSize()) result[0] = builder.createConstructor(precision, result, convertGlslangToSpvType(node->getType())); return result[0]; } else if (node->getOp() == glslang::EOpImageStore || node->getOp() == glslang::EOpImageStoreLod) { // Push the texel value before the operands if (sampler.isMultiSample() || cracked.lod) { spv::IdImmediate texel = { true, *(opIt + 1) }; operands.push_back(texel); } else { spv::IdImmediate texel = { true, *opIt }; operands.push_back(texel); } spv::ImageOperandsMask mask = spv::ImageOperandsMaskNone; if (sampler.isMultiSample()) { mask = mask | spv::ImageOperandsSampleMask; } if (cracked.lod) { builder.addExtension(spv::E_SPV_AMD_shader_image_load_store_lod); builder.addCapability(spv::CapabilityImageReadWriteLodAMD); mask = mask | spv::ImageOperandsLodMask; } mask = mask | TranslateImageOperands(TranslateCoherent(imageType)); mask = (spv::ImageOperandsMask)(mask & ~spv::ImageOperandsMakeTexelVisibleKHRMask); mask = mask | signExtensionMask(); if (mask != spv::ImageOperandsMaskNone) { spv::IdImmediate imageOperands = { false, (unsigned int)mask }; operands.push_back(imageOperands); } if (mask & spv::ImageOperandsSampleMask) { spv::IdImmediate imageOperand = { true, *opIt++ }; operands.push_back(imageOperand); } if (mask & spv::ImageOperandsLodMask) { spv::IdImmediate imageOperand = { true, *opIt++ }; operands.push_back(imageOperand); } if (mask & spv::ImageOperandsMakeTexelAvailableKHRMask) { spv::IdImmediate imageOperand = { true, builder.makeUintConstant(TranslateMemoryScope(TranslateCoherent(imageType))) }; operands.push_back(imageOperand); } builder.createNoResultOp(spv::OpImageWrite, operands); if (builder.getImageTypeFormat(builder.getImageType(operands.front().word)) == spv::ImageFormatUnknown) builder.addCapability(spv::CapabilityStorageImageWriteWithoutFormat); return spv::NoResult; } else if (node->getOp() == glslang::EOpSparseImageLoad || node->getOp() == glslang::EOpSparseImageLoadLod) { builder.addCapability(spv::CapabilitySparseResidency); if (builder.getImageTypeFormat(builder.getImageType(operands.front().word)) == spv::ImageFormatUnknown) builder.addCapability(spv::CapabilityStorageImageReadWithoutFormat); spv::ImageOperandsMask mask = spv::ImageOperandsMaskNone; if (sampler.isMultiSample()) { mask = mask | spv::ImageOperandsSampleMask; } if (cracked.lod) { builder.addExtension(spv::E_SPV_AMD_shader_image_load_store_lod); builder.addCapability(spv::CapabilityImageReadWriteLodAMD); mask = mask | spv::ImageOperandsLodMask; } mask = mask | TranslateImageOperands(TranslateCoherent(imageType)); mask = (spv::ImageOperandsMask)(mask & ~spv::ImageOperandsMakeTexelAvailableKHRMask); mask = mask | signExtensionMask(); if (mask != spv::ImageOperandsMaskNone) { spv::IdImmediate imageOperands = { false, (unsigned int)mask }; operands.push_back(imageOperands); } if (mask & spv::ImageOperandsSampleMask) { spv::IdImmediate imageOperand = { true, *opIt++ }; operands.push_back(imageOperand); } if (mask & spv::ImageOperandsLodMask) { spv::IdImmediate imageOperand = { true, *opIt++ }; operands.push_back(imageOperand); } if (mask & spv::ImageOperandsMakeTexelVisibleKHRMask) { spv::IdImmediate imageOperand = { true, builder.makeUintConstant(TranslateMemoryScope(TranslateCoherent(imageType))) }; operands.push_back(imageOperand); } // Create the return type that was a special structure spv::Id texelOut = *opIt; spv::Id typeId0 = resultType(); spv::Id typeId1 = builder.getDerefTypeId(texelOut); spv::Id resultTypeId = builder.makeStructResultType(typeId0, typeId1); spv::Id resultId = builder.createOp(spv::OpImageSparseRead, resultTypeId, operands); // Decode the return type builder.createStore(builder.createCompositeExtract(resultId, typeId1, 1), texelOut); return builder.createCompositeExtract(resultId, typeId0, 0); } else { // Process image atomic operations // GLSL "IMAGE_PARAMS" will involve in constructing an image texel pointer and this pointer, // as the first source operand, is required by SPIR-V atomic operations. // For non-MS, the sample value should be 0 spv::IdImmediate sample = { true, sampler.isMultiSample() ? *(opIt++) : builder.makeUintConstant(0) }; operands.push_back(sample); spv::Id resultTypeId; // imageAtomicStore has a void return type so base the pointer type on // the type of the value operand. if (node->getOp() == glslang::EOpImageAtomicStore) { resultTypeId = builder.makePointer(spv::StorageClassImage, builder.getTypeId(operands[2].word)); } else { resultTypeId = builder.makePointer(spv::StorageClassImage, resultType()); } spv::Id pointer = builder.createOp(spv::OpImageTexelPointer, resultTypeId, operands); std::vector operands; operands.push_back(pointer); for (; opIt != arguments.end(); ++opIt) operands.push_back(*opIt); return createAtomicOperation(node->getOp(), precision, resultType(), operands, node->getBasicType(), lvalueCoherentFlags); } } #ifndef GLSLANG_WEB // Check for fragment mask functions other than queries if (cracked.fragMask) { assert(sampler.ms); auto opIt = arguments.begin(); std::vector operands; // Extract the image if necessary if (builder.isSampledImage(params.sampler)) params.sampler = builder.createUnaryOp(spv::OpImage, builder.getImageType(params.sampler), params.sampler); operands.push_back(params.sampler); ++opIt; if (sampler.isSubpass()) { // add on the (0,0) coordinate spv::Id zero = builder.makeIntConstant(0); std::vector comps; comps.push_back(zero); comps.push_back(zero); operands.push_back(builder.makeCompositeConstant(builder.makeVectorType(builder.makeIntType(32), 2), comps)); } for (; opIt != arguments.end(); ++opIt) operands.push_back(*opIt); spv::Op fragMaskOp = spv::OpNop; if (node->getOp() == glslang::EOpFragmentMaskFetch) fragMaskOp = spv::OpFragmentMaskFetchAMD; else if (node->getOp() == glslang::EOpFragmentFetch) fragMaskOp = spv::OpFragmentFetchAMD; builder.addExtension(spv::E_SPV_AMD_shader_fragment_mask); builder.addCapability(spv::CapabilityFragmentMaskAMD); return builder.createOp(fragMaskOp, resultType(), operands); } #endif // Check for texture functions other than queries bool sparse = node->isSparseTexture(); bool imageFootprint = node->isImageFootprint(); bool cubeCompare = sampler.dim == glslang::EsdCube && sampler.isArrayed() && sampler.isShadow(); // check for bias argument bool bias = false; if (! cracked.lod && ! cracked.grad && ! cracked.fetch && ! cubeCompare) { int nonBiasArgCount = 2; if (cracked.gather) ++nonBiasArgCount; // comp argument should be present when bias argument is present if (f16ShadowCompare) ++nonBiasArgCount; if (cracked.offset) ++nonBiasArgCount; else if (cracked.offsets) ++nonBiasArgCount; if (cracked.grad) nonBiasArgCount += 2; if (cracked.lodClamp) ++nonBiasArgCount; if (sparse) ++nonBiasArgCount; if (imageFootprint) //Following three extra arguments // int granularity, bool coarse, out gl_TextureFootprint2DNV footprint nonBiasArgCount += 3; if ((int)arguments.size() > nonBiasArgCount) bias = true; } // See if the sampler param should really be just the SPV image part if (cracked.fetch) { // a fetch needs to have the image extracted first if (builder.isSampledImage(params.sampler)) params.sampler = builder.createUnaryOp(spv::OpImage, builder.getImageType(params.sampler), params.sampler); } #ifndef GLSLANG_WEB if (cracked.gather) { const auto& sourceExtensions = glslangIntermediate->getRequestedExtensions(); if (bias || cracked.lod || sourceExtensions.find(glslang::E_GL_AMD_texture_gather_bias_lod) != sourceExtensions.end()) { builder.addExtension(spv::E_SPV_AMD_texture_gather_bias_lod); builder.addCapability(spv::CapabilityImageGatherBiasLodAMD); } } #endif // set the rest of the arguments params.coords = arguments[1]; int extraArgs = 0; bool noImplicitLod = false; // sort out where Dref is coming from if (cubeCompare || f16ShadowCompare) { params.Dref = arguments[2]; ++extraArgs; } else if (sampler.shadow && cracked.gather) { params.Dref = arguments[2]; ++extraArgs; } else if (sampler.shadow) { std::vector indexes; int dRefComp; if (cracked.proj) dRefComp = 2; // "The resulting 3rd component of P in the shadow forms is used as Dref" else dRefComp = builder.getNumComponents(params.coords) - 1; indexes.push_back(dRefComp); params.Dref = builder.createCompositeExtract(params.coords, builder.getScalarTypeId(builder.getTypeId(params.coords)), indexes); } // lod if (cracked.lod) { params.lod = arguments[2 + extraArgs]; ++extraArgs; } else if (glslangIntermediate->getStage() != EShLangFragment && !(glslangIntermediate->getStage() == EShLangCompute && glslangIntermediate->hasLayoutDerivativeModeNone())) { // we need to invent the default lod for an explicit lod instruction for a non-fragment stage noImplicitLod = true; } // multisample if (sampler.isMultiSample()) { params.sample = arguments[2 + extraArgs]; // For MS, "sample" should be specified ++extraArgs; } // gradient if (cracked.grad) { params.gradX = arguments[2 + extraArgs]; params.gradY = arguments[3 + extraArgs]; extraArgs += 2; } // offset and offsets if (cracked.offset) { params.offset = arguments[2 + extraArgs]; ++extraArgs; } else if (cracked.offsets) { params.offsets = arguments[2 + extraArgs]; ++extraArgs; } #ifndef GLSLANG_WEB // lod clamp if (cracked.lodClamp) { params.lodClamp = arguments[2 + extraArgs]; ++extraArgs; } // sparse if (sparse) { params.texelOut = arguments[2 + extraArgs]; ++extraArgs; } // gather component if (cracked.gather && ! sampler.shadow) { // default component is 0, if missing, otherwise an argument if (2 + extraArgs < (int)arguments.size()) { params.component = arguments[2 + extraArgs]; ++extraArgs; } else params.component = builder.makeIntConstant(0); } spv::Id resultStruct = spv::NoResult; if (imageFootprint) { //Following three extra arguments // int granularity, bool coarse, out gl_TextureFootprint2DNV footprint params.granularity = arguments[2 + extraArgs]; params.coarse = arguments[3 + extraArgs]; resultStruct = arguments[4 + extraArgs]; extraArgs += 3; } #endif // bias if (bias) { params.bias = arguments[2 + extraArgs]; ++extraArgs; } #ifndef GLSLANG_WEB if (imageFootprint) { builder.addExtension(spv::E_SPV_NV_shader_image_footprint); builder.addCapability(spv::CapabilityImageFootprintNV); //resultStructType(OpenGL type) contains 5 elements: //struct gl_TextureFootprint2DNV { // uvec2 anchor; // uvec2 offset; // uvec2 mask; // uint lod; // uint granularity; //}; //or //struct gl_TextureFootprint3DNV { // uvec3 anchor; // uvec3 offset; // uvec2 mask; // uint lod; // uint granularity; //}; spv::Id resultStructType = builder.getContainedTypeId(builder.getTypeId(resultStruct)); assert(builder.isStructType(resultStructType)); //resType (SPIR-V type) contains 6 elements: //Member 0 must be a Boolean type scalar(LOD), //Member 1 must be a vector of integer type, whose Signedness operand is 0(anchor), //Member 2 must be a vector of integer type, whose Signedness operand is 0(offset), //Member 3 must be a vector of integer type, whose Signedness operand is 0(mask), //Member 4 must be a scalar of integer type, whose Signedness operand is 0(lod), //Member 5 must be a scalar of integer type, whose Signedness operand is 0(granularity). std::vector members; members.push_back(resultType()); for (int i = 0; i < 5; i++) { members.push_back(builder.getContainedTypeId(resultStructType, i)); } spv::Id resType = builder.makeStructType(members, "ResType"); //call ImageFootprintNV spv::Id res = builder.createTextureCall(precision, resType, sparse, cracked.fetch, cracked.proj, cracked.gather, noImplicitLod, params, signExtensionMask()); //copy resType (SPIR-V type) to resultStructType(OpenGL type) for (int i = 0; i < 5; i++) { builder.clearAccessChain(); builder.setAccessChainLValue(resultStruct); //Accessing to a struct we created, no coherent flag is set spv::Builder::AccessChain::CoherentFlags flags; flags.clear(); builder.accessChainPush(builder.makeIntConstant(i), flags, 0); builder.accessChainStore(builder.createCompositeExtract(res, builder.getContainedTypeId(resType, i+1), i+1)); } return builder.createCompositeExtract(res, resultType(), 0); } #endif // projective component (might not to move) // GLSL: "The texture coordinates consumed from P, not including the last component of P, // are divided by the last component of P." // SPIR-V: "... (u [, v] [, w], q)... It may be a vector larger than needed, but all // unused components will appear after all used components." if (cracked.proj) { int projSourceComp = builder.getNumComponents(params.coords) - 1; int projTargetComp; switch (sampler.dim) { case glslang::Esd1D: projTargetComp = 1; break; case glslang::Esd2D: projTargetComp = 2; break; case glslang::EsdRect: projTargetComp = 2; break; default: projTargetComp = projSourceComp; break; } // copy the projective coordinate if we have to if (projTargetComp != projSourceComp) { spv::Id projComp = builder.createCompositeExtract(params.coords, builder.getScalarTypeId(builder.getTypeId(params.coords)), projSourceComp); params.coords = builder.createCompositeInsert(projComp, params.coords, builder.getTypeId(params.coords), projTargetComp); } } #ifndef GLSLANG_WEB // nonprivate if (imageType.getQualifier().nonprivate) { params.nonprivate = true; } // volatile if (imageType.getQualifier().volatil) { params.volatil = true; } #endif std::vector result( 1, builder.createTextureCall(precision, resultType(), sparse, cracked.fetch, cracked.proj, cracked.gather, noImplicitLod, params, signExtensionMask()) ); if (components != node->getType().getVectorSize()) result[0] = builder.createConstructor(precision, result, convertGlslangToSpvType(node->getType())); return result[0]; } spv::Id TGlslangToSpvTraverser::handleUserFunctionCall(const glslang::TIntermAggregate* node) { // Grab the function's pointer from the previously created function spv::Function* function = functionMap[node->getName().c_str()]; if (! function) return 0; const glslang::TIntermSequence& glslangArgs = node->getSequence(); const glslang::TQualifierList& qualifiers = node->getQualifierList(); // See comments in makeFunctions() for details about the semantics for parameter passing. // // These imply we need a four step process: // 1. Evaluate the arguments // 2. Allocate and make copies of in, out, and inout arguments // 3. Make the call // 4. Copy back the results // 1. Evaluate the arguments and their types std::vector lValues; std::vector rValues; std::vector argTypes; for (int a = 0; a < (int)glslangArgs.size(); ++a) { argTypes.push_back(&glslangArgs[a]->getAsTyped()->getType()); // build l-value builder.clearAccessChain(); glslangArgs[a]->traverse(this); // keep outputs and pass-by-originals as l-values, evaluate others as r-values if (originalParam(qualifiers[a], *argTypes[a], function->hasImplicitThis() && a == 0) || writableParam(qualifiers[a])) { // save l-value lValues.push_back(builder.getAccessChain()); } else { // process r-value rValues.push_back(accessChainLoad(*argTypes.back())); } } // 2. Allocate space for anything needing a copy, and if it's "in" or "inout" // copy the original into that space. // // Also, build up the list of actual arguments to pass in for the call int lValueCount = 0; int rValueCount = 0; std::vector spvArgs; for (int a = 0; a < (int)glslangArgs.size(); ++a) { spv::Id arg; if (originalParam(qualifiers[a], *argTypes[a], function->hasImplicitThis() && a == 0)) { builder.setAccessChain(lValues[lValueCount]); arg = builder.accessChainGetLValue(); ++lValueCount; } else if (writableParam(qualifiers[a])) { // need space to hold the copy arg = builder.createVariable(spv::StorageClassFunction, builder.getContainedTypeId(function->getParamType(a)), "param"); if (qualifiers[a] == glslang::EvqIn || qualifiers[a] == glslang::EvqInOut) { // need to copy the input into output space builder.setAccessChain(lValues[lValueCount]); spv::Id copy = accessChainLoad(*argTypes[a]); builder.clearAccessChain(); builder.setAccessChainLValue(arg); multiTypeStore(*argTypes[a], copy); } ++lValueCount; } else { // process r-value, which involves a copy for a type mismatch if (function->getParamType(a) != convertGlslangToSpvType(*argTypes[a])) { spv::Id argCopy = builder.createVariable(spv::StorageClassFunction, function->getParamType(a), "arg"); builder.clearAccessChain(); builder.setAccessChainLValue(argCopy); multiTypeStore(*argTypes[a], rValues[rValueCount]); arg = builder.createLoad(argCopy); } else arg = rValues[rValueCount]; ++rValueCount; } spvArgs.push_back(arg); } // 3. Make the call. spv::Id result = builder.createFunctionCall(function, spvArgs); builder.setPrecision(result, TranslatePrecisionDecoration(node->getType())); // 4. Copy back out an "out" arguments. lValueCount = 0; for (int a = 0; a < (int)glslangArgs.size(); ++a) { if (originalParam(qualifiers[a], *argTypes[a], function->hasImplicitThis() && a == 0)) ++lValueCount; else if (writableParam(qualifiers[a])) { if (qualifiers[a] == glslang::EvqOut || qualifiers[a] == glslang::EvqInOut) { spv::Id copy = builder.createLoad(spvArgs[a]); builder.setAccessChain(lValues[lValueCount]); multiTypeStore(*argTypes[a], copy); } ++lValueCount; } } return result; } // Translate AST operation to SPV operation, already having SPV-based operands/types. spv::Id TGlslangToSpvTraverser::createBinaryOperation(glslang::TOperator op, OpDecorations& decorations, spv::Id typeId, spv::Id left, spv::Id right, glslang::TBasicType typeProxy, bool reduceComparison) { bool isUnsigned = isTypeUnsignedInt(typeProxy); bool isFloat = isTypeFloat(typeProxy); bool isBool = typeProxy == glslang::EbtBool; spv::Op binOp = spv::OpNop; bool needMatchingVectors = true; // for non-matrix ops, would a scalar need to smear to match a vector? bool comparison = false; switch (op) { case glslang::EOpAdd: case glslang::EOpAddAssign: if (isFloat) binOp = spv::OpFAdd; else binOp = spv::OpIAdd; break; case glslang::EOpSub: case glslang::EOpSubAssign: if (isFloat) binOp = spv::OpFSub; else binOp = spv::OpISub; break; case glslang::EOpMul: case glslang::EOpMulAssign: if (isFloat) binOp = spv::OpFMul; else binOp = spv::OpIMul; break; case glslang::EOpVectorTimesScalar: case glslang::EOpVectorTimesScalarAssign: if (isFloat && (builder.isVector(left) || builder.isVector(right))) { if (builder.isVector(right)) std::swap(left, right); assert(builder.isScalar(right)); needMatchingVectors = false; binOp = spv::OpVectorTimesScalar; } else if (isFloat) binOp = spv::OpFMul; else binOp = spv::OpIMul; break; case glslang::EOpVectorTimesMatrix: case glslang::EOpVectorTimesMatrixAssign: binOp = spv::OpVectorTimesMatrix; break; case glslang::EOpMatrixTimesVector: binOp = spv::OpMatrixTimesVector; break; case glslang::EOpMatrixTimesScalar: case glslang::EOpMatrixTimesScalarAssign: binOp = spv::OpMatrixTimesScalar; break; case glslang::EOpMatrixTimesMatrix: case glslang::EOpMatrixTimesMatrixAssign: binOp = spv::OpMatrixTimesMatrix; break; case glslang::EOpOuterProduct: binOp = spv::OpOuterProduct; needMatchingVectors = false; break; case glslang::EOpDiv: case glslang::EOpDivAssign: if (isFloat) binOp = spv::OpFDiv; else if (isUnsigned) binOp = spv::OpUDiv; else binOp = spv::OpSDiv; break; case glslang::EOpMod: case glslang::EOpModAssign: if (isFloat) binOp = spv::OpFMod; else if (isUnsigned) binOp = spv::OpUMod; else binOp = spv::OpSMod; break; case glslang::EOpRightShift: case glslang::EOpRightShiftAssign: if (isUnsigned) binOp = spv::OpShiftRightLogical; else binOp = spv::OpShiftRightArithmetic; break; case glslang::EOpLeftShift: case glslang::EOpLeftShiftAssign: binOp = spv::OpShiftLeftLogical; break; case glslang::EOpAnd: case glslang::EOpAndAssign: binOp = spv::OpBitwiseAnd; break; case glslang::EOpLogicalAnd: needMatchingVectors = false; binOp = spv::OpLogicalAnd; break; case glslang::EOpInclusiveOr: case glslang::EOpInclusiveOrAssign: binOp = spv::OpBitwiseOr; break; case glslang::EOpLogicalOr: needMatchingVectors = false; binOp = spv::OpLogicalOr; break; case glslang::EOpExclusiveOr: case glslang::EOpExclusiveOrAssign: binOp = spv::OpBitwiseXor; break; case glslang::EOpLogicalXor: needMatchingVectors = false; binOp = spv::OpLogicalNotEqual; break; case glslang::EOpAbsDifference: binOp = isUnsigned ? spv::OpAbsUSubINTEL : spv::OpAbsISubINTEL; break; case glslang::EOpAddSaturate: binOp = isUnsigned ? spv::OpUAddSatINTEL : spv::OpIAddSatINTEL; break; case glslang::EOpSubSaturate: binOp = isUnsigned ? spv::OpUSubSatINTEL : spv::OpISubSatINTEL; break; case glslang::EOpAverage: binOp = isUnsigned ? spv::OpUAverageINTEL : spv::OpIAverageINTEL; break; case glslang::EOpAverageRounded: binOp = isUnsigned ? spv::OpUAverageRoundedINTEL : spv::OpIAverageRoundedINTEL; break; case glslang::EOpMul32x16: binOp = isUnsigned ? spv::OpUMul32x16INTEL : spv::OpIMul32x16INTEL; break; case glslang::EOpLessThan: case glslang::EOpGreaterThan: case glslang::EOpLessThanEqual: case glslang::EOpGreaterThanEqual: case glslang::EOpEqual: case glslang::EOpNotEqual: case glslang::EOpVectorEqual: case glslang::EOpVectorNotEqual: comparison = true; break; default: break; } // handle mapped binary operations (should be non-comparison) if (binOp != spv::OpNop) { assert(comparison == false); if (builder.isMatrix(left) || builder.isMatrix(right) || builder.isCooperativeMatrix(left) || builder.isCooperativeMatrix(right)) return createBinaryMatrixOperation(binOp, decorations, typeId, left, right); // No matrix involved; make both operands be the same number of components, if needed if (needMatchingVectors) builder.promoteScalar(decorations.precision, left, right); spv::Id result = builder.createBinOp(binOp, typeId, left, right); decorations.addNoContraction(builder, result); decorations.addNonUniform(builder, result); return builder.setPrecision(result, decorations.precision); } if (! comparison) return 0; // Handle comparison instructions if (reduceComparison && (op == glslang::EOpEqual || op == glslang::EOpNotEqual) && (builder.isVector(left) || builder.isMatrix(left) || builder.isAggregate(left))) { spv::Id result = builder.createCompositeCompare(decorations.precision, left, right, op == glslang::EOpEqual); decorations.addNonUniform(builder, result); return result; } switch (op) { case glslang::EOpLessThan: if (isFloat) binOp = spv::OpFOrdLessThan; else if (isUnsigned) binOp = spv::OpULessThan; else binOp = spv::OpSLessThan; break; case glslang::EOpGreaterThan: if (isFloat) binOp = spv::OpFOrdGreaterThan; else if (isUnsigned) binOp = spv::OpUGreaterThan; else binOp = spv::OpSGreaterThan; break; case glslang::EOpLessThanEqual: if (isFloat) binOp = spv::OpFOrdLessThanEqual; else if (isUnsigned) binOp = spv::OpULessThanEqual; else binOp = spv::OpSLessThanEqual; break; case glslang::EOpGreaterThanEqual: if (isFloat) binOp = spv::OpFOrdGreaterThanEqual; else if (isUnsigned) binOp = spv::OpUGreaterThanEqual; else binOp = spv::OpSGreaterThanEqual; break; case glslang::EOpEqual: case glslang::EOpVectorEqual: if (isFloat) binOp = spv::OpFOrdEqual; else if (isBool) binOp = spv::OpLogicalEqual; else binOp = spv::OpIEqual; break; case glslang::EOpNotEqual: case glslang::EOpVectorNotEqual: if (isFloat) binOp = spv::OpFOrdNotEqual; else if (isBool) binOp = spv::OpLogicalNotEqual; else binOp = spv::OpINotEqual; break; default: break; } if (binOp != spv::OpNop) { spv::Id result = builder.createBinOp(binOp, typeId, left, right); decorations.addNoContraction(builder, result); decorations.addNonUniform(builder, result); return builder.setPrecision(result, decorations.precision); } return 0; } // // Translate AST matrix operation to SPV operation, already having SPV-based operands/types. // These can be any of: // // matrix * scalar // scalar * matrix // matrix * matrix linear algebraic // matrix * vector // vector * matrix // matrix * matrix componentwise // matrix op matrix op in {+, -, /} // matrix op scalar op in {+, -, /} // scalar op matrix op in {+, -, /} // spv::Id TGlslangToSpvTraverser::createBinaryMatrixOperation(spv::Op op, OpDecorations& decorations, spv::Id typeId, spv::Id left, spv::Id right) { bool firstClass = true; // First, handle first-class matrix operations (* and matrix/scalar) switch (op) { case spv::OpFDiv: if (builder.isMatrix(left) && builder.isScalar(right)) { // turn matrix / scalar into a multiply... spv::Id resultType = builder.getTypeId(right); right = builder.createBinOp(spv::OpFDiv, resultType, builder.makeFpConstant(resultType, 1.0), right); op = spv::OpMatrixTimesScalar; } else firstClass = false; break; case spv::OpMatrixTimesScalar: if (builder.isMatrix(right) || builder.isCooperativeMatrix(right)) std::swap(left, right); assert(builder.isScalar(right)); break; case spv::OpVectorTimesMatrix: assert(builder.isVector(left)); assert(builder.isMatrix(right)); break; case spv::OpMatrixTimesVector: assert(builder.isMatrix(left)); assert(builder.isVector(right)); break; case spv::OpMatrixTimesMatrix: assert(builder.isMatrix(left)); assert(builder.isMatrix(right)); break; default: firstClass = false; break; } if (builder.isCooperativeMatrix(left) || builder.isCooperativeMatrix(right)) firstClass = true; if (firstClass) { spv::Id result = builder.createBinOp(op, typeId, left, right); decorations.addNoContraction(builder, result); decorations.addNonUniform(builder, result); return builder.setPrecision(result, decorations.precision); } // Handle component-wise +, -, *, %, and / for all combinations of type. // The result type of all of them is the same type as the (a) matrix operand. // The algorithm is to: // - break the matrix(es) into vectors // - smear any scalar to a vector // - do vector operations // - make a matrix out the vector results switch (op) { case spv::OpFAdd: case spv::OpFSub: case spv::OpFDiv: case spv::OpFMod: case spv::OpFMul: { // one time set up... bool leftMat = builder.isMatrix(left); bool rightMat = builder.isMatrix(right); unsigned int numCols = leftMat ? builder.getNumColumns(left) : builder.getNumColumns(right); int numRows = leftMat ? builder.getNumRows(left) : builder.getNumRows(right); spv::Id scalarType = builder.getScalarTypeId(typeId); spv::Id vecType = builder.makeVectorType(scalarType, numRows); std::vector results; spv::Id smearVec = spv::NoResult; if (builder.isScalar(left)) smearVec = builder.smearScalar(decorations.precision, left, vecType); else if (builder.isScalar(right)) smearVec = builder.smearScalar(decorations.precision, right, vecType); // do each vector op for (unsigned int c = 0; c < numCols; ++c) { std::vector indexes; indexes.push_back(c); spv::Id leftVec = leftMat ? builder.createCompositeExtract( left, vecType, indexes) : smearVec; spv::Id rightVec = rightMat ? builder.createCompositeExtract(right, vecType, indexes) : smearVec; spv::Id result = builder.createBinOp(op, vecType, leftVec, rightVec); decorations.addNoContraction(builder, result); decorations.addNonUniform(builder, result); results.push_back(builder.setPrecision(result, decorations.precision)); } // put the pieces together spv::Id result = builder.setPrecision(builder.createCompositeConstruct(typeId, results), decorations.precision); decorations.addNonUniform(builder, result); return result; } default: assert(0); return spv::NoResult; } } spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, OpDecorations& decorations, spv::Id typeId, spv::Id operand, glslang::TBasicType typeProxy, const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags) { spv::Op unaryOp = spv::OpNop; int extBuiltins = -1; int libCall = -1; bool isUnsigned = isTypeUnsignedInt(typeProxy); bool isFloat = isTypeFloat(typeProxy); switch (op) { case glslang::EOpNegative: if (isFloat) { unaryOp = spv::OpFNegate; if (builder.isMatrixType(typeId)) return createUnaryMatrixOperation(unaryOp, decorations, typeId, operand, typeProxy); } else unaryOp = spv::OpSNegate; break; case glslang::EOpLogicalNot: case glslang::EOpVectorLogicalNot: unaryOp = spv::OpLogicalNot; break; case glslang::EOpBitwiseNot: unaryOp = spv::OpNot; break; case glslang::EOpDeterminant: libCall = spv::GLSLstd450Determinant; break; case glslang::EOpMatrixInverse: libCall = spv::GLSLstd450MatrixInverse; break; case glslang::EOpTranspose: unaryOp = spv::OpTranspose; break; case glslang::EOpRadians: libCall = spv::GLSLstd450Radians; break; case glslang::EOpDegrees: libCall = spv::GLSLstd450Degrees; break; case glslang::EOpSin: libCall = spv::GLSLstd450Sin; break; case glslang::EOpCos: libCall = spv::GLSLstd450Cos; break; case glslang::EOpTan: libCall = spv::GLSLstd450Tan; break; case glslang::EOpAcos: libCall = spv::GLSLstd450Acos; break; case glslang::EOpAsin: libCall = spv::GLSLstd450Asin; break; case glslang::EOpAtan: libCall = spv::GLSLstd450Atan; break; case glslang::EOpAcosh: libCall = spv::GLSLstd450Acosh; break; case glslang::EOpAsinh: libCall = spv::GLSLstd450Asinh; break; case glslang::EOpAtanh: libCall = spv::GLSLstd450Atanh; break; case glslang::EOpTanh: libCall = spv::GLSLstd450Tanh; break; case glslang::EOpCosh: libCall = spv::GLSLstd450Cosh; break; case glslang::EOpSinh: libCall = spv::GLSLstd450Sinh; break; case glslang::EOpLength: libCall = spv::GLSLstd450Length; break; case glslang::EOpNormalize: libCall = spv::GLSLstd450Normalize; break; case glslang::EOpExp: libCall = spv::GLSLstd450Exp; break; case glslang::EOpLog: libCall = spv::GLSLstd450Log; break; case glslang::EOpExp2: libCall = spv::GLSLstd450Exp2; break; case glslang::EOpLog2: libCall = spv::GLSLstd450Log2; break; case glslang::EOpSqrt: libCall = spv::GLSLstd450Sqrt; break; case glslang::EOpInverseSqrt: libCall = spv::GLSLstd450InverseSqrt; break; case glslang::EOpFloor: libCall = spv::GLSLstd450Floor; break; case glslang::EOpTrunc: libCall = spv::GLSLstd450Trunc; break; case glslang::EOpRound: libCall = spv::GLSLstd450Round; break; case glslang::EOpRoundEven: libCall = spv::GLSLstd450RoundEven; break; case glslang::EOpCeil: libCall = spv::GLSLstd450Ceil; break; case glslang::EOpFract: libCall = spv::GLSLstd450Fract; break; case glslang::EOpIsNan: unaryOp = spv::OpIsNan; break; case glslang::EOpIsInf: unaryOp = spv::OpIsInf; break; case glslang::EOpIsFinite: unaryOp = spv::OpIsFinite; break; case glslang::EOpFloatBitsToInt: case glslang::EOpFloatBitsToUint: case glslang::EOpIntBitsToFloat: case glslang::EOpUintBitsToFloat: case glslang::EOpDoubleBitsToInt64: case glslang::EOpDoubleBitsToUint64: case glslang::EOpInt64BitsToDouble: case glslang::EOpUint64BitsToDouble: case glslang::EOpFloat16BitsToInt16: case glslang::EOpFloat16BitsToUint16: case glslang::EOpInt16BitsToFloat16: case glslang::EOpUint16BitsToFloat16: unaryOp = spv::OpBitcast; break; case glslang::EOpPackSnorm2x16: libCall = spv::GLSLstd450PackSnorm2x16; break; case glslang::EOpUnpackSnorm2x16: libCall = spv::GLSLstd450UnpackSnorm2x16; break; case glslang::EOpPackUnorm2x16: libCall = spv::GLSLstd450PackUnorm2x16; break; case glslang::EOpUnpackUnorm2x16: libCall = spv::GLSLstd450UnpackUnorm2x16; break; case glslang::EOpPackHalf2x16: libCall = spv::GLSLstd450PackHalf2x16; break; case glslang::EOpUnpackHalf2x16: libCall = spv::GLSLstd450UnpackHalf2x16; break; #ifndef GLSLANG_WEB case glslang::EOpPackSnorm4x8: libCall = spv::GLSLstd450PackSnorm4x8; break; case glslang::EOpUnpackSnorm4x8: libCall = spv::GLSLstd450UnpackSnorm4x8; break; case glslang::EOpPackUnorm4x8: libCall = spv::GLSLstd450PackUnorm4x8; break; case glslang::EOpUnpackUnorm4x8: libCall = spv::GLSLstd450UnpackUnorm4x8; break; case glslang::EOpPackDouble2x32: libCall = spv::GLSLstd450PackDouble2x32; break; case glslang::EOpUnpackDouble2x32: libCall = spv::GLSLstd450UnpackDouble2x32; break; #endif case glslang::EOpPackInt2x32: case glslang::EOpUnpackInt2x32: case glslang::EOpPackUint2x32: case glslang::EOpUnpackUint2x32: case glslang::EOpPack16: case glslang::EOpPack32: case glslang::EOpPack64: case glslang::EOpUnpack32: case glslang::EOpUnpack16: case glslang::EOpUnpack8: case glslang::EOpPackInt2x16: case glslang::EOpUnpackInt2x16: case glslang::EOpPackUint2x16: case glslang::EOpUnpackUint2x16: case glslang::EOpPackInt4x16: case glslang::EOpUnpackInt4x16: case glslang::EOpPackUint4x16: case glslang::EOpUnpackUint4x16: case glslang::EOpPackFloat2x16: case glslang::EOpUnpackFloat2x16: unaryOp = spv::OpBitcast; break; case glslang::EOpDPdx: unaryOp = spv::OpDPdx; break; case glslang::EOpDPdy: unaryOp = spv::OpDPdy; break; case glslang::EOpFwidth: unaryOp = spv::OpFwidth; break; case glslang::EOpAny: unaryOp = spv::OpAny; break; case glslang::EOpAll: unaryOp = spv::OpAll; break; case glslang::EOpAbs: if (isFloat) libCall = spv::GLSLstd450FAbs; else libCall = spv::GLSLstd450SAbs; break; case glslang::EOpSign: if (isFloat) libCall = spv::GLSLstd450FSign; else libCall = spv::GLSLstd450SSign; break; #ifndef GLSLANG_WEB case glslang::EOpDPdxFine: unaryOp = spv::OpDPdxFine; break; case glslang::EOpDPdyFine: unaryOp = spv::OpDPdyFine; break; case glslang::EOpFwidthFine: unaryOp = spv::OpFwidthFine; break; case glslang::EOpDPdxCoarse: unaryOp = spv::OpDPdxCoarse; break; case glslang::EOpDPdyCoarse: unaryOp = spv::OpDPdyCoarse; break; case glslang::EOpFwidthCoarse: unaryOp = spv::OpFwidthCoarse; break; case glslang::EOpInterpolateAtCentroid: if (typeProxy == glslang::EbtFloat16) builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float); libCall = spv::GLSLstd450InterpolateAtCentroid; break; case glslang::EOpAtomicCounterIncrement: case glslang::EOpAtomicCounterDecrement: case glslang::EOpAtomicCounter: { // Handle all of the atomics in one place, in createAtomicOperation() std::vector operands; operands.push_back(operand); return createAtomicOperation(op, decorations.precision, typeId, operands, typeProxy, lvalueCoherentFlags); } case glslang::EOpBitFieldReverse: unaryOp = spv::OpBitReverse; break; case glslang::EOpBitCount: unaryOp = spv::OpBitCount; break; case glslang::EOpFindLSB: libCall = spv::GLSLstd450FindILsb; break; case glslang::EOpFindMSB: if (isUnsigned) libCall = spv::GLSLstd450FindUMsb; else libCall = spv::GLSLstd450FindSMsb; break; case glslang::EOpCountLeadingZeros: builder.addCapability(spv::CapabilityIntegerFunctions2INTEL); builder.addExtension("SPV_INTEL_shader_integer_functions2"); unaryOp = spv::OpUCountLeadingZerosINTEL; break; case glslang::EOpCountTrailingZeros: builder.addCapability(spv::CapabilityIntegerFunctions2INTEL); builder.addExtension("SPV_INTEL_shader_integer_functions2"); unaryOp = spv::OpUCountTrailingZerosINTEL; break; case glslang::EOpBallot: case glslang::EOpReadFirstInvocation: case glslang::EOpAnyInvocation: case glslang::EOpAllInvocations: case glslang::EOpAllInvocationsEqual: case glslang::EOpMinInvocations: case glslang::EOpMaxInvocations: case glslang::EOpAddInvocations: case glslang::EOpMinInvocationsNonUniform: case glslang::EOpMaxInvocationsNonUniform: case glslang::EOpAddInvocationsNonUniform: case glslang::EOpMinInvocationsInclusiveScan: case glslang::EOpMaxInvocationsInclusiveScan: case glslang::EOpAddInvocationsInclusiveScan: case glslang::EOpMinInvocationsInclusiveScanNonUniform: case glslang::EOpMaxInvocationsInclusiveScanNonUniform: case glslang::EOpAddInvocationsInclusiveScanNonUniform: case glslang::EOpMinInvocationsExclusiveScan: case glslang::EOpMaxInvocationsExclusiveScan: case glslang::EOpAddInvocationsExclusiveScan: case glslang::EOpMinInvocationsExclusiveScanNonUniform: case glslang::EOpMaxInvocationsExclusiveScanNonUniform: case glslang::EOpAddInvocationsExclusiveScanNonUniform: { std::vector operands; operands.push_back(operand); return createInvocationsOperation(op, typeId, operands, typeProxy); } case glslang::EOpSubgroupAll: case glslang::EOpSubgroupAny: case glslang::EOpSubgroupAllEqual: case glslang::EOpSubgroupBroadcastFirst: case glslang::EOpSubgroupBallot: case glslang::EOpSubgroupInverseBallot: case glslang::EOpSubgroupBallotBitCount: case glslang::EOpSubgroupBallotInclusiveBitCount: case glslang::EOpSubgroupBallotExclusiveBitCount: case glslang::EOpSubgroupBallotFindLSB: case glslang::EOpSubgroupBallotFindMSB: case glslang::EOpSubgroupAdd: case glslang::EOpSubgroupMul: case glslang::EOpSubgroupMin: case glslang::EOpSubgroupMax: case glslang::EOpSubgroupAnd: case glslang::EOpSubgroupOr: case glslang::EOpSubgroupXor: case glslang::EOpSubgroupInclusiveAdd: case glslang::EOpSubgroupInclusiveMul: case glslang::EOpSubgroupInclusiveMin: case glslang::EOpSubgroupInclusiveMax: case glslang::EOpSubgroupInclusiveAnd: case glslang::EOpSubgroupInclusiveOr: case glslang::EOpSubgroupInclusiveXor: case glslang::EOpSubgroupExclusiveAdd: case glslang::EOpSubgroupExclusiveMul: case glslang::EOpSubgroupExclusiveMin: case glslang::EOpSubgroupExclusiveMax: case glslang::EOpSubgroupExclusiveAnd: case glslang::EOpSubgroupExclusiveOr: case glslang::EOpSubgroupExclusiveXor: case glslang::EOpSubgroupQuadSwapHorizontal: case glslang::EOpSubgroupQuadSwapVertical: case glslang::EOpSubgroupQuadSwapDiagonal: { std::vector operands; operands.push_back(operand); return createSubgroupOperation(op, typeId, operands, typeProxy); } case glslang::EOpMbcnt: extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_ballot); libCall = spv::MbcntAMD; break; case glslang::EOpCubeFaceIndex: extBuiltins = getExtBuiltins(spv::E_SPV_AMD_gcn_shader); libCall = spv::CubeFaceIndexAMD; break; case glslang::EOpCubeFaceCoord: extBuiltins = getExtBuiltins(spv::E_SPV_AMD_gcn_shader); libCall = spv::CubeFaceCoordAMD; break; case glslang::EOpSubgroupPartition: unaryOp = spv::OpGroupNonUniformPartitionNV; break; case glslang::EOpConstructReference: unaryOp = spv::OpBitcast; break; #endif case glslang::EOpCopyObject: unaryOp = spv::OpCopyObject; break; default: return 0; } spv::Id id; if (libCall >= 0) { std::vector args; args.push_back(operand); id = builder.createBuiltinCall(typeId, extBuiltins >= 0 ? extBuiltins : stdBuiltins, libCall, args); } else { id = builder.createUnaryOp(unaryOp, typeId, operand); } decorations.addNoContraction(builder, id); decorations.addNonUniform(builder, id); return builder.setPrecision(id, decorations.precision); } // Create a unary operation on a matrix spv::Id TGlslangToSpvTraverser::createUnaryMatrixOperation(spv::Op op, OpDecorations& decorations, spv::Id typeId, spv::Id operand, glslang::TBasicType /* typeProxy */) { // Handle unary operations vector by vector. // The result type is the same type as the original type. // The algorithm is to: // - break the matrix into vectors // - apply the operation to each vector // - make a matrix out the vector results // get the types sorted out int numCols = builder.getNumColumns(operand); int numRows = builder.getNumRows(operand); spv::Id srcVecType = builder.makeVectorType(builder.getScalarTypeId(builder.getTypeId(operand)), numRows); spv::Id destVecType = builder.makeVectorType(builder.getScalarTypeId(typeId), numRows); std::vector results; // do each vector op for (int c = 0; c < numCols; ++c) { std::vector indexes; indexes.push_back(c); spv::Id srcVec = builder.createCompositeExtract(operand, srcVecType, indexes); spv::Id destVec = builder.createUnaryOp(op, destVecType, srcVec); decorations.addNoContraction(builder, destVec); decorations.addNonUniform(builder, destVec); results.push_back(builder.setPrecision(destVec, decorations.precision)); } // put the pieces together spv::Id result = builder.setPrecision(builder.createCompositeConstruct(typeId, results), decorations.precision); decorations.addNonUniform(builder, result); return result; } // For converting integers where both the bitwidth and the signedness could // change, but only do the width change here. The caller is still responsible // for the signedness conversion. spv::Id TGlslangToSpvTraverser::createIntWidthConversion(glslang::TOperator op, spv::Id operand, int vectorSize) { // Get the result type width, based on the type to convert to. int width = 32; switch(op) { case glslang::EOpConvInt16ToUint8: case glslang::EOpConvIntToUint8: case glslang::EOpConvInt64ToUint8: case glslang::EOpConvUint16ToInt8: case glslang::EOpConvUintToInt8: case glslang::EOpConvUint64ToInt8: width = 8; break; case glslang::EOpConvInt8ToUint16: case glslang::EOpConvIntToUint16: case glslang::EOpConvInt64ToUint16: case glslang::EOpConvUint8ToInt16: case glslang::EOpConvUintToInt16: case glslang::EOpConvUint64ToInt16: width = 16; break; case glslang::EOpConvInt8ToUint: case glslang::EOpConvInt16ToUint: case glslang::EOpConvInt64ToUint: case glslang::EOpConvUint8ToInt: case glslang::EOpConvUint16ToInt: case glslang::EOpConvUint64ToInt: width = 32; break; case glslang::EOpConvInt8ToUint64: case glslang::EOpConvInt16ToUint64: case glslang::EOpConvIntToUint64: case glslang::EOpConvUint8ToInt64: case glslang::EOpConvUint16ToInt64: case glslang::EOpConvUintToInt64: width = 64; break; default: assert(false && "Default missing"); break; } // Get the conversion operation and result type, // based on the target width, but the source type. spv::Id type = spv::NoType; spv::Op convOp = spv::OpNop; switch(op) { case glslang::EOpConvInt8ToUint16: case glslang::EOpConvInt8ToUint: case glslang::EOpConvInt8ToUint64: case glslang::EOpConvInt16ToUint8: case glslang::EOpConvInt16ToUint: case glslang::EOpConvInt16ToUint64: case glslang::EOpConvIntToUint8: case glslang::EOpConvIntToUint16: case glslang::EOpConvIntToUint64: case glslang::EOpConvInt64ToUint8: case glslang::EOpConvInt64ToUint16: case glslang::EOpConvInt64ToUint: convOp = spv::OpSConvert; type = builder.makeIntType(width); break; default: convOp = spv::OpUConvert; type = builder.makeUintType(width); break; } if (vectorSize > 0) type = builder.makeVectorType(type, vectorSize); return builder.createUnaryOp(convOp, type, operand); } spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, OpDecorations& decorations, spv::Id destType, spv::Id operand, glslang::TBasicType typeProxy) { spv::Op convOp = spv::OpNop; spv::Id zero = 0; spv::Id one = 0; int vectorSize = builder.isVectorType(destType) ? builder.getNumTypeComponents(destType) : 0; switch (op) { case glslang::EOpConvIntToBool: case glslang::EOpConvUintToBool: zero = builder.makeUintConstant(0); zero = makeSmearedConstant(zero, vectorSize); return builder.createBinOp(spv::OpINotEqual, destType, operand, zero); case glslang::EOpConvFloatToBool: zero = builder.makeFloatConstant(0.0F); zero = makeSmearedConstant(zero, vectorSize); return builder.createBinOp(spv::OpFOrdNotEqual, destType, operand, zero); case glslang::EOpConvBoolToFloat: convOp = spv::OpSelect; zero = builder.makeFloatConstant(0.0F); one = builder.makeFloatConstant(1.0F); break; case glslang::EOpConvBoolToInt: case glslang::EOpConvBoolToInt64: #ifndef GLSLANG_WEB if (op == glslang::EOpConvBoolToInt64) { zero = builder.makeInt64Constant(0); one = builder.makeInt64Constant(1); } else #endif { zero = builder.makeIntConstant(0); one = builder.makeIntConstant(1); } convOp = spv::OpSelect; break; case glslang::EOpConvBoolToUint: case glslang::EOpConvBoolToUint64: #ifndef GLSLANG_WEB if (op == glslang::EOpConvBoolToUint64) { zero = builder.makeUint64Constant(0); one = builder.makeUint64Constant(1); } else #endif { zero = builder.makeUintConstant(0); one = builder.makeUintConstant(1); } convOp = spv::OpSelect; break; case glslang::EOpConvInt8ToFloat16: case glslang::EOpConvInt8ToFloat: case glslang::EOpConvInt8ToDouble: case glslang::EOpConvInt16ToFloat16: case glslang::EOpConvInt16ToFloat: case glslang::EOpConvInt16ToDouble: case glslang::EOpConvIntToFloat16: case glslang::EOpConvIntToFloat: case glslang::EOpConvIntToDouble: case glslang::EOpConvInt64ToFloat: case glslang::EOpConvInt64ToDouble: case glslang::EOpConvInt64ToFloat16: convOp = spv::OpConvertSToF; break; case glslang::EOpConvUint8ToFloat16: case glslang::EOpConvUint8ToFloat: case glslang::EOpConvUint8ToDouble: case glslang::EOpConvUint16ToFloat16: case glslang::EOpConvUint16ToFloat: case glslang::EOpConvUint16ToDouble: case glslang::EOpConvUintToFloat16: case glslang::EOpConvUintToFloat: case glslang::EOpConvUintToDouble: case glslang::EOpConvUint64ToFloat: case glslang::EOpConvUint64ToDouble: case glslang::EOpConvUint64ToFloat16: convOp = spv::OpConvertUToF; break; case glslang::EOpConvFloat16ToInt8: case glslang::EOpConvFloatToInt8: case glslang::EOpConvDoubleToInt8: case glslang::EOpConvFloat16ToInt16: case glslang::EOpConvFloatToInt16: case glslang::EOpConvDoubleToInt16: case glslang::EOpConvFloat16ToInt: case glslang::EOpConvFloatToInt: case glslang::EOpConvDoubleToInt: case glslang::EOpConvFloat16ToInt64: case glslang::EOpConvFloatToInt64: case glslang::EOpConvDoubleToInt64: convOp = spv::OpConvertFToS; break; case glslang::EOpConvUint8ToInt8: case glslang::EOpConvInt8ToUint8: case glslang::EOpConvUint16ToInt16: case glslang::EOpConvInt16ToUint16: case glslang::EOpConvUintToInt: case glslang::EOpConvIntToUint: case glslang::EOpConvUint64ToInt64: case glslang::EOpConvInt64ToUint64: if (builder.isInSpecConstCodeGenMode()) { // Build zero scalar or vector for OpIAdd. #ifndef GLSLANG_WEB if(op == glslang::EOpConvUint8ToInt8 || op == glslang::EOpConvInt8ToUint8) { zero = builder.makeUint8Constant(0); } else if (op == glslang::EOpConvUint16ToInt16 || op == glslang::EOpConvInt16ToUint16) { zero = builder.makeUint16Constant(0); } else if (op == glslang::EOpConvUint64ToInt64 || op == glslang::EOpConvInt64ToUint64) { zero = builder.makeUint64Constant(0); } else #endif { zero = builder.makeUintConstant(0); } zero = makeSmearedConstant(zero, vectorSize); // Use OpIAdd, instead of OpBitcast to do the conversion when // generating for OpSpecConstantOp instruction. return builder.createBinOp(spv::OpIAdd, destType, operand, zero); } // For normal run-time conversion instruction, use OpBitcast. convOp = spv::OpBitcast; break; case glslang::EOpConvFloat16ToUint8: case glslang::EOpConvFloatToUint8: case glslang::EOpConvDoubleToUint8: case glslang::EOpConvFloat16ToUint16: case glslang::EOpConvFloatToUint16: case glslang::EOpConvDoubleToUint16: case glslang::EOpConvFloat16ToUint: case glslang::EOpConvFloatToUint: case glslang::EOpConvDoubleToUint: case glslang::EOpConvFloatToUint64: case glslang::EOpConvDoubleToUint64: case glslang::EOpConvFloat16ToUint64: convOp = spv::OpConvertFToU; break; #ifndef GLSLANG_WEB case glslang::EOpConvInt8ToBool: case glslang::EOpConvUint8ToBool: zero = builder.makeUint8Constant(0); zero = makeSmearedConstant(zero, vectorSize); return builder.createBinOp(spv::OpINotEqual, destType, operand, zero); case glslang::EOpConvInt16ToBool: case glslang::EOpConvUint16ToBool: zero = builder.makeUint16Constant(0); zero = makeSmearedConstant(zero, vectorSize); return builder.createBinOp(spv::OpINotEqual, destType, operand, zero); case glslang::EOpConvInt64ToBool: case glslang::EOpConvUint64ToBool: zero = builder.makeUint64Constant(0); zero = makeSmearedConstant(zero, vectorSize); return builder.createBinOp(spv::OpINotEqual, destType, operand, zero); case glslang::EOpConvDoubleToBool: zero = builder.makeDoubleConstant(0.0); zero = makeSmearedConstant(zero, vectorSize); return builder.createBinOp(spv::OpFOrdNotEqual, destType, operand, zero); case glslang::EOpConvFloat16ToBool: zero = builder.makeFloat16Constant(0.0F); zero = makeSmearedConstant(zero, vectorSize); return builder.createBinOp(spv::OpFOrdNotEqual, destType, operand, zero); case glslang::EOpConvBoolToDouble: convOp = spv::OpSelect; zero = builder.makeDoubleConstant(0.0); one = builder.makeDoubleConstant(1.0); break; case glslang::EOpConvBoolToFloat16: convOp = spv::OpSelect; zero = builder.makeFloat16Constant(0.0F); one = builder.makeFloat16Constant(1.0F); break; case glslang::EOpConvBoolToInt8: zero = builder.makeInt8Constant(0); one = builder.makeInt8Constant(1); convOp = spv::OpSelect; break; case glslang::EOpConvBoolToUint8: zero = builder.makeUint8Constant(0); one = builder.makeUint8Constant(1); convOp = spv::OpSelect; break; case glslang::EOpConvBoolToInt16: zero = builder.makeInt16Constant(0); one = builder.makeInt16Constant(1); convOp = spv::OpSelect; break; case glslang::EOpConvBoolToUint16: zero = builder.makeUint16Constant(0); one = builder.makeUint16Constant(1); convOp = spv::OpSelect; break; case glslang::EOpConvDoubleToFloat: case glslang::EOpConvFloatToDouble: case glslang::EOpConvDoubleToFloat16: case glslang::EOpConvFloat16ToDouble: case glslang::EOpConvFloatToFloat16: case glslang::EOpConvFloat16ToFloat: convOp = spv::OpFConvert; if (builder.isMatrixType(destType)) return createUnaryMatrixOperation(convOp, decorations, destType, operand, typeProxy); break; case glslang::EOpConvInt8ToInt16: case glslang::EOpConvInt8ToInt: case glslang::EOpConvInt8ToInt64: case glslang::EOpConvInt16ToInt8: case glslang::EOpConvInt16ToInt: case glslang::EOpConvInt16ToInt64: case glslang::EOpConvIntToInt8: case glslang::EOpConvIntToInt16: case glslang::EOpConvIntToInt64: case glslang::EOpConvInt64ToInt8: case glslang::EOpConvInt64ToInt16: case glslang::EOpConvInt64ToInt: convOp = spv::OpSConvert; break; case glslang::EOpConvUint8ToUint16: case glslang::EOpConvUint8ToUint: case glslang::EOpConvUint8ToUint64: case glslang::EOpConvUint16ToUint8: case glslang::EOpConvUint16ToUint: case glslang::EOpConvUint16ToUint64: case glslang::EOpConvUintToUint8: case glslang::EOpConvUintToUint16: case glslang::EOpConvUintToUint64: case glslang::EOpConvUint64ToUint8: case glslang::EOpConvUint64ToUint16: case glslang::EOpConvUint64ToUint: convOp = spv::OpUConvert; break; case glslang::EOpConvInt8ToUint16: case glslang::EOpConvInt8ToUint: case glslang::EOpConvInt8ToUint64: case glslang::EOpConvInt16ToUint8: case glslang::EOpConvInt16ToUint: case glslang::EOpConvInt16ToUint64: case glslang::EOpConvIntToUint8: case glslang::EOpConvIntToUint16: case glslang::EOpConvIntToUint64: case glslang::EOpConvInt64ToUint8: case glslang::EOpConvInt64ToUint16: case glslang::EOpConvInt64ToUint: case glslang::EOpConvUint8ToInt16: case glslang::EOpConvUint8ToInt: case glslang::EOpConvUint8ToInt64: case glslang::EOpConvUint16ToInt8: case glslang::EOpConvUint16ToInt: case glslang::EOpConvUint16ToInt64: case glslang::EOpConvUintToInt8: case glslang::EOpConvUintToInt16: case glslang::EOpConvUintToInt64: case glslang::EOpConvUint64ToInt8: case glslang::EOpConvUint64ToInt16: case glslang::EOpConvUint64ToInt: // OpSConvert/OpUConvert + OpBitCast operand = createIntWidthConversion(op, operand, vectorSize); if (builder.isInSpecConstCodeGenMode()) { // Build zero scalar or vector for OpIAdd. switch(op) { case glslang::EOpConvInt16ToUint8: case glslang::EOpConvIntToUint8: case glslang::EOpConvInt64ToUint8: case glslang::EOpConvUint16ToInt8: case glslang::EOpConvUintToInt8: case glslang::EOpConvUint64ToInt8: zero = builder.makeUint8Constant(0); break; case glslang::EOpConvInt8ToUint16: case glslang::EOpConvIntToUint16: case glslang::EOpConvInt64ToUint16: case glslang::EOpConvUint8ToInt16: case glslang::EOpConvUintToInt16: case glslang::EOpConvUint64ToInt16: zero = builder.makeUint16Constant(0); break; case glslang::EOpConvInt8ToUint: case glslang::EOpConvInt16ToUint: case glslang::EOpConvInt64ToUint: case glslang::EOpConvUint8ToInt: case glslang::EOpConvUint16ToInt: case glslang::EOpConvUint64ToInt: zero = builder.makeUintConstant(0); break; case glslang::EOpConvInt8ToUint64: case glslang::EOpConvInt16ToUint64: case glslang::EOpConvIntToUint64: case glslang::EOpConvUint8ToInt64: case glslang::EOpConvUint16ToInt64: case glslang::EOpConvUintToInt64: zero = builder.makeUint64Constant(0); break; default: assert(false && "Default missing"); break; } zero = makeSmearedConstant(zero, vectorSize); // Use OpIAdd, instead of OpBitcast to do the conversion when // generating for OpSpecConstantOp instruction. return builder.createBinOp(spv::OpIAdd, destType, operand, zero); } // For normal run-time conversion instruction, use OpBitcast. convOp = spv::OpBitcast; break; case glslang::EOpConvUint64ToPtr: convOp = spv::OpConvertUToPtr; break; case glslang::EOpConvPtrToUint64: convOp = spv::OpConvertPtrToU; break; case glslang::EOpConvPtrToUvec2: case glslang::EOpConvUvec2ToPtr: if (builder.isVector(operand)) builder.promoteIncorporatedExtension(spv::E_SPV_EXT_physical_storage_buffer, spv::E_SPV_KHR_physical_storage_buffer, spv::Spv_1_5); convOp = spv::OpBitcast; break; #endif default: break; } spv::Id result = 0; if (convOp == spv::OpNop) return result; if (convOp == spv::OpSelect) { zero = makeSmearedConstant(zero, vectorSize); one = makeSmearedConstant(one, vectorSize); result = builder.createTriOp(convOp, destType, operand, one, zero); } else result = builder.createUnaryOp(convOp, destType, operand); result = builder.setPrecision(result, decorations.precision); decorations.addNonUniform(builder, result); return result; } spv::Id TGlslangToSpvTraverser::makeSmearedConstant(spv::Id constant, int vectorSize) { if (vectorSize == 0) return constant; spv::Id vectorTypeId = builder.makeVectorType(builder.getTypeId(constant), vectorSize); std::vector components; for (int c = 0; c < vectorSize; ++c) components.push_back(constant); return builder.makeCompositeConstant(vectorTypeId, components); } // For glslang ops that map to SPV atomic opCodes spv::Id TGlslangToSpvTraverser::createAtomicOperation(glslang::TOperator op, spv::Decoration /*precision*/, spv::Id typeId, std::vector& operands, glslang::TBasicType typeProxy, const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags) { spv::Op opCode = spv::OpNop; switch (op) { case glslang::EOpAtomicAdd: case glslang::EOpImageAtomicAdd: case glslang::EOpAtomicCounterAdd: opCode = spv::OpAtomicIAdd; break; case glslang::EOpAtomicCounterSubtract: opCode = spv::OpAtomicISub; break; case glslang::EOpAtomicMin: case glslang::EOpImageAtomicMin: case glslang::EOpAtomicCounterMin: opCode = (typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64) ? spv::OpAtomicUMin : spv::OpAtomicSMin; break; case glslang::EOpAtomicMax: case glslang::EOpImageAtomicMax: case glslang::EOpAtomicCounterMax: opCode = (typeProxy == glslang::EbtUint || typeProxy == glslang::EbtUint64) ? spv::OpAtomicUMax : spv::OpAtomicSMax; break; case glslang::EOpAtomicAnd: case glslang::EOpImageAtomicAnd: case glslang::EOpAtomicCounterAnd: opCode = spv::OpAtomicAnd; break; case glslang::EOpAtomicOr: case glslang::EOpImageAtomicOr: case glslang::EOpAtomicCounterOr: opCode = spv::OpAtomicOr; break; case glslang::EOpAtomicXor: case glslang::EOpImageAtomicXor: case glslang::EOpAtomicCounterXor: opCode = spv::OpAtomicXor; break; case glslang::EOpAtomicExchange: case glslang::EOpImageAtomicExchange: case glslang::EOpAtomicCounterExchange: opCode = spv::OpAtomicExchange; break; case glslang::EOpAtomicCompSwap: case glslang::EOpImageAtomicCompSwap: case glslang::EOpAtomicCounterCompSwap: opCode = spv::OpAtomicCompareExchange; break; case glslang::EOpAtomicCounterIncrement: opCode = spv::OpAtomicIIncrement; break; case glslang::EOpAtomicCounterDecrement: opCode = spv::OpAtomicIDecrement; break; case glslang::EOpAtomicCounter: case glslang::EOpImageAtomicLoad: case glslang::EOpAtomicLoad: opCode = spv::OpAtomicLoad; break; case glslang::EOpAtomicStore: case glslang::EOpImageAtomicStore: opCode = spv::OpAtomicStore; break; default: assert(0); break; } if (typeProxy == glslang::EbtInt64 || typeProxy == glslang::EbtUint64) builder.addCapability(spv::CapabilityInt64Atomics); // Sort out the operands // - mapping from glslang -> SPV // - there are extra SPV operands that are optional in glslang // - compare-exchange swaps the value and comparator // - compare-exchange has an extra memory semantics // - EOpAtomicCounterDecrement needs a post decrement spv::Id pointerId = 0, compareId = 0, valueId = 0; // scope defaults to Device in the old model, QueueFamilyKHR in the new model spv::Id scopeId; if (glslangIntermediate->usingVulkanMemoryModel()) { scopeId = builder.makeUintConstant(spv::ScopeQueueFamilyKHR); } else { scopeId = builder.makeUintConstant(spv::ScopeDevice); } // semantics default to relaxed spv::Id semanticsId = builder.makeUintConstant(lvalueCoherentFlags.isVolatile() && glslangIntermediate->usingVulkanMemoryModel() ? spv::MemorySemanticsVolatileMask : spv::MemorySemanticsMaskNone); spv::Id semanticsId2 = semanticsId; pointerId = operands[0]; if (opCode == spv::OpAtomicIIncrement || opCode == spv::OpAtomicIDecrement) { // no additional operands } else if (opCode == spv::OpAtomicCompareExchange) { compareId = operands[1]; valueId = operands[2]; if (operands.size() > 3) { scopeId = operands[3]; semanticsId = builder.makeUintConstant(builder.getConstantScalar(operands[4]) | builder.getConstantScalar(operands[5])); semanticsId2 = builder.makeUintConstant(builder.getConstantScalar(operands[6]) | builder.getConstantScalar(operands[7])); } } else if (opCode == spv::OpAtomicLoad) { if (operands.size() > 1) { scopeId = operands[1]; semanticsId = builder.makeUintConstant(builder.getConstantScalar(operands[2]) | builder.getConstantScalar(operands[3])); } } else { // atomic store or RMW valueId = operands[1]; if (operands.size() > 2) { scopeId = operands[2]; semanticsId = builder.makeUintConstant(builder.getConstantScalar(operands[3]) | builder.getConstantScalar(operands[4])); } } // Check for capabilities unsigned semanticsImmediate = builder.getConstantScalar(semanticsId) | builder.getConstantScalar(semanticsId2); if (semanticsImmediate & (spv::MemorySemanticsMakeAvailableKHRMask | spv::MemorySemanticsMakeVisibleKHRMask | spv::MemorySemanticsOutputMemoryKHRMask | spv::MemorySemanticsVolatileMask)) { builder.addCapability(spv::CapabilityVulkanMemoryModelKHR); } if (glslangIntermediate->usingVulkanMemoryModel() && builder.getConstantScalar(scopeId) == spv::ScopeDevice) { builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR); } std::vector spvAtomicOperands; // hold the spv operands spvAtomicOperands.push_back(pointerId); spvAtomicOperands.push_back(scopeId); spvAtomicOperands.push_back(semanticsId); if (opCode == spv::OpAtomicCompareExchange) { spvAtomicOperands.push_back(semanticsId2); spvAtomicOperands.push_back(valueId); spvAtomicOperands.push_back(compareId); } else if (opCode != spv::OpAtomicLoad && opCode != spv::OpAtomicIIncrement && opCode != spv::OpAtomicIDecrement) { spvAtomicOperands.push_back(valueId); } if (opCode == spv::OpAtomicStore) { builder.createNoResultOp(opCode, spvAtomicOperands); return 0; } else { spv::Id resultId = builder.createOp(opCode, typeId, spvAtomicOperands); // GLSL and HLSL atomic-counter decrement return post-decrement value, // while SPIR-V returns pre-decrement value. Translate between these semantics. if (op == glslang::EOpAtomicCounterDecrement) resultId = builder.createBinOp(spv::OpISub, typeId, resultId, builder.makeIntConstant(1)); return resultId; } } // Create group invocation operations. spv::Id TGlslangToSpvTraverser::createInvocationsOperation(glslang::TOperator op, spv::Id typeId, std::vector& operands, glslang::TBasicType typeProxy) { bool isUnsigned = isTypeUnsignedInt(typeProxy); bool isFloat = isTypeFloat(typeProxy); spv::Op opCode = spv::OpNop; std::vector spvGroupOperands; spv::GroupOperation groupOperation = spv::GroupOperationMax; if (op == glslang::EOpBallot || op == glslang::EOpReadFirstInvocation || op == glslang::EOpReadInvocation) { builder.addExtension(spv::E_SPV_KHR_shader_ballot); builder.addCapability(spv::CapabilitySubgroupBallotKHR); } else if (op == glslang::EOpAnyInvocation || op == glslang::EOpAllInvocations || op == glslang::EOpAllInvocationsEqual) { builder.addExtension(spv::E_SPV_KHR_subgroup_vote); builder.addCapability(spv::CapabilitySubgroupVoteKHR); } else { builder.addCapability(spv::CapabilityGroups); if (op == glslang::EOpMinInvocationsNonUniform || op == glslang::EOpMaxInvocationsNonUniform || op == glslang::EOpAddInvocationsNonUniform || op == glslang::EOpMinInvocationsInclusiveScanNonUniform || op == glslang::EOpMaxInvocationsInclusiveScanNonUniform || op == glslang::EOpAddInvocationsInclusiveScanNonUniform || op == glslang::EOpMinInvocationsExclusiveScanNonUniform || op == glslang::EOpMaxInvocationsExclusiveScanNonUniform || op == glslang::EOpAddInvocationsExclusiveScanNonUniform) builder.addExtension(spv::E_SPV_AMD_shader_ballot); switch (op) { case glslang::EOpMinInvocations: case glslang::EOpMaxInvocations: case glslang::EOpAddInvocations: case glslang::EOpMinInvocationsNonUniform: case glslang::EOpMaxInvocationsNonUniform: case glslang::EOpAddInvocationsNonUniform: groupOperation = spv::GroupOperationReduce; break; case glslang::EOpMinInvocationsInclusiveScan: case glslang::EOpMaxInvocationsInclusiveScan: case glslang::EOpAddInvocationsInclusiveScan: case glslang::EOpMinInvocationsInclusiveScanNonUniform: case glslang::EOpMaxInvocationsInclusiveScanNonUniform: case glslang::EOpAddInvocationsInclusiveScanNonUniform: groupOperation = spv::GroupOperationInclusiveScan; break; case glslang::EOpMinInvocationsExclusiveScan: case glslang::EOpMaxInvocationsExclusiveScan: case glslang::EOpAddInvocationsExclusiveScan: case glslang::EOpMinInvocationsExclusiveScanNonUniform: case glslang::EOpMaxInvocationsExclusiveScanNonUniform: case glslang::EOpAddInvocationsExclusiveScanNonUniform: groupOperation = spv::GroupOperationExclusiveScan; break; default: break; } spv::IdImmediate scope = { true, builder.makeUintConstant(spv::ScopeSubgroup) }; spvGroupOperands.push_back(scope); if (groupOperation != spv::GroupOperationMax) { spv::IdImmediate groupOp = { false, (unsigned)groupOperation }; spvGroupOperands.push_back(groupOp); } } for (auto opIt = operands.begin(); opIt != operands.end(); ++opIt) { spv::IdImmediate op = { true, *opIt }; spvGroupOperands.push_back(op); } switch (op) { case glslang::EOpAnyInvocation: opCode = spv::OpSubgroupAnyKHR; break; case glslang::EOpAllInvocations: opCode = spv::OpSubgroupAllKHR; break; case glslang::EOpAllInvocationsEqual: opCode = spv::OpSubgroupAllEqualKHR; break; case glslang::EOpReadInvocation: opCode = spv::OpSubgroupReadInvocationKHR; if (builder.isVectorType(typeId)) return CreateInvocationsVectorOperation(opCode, groupOperation, typeId, operands); break; case glslang::EOpReadFirstInvocation: opCode = spv::OpSubgroupFirstInvocationKHR; break; case glslang::EOpBallot: { // NOTE: According to the spec, the result type of "OpSubgroupBallotKHR" must be a 4 component vector of 32 // bit integer types. The GLSL built-in function "ballotARB()" assumes the maximum number of invocations in // a subgroup is 64. Thus, we have to convert uvec4.xy to uint64_t as follow: // // result = Bitcast(SubgroupBallotKHR(Predicate).xy) // spv::Id uintType = builder.makeUintType(32); spv::Id uvec4Type = builder.makeVectorType(uintType, 4); spv::Id result = builder.createOp(spv::OpSubgroupBallotKHR, uvec4Type, spvGroupOperands); std::vector components; components.push_back(builder.createCompositeExtract(result, uintType, 0)); components.push_back(builder.createCompositeExtract(result, uintType, 1)); spv::Id uvec2Type = builder.makeVectorType(uintType, 2); return builder.createUnaryOp(spv::OpBitcast, typeId, builder.createCompositeConstruct(uvec2Type, components)); } case glslang::EOpMinInvocations: case glslang::EOpMaxInvocations: case glslang::EOpAddInvocations: case glslang::EOpMinInvocationsInclusiveScan: case glslang::EOpMaxInvocationsInclusiveScan: case glslang::EOpAddInvocationsInclusiveScan: case glslang::EOpMinInvocationsExclusiveScan: case glslang::EOpMaxInvocationsExclusiveScan: case glslang::EOpAddInvocationsExclusiveScan: if (op == glslang::EOpMinInvocations || op == glslang::EOpMinInvocationsInclusiveScan || op == glslang::EOpMinInvocationsExclusiveScan) { if (isFloat) opCode = spv::OpGroupFMin; else { if (isUnsigned) opCode = spv::OpGroupUMin; else opCode = spv::OpGroupSMin; } } else if (op == glslang::EOpMaxInvocations || op == glslang::EOpMaxInvocationsInclusiveScan || op == glslang::EOpMaxInvocationsExclusiveScan) { if (isFloat) opCode = spv::OpGroupFMax; else { if (isUnsigned) opCode = spv::OpGroupUMax; else opCode = spv::OpGroupSMax; } } else { if (isFloat) opCode = spv::OpGroupFAdd; else opCode = spv::OpGroupIAdd; } if (builder.isVectorType(typeId)) return CreateInvocationsVectorOperation(opCode, groupOperation, typeId, operands); break; case glslang::EOpMinInvocationsNonUniform: case glslang::EOpMaxInvocationsNonUniform: case glslang::EOpAddInvocationsNonUniform: case glslang::EOpMinInvocationsInclusiveScanNonUniform: case glslang::EOpMaxInvocationsInclusiveScanNonUniform: case glslang::EOpAddInvocationsInclusiveScanNonUniform: case glslang::EOpMinInvocationsExclusiveScanNonUniform: case glslang::EOpMaxInvocationsExclusiveScanNonUniform: case glslang::EOpAddInvocationsExclusiveScanNonUniform: if (op == glslang::EOpMinInvocationsNonUniform || op == glslang::EOpMinInvocationsInclusiveScanNonUniform || op == glslang::EOpMinInvocationsExclusiveScanNonUniform) { if (isFloat) opCode = spv::OpGroupFMinNonUniformAMD; else { if (isUnsigned) opCode = spv::OpGroupUMinNonUniformAMD; else opCode = spv::OpGroupSMinNonUniformAMD; } } else if (op == glslang::EOpMaxInvocationsNonUniform || op == glslang::EOpMaxInvocationsInclusiveScanNonUniform || op == glslang::EOpMaxInvocationsExclusiveScanNonUniform) { if (isFloat) opCode = spv::OpGroupFMaxNonUniformAMD; else { if (isUnsigned) opCode = spv::OpGroupUMaxNonUniformAMD; else opCode = spv::OpGroupSMaxNonUniformAMD; } } else { if (isFloat) opCode = spv::OpGroupFAddNonUniformAMD; else opCode = spv::OpGroupIAddNonUniformAMD; } if (builder.isVectorType(typeId)) return CreateInvocationsVectorOperation(opCode, groupOperation, typeId, operands); break; default: logger->missingFunctionality("invocation operation"); return spv::NoResult; } assert(opCode != spv::OpNop); return builder.createOp(opCode, typeId, spvGroupOperands); } // Create group invocation operations on a vector spv::Id TGlslangToSpvTraverser::CreateInvocationsVectorOperation(spv::Op op, spv::GroupOperation groupOperation, spv::Id typeId, std::vector& operands) { assert(op == spv::OpGroupFMin || op == spv::OpGroupUMin || op == spv::OpGroupSMin || op == spv::OpGroupFMax || op == spv::OpGroupUMax || op == spv::OpGroupSMax || op == spv::OpGroupFAdd || op == spv::OpGroupIAdd || op == spv::OpGroupBroadcast || op == spv::OpSubgroupReadInvocationKHR || op == spv::OpGroupFMinNonUniformAMD || op == spv::OpGroupUMinNonUniformAMD || op == spv::OpGroupSMinNonUniformAMD || op == spv::OpGroupFMaxNonUniformAMD || op == spv::OpGroupUMaxNonUniformAMD || op == spv::OpGroupSMaxNonUniformAMD || op == spv::OpGroupFAddNonUniformAMD || op == spv::OpGroupIAddNonUniformAMD); // Handle group invocation operations scalar by scalar. // The result type is the same type as the original type. // The algorithm is to: // - break the vector into scalars // - apply the operation to each scalar // - make a vector out the scalar results // get the types sorted out int numComponents = builder.getNumComponents(operands[0]); spv::Id scalarType = builder.getScalarTypeId(builder.getTypeId(operands[0])); std::vector results; // do each scalar op for (int comp = 0; comp < numComponents; ++comp) { std::vector indexes; indexes.push_back(comp); spv::IdImmediate scalar = { true, builder.createCompositeExtract(operands[0], scalarType, indexes) }; std::vector spvGroupOperands; if (op == spv::OpSubgroupReadInvocationKHR) { spvGroupOperands.push_back(scalar); spv::IdImmediate operand = { true, operands[1] }; spvGroupOperands.push_back(operand); } else if (op == spv::OpGroupBroadcast) { spv::IdImmediate scope = { true, builder.makeUintConstant(spv::ScopeSubgroup) }; spvGroupOperands.push_back(scope); spvGroupOperands.push_back(scalar); spv::IdImmediate operand = { true, operands[1] }; spvGroupOperands.push_back(operand); } else { spv::IdImmediate scope = { true, builder.makeUintConstant(spv::ScopeSubgroup) }; spvGroupOperands.push_back(scope); spv::IdImmediate groupOp = { false, (unsigned)groupOperation }; spvGroupOperands.push_back(groupOp); spvGroupOperands.push_back(scalar); } results.push_back(builder.createOp(op, scalarType, spvGroupOperands)); } // put the pieces together return builder.createCompositeConstruct(typeId, results); } // Create subgroup invocation operations. spv::Id TGlslangToSpvTraverser::createSubgroupOperation(glslang::TOperator op, spv::Id typeId, std::vector& operands, glslang::TBasicType typeProxy) { // Add the required capabilities. switch (op) { case glslang::EOpSubgroupElect: builder.addCapability(spv::CapabilityGroupNonUniform); break; case glslang::EOpSubgroupAll: case glslang::EOpSubgroupAny: case glslang::EOpSubgroupAllEqual: builder.addCapability(spv::CapabilityGroupNonUniform); builder.addCapability(spv::CapabilityGroupNonUniformVote); break; case glslang::EOpSubgroupBroadcast: case glslang::EOpSubgroupBroadcastFirst: case glslang::EOpSubgroupBallot: case glslang::EOpSubgroupInverseBallot: case glslang::EOpSubgroupBallotBitExtract: case glslang::EOpSubgroupBallotBitCount: case glslang::EOpSubgroupBallotInclusiveBitCount: case glslang::EOpSubgroupBallotExclusiveBitCount: case glslang::EOpSubgroupBallotFindLSB: case glslang::EOpSubgroupBallotFindMSB: builder.addCapability(spv::CapabilityGroupNonUniform); builder.addCapability(spv::CapabilityGroupNonUniformBallot); break; case glslang::EOpSubgroupShuffle: case glslang::EOpSubgroupShuffleXor: builder.addCapability(spv::CapabilityGroupNonUniform); builder.addCapability(spv::CapabilityGroupNonUniformShuffle); break; case glslang::EOpSubgroupShuffleUp: case glslang::EOpSubgroupShuffleDown: builder.addCapability(spv::CapabilityGroupNonUniform); builder.addCapability(spv::CapabilityGroupNonUniformShuffleRelative); break; case glslang::EOpSubgroupAdd: case glslang::EOpSubgroupMul: case glslang::EOpSubgroupMin: case glslang::EOpSubgroupMax: case glslang::EOpSubgroupAnd: case glslang::EOpSubgroupOr: case glslang::EOpSubgroupXor: case glslang::EOpSubgroupInclusiveAdd: case glslang::EOpSubgroupInclusiveMul: case glslang::EOpSubgroupInclusiveMin: case glslang::EOpSubgroupInclusiveMax: case glslang::EOpSubgroupInclusiveAnd: case glslang::EOpSubgroupInclusiveOr: case glslang::EOpSubgroupInclusiveXor: case glslang::EOpSubgroupExclusiveAdd: case glslang::EOpSubgroupExclusiveMul: case glslang::EOpSubgroupExclusiveMin: case glslang::EOpSubgroupExclusiveMax: case glslang::EOpSubgroupExclusiveAnd: case glslang::EOpSubgroupExclusiveOr: case glslang::EOpSubgroupExclusiveXor: builder.addCapability(spv::CapabilityGroupNonUniform); builder.addCapability(spv::CapabilityGroupNonUniformArithmetic); break; case glslang::EOpSubgroupClusteredAdd: case glslang::EOpSubgroupClusteredMul: case glslang::EOpSubgroupClusteredMin: case glslang::EOpSubgroupClusteredMax: case glslang::EOpSubgroupClusteredAnd: case glslang::EOpSubgroupClusteredOr: case glslang::EOpSubgroupClusteredXor: builder.addCapability(spv::CapabilityGroupNonUniform); builder.addCapability(spv::CapabilityGroupNonUniformClustered); break; case glslang::EOpSubgroupQuadBroadcast: case glslang::EOpSubgroupQuadSwapHorizontal: case glslang::EOpSubgroupQuadSwapVertical: case glslang::EOpSubgroupQuadSwapDiagonal: builder.addCapability(spv::CapabilityGroupNonUniform); builder.addCapability(spv::CapabilityGroupNonUniformQuad); break; case glslang::EOpSubgroupPartitionedAdd: case glslang::EOpSubgroupPartitionedMul: case glslang::EOpSubgroupPartitionedMin: case glslang::EOpSubgroupPartitionedMax: case glslang::EOpSubgroupPartitionedAnd: case glslang::EOpSubgroupPartitionedOr: case glslang::EOpSubgroupPartitionedXor: case glslang::EOpSubgroupPartitionedInclusiveAdd: case glslang::EOpSubgroupPartitionedInclusiveMul: case glslang::EOpSubgroupPartitionedInclusiveMin: case glslang::EOpSubgroupPartitionedInclusiveMax: case glslang::EOpSubgroupPartitionedInclusiveAnd: case glslang::EOpSubgroupPartitionedInclusiveOr: case glslang::EOpSubgroupPartitionedInclusiveXor: case glslang::EOpSubgroupPartitionedExclusiveAdd: case glslang::EOpSubgroupPartitionedExclusiveMul: case glslang::EOpSubgroupPartitionedExclusiveMin: case glslang::EOpSubgroupPartitionedExclusiveMax: case glslang::EOpSubgroupPartitionedExclusiveAnd: case glslang::EOpSubgroupPartitionedExclusiveOr: case glslang::EOpSubgroupPartitionedExclusiveXor: builder.addExtension(spv::E_SPV_NV_shader_subgroup_partitioned); builder.addCapability(spv::CapabilityGroupNonUniformPartitionedNV); break; default: assert(0 && "Unhandled subgroup operation!"); } const bool isUnsigned = isTypeUnsignedInt(typeProxy); const bool isFloat = isTypeFloat(typeProxy); const bool isBool = typeProxy == glslang::EbtBool; spv::Op opCode = spv::OpNop; // Figure out which opcode to use. switch (op) { case glslang::EOpSubgroupElect: opCode = spv::OpGroupNonUniformElect; break; case glslang::EOpSubgroupAll: opCode = spv::OpGroupNonUniformAll; break; case glslang::EOpSubgroupAny: opCode = spv::OpGroupNonUniformAny; break; case glslang::EOpSubgroupAllEqual: opCode = spv::OpGroupNonUniformAllEqual; break; case glslang::EOpSubgroupBroadcast: opCode = spv::OpGroupNonUniformBroadcast; break; case glslang::EOpSubgroupBroadcastFirst: opCode = spv::OpGroupNonUniformBroadcastFirst; break; case glslang::EOpSubgroupBallot: opCode = spv::OpGroupNonUniformBallot; break; case glslang::EOpSubgroupInverseBallot: opCode = spv::OpGroupNonUniformInverseBallot; break; case glslang::EOpSubgroupBallotBitExtract: opCode = spv::OpGroupNonUniformBallotBitExtract; break; case glslang::EOpSubgroupBallotBitCount: case glslang::EOpSubgroupBallotInclusiveBitCount: case glslang::EOpSubgroupBallotExclusiveBitCount: opCode = spv::OpGroupNonUniformBallotBitCount; break; case glslang::EOpSubgroupBallotFindLSB: opCode = spv::OpGroupNonUniformBallotFindLSB; break; case glslang::EOpSubgroupBallotFindMSB: opCode = spv::OpGroupNonUniformBallotFindMSB; break; case glslang::EOpSubgroupShuffle: opCode = spv::OpGroupNonUniformShuffle; break; case glslang::EOpSubgroupShuffleXor: opCode = spv::OpGroupNonUniformShuffleXor; break; case glslang::EOpSubgroupShuffleUp: opCode = spv::OpGroupNonUniformShuffleUp; break; case glslang::EOpSubgroupShuffleDown: opCode = spv::OpGroupNonUniformShuffleDown; break; case glslang::EOpSubgroupAdd: case glslang::EOpSubgroupInclusiveAdd: case glslang::EOpSubgroupExclusiveAdd: case glslang::EOpSubgroupClusteredAdd: case glslang::EOpSubgroupPartitionedAdd: case glslang::EOpSubgroupPartitionedInclusiveAdd: case glslang::EOpSubgroupPartitionedExclusiveAdd: if (isFloat) { opCode = spv::OpGroupNonUniformFAdd; } else { opCode = spv::OpGroupNonUniformIAdd; } break; case glslang::EOpSubgroupMul: case glslang::EOpSubgroupInclusiveMul: case glslang::EOpSubgroupExclusiveMul: case glslang::EOpSubgroupClusteredMul: case glslang::EOpSubgroupPartitionedMul: case glslang::EOpSubgroupPartitionedInclusiveMul: case glslang::EOpSubgroupPartitionedExclusiveMul: if (isFloat) { opCode = spv::OpGroupNonUniformFMul; } else { opCode = spv::OpGroupNonUniformIMul; } break; case glslang::EOpSubgroupMin: case glslang::EOpSubgroupInclusiveMin: case glslang::EOpSubgroupExclusiveMin: case glslang::EOpSubgroupClusteredMin: case glslang::EOpSubgroupPartitionedMin: case glslang::EOpSubgroupPartitionedInclusiveMin: case glslang::EOpSubgroupPartitionedExclusiveMin: if (isFloat) { opCode = spv::OpGroupNonUniformFMin; } else if (isUnsigned) { opCode = spv::OpGroupNonUniformUMin; } else { opCode = spv::OpGroupNonUniformSMin; } break; case glslang::EOpSubgroupMax: case glslang::EOpSubgroupInclusiveMax: case glslang::EOpSubgroupExclusiveMax: case glslang::EOpSubgroupClusteredMax: case glslang::EOpSubgroupPartitionedMax: case glslang::EOpSubgroupPartitionedInclusiveMax: case glslang::EOpSubgroupPartitionedExclusiveMax: if (isFloat) { opCode = spv::OpGroupNonUniformFMax; } else if (isUnsigned) { opCode = spv::OpGroupNonUniformUMax; } else { opCode = spv::OpGroupNonUniformSMax; } break; case glslang::EOpSubgroupAnd: case glslang::EOpSubgroupInclusiveAnd: case glslang::EOpSubgroupExclusiveAnd: case glslang::EOpSubgroupClusteredAnd: case glslang::EOpSubgroupPartitionedAnd: case glslang::EOpSubgroupPartitionedInclusiveAnd: case glslang::EOpSubgroupPartitionedExclusiveAnd: if (isBool) { opCode = spv::OpGroupNonUniformLogicalAnd; } else { opCode = spv::OpGroupNonUniformBitwiseAnd; } break; case glslang::EOpSubgroupOr: case glslang::EOpSubgroupInclusiveOr: case glslang::EOpSubgroupExclusiveOr: case glslang::EOpSubgroupClusteredOr: case glslang::EOpSubgroupPartitionedOr: case glslang::EOpSubgroupPartitionedInclusiveOr: case glslang::EOpSubgroupPartitionedExclusiveOr: if (isBool) { opCode = spv::OpGroupNonUniformLogicalOr; } else { opCode = spv::OpGroupNonUniformBitwiseOr; } break; case glslang::EOpSubgroupXor: case glslang::EOpSubgroupInclusiveXor: case glslang::EOpSubgroupExclusiveXor: case glslang::EOpSubgroupClusteredXor: case glslang::EOpSubgroupPartitionedXor: case glslang::EOpSubgroupPartitionedInclusiveXor: case glslang::EOpSubgroupPartitionedExclusiveXor: if (isBool) { opCode = spv::OpGroupNonUniformLogicalXor; } else { opCode = spv::OpGroupNonUniformBitwiseXor; } break; case glslang::EOpSubgroupQuadBroadcast: opCode = spv::OpGroupNonUniformQuadBroadcast; break; case glslang::EOpSubgroupQuadSwapHorizontal: case glslang::EOpSubgroupQuadSwapVertical: case glslang::EOpSubgroupQuadSwapDiagonal: opCode = spv::OpGroupNonUniformQuadSwap; break; default: assert(0 && "Unhandled subgroup operation!"); } // get the right Group Operation spv::GroupOperation groupOperation = spv::GroupOperationMax; switch (op) { default: break; case glslang::EOpSubgroupBallotBitCount: case glslang::EOpSubgroupAdd: case glslang::EOpSubgroupMul: case glslang::EOpSubgroupMin: case glslang::EOpSubgroupMax: case glslang::EOpSubgroupAnd: case glslang::EOpSubgroupOr: case glslang::EOpSubgroupXor: groupOperation = spv::GroupOperationReduce; break; case glslang::EOpSubgroupBallotInclusiveBitCount: case glslang::EOpSubgroupInclusiveAdd: case glslang::EOpSubgroupInclusiveMul: case glslang::EOpSubgroupInclusiveMin: case glslang::EOpSubgroupInclusiveMax: case glslang::EOpSubgroupInclusiveAnd: case glslang::EOpSubgroupInclusiveOr: case glslang::EOpSubgroupInclusiveXor: groupOperation = spv::GroupOperationInclusiveScan; break; case glslang::EOpSubgroupBallotExclusiveBitCount: case glslang::EOpSubgroupExclusiveAdd: case glslang::EOpSubgroupExclusiveMul: case glslang::EOpSubgroupExclusiveMin: case glslang::EOpSubgroupExclusiveMax: case glslang::EOpSubgroupExclusiveAnd: case glslang::EOpSubgroupExclusiveOr: case glslang::EOpSubgroupExclusiveXor: groupOperation = spv::GroupOperationExclusiveScan; break; case glslang::EOpSubgroupClusteredAdd: case glslang::EOpSubgroupClusteredMul: case glslang::EOpSubgroupClusteredMin: case glslang::EOpSubgroupClusteredMax: case glslang::EOpSubgroupClusteredAnd: case glslang::EOpSubgroupClusteredOr: case glslang::EOpSubgroupClusteredXor: groupOperation = spv::GroupOperationClusteredReduce; break; case glslang::EOpSubgroupPartitionedAdd: case glslang::EOpSubgroupPartitionedMul: case glslang::EOpSubgroupPartitionedMin: case glslang::EOpSubgroupPartitionedMax: case glslang::EOpSubgroupPartitionedAnd: case glslang::EOpSubgroupPartitionedOr: case glslang::EOpSubgroupPartitionedXor: groupOperation = spv::GroupOperationPartitionedReduceNV; break; case glslang::EOpSubgroupPartitionedInclusiveAdd: case glslang::EOpSubgroupPartitionedInclusiveMul: case glslang::EOpSubgroupPartitionedInclusiveMin: case glslang::EOpSubgroupPartitionedInclusiveMax: case glslang::EOpSubgroupPartitionedInclusiveAnd: case glslang::EOpSubgroupPartitionedInclusiveOr: case glslang::EOpSubgroupPartitionedInclusiveXor: groupOperation = spv::GroupOperationPartitionedInclusiveScanNV; break; case glslang::EOpSubgroupPartitionedExclusiveAdd: case glslang::EOpSubgroupPartitionedExclusiveMul: case glslang::EOpSubgroupPartitionedExclusiveMin: case glslang::EOpSubgroupPartitionedExclusiveMax: case glslang::EOpSubgroupPartitionedExclusiveAnd: case glslang::EOpSubgroupPartitionedExclusiveOr: case glslang::EOpSubgroupPartitionedExclusiveXor: groupOperation = spv::GroupOperationPartitionedExclusiveScanNV; break; } // build the instruction std::vector spvGroupOperands; // Every operation begins with the Execution Scope operand. spv::IdImmediate executionScope = { true, builder.makeUintConstant(spv::ScopeSubgroup) }; spvGroupOperands.push_back(executionScope); // Next, for all operations that use a Group Operation, push that as an operand. if (groupOperation != spv::GroupOperationMax) { spv::IdImmediate groupOperand = { false, (unsigned)groupOperation }; spvGroupOperands.push_back(groupOperand); } // Push back the operands next. for (auto opIt = operands.cbegin(); opIt != operands.cend(); ++opIt) { spv::IdImmediate operand = { true, *opIt }; spvGroupOperands.push_back(operand); } // Some opcodes have additional operands. spv::Id directionId = spv::NoResult; switch (op) { default: break; case glslang::EOpSubgroupQuadSwapHorizontal: directionId = builder.makeUintConstant(0); break; case glslang::EOpSubgroupQuadSwapVertical: directionId = builder.makeUintConstant(1); break; case glslang::EOpSubgroupQuadSwapDiagonal: directionId = builder.makeUintConstant(2); break; } if (directionId != spv::NoResult) { spv::IdImmediate direction = { true, directionId }; spvGroupOperands.push_back(direction); } return builder.createOp(opCode, typeId, spvGroupOperands); } spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId, std::vector& operands, glslang::TBasicType typeProxy) { bool isUnsigned = isTypeUnsignedInt(typeProxy); bool isFloat = isTypeFloat(typeProxy); spv::Op opCode = spv::OpNop; int extBuiltins = -1; int libCall = -1; size_t consumedOperands = operands.size(); spv::Id typeId0 = 0; if (consumedOperands > 0) typeId0 = builder.getTypeId(operands[0]); spv::Id typeId1 = 0; if (consumedOperands > 1) typeId1 = builder.getTypeId(operands[1]); spv::Id frexpIntType = 0; switch (op) { case glslang::EOpMin: if (isFloat) libCall = nanMinMaxClamp ? spv::GLSLstd450NMin : spv::GLSLstd450FMin; else if (isUnsigned) libCall = spv::GLSLstd450UMin; else libCall = spv::GLSLstd450SMin; builder.promoteScalar(precision, operands.front(), operands.back()); break; case glslang::EOpModf: libCall = spv::GLSLstd450Modf; break; case glslang::EOpMax: if (isFloat) libCall = nanMinMaxClamp ? spv::GLSLstd450NMax : spv::GLSLstd450FMax; else if (isUnsigned) libCall = spv::GLSLstd450UMax; else libCall = spv::GLSLstd450SMax; builder.promoteScalar(precision, operands.front(), operands.back()); break; case glslang::EOpPow: libCall = spv::GLSLstd450Pow; break; case glslang::EOpDot: opCode = spv::OpDot; break; case glslang::EOpAtan: libCall = spv::GLSLstd450Atan2; break; case glslang::EOpClamp: if (isFloat) libCall = nanMinMaxClamp ? spv::GLSLstd450NClamp : spv::GLSLstd450FClamp; else if (isUnsigned) libCall = spv::GLSLstd450UClamp; else libCall = spv::GLSLstd450SClamp; builder.promoteScalar(precision, operands.front(), operands[1]); builder.promoteScalar(precision, operands.front(), operands[2]); break; case glslang::EOpMix: if (! builder.isBoolType(builder.getScalarTypeId(builder.getTypeId(operands.back())))) { assert(isFloat); libCall = spv::GLSLstd450FMix; } else { opCode = spv::OpSelect; std::swap(operands.front(), operands.back()); } builder.promoteScalar(precision, operands.front(), operands.back()); break; case glslang::EOpStep: libCall = spv::GLSLstd450Step; builder.promoteScalar(precision, operands.front(), operands.back()); break; case glslang::EOpSmoothStep: libCall = spv::GLSLstd450SmoothStep; builder.promoteScalar(precision, operands[0], operands[2]); builder.promoteScalar(precision, operands[1], operands[2]); break; case glslang::EOpDistance: libCall = spv::GLSLstd450Distance; break; case glslang::EOpCross: libCall = spv::GLSLstd450Cross; break; case glslang::EOpFaceForward: libCall = spv::GLSLstd450FaceForward; break; case glslang::EOpReflect: libCall = spv::GLSLstd450Reflect; break; case glslang::EOpRefract: libCall = spv::GLSLstd450Refract; break; case glslang::EOpBarrier: { // This is for the extended controlBarrier function, with four operands. // The unextended barrier() goes through createNoArgOperation. assert(operands.size() == 4); unsigned int executionScope = builder.getConstantScalar(operands[0]); unsigned int memoryScope = builder.getConstantScalar(operands[1]); unsigned int semantics = builder.getConstantScalar(operands[2]) | builder.getConstantScalar(operands[3]); builder.createControlBarrier((spv::Scope)executionScope, (spv::Scope)memoryScope, (spv::MemorySemanticsMask)semantics); if (semantics & (spv::MemorySemanticsMakeAvailableKHRMask | spv::MemorySemanticsMakeVisibleKHRMask | spv::MemorySemanticsOutputMemoryKHRMask | spv::MemorySemanticsVolatileMask)) { builder.addCapability(spv::CapabilityVulkanMemoryModelKHR); } if (glslangIntermediate->usingVulkanMemoryModel() && (executionScope == spv::ScopeDevice || memoryScope == spv::ScopeDevice)) { builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR); } return 0; } break; case glslang::EOpMemoryBarrier: { // This is for the extended memoryBarrier function, with three operands. // The unextended memoryBarrier() goes through createNoArgOperation. assert(operands.size() == 3); unsigned int memoryScope = builder.getConstantScalar(operands[0]); unsigned int semantics = builder.getConstantScalar(operands[1]) | builder.getConstantScalar(operands[2]); builder.createMemoryBarrier((spv::Scope)memoryScope, (spv::MemorySemanticsMask)semantics); if (semantics & (spv::MemorySemanticsMakeAvailableKHRMask | spv::MemorySemanticsMakeVisibleKHRMask | spv::MemorySemanticsOutputMemoryKHRMask | spv::MemorySemanticsVolatileMask)) { builder.addCapability(spv::CapabilityVulkanMemoryModelKHR); } if (glslangIntermediate->usingVulkanMemoryModel() && memoryScope == spv::ScopeDevice) { builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR); } return 0; } break; #ifndef GLSLANG_WEB case glslang::EOpInterpolateAtSample: if (typeProxy == glslang::EbtFloat16) builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float); libCall = spv::GLSLstd450InterpolateAtSample; break; case glslang::EOpInterpolateAtOffset: if (typeProxy == glslang::EbtFloat16) builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float); libCall = spv::GLSLstd450InterpolateAtOffset; break; case glslang::EOpAddCarry: opCode = spv::OpIAddCarry; typeId = builder.makeStructResultType(typeId0, typeId0); consumedOperands = 2; break; case glslang::EOpSubBorrow: opCode = spv::OpISubBorrow; typeId = builder.makeStructResultType(typeId0, typeId0); consumedOperands = 2; break; case glslang::EOpUMulExtended: opCode = spv::OpUMulExtended; typeId = builder.makeStructResultType(typeId0, typeId0); consumedOperands = 2; break; case glslang::EOpIMulExtended: opCode = spv::OpSMulExtended; typeId = builder.makeStructResultType(typeId0, typeId0); consumedOperands = 2; break; case glslang::EOpBitfieldExtract: if (isUnsigned) opCode = spv::OpBitFieldUExtract; else opCode = spv::OpBitFieldSExtract; break; case glslang::EOpBitfieldInsert: opCode = spv::OpBitFieldInsert; break; case glslang::EOpFma: libCall = spv::GLSLstd450Fma; break; case glslang::EOpFrexp: { libCall = spv::GLSLstd450FrexpStruct; assert(builder.isPointerType(typeId1)); typeId1 = builder.getContainedTypeId(typeId1); int width = builder.getScalarTypeWidth(typeId1); if (width == 16) // Using 16-bit exp operand, enable extension SPV_AMD_gpu_shader_int16 builder.addExtension(spv::E_SPV_AMD_gpu_shader_int16); if (builder.getNumComponents(operands[0]) == 1) frexpIntType = builder.makeIntegerType(width, true); else frexpIntType = builder.makeVectorType(builder.makeIntegerType(width, true), builder.getNumComponents(operands[0])); typeId = builder.makeStructResultType(typeId0, frexpIntType); consumedOperands = 1; } break; case glslang::EOpLdexp: libCall = spv::GLSLstd450Ldexp; break; case glslang::EOpReadInvocation: return createInvocationsOperation(op, typeId, operands, typeProxy); case glslang::EOpSubgroupBroadcast: case glslang::EOpSubgroupBallotBitExtract: case glslang::EOpSubgroupShuffle: case glslang::EOpSubgroupShuffleXor: case glslang::EOpSubgroupShuffleUp: case glslang::EOpSubgroupShuffleDown: case glslang::EOpSubgroupClusteredAdd: case glslang::EOpSubgroupClusteredMul: case glslang::EOpSubgroupClusteredMin: case glslang::EOpSubgroupClusteredMax: case glslang::EOpSubgroupClusteredAnd: case glslang::EOpSubgroupClusteredOr: case glslang::EOpSubgroupClusteredXor: case glslang::EOpSubgroupQuadBroadcast: case glslang::EOpSubgroupPartitionedAdd: case glslang::EOpSubgroupPartitionedMul: case glslang::EOpSubgroupPartitionedMin: case glslang::EOpSubgroupPartitionedMax: case glslang::EOpSubgroupPartitionedAnd: case glslang::EOpSubgroupPartitionedOr: case glslang::EOpSubgroupPartitionedXor: case glslang::EOpSubgroupPartitionedInclusiveAdd: case glslang::EOpSubgroupPartitionedInclusiveMul: case glslang::EOpSubgroupPartitionedInclusiveMin: case glslang::EOpSubgroupPartitionedInclusiveMax: case glslang::EOpSubgroupPartitionedInclusiveAnd: case glslang::EOpSubgroupPartitionedInclusiveOr: case glslang::EOpSubgroupPartitionedInclusiveXor: case glslang::EOpSubgroupPartitionedExclusiveAdd: case glslang::EOpSubgroupPartitionedExclusiveMul: case glslang::EOpSubgroupPartitionedExclusiveMin: case glslang::EOpSubgroupPartitionedExclusiveMax: case glslang::EOpSubgroupPartitionedExclusiveAnd: case glslang::EOpSubgroupPartitionedExclusiveOr: case glslang::EOpSubgroupPartitionedExclusiveXor: return createSubgroupOperation(op, typeId, operands, typeProxy); case glslang::EOpSwizzleInvocations: extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_ballot); libCall = spv::SwizzleInvocationsAMD; break; case glslang::EOpSwizzleInvocationsMasked: extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_ballot); libCall = spv::SwizzleInvocationsMaskedAMD; break; case glslang::EOpWriteInvocation: extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_ballot); libCall = spv::WriteInvocationAMD; break; case glslang::EOpMin3: extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_trinary_minmax); if (isFloat) libCall = spv::FMin3AMD; else { if (isUnsigned) libCall = spv::UMin3AMD; else libCall = spv::SMin3AMD; } break; case glslang::EOpMax3: extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_trinary_minmax); if (isFloat) libCall = spv::FMax3AMD; else { if (isUnsigned) libCall = spv::UMax3AMD; else libCall = spv::SMax3AMD; } break; case glslang::EOpMid3: extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_trinary_minmax); if (isFloat) libCall = spv::FMid3AMD; else { if (isUnsigned) libCall = spv::UMid3AMD; else libCall = spv::SMid3AMD; } break; case glslang::EOpInterpolateAtVertex: if (typeProxy == glslang::EbtFloat16) builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float); extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_explicit_vertex_parameter); libCall = spv::InterpolateAtVertexAMD; break; case glslang::EOpReportIntersectionNV: { typeId = builder.makeBoolType(); opCode = spv::OpReportIntersectionNV; } break; case glslang::EOpTraceNV: { builder.createNoResultOp(spv::OpTraceNV, operands); return 0; } break; case glslang::EOpExecuteCallableNV: { builder.createNoResultOp(spv::OpExecuteCallableNV, operands); return 0; } break; case glslang::EOpWritePackedPrimitiveIndices4x8NV: builder.createNoResultOp(spv::OpWritePackedPrimitiveIndices4x8NV, operands); return 0; case glslang::EOpCooperativeMatrixMulAdd: opCode = spv::OpCooperativeMatrixMulAddNV; break; #endif // GLSLANG_WEB default: return 0; } spv::Id id = 0; if (libCall >= 0) { // Use an extended instruction from the standard library. // Construct the call arguments, without modifying the original operands vector. // We might need the remaining arguments, e.g. in the EOpFrexp case. std::vector callArguments(operands.begin(), operands.begin() + consumedOperands); id = builder.createBuiltinCall(typeId, extBuiltins >= 0 ? extBuiltins : stdBuiltins, libCall, callArguments); } else if (opCode == spv::OpDot && !isFloat) { // int dot(int, int) // NOTE: never called for scalar/vector1, this is turned into simple mul before this can be reached const int componentCount = builder.getNumComponents(operands[0]); spv::Id mulOp = builder.createBinOp(spv::OpIMul, builder.getTypeId(operands[0]), operands[0], operands[1]); builder.setPrecision(mulOp, precision); id = builder.createCompositeExtract(mulOp, typeId, 0); for (int i = 1; i < componentCount; ++i) { builder.setPrecision(id, precision); id = builder.createBinOp(spv::OpIAdd, typeId, id, builder.createCompositeExtract(mulOp, typeId, i)); } } else { switch (consumedOperands) { case 0: // should all be handled by visitAggregate and createNoArgOperation assert(0); return 0; case 1: // should all be handled by createUnaryOperation assert(0); return 0; case 2: id = builder.createBinOp(opCode, typeId, operands[0], operands[1]); break; default: // anything 3 or over doesn't have l-value operands, so all should be consumed assert(consumedOperands == operands.size()); id = builder.createOp(opCode, typeId, operands); break; } } #ifndef GLSLANG_WEB // Decode the return types that were structures switch (op) { case glslang::EOpAddCarry: case glslang::EOpSubBorrow: builder.createStore(builder.createCompositeExtract(id, typeId0, 1), operands[2]); id = builder.createCompositeExtract(id, typeId0, 0); break; case glslang::EOpUMulExtended: case glslang::EOpIMulExtended: builder.createStore(builder.createCompositeExtract(id, typeId0, 0), operands[3]); builder.createStore(builder.createCompositeExtract(id, typeId0, 1), operands[2]); break; case glslang::EOpFrexp: { assert(operands.size() == 2); if (builder.isFloatType(builder.getScalarTypeId(typeId1))) { // "exp" is floating-point type (from HLSL intrinsic) spv::Id member1 = builder.createCompositeExtract(id, frexpIntType, 1); member1 = builder.createUnaryOp(spv::OpConvertSToF, typeId1, member1); builder.createStore(member1, operands[1]); } else // "exp" is integer type (from GLSL built-in function) builder.createStore(builder.createCompositeExtract(id, frexpIntType, 1), operands[1]); id = builder.createCompositeExtract(id, typeId0, 0); } break; default: break; } #endif return builder.setPrecision(id, precision); } // Intrinsics with no arguments (or no return value, and no precision). spv::Id TGlslangToSpvTraverser::createNoArgOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId) { // GLSL memory barriers use queuefamily scope in new model, device scope in old model spv::Scope memoryBarrierScope = glslangIntermediate->usingVulkanMemoryModel() ? spv::ScopeQueueFamilyKHR : spv::ScopeDevice; switch (op) { case glslang::EOpBarrier: if (glslangIntermediate->getStage() == EShLangTessControl) { if (glslangIntermediate->usingVulkanMemoryModel()) { builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup, spv::MemorySemanticsOutputMemoryKHRMask | spv::MemorySemanticsAcquireReleaseMask); builder.addCapability(spv::CapabilityVulkanMemoryModelKHR); } else { builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeInvocation, spv::MemorySemanticsMaskNone); } } else { builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup, spv::MemorySemanticsWorkgroupMemoryMask | spv::MemorySemanticsAcquireReleaseMask); } return 0; case glslang::EOpMemoryBarrier: builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsAllMemory | spv::MemorySemanticsAcquireReleaseMask); return 0; case glslang::EOpMemoryBarrierBuffer: builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsUniformMemoryMask | spv::MemorySemanticsAcquireReleaseMask); return 0; case glslang::EOpMemoryBarrierShared: builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsWorkgroupMemoryMask | spv::MemorySemanticsAcquireReleaseMask); return 0; case glslang::EOpGroupMemoryBarrier: builder.createMemoryBarrier(spv::ScopeWorkgroup, spv::MemorySemanticsAllMemory | spv::MemorySemanticsAcquireReleaseMask); return 0; #ifndef GLSLANG_WEB case glslang::EOpMemoryBarrierAtomicCounter: builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsAtomicCounterMemoryMask | spv::MemorySemanticsAcquireReleaseMask); return 0; case glslang::EOpMemoryBarrierImage: builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsImageMemoryMask | spv::MemorySemanticsAcquireReleaseMask); return 0; case glslang::EOpAllMemoryBarrierWithGroupSync: builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeDevice, spv::MemorySemanticsAllMemory | spv::MemorySemanticsAcquireReleaseMask); return 0; case glslang::EOpDeviceMemoryBarrier: builder.createMemoryBarrier(spv::ScopeDevice, spv::MemorySemanticsUniformMemoryMask | spv::MemorySemanticsImageMemoryMask | spv::MemorySemanticsAcquireReleaseMask); return 0; case glslang::EOpDeviceMemoryBarrierWithGroupSync: builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeDevice, spv::MemorySemanticsUniformMemoryMask | spv::MemorySemanticsImageMemoryMask | spv::MemorySemanticsAcquireReleaseMask); return 0; case glslang::EOpWorkgroupMemoryBarrier: builder.createMemoryBarrier(spv::ScopeWorkgroup, spv::MemorySemanticsWorkgroupMemoryMask | spv::MemorySemanticsAcquireReleaseMask); return 0; case glslang::EOpWorkgroupMemoryBarrierWithGroupSync: builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup, spv::MemorySemanticsWorkgroupMemoryMask | spv::MemorySemanticsAcquireReleaseMask); return 0; case glslang::EOpSubgroupBarrier: builder.createControlBarrier(spv::ScopeSubgroup, spv::ScopeSubgroup, spv::MemorySemanticsAllMemory | spv::MemorySemanticsAcquireReleaseMask); return spv::NoResult; case glslang::EOpSubgroupMemoryBarrier: builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsAllMemory | spv::MemorySemanticsAcquireReleaseMask); return spv::NoResult; case glslang::EOpSubgroupMemoryBarrierBuffer: builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsUniformMemoryMask | spv::MemorySemanticsAcquireReleaseMask); return spv::NoResult; case glslang::EOpSubgroupMemoryBarrierImage: builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsImageMemoryMask | spv::MemorySemanticsAcquireReleaseMask); return spv::NoResult; case glslang::EOpSubgroupMemoryBarrierShared: builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsWorkgroupMemoryMask | spv::MemorySemanticsAcquireReleaseMask); return spv::NoResult; case glslang::EOpEmitVertex: builder.createNoResultOp(spv::OpEmitVertex); return 0; case glslang::EOpEndPrimitive: builder.createNoResultOp(spv::OpEndPrimitive); return 0; case glslang::EOpSubgroupElect: { std::vector operands; return createSubgroupOperation(op, typeId, operands, glslang::EbtVoid); } case glslang::EOpTime: { std::vector args; // Dummy arguments spv::Id id = builder.createBuiltinCall(typeId, getExtBuiltins(spv::E_SPV_AMD_gcn_shader), spv::TimeAMD, args); return builder.setPrecision(id, precision); } case glslang::EOpIgnoreIntersectionNV: builder.createNoResultOp(spv::OpIgnoreIntersectionNV); return 0; case glslang::EOpTerminateRayNV: builder.createNoResultOp(spv::OpTerminateRayNV); return 0; case glslang::EOpBeginInvocationInterlock: builder.createNoResultOp(spv::OpBeginInvocationInterlockEXT); return 0; case glslang::EOpEndInvocationInterlock: builder.createNoResultOp(spv::OpEndInvocationInterlockEXT); return 0; case glslang::EOpIsHelperInvocation: { std::vector args; // Dummy arguments builder.addExtension(spv::E_SPV_EXT_demote_to_helper_invocation); builder.addCapability(spv::CapabilityDemoteToHelperInvocationEXT); return builder.createOp(spv::OpIsHelperInvocationEXT, typeId, args); } case glslang::EOpReadClockSubgroupKHR: { std::vector args; args.push_back(builder.makeUintConstant(spv::ScopeSubgroup)); builder.addExtension(spv::E_SPV_KHR_shader_clock); builder.addCapability(spv::CapabilityShaderClockKHR); return builder.createOp(spv::OpReadClockKHR, typeId, args); } case glslang::EOpReadClockDeviceKHR: { std::vector args; args.push_back(builder.makeUintConstant(spv::ScopeDevice)); builder.addExtension(spv::E_SPV_KHR_shader_clock); builder.addCapability(spv::CapabilityShaderClockKHR); return builder.createOp(spv::OpReadClockKHR, typeId, args); } #endif default: break; } logger->missingFunctionality("unknown operation with no arguments"); return 0; } spv::Id TGlslangToSpvTraverser::getSymbolId(const glslang::TIntermSymbol* symbol) { auto iter = symbolValues.find(symbol->getId()); spv::Id id; if (symbolValues.end() != iter) { id = iter->second; return id; } // it was not found, create it spv::BuiltIn builtIn = TranslateBuiltInDecoration(symbol->getQualifier().builtIn, false); auto forcedType = getForcedType(builtIn, symbol->getType()); id = createSpvVariable(symbol, forcedType.first); symbolValues[symbol->getId()] = id; if (forcedType.second != spv::NoType) forceType[id] = forcedType.second; if (symbol->getBasicType() != glslang::EbtBlock) { builder.addDecoration(id, TranslatePrecisionDecoration(symbol->getType())); builder.addDecoration(id, TranslateInterpolationDecoration(symbol->getType().getQualifier())); builder.addDecoration(id, TranslateAuxiliaryStorageDecoration(symbol->getType().getQualifier())); #ifndef GLSLANG_WEB addMeshNVDecoration(id, /*member*/ -1, symbol->getType().getQualifier()); if (symbol->getQualifier().hasComponent()) builder.addDecoration(id, spv::DecorationComponent, symbol->getQualifier().layoutComponent); if (symbol->getQualifier().hasIndex()) builder.addDecoration(id, spv::DecorationIndex, symbol->getQualifier().layoutIndex); #endif if (symbol->getType().getQualifier().hasSpecConstantId()) builder.addDecoration(id, spv::DecorationSpecId, symbol->getType().getQualifier().layoutSpecConstantId); // atomic counters use this: if (symbol->getQualifier().hasOffset()) builder.addDecoration(id, spv::DecorationOffset, symbol->getQualifier().layoutOffset); } if (symbol->getQualifier().hasLocation()) builder.addDecoration(id, spv::DecorationLocation, symbol->getQualifier().layoutLocation); builder.addDecoration(id, TranslateInvariantDecoration(symbol->getType().getQualifier())); if (symbol->getQualifier().hasStream() && glslangIntermediate->isMultiStream()) { builder.addCapability(spv::CapabilityGeometryStreams); builder.addDecoration(id, spv::DecorationStream, symbol->getQualifier().layoutStream); } if (symbol->getQualifier().hasSet()) builder.addDecoration(id, spv::DecorationDescriptorSet, symbol->getQualifier().layoutSet); else if (IsDescriptorResource(symbol->getType())) { // default to 0 builder.addDecoration(id, spv::DecorationDescriptorSet, 0); } if (symbol->getQualifier().hasBinding()) builder.addDecoration(id, spv::DecorationBinding, symbol->getQualifier().layoutBinding); else if (IsDescriptorResource(symbol->getType())) { // default to 0 builder.addDecoration(id, spv::DecorationBinding, 0); } if (symbol->getQualifier().hasAttachment()) builder.addDecoration(id, spv::DecorationInputAttachmentIndex, symbol->getQualifier().layoutAttachment); if (glslangIntermediate->getXfbMode()) { builder.addCapability(spv::CapabilityTransformFeedback); if (symbol->getQualifier().hasXfbBuffer()) { builder.addDecoration(id, spv::DecorationXfbBuffer, symbol->getQualifier().layoutXfbBuffer); unsigned stride = glslangIntermediate->getXfbStride(symbol->getQualifier().layoutXfbBuffer); if (stride != glslang::TQualifier::layoutXfbStrideEnd) builder.addDecoration(id, spv::DecorationXfbStride, stride); } if (symbol->getQualifier().hasXfbOffset()) builder.addDecoration(id, spv::DecorationOffset, symbol->getQualifier().layoutXfbOffset); } // add built-in variable decoration if (builtIn != spv::BuiltInMax) { builder.addDecoration(id, spv::DecorationBuiltIn, (int)builtIn); } #ifndef GLSLANG_WEB if (symbol->getType().isImage()) { std::vector memory; TranslateMemoryDecoration(symbol->getType().getQualifier(), memory, glslangIntermediate->usingVulkanMemoryModel()); for (unsigned int i = 0; i < memory.size(); ++i) builder.addDecoration(id, memory[i]); } // nonuniform builder.addDecoration(id, TranslateNonUniformDecoration(symbol->getType().getQualifier())); if (builtIn == spv::BuiltInSampleMask) { spv::Decoration decoration; // GL_NV_sample_mask_override_coverage extension if (glslangIntermediate->getLayoutOverrideCoverage()) decoration = (spv::Decoration)spv::DecorationOverrideCoverageNV; else decoration = (spv::Decoration)spv::DecorationMax; builder.addDecoration(id, decoration); if (decoration != spv::DecorationMax) { builder.addCapability(spv::CapabilitySampleMaskOverrideCoverageNV); builder.addExtension(spv::E_SPV_NV_sample_mask_override_coverage); } } else if (builtIn == spv::BuiltInLayer) { // SPV_NV_viewport_array2 extension if (symbol->getQualifier().layoutViewportRelative) { builder.addDecoration(id, (spv::Decoration)spv::DecorationViewportRelativeNV); builder.addCapability(spv::CapabilityShaderViewportMaskNV); builder.addExtension(spv::E_SPV_NV_viewport_array2); } if (symbol->getQualifier().layoutSecondaryViewportRelativeOffset != -2048) { builder.addDecoration(id, (spv::Decoration)spv::DecorationSecondaryViewportRelativeNV, symbol->getQualifier().layoutSecondaryViewportRelativeOffset); builder.addCapability(spv::CapabilityShaderStereoViewNV); builder.addExtension(spv::E_SPV_NV_stereo_view_rendering); } } if (symbol->getQualifier().layoutPassthrough) { builder.addDecoration(id, spv::DecorationPassthroughNV); builder.addCapability(spv::CapabilityGeometryShaderPassthroughNV); builder.addExtension(spv::E_SPV_NV_geometry_shader_passthrough); } if (symbol->getQualifier().pervertexNV) { builder.addDecoration(id, spv::DecorationPerVertexNV); builder.addCapability(spv::CapabilityFragmentBarycentricNV); builder.addExtension(spv::E_SPV_NV_fragment_shader_barycentric); } if (glslangIntermediate->getHlslFunctionality1() && symbol->getType().getQualifier().semanticName != nullptr) { builder.addExtension("SPV_GOOGLE_hlsl_functionality1"); builder.addDecoration(id, (spv::Decoration)spv::DecorationHlslSemanticGOOGLE, symbol->getType().getQualifier().semanticName); } if (symbol->isReference()) { builder.addDecoration(id, symbol->getType().getQualifier().restrict ? spv::DecorationRestrictPointerEXT : spv::DecorationAliasedPointerEXT); } #endif return id; } #ifndef GLSLANG_WEB // add per-primitive, per-view. per-task decorations to a struct member (member >= 0) or an object void TGlslangToSpvTraverser::addMeshNVDecoration(spv::Id id, int member, const glslang::TQualifier& qualifier) { if (member >= 0) { if (qualifier.perPrimitiveNV) { // Need to add capability/extension for fragment shader. // Mesh shader already adds this by default. if (glslangIntermediate->getStage() == EShLangFragment) { builder.addCapability(spv::CapabilityMeshShadingNV); builder.addExtension(spv::E_SPV_NV_mesh_shader); } builder.addMemberDecoration(id, (unsigned)member, spv::DecorationPerPrimitiveNV); } if (qualifier.perViewNV) builder.addMemberDecoration(id, (unsigned)member, spv::DecorationPerViewNV); if (qualifier.perTaskNV) builder.addMemberDecoration(id, (unsigned)member, spv::DecorationPerTaskNV); } else { if (qualifier.perPrimitiveNV) { // Need to add capability/extension for fragment shader. // Mesh shader already adds this by default. if (glslangIntermediate->getStage() == EShLangFragment) { builder.addCapability(spv::CapabilityMeshShadingNV); builder.addExtension(spv::E_SPV_NV_mesh_shader); } builder.addDecoration(id, spv::DecorationPerPrimitiveNV); } if (qualifier.perViewNV) builder.addDecoration(id, spv::DecorationPerViewNV); if (qualifier.perTaskNV) builder.addDecoration(id, spv::DecorationPerTaskNV); } } #endif // Make a full tree of instructions to build a SPIR-V specialization constant, // or regular constant if possible. // // TBD: this is not yet done, nor verified to be the best design, it does do the leaf symbols though // // Recursively walk the nodes. The nodes form a tree whose leaves are // regular constants, which themselves are trees that createSpvConstant() // recursively walks. So, this function walks the "top" of the tree: // - emit specialization constant-building instructions for specConstant // - when running into a non-spec-constant, switch to createSpvConstant() spv::Id TGlslangToSpvTraverser::createSpvConstant(const glslang::TIntermTyped& node) { assert(node.getQualifier().isConstant()); // Handle front-end constants first (non-specialization constants). if (! node.getQualifier().specConstant) { // hand off to the non-spec-constant path assert(node.getAsConstantUnion() != nullptr || node.getAsSymbolNode() != nullptr); int nextConst = 0; return createSpvConstantFromConstUnionArray(node.getType(), node.getAsConstantUnion() ? node.getAsConstantUnion()->getConstArray() : node.getAsSymbolNode()->getConstArray(), nextConst, false); } // We now know we have a specialization constant to build // gl_WorkGroupSize is a special case until the front-end handles hierarchical specialization constants, // even then, it's specialization ids are handled by special case syntax in GLSL: layout(local_size_x = ... if (node.getType().getQualifier().builtIn == glslang::EbvWorkGroupSize) { std::vector dimConstId; for (int dim = 0; dim < 3; ++dim) { bool specConst = (glslangIntermediate->getLocalSizeSpecId(dim) != glslang::TQualifier::layoutNotSet); dimConstId.push_back(builder.makeUintConstant(glslangIntermediate->getLocalSize(dim), specConst)); if (specConst) { builder.addDecoration(dimConstId.back(), spv::DecorationSpecId, glslangIntermediate->getLocalSizeSpecId(dim)); } } return builder.makeCompositeConstant(builder.makeVectorType(builder.makeUintType(32), 3), dimConstId, true); } // An AST node labelled as specialization constant should be a symbol node. // Its initializer should either be a sub tree with constant nodes, or a constant union array. if (auto* sn = node.getAsSymbolNode()) { spv::Id result; if (auto* sub_tree = sn->getConstSubtree()) { // Traverse the constant constructor sub tree like generating normal run-time instructions. // During the AST traversal, if the node is marked as 'specConstant', SpecConstantOpModeGuard // will set the builder into spec constant op instruction generating mode. sub_tree->traverse(this); result = accessChainLoad(sub_tree->getType()); } else if (auto* const_union_array = &sn->getConstArray()) { int nextConst = 0; result = createSpvConstantFromConstUnionArray(sn->getType(), *const_union_array, nextConst, true); } else { logger->missingFunctionality("Invalid initializer for spec onstant."); return spv::NoResult; } builder.addName(result, sn->getName().c_str()); return result; } // Neither a front-end constant node, nor a specialization constant node with constant union array or // constant sub tree as initializer. logger->missingFunctionality("Neither a front-end constant nor a spec constant."); return spv::NoResult; } // Use 'consts' as the flattened glslang source of scalar constants to recursively // build the aggregate SPIR-V constant. // // If there are not enough elements present in 'consts', 0 will be substituted; // an empty 'consts' can be used to create a fully zeroed SPIR-V constant. // spv::Id TGlslangToSpvTraverser::createSpvConstantFromConstUnionArray(const glslang::TType& glslangType, const glslang::TConstUnionArray& consts, int& nextConst, bool specConstant) { // vector of constants for SPIR-V std::vector spvConsts; // Type is used for struct and array constants spv::Id typeId = convertGlslangToSpvType(glslangType); if (glslangType.isArray()) { glslang::TType elementType(glslangType, 0); for (int i = 0; i < glslangType.getOuterArraySize(); ++i) spvConsts.push_back(createSpvConstantFromConstUnionArray(elementType, consts, nextConst, false)); } else if (glslangType.isMatrix()) { glslang::TType vectorType(glslangType, 0); for (int col = 0; col < glslangType.getMatrixCols(); ++col) spvConsts.push_back(createSpvConstantFromConstUnionArray(vectorType, consts, nextConst, false)); } else if (glslangType.isCoopMat()) { glslang::TType componentType(glslangType.getBasicType()); spvConsts.push_back(createSpvConstantFromConstUnionArray(componentType, consts, nextConst, false)); } else if (glslangType.isStruct()) { glslang::TVector::const_iterator iter; for (iter = glslangType.getStruct()->begin(); iter != glslangType.getStruct()->end(); ++iter) spvConsts.push_back(createSpvConstantFromConstUnionArray(*iter->type, consts, nextConst, false)); } else if (glslangType.getVectorSize() > 1) { for (unsigned int i = 0; i < (unsigned int)glslangType.getVectorSize(); ++i) { bool zero = nextConst >= consts.size(); switch (glslangType.getBasicType()) { case glslang::EbtInt: spvConsts.push_back(builder.makeIntConstant(zero ? 0 : consts[nextConst].getIConst())); break; case glslang::EbtUint: spvConsts.push_back(builder.makeUintConstant(zero ? 0 : consts[nextConst].getUConst())); break; case glslang::EbtFloat: spvConsts.push_back(builder.makeFloatConstant(zero ? 0.0F : (float)consts[nextConst].getDConst())); break; case glslang::EbtBool: spvConsts.push_back(builder.makeBoolConstant(zero ? false : consts[nextConst].getBConst())); break; #ifndef GLSLANG_WEB case glslang::EbtInt8: spvConsts.push_back(builder.makeInt8Constant(zero ? 0 : consts[nextConst].getI8Const())); break; case glslang::EbtUint8: spvConsts.push_back(builder.makeUint8Constant(zero ? 0 : consts[nextConst].getU8Const())); break; case glslang::EbtInt16: spvConsts.push_back(builder.makeInt16Constant(zero ? 0 : consts[nextConst].getI16Const())); break; case glslang::EbtUint16: spvConsts.push_back(builder.makeUint16Constant(zero ? 0 : consts[nextConst].getU16Const())); break; case glslang::EbtInt64: spvConsts.push_back(builder.makeInt64Constant(zero ? 0 : consts[nextConst].getI64Const())); break; case glslang::EbtUint64: spvConsts.push_back(builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const())); break; case glslang::EbtDouble: spvConsts.push_back(builder.makeDoubleConstant(zero ? 0.0 : consts[nextConst].getDConst())); break; case glslang::EbtFloat16: spvConsts.push_back(builder.makeFloat16Constant(zero ? 0.0F : (float)consts[nextConst].getDConst())); break; #endif default: assert(0); break; } ++nextConst; } } else { // we have a non-aggregate (scalar) constant bool zero = nextConst >= consts.size(); spv::Id scalar = 0; switch (glslangType.getBasicType()) { case glslang::EbtInt: scalar = builder.makeIntConstant(zero ? 0 : consts[nextConst].getIConst(), specConstant); break; case glslang::EbtUint: scalar = builder.makeUintConstant(zero ? 0 : consts[nextConst].getUConst(), specConstant); break; case glslang::EbtFloat: scalar = builder.makeFloatConstant(zero ? 0.0F : (float)consts[nextConst].getDConst(), specConstant); break; case glslang::EbtBool: scalar = builder.makeBoolConstant(zero ? false : consts[nextConst].getBConst(), specConstant); break; #ifndef GLSLANG_WEB case glslang::EbtInt8: scalar = builder.makeInt8Constant(zero ? 0 : consts[nextConst].getI8Const(), specConstant); break; case glslang::EbtUint8: scalar = builder.makeUint8Constant(zero ? 0 : consts[nextConst].getU8Const(), specConstant); break; case glslang::EbtInt16: scalar = builder.makeInt16Constant(zero ? 0 : consts[nextConst].getI16Const(), specConstant); break; case glslang::EbtUint16: scalar = builder.makeUint16Constant(zero ? 0 : consts[nextConst].getU16Const(), specConstant); break; case glslang::EbtInt64: scalar = builder.makeInt64Constant(zero ? 0 : consts[nextConst].getI64Const(), specConstant); break; case glslang::EbtUint64: scalar = builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const(), specConstant); break; case glslang::EbtDouble: scalar = builder.makeDoubleConstant(zero ? 0.0 : consts[nextConst].getDConst(), specConstant); break; case glslang::EbtFloat16: scalar = builder.makeFloat16Constant(zero ? 0.0F : (float)consts[nextConst].getDConst(), specConstant); break; case glslang::EbtReference: scalar = builder.makeUint64Constant(zero ? 0 : consts[nextConst].getU64Const(), specConstant); scalar = builder.createUnaryOp(spv::OpBitcast, typeId, scalar); break; #endif default: assert(0); break; } ++nextConst; return scalar; } return builder.makeCompositeConstant(typeId, spvConsts); } // Return true if the node is a constant or symbol whose reading has no // non-trivial observable cost or effect. bool TGlslangToSpvTraverser::isTrivialLeaf(const glslang::TIntermTyped* node) { // don't know what this is if (node == nullptr) return false; // a constant is safe if (node->getAsConstantUnion() != nullptr) return true; // not a symbol means non-trivial if (node->getAsSymbolNode() == nullptr) return false; // a symbol, depends on what's being read switch (node->getType().getQualifier().storage) { case glslang::EvqTemporary: case glslang::EvqGlobal: case glslang::EvqIn: case glslang::EvqInOut: case glslang::EvqConst: case glslang::EvqConstReadOnly: case glslang::EvqUniform: return true; default: return false; } } // A node is trivial if it is a single operation with no side effects. // HLSL (and/or vectors) are always trivial, as it does not short circuit. // Otherwise, error on the side of saying non-trivial. // Return true if trivial. bool TGlslangToSpvTraverser::isTrivial(const glslang::TIntermTyped* node) { if (node == nullptr) return false; // count non scalars as trivial, as well as anything coming from HLSL if (! node->getType().isScalarOrVec1() || glslangIntermediate->getSource() == glslang::EShSourceHlsl) return true; // symbols and constants are trivial if (isTrivialLeaf(node)) return true; // otherwise, it needs to be a simple operation or one or two leaf nodes // not a simple operation const glslang::TIntermBinary* binaryNode = node->getAsBinaryNode(); const glslang::TIntermUnary* unaryNode = node->getAsUnaryNode(); if (binaryNode == nullptr && unaryNode == nullptr) return false; // not on leaf nodes if (binaryNode && (! isTrivialLeaf(binaryNode->getLeft()) || ! isTrivialLeaf(binaryNode->getRight()))) return false; if (unaryNode && ! isTrivialLeaf(unaryNode->getOperand())) { return false; } switch (node->getAsOperator()->getOp()) { case glslang::EOpLogicalNot: case glslang::EOpConvIntToBool: case glslang::EOpConvUintToBool: case glslang::EOpConvFloatToBool: case glslang::EOpConvDoubleToBool: case glslang::EOpEqual: case glslang::EOpNotEqual: case glslang::EOpLessThan: case glslang::EOpGreaterThan: case glslang::EOpLessThanEqual: case glslang::EOpGreaterThanEqual: case glslang::EOpIndexDirect: case glslang::EOpIndexDirectStruct: case glslang::EOpLogicalXor: case glslang::EOpAny: case glslang::EOpAll: return true; default: return false; } } // Emit short-circuiting code, where 'right' is never evaluated unless // the left side is true (for &&) or false (for ||). spv::Id TGlslangToSpvTraverser::createShortCircuit(glslang::TOperator op, glslang::TIntermTyped& left, glslang::TIntermTyped& right) { spv::Id boolTypeId = builder.makeBoolType(); // emit left operand builder.clearAccessChain(); left.traverse(this); spv::Id leftId = accessChainLoad(left.getType()); // Operands to accumulate OpPhi operands std::vector phiOperands; // accumulate left operand's phi information phiOperands.push_back(leftId); phiOperands.push_back(builder.getBuildPoint()->getId()); // Make the two kinds of operation symmetric with a "!" // || => emit "if (! left) result = right" // && => emit "if ( left) result = right" // // TODO: this runtime "not" for || could be avoided by adding functionality // to 'builder' to have an "else" without an "then" if (op == glslang::EOpLogicalOr) leftId = builder.createUnaryOp(spv::OpLogicalNot, boolTypeId, leftId); // make an "if" based on the left value spv::Builder::If ifBuilder(leftId, spv::SelectionControlMaskNone, builder); // emit right operand as the "then" part of the "if" builder.clearAccessChain(); right.traverse(this); spv::Id rightId = accessChainLoad(right.getType()); // accumulate left operand's phi information phiOperands.push_back(rightId); phiOperands.push_back(builder.getBuildPoint()->getId()); // finish the "if" ifBuilder.makeEndIf(); // phi together the two results return builder.createOp(spv::OpPhi, boolTypeId, phiOperands); } #ifndef GLSLANG_WEB // Return type Id of the imported set of extended instructions corresponds to the name. // Import this set if it has not been imported yet. spv::Id TGlslangToSpvTraverser::getExtBuiltins(const char* name) { if (extBuiltinMap.find(name) != extBuiltinMap.end()) return extBuiltinMap[name]; else { builder.addExtension(name); spv::Id extBuiltins = builder.import(name); extBuiltinMap[name] = extBuiltins; return extBuiltins; } } #endif }; // end anonymous namespace namespace glslang { void GetSpirvVersion(std::string& version) { const int bufSize = 100; char buf[bufSize]; snprintf(buf, bufSize, "0x%08x, Revision %d", spv::Version, spv::Revision); version = buf; } // For low-order part of the generator's magic number. Bump up // when there is a change in the style (e.g., if SSA form changes, // or a different instruction sequence to do something gets used). int GetSpirvGeneratorVersion() { // return 1; // start // return 2; // EOpAtomicCounterDecrement gets a post decrement, to map between GLSL -> SPIR-V // return 3; // change/correct barrier-instruction operands, to match memory model group decisions // return 4; // some deeper access chains: for dynamic vector component, and local Boolean component // return 5; // make OpArrayLength result type be an int with signedness of 0 // return 6; // revert version 5 change, which makes a different (new) kind of incorrect code, // versions 4 and 6 each generate OpArrayLength as it has long been done // return 7; // GLSL volatile keyword maps to both SPIR-V decorations Volatile and Coherent return 8; // switch to new dead block eliminator; use OpUnreachable } // Write SPIR-V out to a binary file void OutputSpvBin(const std::vector& spirv, const char* baseName) { std::ofstream out; out.open(baseName, std::ios::binary | std::ios::out); if (out.fail()) printf("ERROR: Failed to open file: %s\n", baseName); for (int i = 0; i < (int)spirv.size(); ++i) { unsigned int word = spirv[i]; out.write((const char*)&word, 4); } out.close(); } // Write SPIR-V out to a text file with 32-bit hexadecimal words void OutputSpvHex(const std::vector& spirv, const char* baseName, const char* varName) { #ifndef GLSLANG_WEB std::ofstream out; out.open(baseName, std::ios::binary | std::ios::out); if (out.fail()) printf("ERROR: Failed to open file: %s\n", baseName); out << "\t// " << GetSpirvGeneratorVersion() << "." << GLSLANG_MINOR_VERSION << "." << GLSLANG_PATCH_LEVEL << std::endl; if (varName != nullptr) { out << "\t #pragma once" << std::endl; out << "const uint32_t " << varName << "[] = {" << std::endl; } const int WORDS_PER_LINE = 8; for (int i = 0; i < (int)spirv.size(); i += WORDS_PER_LINE) { out << "\t"; for (int j = 0; j < WORDS_PER_LINE && i + j < (int)spirv.size(); ++j) { const unsigned int word = spirv[i + j]; out << "0x" << std::hex << std::setw(8) << std::setfill('0') << word; if (i + j + 1 < (int)spirv.size()) { out << ","; } } out << std::endl; } if (varName != nullptr) { out << "};"; } out.close(); #endif } // // Set up the glslang traversal // void GlslangToSpv(const TIntermediate& intermediate, std::vector& spirv, SpvOptions* options) { spv::SpvBuildLogger logger; GlslangToSpv(intermediate, spirv, &logger, options); } void GlslangToSpv(const TIntermediate& intermediate, std::vector& spirv, spv::SpvBuildLogger* logger, SpvOptions* options) { TIntermNode* root = intermediate.getTreeRoot(); if (root == 0) return; SpvOptions defaultOptions; if (options == nullptr) options = &defaultOptions; GetThreadPoolAllocator().push(); TGlslangToSpvTraverser it(intermediate.getSpv().spv, &intermediate, logger, *options); root->traverse(&it); it.finishSpv(); it.dumpSpv(spirv); #if ENABLE_OPT // If from HLSL, run spirv-opt to "legalize" the SPIR-V for Vulkan // eg. forward and remove memory writes of opaque types. bool prelegalization = intermediate.getSource() == EShSourceHlsl; if ((intermediate.getSource() == EShSourceHlsl || options->optimizeSize) && !options->disableOptimizer) { SpirvToolsLegalize(intermediate, spirv, logger, options); prelegalization = false; } if (options->validate) SpirvToolsValidate(intermediate, spirv, logger, prelegalization); if (options->disassemble) SpirvToolsDisassemble(std::cout, spirv); #endif GetThreadPoolAllocator().pop(); } }; // end namespace glslang