Lines Matching refs:spv
47 namespace spv {
80 SpecConstantOpModeGuard(spv::Builder* builder)
93 spv::Builder* builder_;
99 OpDecorations(spv::Decoration precision, spv::Decoration noContraction, spv::Decoration nonUniform) :
106 spv::Decoration precision;
108 void addNoContraction(spv::Builder& builder, spv::Id t) { builder.addDecoration(t, noContraction); }
109 void addNonUniform(spv::Builder& builder, spv::Id t) { builder.addDecoration(t, nonUniform); }
111 spv::Decoration noContraction;
112 spv::Decoration nonUniform;
124 TGlslangToSpvTraverser(unsigned int spvVersion, const glslang::TIntermediate*, spv::SpvBuildLogger* logger,
145 spv::Decoration TranslateInterpolationDecoration(const glslang::TQualifier& qualifier);
146 spv::Decoration TranslateAuxiliaryStorageDecoration(const glslang::TQualifier& qualifier);
147 spv::Decoration TranslateNonUniformDecoration(const glslang::TQualifier& qualifier);
148 spv::Decoration TranslateNonUniformDecoration(const spv::Builder::AccessChain::CoherentFlags& coherentFlags);
149 spv::Builder::AccessChain::CoherentFlags TranslateCoherent(const glslang::TType& type);
150 spv::MemoryAccessMask TranslateMemoryAccess(const spv::Builder::AccessChain::CoherentFlags &coherentFlags);
151 spv::ImageOperandsMask TranslateImageOperands(const spv::Builder::AccessChain::CoherentFlags &coherentFlags);
152 spv::Scope TranslateMemoryScope(const spv::Builder::AccessChain::CoherentFlags &coherentFlags);
153 spv::BuiltIn TranslateBuiltInDecoration(glslang::TBuiltInVariable, bool memberDeclaration);
154 spv::ImageFormat TranslateImageFormat(const glslang::TType& type);
155 spv::SelectionControlMask TranslateSelectionControl(const glslang::TIntermSelection&) const;
156 spv::SelectionControlMask TranslateSwitchControl(const glslang::TIntermSwitch&) const;
157 spv::LoopControlMask TranslateLoopControl(const glslang::TIntermLoop&, std::vector<unsigned int>& operands) const;
158 spv::StorageClass TranslateStorageClass(const glslang::TType&);
161 spv::Id createSpvVariable(const glslang::TIntermSymbol*, spv::Id forcedType);
162 spv::Id getSampledType(const glslang::TSampler&);
163 spv::Id getInvertedSwizzleType(const glslang::TIntermTyped&);
164 spv::Id createInvertedSwizzle(spv::Decoration precision, const glslang::TIntermTyped&, spv::Id parentResult);
166 spv::Id convertGlslangToSpvType(const glslang::TType& type, bool forwardReferenceOnly = false);
167 spv::Id convertGlslangToSpvType(const glslang::TType& type, glslang::TLayoutPacking, const glslang::TQualifier&,
169 void applySpirvDecorate(const glslang::TType& type, spv::Id id, std::optional<int> member);
171 spv::Id convertGlslangStructToSpvType(const glslang::TType&, const glslang::TTypeList* glslangStruct,
173 spv::LinkageType convertGlslangLinkageToSpv(glslang::TLinkType glslangLinkType);
175 const glslang::TQualifier&, spv::Id, const std::vector<spv::Id>& spvMembers);
176 spv::Id makeArraySizeId(const glslang::TArraySizes&, int dim, bool allowZero = false);
177 spv::Id accessChainLoad(const glslang::TType& type);
178 void accessChainStore(const glslang::TType& type, spv::Id rvalue);
179 void multiTypeStore(const glslang::TType&, spv::Id rValue);
180 spv::Id convertLoadedBoolInUniformToUint(const glslang::TType& type, spv::Id nominalTypeId, spv::Id loadedId);
196 void translateArguments(const glslang::TIntermAggregate& node, std::vector<spv::Id>& arguments,
197 spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags);
198 void translateArguments(glslang::TIntermUnary& node, std::vector<spv::Id>& arguments);
199 spv::Id createImageTextureFunctionCall(glslang::TIntermOperator* node);
200 spv::Id handleUserFunctionCall(const glslang::TIntermAggregate*);
202 spv::Id createBinaryOperation(glslang::TOperator op, OpDecorations&, spv::Id typeId, spv::Id left, spv::Id right,
204 spv::Id createBinaryMatrixOperation(spv::Op, OpDecorations&, spv::Id typeId, spv::Id left, spv::Id right);
205 spv::Id createUnaryOperation(glslang::TOperator op, OpDecorations&, spv::Id typeId, spv::Id operand,
207 const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags);
208 spv::Id createUnaryMatrixOperation(spv::Op op, OpDecorations&, spv::Id typeId, spv::Id operand,
210 spv::Id createConversion(glslang::TOperator op, OpDecorations&, spv::Id destTypeId, spv::Id operand,
212 spv::Id createIntWidthConversion(glslang::TOperator op, spv::Id operand, int vectorSize, spv::Id destType);
213 spv::Id makeSmearedConstant(spv::Id constant, int vectorSize);
214 spv::Id createAtomicOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId,
215 std::vector<spv::Id>& operands, glslang::TBasicType typeProxy,
216 const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags);
217 spv::Id createInvocationsOperation(glslang::TOperator op, spv::Id typeId, std::vector<spv::Id>& operands,
219 spv::Id CreateInvocationsVectorOperation(spv::Op op, spv::GroupOperation groupOperation,
220 spv::Id typeId, std::vector<spv::Id>& operands);
221 spv::Id createSubgroupOperation(glslang::TOperator op, spv::Id typeId, std::vector<spv::Id>& operands,
223 spv::Id createMiscOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId,
224 std::vector<spv::Id>& operands, glslang::TBasicType typeProxy);
225 spv::Id createNoArgOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId);
226 spv::Id getSymbolId(const glslang::TIntermSymbol* node);
227 void addMeshNVDecoration(spv::Id id, int member, const glslang::TQualifier & qualifier);
228 void addImageProcessingQCOMDecoration(spv::Id id, spv::Decoration decor);
229 spv::Id createSpvConstant(const glslang::TIntermTyped&);
230 spv::Id createSpvConstantFromConstUnionArray(const glslang::TType& type, const glslang::TConstUnionArray&,
234 spv::Id createShortCircuit(glslang::TOperator, glslang::TIntermTyped& left, glslang::TIntermTyped& right);
235 spv::Id getExtBuiltins(const char* name);
236 std::pair<spv::Id, spv::Id> getForcedType(glslang::TBuiltInVariable builtIn, const glslang::TType&);
237 spv::Id translateForcedType(spv::Id object);
238 spv::Id createCompositeConstruct(spv::Id typeId, std::vector<spv::Id> constituents);
241 spv::Function* shaderEntry;
242 spv::Function* currentFunction;
243 spv::Instruction* entryPoint;
246 spv::SpvBuildLogger* logger;
248 // There is a 1:1 mapping between a spv builder and a module; this is thread safe
249 spv::Builder builder;
254 std::set<spv::Id> iOSet; // all input/output variables from either static use or declaration of interface
257 spv::Id stdBuiltins;
258 spv::Id nonSemanticDebugPrintf;
259 std::unordered_map<std::string, spv::Id> extBuiltinMap;
261 std::unordered_map<long long, spv::Id> symbolValues;
262 std::unordered_map<uint32_t, spv::Id> builtInVariableIds;
265 std::unordered_map<std::string, spv::Function*> functionMap;
266 std::unordered_map<const glslang::TTypeList*, spv::Id> structMap[glslang::ElpCount][glslang::ElmCount];
267 // for mapping glslang block indices to spv indices (e.g., due to hidden members):
274 std::map<const glslang::TType *, spv::Id> forwardPointers;
278 std::unordered_map<spv::Id, spv::Id> forceType;
280 spv::Id taskPayloadID;
290 spv::SourceLanguage TranslateSourceLanguage(glslang::EShSource source, EProfile profile)
298 return spv::SourceLanguageGLSL;
300 return spv::SourceLanguageESSL;
302 return spv::SourceLanguageUnknown;
305 return spv::SourceLanguageHLSL;
307 return spv::SourceLanguageUnknown;
312 spv::ExecutionModel TranslateExecutionModel(EShLanguage stage, bool isMeshShaderEXT = false)
315 case EShLangVertex: return spv::ExecutionModelVertex;
316 case EShLangFragment: return spv::ExecutionModelFragment;
317 case EShLangCompute: return spv::ExecutionModelGLCompute;
318 case EShLangTessControl: return spv::ExecutionModelTessellationControl;
319 case EShLangTessEvaluation: return spv::ExecutionModelTessellationEvaluation;
320 case EShLangGeometry: return spv::ExecutionModelGeometry;
321 case EShLangRayGen: return spv::ExecutionModelRayGenerationKHR;
322 case EShLangIntersect: return spv::ExecutionModelIntersectionKHR;
323 case EShLangAnyHit: return spv::ExecutionModelAnyHitKHR;
324 case EShLangClosestHit: return spv::ExecutionModelClosestHitKHR;
325 case EShLangMiss: return spv::ExecutionModelMissKHR;
326 case EShLangCallable: return spv::ExecutionModelCallableKHR;
327 case EShLangTask: return (isMeshShaderEXT)? spv::ExecutionModelTaskEXT : spv::ExecutionModelTaskNV;
328 case EShLangMesh: return (isMeshShaderEXT)? spv::ExecutionModelMeshEXT: spv::ExecutionModelMeshNV;
331 return spv::ExecutionModelFragment;
336 spv::Dim TranslateDimensionality(const glslang::TSampler& sampler)
339 case glslang::Esd1D: return spv::Dim1D;
340 case glslang::Esd2D: return spv::Dim2D;
341 case glslang::Esd3D: return spv::Dim3D;
342 case glslang::EsdCube: return spv::DimCube;
343 case glslang::EsdRect: return spv::DimRect;
344 case glslang::EsdBuffer: return spv::DimBuffer;
345 case glslang::EsdSubpass: return spv::DimSubpassData;
346 case glslang::EsdAttachmentEXT: return spv::DimTileImageDataEXT;
349 return spv::Dim2D;
354 spv::Decoration TranslatePrecisionDecoration(glslang::TPrecisionQualifier glslangPrecision)
357 case glslang::EpqLow: return spv::DecorationRelaxedPrecision;
358 case glslang::EpqMedium: return spv::DecorationRelaxedPrecision;
360 return spv::NoPrecision;
365 spv::Decoration TranslatePrecisionDecoration(const glslang::TType& type)
371 spv::Decoration TranslateBlockDecoration(const glslang::TStorageQualifier storage, bool useStorageBuffer)
374 case glslang::EvqUniform: return spv::DecorationBlock;
375 case glslang::EvqBuffer: return useStorageBuffer ? spv::DecorationBlock : spv::DecorationBufferBlock;
376 case glslang::EvqVaryingIn: return spv::DecorationBlock;
377 case glslang::EvqVaryingOut: return spv::DecorationBlock;
378 case glslang::EvqShared: return spv::DecorationBlock;
379 case glslang::EvqPayload: return spv::DecorationBlock;
380 case glslang::EvqPayloadIn: return spv::DecorationBlock;
381 case glslang::EvqHitAttr: return spv::DecorationBlock;
382 case glslang::EvqCallableData: return spv::DecorationBlock;
383 case glslang::EvqCallableDataIn: return spv::DecorationBlock;
384 case glslang::EvqHitObjectAttrNV: return spv::DecorationBlock;
390 return spv::DecorationMax;
394 void TranslateMemoryDecoration(const glslang::TQualifier& qualifier, std::vector<spv::Decoration>& memory,
399 memory.push_back(spv::DecorationCoherent);
401 memory.push_back(spv::DecorationVolatile);
402 memory.push_back(spv::DecorationCoherent);
406 memory.push_back(spv::DecorationRestrict);
408 memory.push_back(spv::DecorationNonWritable);
410 memory.push_back(spv::DecorationNonReadable);
414 spv::Decoration TranslateLayoutDecoration(const glslang::TType& type, glslang::TLayoutMatrix matrixLayout)
419 return spv::DecorationRowMajor;
421 return spv::DecorationColMajor;
424 return spv::DecorationMax;
429 return spv::DecorationMax;
437 case glslang::ElpShared: return spv::DecorationGLSLShared;
438 case glslang::ElpPacked: return spv::DecorationGLSLPacked;
440 return spv::DecorationMax;
446 case glslang::ElpShared: return spv::DecorationGLSLShared;
447 case glslang::ElpPacked: return spv::DecorationGLSLPacked;
453 return spv::DecorationMax;
460 return spv::DecorationMax;
463 return spv::DecorationMax;
470 // Returns spv::DecorationMax when no decoration
472 spv::Decoration TGlslangToSpvTraverser::TranslateInterpolationDecoration(const glslang::TQualifier& qualifier)
476 return spv::DecorationMax;
478 return spv::DecorationNoPerspective;
480 return spv::DecorationFlat;
482 builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
483 return spv::DecorationExplicitInterpAMD;
486 return spv::DecorationMax;
490 // Returns spv::DecorationMax when no decoration
492 spv::Decoration TGlslangToSpvTraverser::TranslateAuxiliaryStorageDecoration(const glslang::TQualifier& qualifier)
495 return spv::DecorationCentroid;
497 return spv::DecorationPatch;
499 builder.addCapability(spv::CapabilitySampleRateShading);
500 return spv::DecorationSample;
503 return spv::DecorationMax;
507 spv::Decoration TranslateInvariantDecoration(const glslang::TQualifier& qualifier)
510 return spv::DecorationInvariant;
512 return spv::DecorationMax;
516 spv::Decoration TranslateNoContractionDecoration(const glslang::TQualifier& qualifier)
519 return spv::DecorationNoContraction;
521 return spv::DecorationMax;
525 spv::Decoration TGlslangToSpvTraverser::TranslateNonUniformDecoration(const glslang::TQualifier& qualifier)
528 builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
529 builder.addCapability(spv::CapabilityShaderNonUniformEXT);
530 return spv::DecorationNonUniformEXT;
532 return spv::DecorationMax;
536 spv::Decoration TGlslangToSpvTraverser::TranslateNonUniformDecoration(
537 const spv::Builder::AccessChain::CoherentFlags& coherentFlags)
540 builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
541 builder.addCapability(spv::CapabilityShaderNonUniformEXT);
542 return spv::DecorationNonUniformEXT;
544 return spv::DecorationMax;
547 spv::MemoryAccessMask TGlslangToSpvTraverser::TranslateMemoryAccess(
548 const spv::Builder::AccessChain::CoherentFlags &coherentFlags)
550 spv::MemoryAccessMask mask = spv::MemoryAccessMaskNone;
556 mask = mask | spv::MemoryAccessMakePointerAvailableKHRMask |
557 spv::MemoryAccessMakePointerVisibleKHRMask;
561 mask = mask | spv::MemoryAccessNonPrivatePointerKHRMask;
564 mask = mask | spv::MemoryAccessVolatileMask;
566 if (mask != spv::MemoryAccessMaskNone) {
567 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
573 spv::ImageOperandsMask TGlslangToSpvTraverser::TranslateImageOperands(
574 const spv::Builder::AccessChain::CoherentFlags &coherentFlags)
576 spv::ImageOperandsMask mask = spv::ImageOperandsMaskNone;
583 mask = mask | spv::ImageOperandsMakeTexelAvailableKHRMask |
584 spv::ImageOperandsMakeTexelVisibleKHRMask;
587 mask = mask | spv::ImageOperandsNonPrivateTexelKHRMask;
590 mask = mask | spv::ImageOperandsVolatileTexelKHRMask;
592 if (mask != spv::ImageOperandsMaskNone) {
593 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
599 spv::Builder::AccessChain::CoherentFlags TGlslangToSpvTraverser::TranslateCoherent(const glslang::TType& type)
601 spv::Builder::AccessChain::CoherentFlags flags = {};
620 spv::Scope TGlslangToSpvTraverser::TranslateMemoryScope(
621 const spv::Builder::AccessChain::CoherentFlags &coherentFlags)
623 spv::Scope scope = spv::ScopeMax;
627 scope = glslangIntermediate->usingVulkanMemoryModel() ? spv::ScopeQueueFamilyKHR : spv::ScopeDevice;
629 scope = spv::ScopeDevice;
631 scope = spv::ScopeQueueFamilyKHR;
633 scope = spv::ScopeWorkgroup;
635 scope = spv::ScopeSubgroup;
637 scope = spv::ScopeShaderCallKHR;
639 if (glslangIntermediate->usingVulkanMemoryModel() && scope == spv::ScopeDevice) {
640 builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR);
651 spv::BuiltIn TGlslangToSpvTraverser::TranslateBuiltInDecoration(glslang::TBuiltInVariable builtIn,
660 builder.addCapability(spv::CapabilityGeometryPointSize);
664 builder.addCapability(spv::CapabilityTessellationPointSize);
670 return spv::BuiltInPointSize;
672 case glslang::EbvPosition: return spv::BuiltInPosition;
673 case glslang::EbvVertexId: return spv::BuiltInVertexId;
674 case glslang::EbvInstanceId: return spv::BuiltInInstanceId;
675 case glslang::EbvVertexIndex: return spv::BuiltInVertexIndex;
676 case glslang::EbvInstanceIndex: return spv::BuiltInInstanceIndex;
678 case glslang::EbvFragCoord: return spv::BuiltInFragCoord;
679 case glslang::EbvPointCoord: return spv::BuiltInPointCoord;
680 case glslang::EbvFace: return spv::BuiltInFrontFacing;
681 case glslang::EbvFragDepth: return spv::BuiltInFragDepth;
683 case glslang::EbvNumWorkGroups: return spv::BuiltInNumWorkgroups;
684 case glslang::EbvWorkGroupSize: return spv::BuiltInWorkgroupSize;
685 case glslang::EbvWorkGroupId: return spv::BuiltInWorkgroupId;
686 case glslang::EbvLocalInvocationId: return spv::BuiltInLocalInvocationId;
687 case glslang::EbvLocalInvocationIndex: return spv::BuiltInLocalInvocationIndex;
688 case glslang::EbvGlobalInvocationId: return spv::BuiltInGlobalInvocationId;
698 builder.addCapability(spv::CapabilityClipDistance);
699 return spv::BuiltInClipDistance;
703 builder.addCapability(spv::CapabilityCullDistance);
704 return spv::BuiltInCullDistance;
709 builder.addCapability(spv::CapabilityMultiViewport);
715 if (builder.getSpvVersion() < spv::Spv_1_5) {
716 builder.addIncorporatedExtension(spv::E_SPV_EXT_shader_viewport_index_layer, spv::Spv_1_5);
717 builder.addCapability(spv::CapabilityShaderViewportIndexLayerEXT);
720 builder.addCapability(spv::CapabilityShaderViewportIndex);
722 return spv::BuiltInViewportIndex;
725 builder.addCapability(spv::CapabilitySampleRateShading);
726 return spv::BuiltInSampleId;
729 builder.addCapability(spv::CapabilitySampleRateShading);
730 return spv::BuiltInSamplePosition;
733 return spv::BuiltInSampleMask;
737 return spv::BuiltInLayer;
741 builder.addCapability(spv::CapabilityGeometry);
747 if (builder.getSpvVersion() < spv::Spv_1_5) {
748 builder.addIncorporatedExtension(spv::E_SPV_EXT_shader_viewport_index_layer, spv::Spv_1_5);
749 builder.addCapability(spv::CapabilityShaderViewportIndexLayerEXT);
751 builder.addCapability(spv::CapabilityShaderLayer);
753 return spv::BuiltInLayer;
756 builder.addIncorporatedExtension(spv::E_SPV_KHR_shader_draw_parameters, spv::Spv_1_3);
757 builder.addCapability(spv::CapabilityDrawParameters);
758 return spv::BuiltInBaseVertex;
761 builder.addIncorporatedExtension(spv::E_SPV_KHR_shader_draw_parameters, spv::Spv_1_3);
762 builder.addCapability(spv::CapabilityDrawParameters);
763 return spv::BuiltInBaseInstance;
766 builder.addIncorporatedExtension(spv::E_SPV_KHR_shader_draw_parameters, spv::Spv_1_3);
767 builder.addCapability(spv::CapabilityDrawParameters);
768 return spv::BuiltInDrawIndex;
772 builder.addCapability(spv::CapabilityGeometry);
773 return spv::BuiltInPrimitiveId;
776 builder.addExtension(spv::E_SPV_EXT_shader_stencil_export);
777 builder.addCapability(spv::CapabilityStencilExportEXT);
778 return spv::BuiltInFragStencilRefEXT;
781 builder.addExtension(spv::E_SPV_KHR_fragment_shading_rate);
782 builder.addCapability(spv::CapabilityFragmentShadingRateKHR);
783 return spv::BuiltInShadingRateKHR;
786 builder.addExtension(spv::E_SPV_KHR_fragment_shading_rate);
787 builder.addCapability(spv::CapabilityFragmentShadingRateKHR);
788 return spv::BuiltInPrimitiveShadingRateKHR;
790 case glslang::EbvInvocationId: return spv::BuiltInInvocationId;
791 case glslang::EbvTessLevelInner: return spv::BuiltInTessLevelInner;
792 case glslang::EbvTessLevelOuter: return spv::BuiltInTessLevelOuter;
793 case glslang::EbvTessCoord: return spv::BuiltInTessCoord;
794 case glslang::EbvPatchVertices: return spv::BuiltInPatchVertices;
795 case glslang::EbvHelperInvocation: return spv::BuiltInHelperInvocation;
798 builder.addExtension(spv::E_SPV_KHR_shader_ballot);
799 builder.addCapability(spv::CapabilitySubgroupBallotKHR);
800 return spv::BuiltInSubgroupSize;
803 builder.addExtension(spv::E_SPV_KHR_shader_ballot);
804 builder.addCapability(spv::CapabilitySubgroupBallotKHR);
805 return spv::BuiltInSubgroupLocalInvocationId;
808 builder.addExtension(spv::E_SPV_KHR_shader_ballot);
809 builder.addCapability(spv::CapabilitySubgroupBallotKHR);
810 return spv::BuiltInSubgroupEqMask;
813 builder.addExtension(spv::E_SPV_KHR_shader_ballot);
814 builder.addCapability(spv::CapabilitySubgroupBallotKHR);
815 return spv::BuiltInSubgroupGeMask;
818 builder.addExtension(spv::E_SPV_KHR_shader_ballot);
819 builder.addCapability(spv::CapabilitySubgroupBallotKHR);
820 return spv::BuiltInSubgroupGtMask;
823 builder.addExtension(spv::E_SPV_KHR_shader_ballot);
824 builder.addCapability(spv::CapabilitySubgroupBallotKHR);
825 return spv::BuiltInSubgroupLeMask;
828 builder.addExtension(spv::E_SPV_KHR_shader_ballot);
829 builder.addCapability(spv::CapabilitySubgroupBallotKHR);
830 return spv::BuiltInSubgroupLtMask;
833 builder.addCapability(spv::CapabilityGroupNonUniform);
834 return spv::BuiltInNumSubgroups;
837 builder.addCapability(spv::CapabilityGroupNonUniform);
838 return spv::BuiltInSubgroupId;
841 builder.addCapability(spv::CapabilityGroupNonUniform);
842 return spv::BuiltInSubgroupSize;
845 builder.addCapability(spv::CapabilityGroupNonUniform);
846 return spv::BuiltInSubgroupLocalInvocationId;
849 builder.addCapability(spv::CapabilityGroupNonUniform);
850 builder.addCapability(spv::CapabilityGroupNonUniformBallot);
851 return spv::BuiltInSubgroupEqMask;
854 builder.addCapability(spv::CapabilityGroupNonUniform);
855 builder.addCapability(spv::CapabilityGroupNonUniformBallot);
856 return spv::BuiltInSubgroupGeMask;
859 builder.addCapability(spv::CapabilityGroupNonUniform);
860 builder.addCapability(spv::CapabilityGroupNonUniformBallot);
861 return spv::BuiltInSubgroupGtMask;
864 builder.addCapability(spv::CapabilityGroupNonUniform);
865 builder.addCapability(spv::CapabilityGroupNonUniformBallot);
866 return spv::BuiltInSubgroupLeMask;
869 builder.addCapability(spv::CapabilityGroupNonUniform);
870 builder.addCapability(spv::CapabilityGroupNonUniformBallot);
871 return spv::BuiltInSubgroupLtMask;
874 builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
875 return spv::BuiltInBaryCoordNoPerspAMD;
878 builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
879 return spv::BuiltInBaryCoordNoPerspCentroidAMD;
882 builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
883 return spv::BuiltInBaryCoordNoPerspSampleAMD;
886 builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
887 return spv::BuiltInBaryCoordSmoothAMD;
890 builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
891 return spv::BuiltInBaryCoordSmoothCentroidAMD;
894 builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
895 return spv::BuiltInBaryCoordSmoothSampleAMD;
898 builder.addExtension(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
899 return spv::BuiltInBaryCoordPullModelAMD;
902 builder.addIncorporatedExtension(spv::E_SPV_KHR_device_group, spv::Spv_1_3);
903 builder.addCapability(spv::CapabilityDeviceGroup);
904 return spv::BuiltInDeviceIndex;
907 builder.addIncorporatedExtension(spv::E_SPV_KHR_multiview, spv::Spv_1_3);
908 builder.addCapability(spv::CapabilityMultiView);
909 return spv::BuiltInViewIndex;
912 builder.addExtension(spv::E_SPV_EXT_fragment_invocation_density);
913 builder.addCapability(spv::CapabilityFragmentDensityEXT);
914 return spv::BuiltInFragSizeEXT;
917 builder.addExtension(spv::E_SPV_EXT_fragment_invocation_density);
918 builder.addCapability(spv::CapabilityFragmentDensityEXT);
919 return spv::BuiltInFragInvocationCountEXT;
923 builder.addExtension(spv::E_SPV_NV_viewport_array2);
924 builder.addCapability(spv::CapabilityShaderViewportMaskNV);
926 return spv::BuiltInViewportMaskNV;
929 builder.addExtension(spv::E_SPV_NV_stereo_view_rendering);
930 builder.addCapability(spv::CapabilityShaderStereoViewNV);
932 return spv::BuiltInSecondaryPositionNV;
935 builder.addExtension(spv::E_SPV_NV_stereo_view_rendering);
936 builder.addCapability(spv::CapabilityShaderStereoViewNV);
938 return spv::BuiltInSecondaryViewportMaskNV;
941 builder.addExtension(spv::E_SPV_NVX_multiview_per_view_attributes);
942 builder.addCapability(spv::CapabilityPerViewAttributesNV);
944 return spv::BuiltInPositionPerViewNV;
947 builder.addExtension(spv::E_SPV_NVX_multiview_per_view_attributes);
948 builder.addCapability(spv::CapabilityPerViewAttributesNV);
950 return spv::BuiltInViewportMaskPerViewNV;
952 builder.addExtension(spv::E_SPV_EXT_fragment_fully_covered);
953 builder.addCapability(spv::CapabilityFragmentFullyCoveredEXT);
954 return spv::BuiltInFullyCoveredEXT;
956 builder.addExtension(spv::E_SPV_NV_shading_rate);
957 builder.addCapability(spv::CapabilityShadingRateNV);
958 return spv::BuiltInFragmentSizeNV;
960 builder.addExtension(spv::E_SPV_NV_shading_rate);
961 builder.addCapability(spv::CapabilityShadingRateNV);
962 return spv::BuiltInInvocationsPerPixelNV;
966 return spv::BuiltInLaunchIdKHR;
968 return spv::BuiltInLaunchSizeKHR;
970 return spv::BuiltInWorldRayOriginKHR;
972 return spv::BuiltInWorldRayDirectionKHR;
974 return spv::BuiltInObjectRayOriginKHR;
976 return spv::BuiltInObjectRayDirectionKHR;
978 return spv::BuiltInRayTminKHR;
980 return spv::BuiltInRayTmaxKHR;
982 return spv::BuiltInCullMaskKHR;
984 return spv::BuiltInHitTriangleVertexPositionsKHR;
986 return spv::BuiltInInstanceCustomIndexKHR;
994 return spv::BuiltInHitTNV;
996 return spv::BuiltInRayTmaxKHR;
1000 return spv::BuiltInHitKindKHR;
1003 return spv::BuiltInObjectToWorldKHR;
1006 return spv::BuiltInWorldToObjectKHR;
1008 return spv::BuiltInIncomingRayFlagsKHR;
1010 return spv::BuiltInRayGeometryIndexKHR;
1012 builder.addExtension(spv::E_SPV_NV_ray_tracing_motion_blur);
1013 builder.addCapability(spv::CapabilityRayTracingMotionBlurNV);
1014 return spv::BuiltInCurrentRayTimeNV;
1016 builder.addCapability(spv::CapabilityRayTracingDisplacementMicromapNV);
1018 return spv::BuiltInHitMicroTriangleVertexPositionsNV;
1020 builder.addCapability(spv::CapabilityRayTracingDisplacementMicromapNV);
1022 return spv::BuiltInHitMicroTriangleVertexBarycentricsNV;
1024 builder.addCapability(spv::CapabilityRayTracingDisplacementMicromapNV);
1026 return spv::BuiltInHitKindFrontFacingMicroTriangleNV;
1028 builder.addCapability(spv::CapabilityRayTracingDisplacementMicromapNV);
1030 return spv::BuiltInHitKindBackFacingMicroTriangleNV;
1034 builder.addExtension(spv::E_SPV_NV_fragment_shader_barycentric);
1035 builder.addCapability(spv::CapabilityFragmentBarycentricNV);
1036 return spv::BuiltInBaryCoordNV;
1038 builder.addExtension(spv::E_SPV_NV_fragment_shader_barycentric);
1039 builder.addCapability(spv::CapabilityFragmentBarycentricNV);
1040 return spv::BuiltInBaryCoordNoPerspNV;
1043 builder.addExtension(spv::E_SPV_KHR_fragment_shader_barycentric);
1044 builder.addCapability(spv::CapabilityFragmentBarycentricKHR);
1045 return spv::BuiltInBaryCoordKHR;
1047 builder.addExtension(spv::E_SPV_KHR_fragment_shader_barycentric);
1048 builder.addCapability(spv::CapabilityFragmentBarycentricKHR);
1049 return spv::BuiltInBaryCoordNoPerspKHR;
1053 return spv::BuiltInTaskCountNV;
1055 return spv::BuiltInPrimitiveCountNV;
1057 return spv::BuiltInPrimitiveIndicesNV;
1059 return spv::BuiltInClipDistancePerViewNV;
1061 return spv::BuiltInCullDistancePerViewNV;
1063 return spv::BuiltInLayerPerViewNV;
1065 return spv::BuiltInMeshViewCountNV;
1067 return spv::BuiltInMeshViewIndicesNV;
1071 return spv::BuiltInPrimitivePointIndicesEXT;
1073 return spv::BuiltInPrimitiveLineIndicesEXT;
1075 return spv::BuiltInPrimitiveTriangleIndicesEXT;
1077 return spv::BuiltInCullPrimitiveEXT;
1081 builder.addExtension(spv::E_SPV_NV_shader_sm_builtins);
1082 builder.addCapability(spv::CapabilityShaderSMBuiltinsNV);
1083 return spv::BuiltInWarpsPerSMNV;
1085 builder.addExtension(spv::E_SPV_NV_shader_sm_builtins);
1086 builder.addCapability(spv::CapabilityShaderSMBuiltinsNV);
1087 return spv::BuiltInSMCountNV;
1089 builder.addExtension(spv::E_SPV_NV_shader_sm_builtins);
1090 builder.addCapability(spv::CapabilityShaderSMBuiltinsNV);
1091 return spv::BuiltInWarpIDNV;
1093 builder.addExtension(spv::E_SPV_NV_shader_sm_builtins);
1094 builder.addCapability(spv::CapabilityShaderSMBuiltinsNV);
1095 return spv::BuiltInSMIDNV;
1099 builder.addExtension(spv::E_SPV_ARM_core_builtins);
1100 builder.addCapability(spv::CapabilityCoreBuiltinsARM);
1101 return spv::BuiltInCoreCountARM;
1103 builder.addExtension(spv::E_SPV_ARM_core_builtins);
1104 builder.addCapability(spv::CapabilityCoreBuiltinsARM);
1105 return spv::BuiltInCoreIDARM;
1107 builder.addExtension(spv::E_SPV_ARM_core_builtins);
1108 builder.addCapability(spv::CapabilityCoreBuiltinsARM);
1109 return spv::BuiltInCoreMaxIDARM;
1111 builder.addExtension(spv::E_SPV_ARM_core_builtins);
1112 builder.addCapability(spv::CapabilityCoreBuiltinsARM);
1113 return spv::BuiltInWarpIDARM;
1115 builder.addExtension(spv::E_SPV_ARM_core_builtins);
1116 builder.addCapability(spv::CapabilityCoreBuiltinsARM);
1117 return spv::BuiltInWarpMaxIDARM;
1120 return spv::BuiltInMax;
1125 spv::ImageFormat TGlslangToSpvTraverser::TranslateImageFormat(const glslang::TType& type)
1159 builder.addCapability(spv::CapabilityStorageImageExtendedFormats);
1164 builder.addExtension(spv::E_SPV_EXT_shader_image_int64);
1165 builder.addCapability(spv::CapabilityInt64ImageEXT);
1172 case glslang::ElfNone: return spv::ImageFormatUnknown;
1173 case glslang::ElfRgba32f: return spv::ImageFormatRgba32f;
1174 case glslang::ElfRgba16f: return spv::ImageFormatRgba16f;
1175 case glslang::ElfR32f: return spv::ImageFormatR32f;
1176 case glslang::ElfRgba8: return spv::ImageFormatRgba8;
1177 case glslang::ElfRgba8Snorm: return spv::ImageFormatRgba8Snorm;
1178 case glslang::ElfRg32f: return spv::ImageFormatRg32f;
1179 case glslang::ElfRg16f: return spv::ImageFormatRg16f;
1180 case glslang::ElfR11fG11fB10f: return spv::ImageFormatR11fG11fB10f;
1181 case glslang::ElfR16f: return spv::ImageFormatR16f;
1182 case glslang::ElfRgba16: return spv::ImageFormatRgba16;
1183 case glslang::ElfRgb10A2: return spv::ImageFormatRgb10A2;
1184 case glslang::ElfRg16: return spv::ImageFormatRg16;
1185 case glslang::ElfRg8: return spv::ImageFormatRg8;
1186 case glslang::ElfR16: return spv::ImageFormatR16;
1187 case glslang::ElfR8: return spv::ImageFormatR8;
1188 case glslang::ElfRgba16Snorm: return spv::ImageFormatRgba16Snorm;
1189 case glslang::ElfRg16Snorm: return spv::ImageFormatRg16Snorm;
1190 case glslang::ElfRg8Snorm: return spv::ImageFormatRg8Snorm;
1191 case glslang::ElfR16Snorm: return spv::ImageFormatR16Snorm;
1192 case glslang::ElfR8Snorm: return spv::ImageFormatR8Snorm;
1193 case glslang::ElfRgba32i: return spv::ImageFormatRgba32i;
1194 case glslang::ElfRgba16i: return spv::ImageFormatRgba16i;
1195 case glslang::ElfRgba8i: return spv::ImageFormatRgba8i;
1196 case glslang::ElfR32i: return spv::ImageFormatR32i;
1197 case glslang::ElfRg32i: return spv::ImageFormatRg32i;
1198 case glslang::ElfRg16i: return spv::ImageFormatRg16i;
1199 case glslang::ElfRg8i: return spv::ImageFormatRg8i;
1200 case glslang::ElfR16i: return spv::ImageFormatR16i;
1201 case glslang::ElfR8i: return spv::ImageFormatR8i;
1202 case glslang::ElfRgba32ui: return spv::ImageFormatRgba32ui;
1203 case glslang::ElfRgba16ui: return spv::ImageFormatRgba16ui;
1204 case glslang::ElfRgba8ui: return spv::ImageFormatRgba8ui;
1205 case glslang::ElfR32ui: return spv::ImageFormatR32ui;
1206 case glslang::ElfRg32ui: return spv::ImageFormatRg32ui;
1207 case glslang::ElfRg16ui: return spv::ImageFormatRg16ui;
1208 case glslang::ElfRgb10a2ui: return spv::ImageFormatRgb10a2ui;
1209 case glslang::ElfRg8ui: return spv::ImageFormatRg8ui;
1210 case glslang::ElfR16ui: return spv::ImageFormatR16ui;
1211 case glslang::ElfR8ui: return spv::ImageFormatR8ui;
1212 case glslang::ElfR64ui: return spv::ImageFormatR64ui;
1213 case glslang::ElfR64i: return spv::ImageFormatR64i;
1214 default: return spv::ImageFormatMax;
1218 spv::SelectionControlMask TGlslangToSpvTraverser::TranslateSelectionControl(
1222 return spv::SelectionControlFlattenMask;
1224 return spv::SelectionControlDontFlattenMask;
1225 return spv::SelectionControlMaskNone;
1228 spv::SelectionControlMask TGlslangToSpvTraverser::TranslateSwitchControl(const glslang::TIntermSwitch& switchNode)
1232 return spv::SelectionControlFlattenMask;
1234 return spv::SelectionControlDontFlattenMask;
1235 return spv::SelectionControlMaskNone;
1239 spv::LoopControlMask TGlslangToSpvTraverser::TranslateLoopControl(const glslang::TIntermLoop& loopNode,
1242 spv::LoopControlMask control = spv::LoopControlMaskNone;
1245 control = control | spv::LoopControlDontUnrollMask;
1247 control = control | spv::LoopControlUnrollMask;
1249 control = control | spv::LoopControlDependencyInfiniteMask;
1251 control = control | spv::LoopControlDependencyLengthMask;
1254 if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4) {
1256 control = control | spv::LoopControlMinIterationsMask;
1260 control = control | spv::LoopControlMaxIterationsMask;
1264 control = control | spv::LoopControlIterationMultipleMask;
1268 control = control | spv::LoopControlPeelCountMask;
1272 control = control | spv::LoopControlPartialCountMask;
1281 spv::StorageClass TGlslangToSpvTraverser::TranslateStorageClass(const glslang::TType& type)
1284 return spv::StorageClassPrivate;
1287 return spv::StorageClassFunction;
1290 return spv::StorageClassInput;
1292 return spv::StorageClassOutput;
1294 builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
1295 builder.addCapability(spv::CapabilityTileImageColorReadAccessEXT);
1296 return spv::StorageClassTileImageEXT;
1302 return spv::StorageClassAtomicCounter;
1304 return spv::StorageClassUniformConstant;
1309 return spv::StorageClassShaderRecordBufferKHR;
1313 builder.addIncorporatedExtension(spv::E_SPV_KHR_storage_buffer_storage_class, spv::Spv_1_3);
1314 return spv::StorageClassStorageBuffer;
1319 return spv::StorageClassPushConstant;
1321 return spv::StorageClassUniform;
1322 return spv::StorageClassUniformConstant;
1326 builder.addExtension(spv::E_SPV_KHR_workgroup_memory_explicit_layout);
1327 builder.addCapability(spv::CapabilityWorkgroupMemoryExplicitLayoutKHR);
1328 return spv::StorageClassWorkgroup;
1332 case glslang::EvqGlobal: return spv::StorageClassPrivate;
1333 case glslang::EvqConstReadOnly: return spv::StorageClassFunction;
1334 case glslang::EvqTemporary: return spv::StorageClassFunction;
1335 case glslang::EvqShared: return spv::StorageClassWorkgroup;
1336 case glslang::EvqPayload: return spv::StorageClassRayPayloadKHR;
1337 case glslang::EvqPayloadIn: return spv::StorageClassIncomingRayPayloadKHR;
1338 case glslang::EvqHitAttr: return spv::StorageClassHitAttributeKHR;
1339 case glslang::EvqCallableData: return spv::StorageClassCallableDataKHR;
1340 case glslang::EvqCallableDataIn: return spv::StorageClassIncomingCallableDataKHR;
1341 case glslang::EvqtaskPayloadSharedEXT : return spv::StorageClassTaskPayloadWorkgroupEXT;
1342 case glslang::EvqHitObjectAttrNV: return spv::StorageClassHitObjectAttributeNV;
1343 case glslang::EvqSpirvStorageClass: return static_cast<spv::StorageClass>(type.getQualifier().spirvStorageClass);
1349 return spv::StorageClassFunction;
1409 builder.addCapability(spv::CapabilityInputAttachmentArrayNonUniformIndexingEXT);
1411 builder.addCapability(spv::CapabilityStorageTexelBufferArrayNonUniformIndexingEXT);
1413 builder.addCapability(spv::CapabilityUniformTexelBufferArrayNonUniformIndexingEXT);
1415 builder.addCapability(spv::CapabilityStorageImageArrayNonUniformIndexingEXT);
1417 builder.addCapability(spv::CapabilitySampledImageArrayNonUniformIndexingEXT);
1420 builder.addCapability(spv::CapabilityStorageBufferArrayNonUniformIndexingEXT);
1422 builder.addCapability(spv::CapabilityUniformBufferArrayNonUniformIndexingEXT);
1428 builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
1429 builder.addCapability(spv::CapabilityInputAttachmentArrayDynamicIndexingEXT);
1431 builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
1432 builder.addCapability(spv::CapabilityStorageTexelBufferArrayDynamicIndexingEXT);
1434 builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
1435 builder.addCapability(spv::CapabilityUniformTexelBufferArrayDynamicIndexingEXT);
1535 spv::SpvBuildLogger* buildLogger, glslang::SpvOptions& options) :
1549 spv::ExecutionModel executionModel = TranslateExecutionModel(glslangIntermediate->getStage(), isMeshShaderExt);
1570 if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_1) {
1577 if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_1 && (int)processes.size() > 0)
1592 spv::AddressingModel addressingModel = spv::AddressingModelLogical;
1593 spv::MemoryModel memoryModel = spv::MemoryModelGLSL450;
1596 addressingModel = spv::AddressingModelPhysicalStorageBuffer64EXT;
1597 builder.addIncorporatedExtension(spv::E_SPV_KHR_physical_storage_buffer, spv::Spv_1_5);
1598 builder.addCapability(spv::CapabilityPhysicalStorageBufferAddressesEXT);
1601 memoryModel = spv::MemoryModelVulkanKHR;
1602 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
1603 builder.addIncorporatedExtension(spv::E_SPV_KHR_vulkan_memory_model, spv::Spv_1_5);
1608 builder.addCapability(spv::CapabilityVariablePointers);
1626 builder.addCapability(spv::CapabilityTransformFeedback);
1627 builder.addExecutionMode(shaderEntry, spv::ExecutionModeXfb);
1631 builder.addCapability(spv::CapabilityRayTraversalPrimitiveCullingKHR);
1635 builder.addExtension(spv::E_SPV_KHR_subgroup_uniform_control_flow);
1636 builder.addExecutionMode(shaderEntry, spv::ExecutionModeSubgroupUniformControlFlowKHR);
1642 builder.addCapability(spv::CapabilityShader);
1646 builder.addCapability(spv::CapabilityShader);
1648 builder.addExecutionMode(shaderEntry, spv::ExecutionModePixelCenterInteger);
1651 builder.addExecutionMode(shaderEntry, spv::ExecutionModeOriginUpperLeft);
1653 builder.addExecutionMode(shaderEntry, spv::ExecutionModeOriginLowerLeft);
1656 builder.addExecutionMode(shaderEntry, spv::ExecutionModeEarlyFragmentTests);
1660 builder.addExecutionMode(shaderEntry, spv::ExecutionModeEarlyAndLateFragmentTestsAMD);
1661 builder.addExtension(spv::E_SPV_AMD_shader_early_and_late_fragment_tests);
1665 builder.addCapability(spv::CapabilitySampleMaskPostDepthCoverage);
1666 builder.addExecutionMode(shaderEntry, spv::ExecutionModePostDepthCoverage);
1667 builder.addExtension(spv::E_SPV_KHR_post_depth_coverage);
1671 builder.addCapability(spv::CapabilityTileImageColorReadAccessEXT);
1672 builder.addExecutionMode(shaderEntry, spv::ExecutionModeNonCoherentColorAttachmentReadEXT);
1673 builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
1677 builder.addCapability(spv::CapabilityTileImageDepthReadAccessEXT);
1678 builder.addExecutionMode(shaderEntry, spv::ExecutionModeNonCoherentDepthAttachmentReadEXT);
1679 builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
1683 builder.addCapability(spv::CapabilityTileImageStencilReadAccessEXT);
1684 builder.addExecutionMode(shaderEntry, spv::ExecutionModeNonCoherentStencilAttachmentReadEXT);
1685 builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
1689 builder.addExecutionMode(shaderEntry, spv::ExecutionModeDepthReplacing);
1692 builder.addExecutionMode(shaderEntry, spv::ExecutionModeStencilRefReplacingEXT);
1695 case glslang::EldGreater: mode = spv::ExecutionModeDepthGreater; break;
1696 case glslang::EldLess: mode = spv::ExecutionModeDepthLess; break;
1697 case glslang::EldUnchanged: mode = spv::ExecutionModeDepthUnchanged; break;
1698 default: mode = spv::ExecutionModeMax; break;
1701 if (mode != spv::ExecutionModeMax)
1702 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1705 case glslang::ElsRefUnchangedFrontAMD: mode = spv::ExecutionModeStencilRefUnchangedFrontAMD; break;
1706 case glslang::ElsRefGreaterFrontAMD: mode = spv::ExecutionModeStencilRefGreaterFrontAMD; break;
1707 case glslang::ElsRefLessFrontAMD: mode = spv::ExecutionModeStencilRefLessFrontAMD; break;
1708 case glslang::ElsRefUnchangedBackAMD: mode = spv::ExecutionModeStencilRefUnchangedBackAMD; break;
1709 case glslang::ElsRefGreaterBackAMD: mode = spv::ExecutionModeStencilRefGreaterBackAMD; break;
1710 case glslang::ElsRefLessBackAMD: mode = spv::ExecutionModeStencilRefLessBackAMD; break;
1711 default: mode = spv::ExecutionModeMax; break;
1714 if (mode != spv::ExecutionModeMax)
1715 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1717 case glslang::EioPixelInterlockOrdered: mode = spv::ExecutionModePixelInterlockOrderedEXT;
1719 case glslang::EioPixelInterlockUnordered: mode = spv::ExecutionModePixelInterlockUnorderedEXT;
1721 case glslang::EioSampleInterlockOrdered: mode = spv::ExecutionModeSampleInterlockOrderedEXT;
1723 case glslang::EioSampleInterlockUnordered: mode = spv::ExecutionModeSampleInterlockUnorderedEXT;
1725 case glslang::EioShadingRateInterlockOrdered: mode = spv::ExecutionModeShadingRateInterlockOrderedEXT;
1727 case glslang::EioShadingRateInterlockUnordered: mode = spv::ExecutionModeShadingRateInterlockUnorderedEXT;
1729 default: mode = spv::ExecutionModeMax;
1732 if (mode != spv::ExecutionModeMax) {
1733 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1734 if (mode == spv::ExecutionModeShadingRateInterlockOrderedEXT ||
1735 mode == spv::ExecutionModeShadingRateInterlockUnorderedEXT) {
1736 builder.addCapability(spv::CapabilityFragmentShaderShadingRateInterlockEXT);
1737 } else if (mode == spv::ExecutionModePixelInterlockOrderedEXT ||
1738 mode == spv::ExecutionModePixelInterlockUnorderedEXT) {
1739 builder.addCapability(spv::CapabilityFragmentShaderPixelInterlockEXT);
1741 builder.addCapability(spv::CapabilityFragmentShaderSampleInterlockEXT);
1743 builder.addExtension(spv::E_SPV_EXT_fragment_shader_interlock);
1748 builder.addCapability(spv::CapabilityShader);
1756 if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6 && needSizeId) {
1757 std::vector<spv::Id> dimConstId;
1762 builder.addDecoration(dimConstId.back(), spv::DecorationSpecId,
1767 builder.addExecutionModeId(shaderEntry, spv::ExecutionModeLocalSizeId, dimConstId);
1769 builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
1774 builder.addCapability(spv::CapabilityComputeDerivativeGroupQuadsNV);
1775 builder.addExecutionMode(shaderEntry, spv::ExecutionModeDerivativeGroupQuadsNV);
1776 builder.addExtension(spv::E_SPV_NV_compute_shader_derivatives);
1778 builder.addCapability(spv::CapabilityComputeDerivativeGroupLinearNV);
1779 builder.addExecutionMode(shaderEntry, spv::ExecutionModeDerivativeGroupLinearNV);
1780 builder.addExtension(spv::E_SPV_NV_compute_shader_derivatives);
1786 builder.addCapability(spv::CapabilityTessellation);
1791 builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputVertices,
1799 case glslang::ElgTriangles: mode = spv::ExecutionModeTriangles; break;
1800 case glslang::ElgQuads: mode = spv::ExecutionModeQuads; break;
1801 case glslang::ElgIsolines: mode = spv::ExecutionModeIsolines; break;
1802 default: mode = spv::ExecutionModeMax; break;
1804 if (mode != spv::ExecutionModeMax)
1805 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1808 case glslang::EvsEqual: mode = spv::ExecutionModeSpacingEqual; break;
1809 case glslang::EvsFractionalEven: mode = spv::ExecutionModeSpacingFractionalEven; break;
1810 case glslang::EvsFractionalOdd: mode = spv::ExecutionModeSpacingFractionalOdd; break;
1811 default: mode = spv::ExecutionModeMax; break;
1813 if (mode != spv::ExecutionModeMax)
1814 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1817 case glslang::EvoCw: mode = spv::ExecutionModeVertexOrderCw; break;
1818 case glslang::EvoCcw: mode = spv::ExecutionModeVertexOrderCcw; break;
1819 default: mode = spv::ExecutionModeMax; break;
1821 if (mode != spv::ExecutionModeMax)
1822 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1825 builder.addExecutionMode(shaderEntry, spv::ExecutionModePointMode);
1829 builder.addCapability(spv::CapabilityGeometry);
1831 case glslang::ElgPoints: mode = spv::ExecutionModeInputPoints; break;
1832 case glslang::ElgLines: mode = spv::ExecutionModeInputLines; break;
1833 case glslang::ElgLinesAdjacency: mode = spv::ExecutionModeInputLinesAdjacency; break;
1834 case glslang::ElgTriangles: mode = spv::ExecutionModeTriangles; break;
1835 case glslang::ElgTrianglesAdjacency: mode = spv::ExecutionModeInputTrianglesAdjacency; break;
1836 default: mode = spv::ExecutionModeMax; break;
1838 if (mode != spv::ExecutionModeMax)
1839 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1841 builder.addExecutionMode(shaderEntry, spv::ExecutionModeInvocations, glslangIntermediate->getInvocations());
1844 case glslang::ElgPoints: mode = spv::ExecutionModeOutputPoints; break;
1845 case glslang::ElgLineStrip: mode = spv::ExecutionModeOutputLineStrip; break;
1846 case glslang::ElgTriangleStrip: mode = spv::ExecutionModeOutputTriangleStrip; break;
1847 default: mode = spv::ExecutionModeMax; break;
1849 if (mode != spv::ExecutionModeMax)
1850 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1851 builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputVertices, glslangIntermediate->getVertices());
1863 builder.addCapability(spv::CapabilityRayTracingKHR);
1867 builder.addCapability(spv::CapabilityRayTracingNV);
1872 builder.addCapability(spv::CapabilityRayCullMaskKHR);
1876 builder.addCapability(spv::CapabilityRayTracingPositionFetchKHR);
1885 builder.addCapability(spv::CapabilityMeshShadingEXT);
1886 builder.addExtension(spv::E_SPV_EXT_mesh_shader);
1888 builder.addCapability(spv::CapabilityMeshShadingNV);
1889 builder.addExtension(spv::E_SPV_NV_mesh_shader);
1891 if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
1892 std::vector<spv::Id> dimConstId;
1897 builder.addDecoration(dimConstId.back(), spv::DecorationSpecId,
1901 builder.addExecutionModeId(shaderEntry, spv::ExecutionModeLocalSizeId, dimConstId);
1903 builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
1908 builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputVertices,
1910 builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputPrimitivesNV,
1914 case glslang::ElgPoints: mode = spv::ExecutionModeOutputPoints; break;
1915 case glslang::ElgLines: mode = spv::ExecutionModeOutputLinesNV; break;
1916 case glslang::ElgTriangles: mode = spv::ExecutionModeOutputTrianglesNV; break;
1917 default: mode = spv::ExecutionModeMax; break;
1919 if (mode != spv::ExecutionModeMax)
1920 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
1940 builder.addCapability(static_cast<spv::Capability>(capability));
1954 builder.addExecutionMode(shaderEntry, static_cast<spv::ExecutionMode>(mode.first), literals);
1956 builder.addExecutionMode(shaderEntry, static_cast<spv::ExecutionMode>(mode.first));
1961 std::vector<spv::Id> operandIds;
1969 builder.addExecutionModeId(shaderEntry, static_cast<spv::ExecutionMode>(modeId.first), operandIds);
2038 spv::Id id = getSymbolId(symbol);
2050 spv::StorageClass sc = builder.getStorageClass(id);
2053 if ((glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4 && builder.isGlobalVariable(id)) ||
2054 (sc == spv::StorageClassInput || sc == spv::StorageClassOutput)) {
2114 if (id != spv::NoResult) {
2115 spv::Id counterId = getSymbolId(symbol);
2116 if (counterId != spv::NoResult) {
2118 builder.addDecorationId(id, spv::DecorationHlslCounterBufferGOOGLE, counterId);
2168 spv::Builder::AccessChain lValue = builder.getAccessChain();
2173 spv::Id rValue = accessChainLoad(node->getRight()->getType());
2181 spv::Id leftRValue = accessChainLoad(node->getLeft()->getType());
2184 spv::Builder::AccessChain::CoherentFlags coherentFlags = TranslateCoherent(node->getLeft()->getType());
2194 assert(rValue != spv::NoResult);
2220 spv::Builder::AccessChain::CoherentFlags coherentFlags = TranslateCoherent(node->getLeft()->getType());
2240 spv::Id left = accessChainLoad(node->getLeft()->getType());
2260 spv::Builder::AccessChain::CoherentFlags coherentFlags =
2288 spv::Builder::AccessChain partial = builder.getAccessChain();
2293 spv::Id index = accessChainLoad(node->getRight()->getType());
2301 spv::Builder::AccessChain::CoherentFlags index_flags = TranslateCoherent(node->getRight()->getType());
2302 spv::Builder::AccessChain::CoherentFlags coherent_flags = TranslateCoherent(node->getLeft()->getType());
2341 spv::Id result = createShortCircuit(node->getOp(), *node->getLeft()->getAsTyped(),
2356 spv::Id left = accessChainLoad(node->getLeft()->getType());
2361 spv::Id right = accessChainLoad(node->getRight()->getType());
2367 spv::Id result = createBinaryOperation(node->getOp(), decorations,
2381 spv::Id TGlslangToSpvTraverser::convertLoadedBoolInUniformToUint(const glslang::TType& type,
2382 spv::Id nominalTypeId,
2383 spv::Id loadedId)
2387 spv::Id boolType = builder.makeBoolType();
2389 return builder.createBinOp(spv::OpINotEqual, boolType, loadedId, builder.makeUintConstant(0));
2393 spv::Id bvecType = builder.makeVectorType(builder.makeBoolType(), vecSize);
2395 loadedId = builder.createBinOp(spv::OpINotEqual, bvecType, loadedId,
2399 spv::Id boolArrayTypeId = convertGlslangToSpvType(type);
2403 if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4)
2404 return builder.createUnaryOp(spv::OpCopyLogical, boolArrayTypeId, loadedId);
2407 spv::Id elementNominalTypeId = builder.getContainedTypeId(nominalTypeId);
2408 std::vector<spv::Id> constituents;
2411 spv::Id elementValue = builder.createCompositeExtract(loadedId, elementNominalTypeId, index);
2414 spv::Id elementConvertedValue = convertLoadedBoolInUniformToUint(glslangElementType, elementNominalTypeId, elementValue);
2427 std::pair<spv::Id, spv::Id> TGlslangToSpvTraverser::getForcedType(glslang::TBuiltInVariable glslangBuiltIn,
2440 spv::Id ivec4_type = builder.makeVectorType(builder.makeUintType(32), 4);
2441 spv::Id uint64_type = builder.makeUintType(64);
2442 std::pair<spv::Id, spv::Id> ret(ivec4_type, uint64_type);
2449 spv::Id mat43 = builder.makeMatrixType(builder.makeFloatType(32), 4, 3);
2450 spv::Id mat34 = builder.makeMatrixType(builder.makeFloatType(32), 3, 4);
2451 std::pair<spv::Id, spv::Id> ret(mat43, mat34);
2458 std::pair<spv::Id, spv::Id> ret(spv::NoType, spv::NoType);
2465 spv::Id TGlslangToSpvTraverser::translateForcedType(spv::Id object)
2471 spv::Id desiredTypeId = forceIt->second;
2472 spv::Id objectTypeId = builder.getTypeId(object);
2481 object = builder.accessChainLoad(spv::NoPrecision, spv::DecorationMax, spv::DecorationMax, objectTypeId);
2482 std::vector<spv::Id> components;
2486 spv::Id vecType = builder.makeVectorType(builder.getContainedTypeId(objectTypeId), 2);
2487 return builder.createUnaryOp(spv::OpBitcast, desiredTypeId,
2497 object = builder.accessChainLoad(spv::NoPrecision, spv::DecorationMax, spv::DecorationMax, objectTypeId);
2498 return builder.createUnaryOp(spv::OpTranspose, desiredTypeId, object);
2515 spv::Id result = spv::NoResult;
2519 if (result != spv::NoResult) {
2540 spv::Id length;
2542 spv::Id typeId = convertGlslangToSpvType(node->getOperand()->getType());
2564 length = builder.createBinOp(spv::OpIAdd, builder.makeIntType(32), length, builder.makeIntConstant(0));
2566 length = builder.createUnaryOp(spv::OpBitcast, builder.makeIntType(32), length);
2588 spv::Id invertedType = spv::NoType;
2589 auto resultType = [&invertedType, &node, this](){ return invertedType != spv::NoType ?
2596 if (invertedType != spv::NoType)
2603 spv::Id operand = spv::NoResult;
2605 spv::Builder::AccessChain::CoherentFlags lvalueCoherentFlags;
2656 operand = spv::NoResult;
2680 spv::IdImmediate idImmOp = {true, operand};
2691 builder.createNoResultOp(static_cast<spv::Op>(spirvInst.id), {idImmOp});
2693 result = builder.createOp(static_cast<spv::Op>(spirvInst.id), resultType(), {idImmOp});
2725 spv::Id one = 0;
2747 spv::Id result = createBinaryOperation(op, decorations,
2750 assert(result != spv::NoResult);
2767 builder.createNoResultOp(spv::OpEmitStreamVertex, operand);
2770 builder.createNoResultOp(spv::OpEndStreamPrimitive, operand);
2773 builder.createNoResultOp(spv::OpRayQueryTerminateKHR, operand);
2776 builder.createNoResultOp(spv::OpRayQueryConfirmIntersectionKHR, operand);
2779 builder.createNoResultOp(spv::OpReorderThreadWithHitObjectNV, operand);
2782 builder.createNoResultOp(spv::OpHitObjectRecordEmptyNV, operand);
2792 spv::Id TGlslangToSpvTraverser::createCompositeConstruct(spv::Id resultTypeId, std::vector<spv::Id> constituents)
2795 spv::Id& constituent = constituents[c];
2796 spv::Id lType = builder.getContainedTypeId(resultTypeId, c);
2797 spv::Id rType = builder.getTypeId(constituent);
2799 if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4) {
2800 constituent = builder.createUnaryOp(spv::OpCopyLogical, lType, constituent);
2802 std::vector<spv::Id> rTypeConstituents;
2811 std::vector<spv::Id> rTypeConstituents;
2814 spv::Id elementRType = builder.getContainedTypeId(rType);
2831 spv::Id result = spv::NoResult;
2832 spv::Id invertedType = spv::NoType; // to use to override the natural type of the node
2833 std::vector<spv::Builder::AccessChain> complexLvalues; // for holding swizzling l-values too complex for
2835 std::vector<spv::Id> temporaryLvalues; // temporaries to pass, as proxies for complexLValues
2837 auto resultType = [&invertedType, &node, this](){ return invertedType != spv::NoType ?
2843 if (result != spv::NoResult) {
2861 spv::Builder::AccessChain::CoherentFlags lvalueCoherentFlags;
2865 spv::Decoration precision = TranslatePrecisionDecoration(node->getOperationPrecision());
2939 spv::Id sourceFileId = sourceFileName ? builder.getStringId(sourceFileName) : builder.getSourceFile();
3079 std::vector<spv::Id> arguments;
3081 spv::Id constructed;
3084 if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6 &&
3091 constructed = builder.createOp(spv::OpSampledImage, resultType(), arguments);
3096 std::vector<spv::Id> constituents;
3106 builder.addDecoration(constructed, spv::DecorationNonUniformEXT);
3209 builder.addCapability(spv::CapabilityAtomicStorageOps);
3219 builder.addCapability(spv::CapabilityIntegerFunctions2INTEL);
3241 builder.addCapability(spv::CapabilityRayQueryKHR);
3264 builder.addCapability(spv::CapabilityRayQueryKHR);
3274 builder.addExtension(spv::E_SPV_EXT_fragment_shader_interlock);
3311 builder.addExtension(spv::E_SPV_NV_shader_invocation_reorder);
3312 builder.addCapability(spv::CapabilityShaderInvocationReorderNV);
3315 builder.addExtension(spv::E_SPV_KHR_ray_tracing_position_fetch);
3316 builder.addCapability(spv::CapabilityRayQueryPositionFetchKHR);
3321 builder.addCapability(spv::CapabilityTextureSampleWeightedQCOM);
3322 builder.addExtension(spv::E_SPV_QCOM_image_processing);
3325 builder.addCapability(spv::CapabilityTextureBoxFilterQCOM);
3326 builder.addExtension(spv::E_SPV_QCOM_image_processing);
3330 builder.addCapability(spv::CapabilityTextureBlockMatchQCOM);
3331 builder.addExtension(spv::E_SPV_QCOM_image_processing);
3336 builder.addExtension(spv::E_SPV_NV_displacement_micromap);
3337 builder.addCapability(spv::CapabilityDisplacementMicromapNV);
3358 spv::Id leftId = accessChainLoad(left->getType());
3362 spv::Id rightId = accessChainLoad(right->getType());
3373 assert(result != spv::NoResult);
3384 std::vector<spv::Id> operands;
3385 std::vector<spv::IdImmediate> memoryAccessOperands;
3525 if (invertedType != spv::NoType && arg == 0)
3537 spv::Builder::AccessChain save = builder.getAccessChain();
3541 spv::Id elementId = accessChainLoad(glslangOperands[2]->getAsTyped()->getType());
3550 spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags;
3556 memoryAccess &= ~spv::MemoryAccessMakePointerAvailableKHRMask;
3559 memoryAccess &= ~spv::MemoryAccessMakePointerVisibleKHRMask;
3561 spv::StorageClassPhysicalStorageBufferEXT) {
3562 memoryAccess = (spv::MemoryAccessMask)(memoryAccess | spv::MemoryAccessAlignedMask);
3565 memoryAccessOperands.push_back(spv::IdImmediate(false, memoryAccess));
3567 if (memoryAccess & spv::MemoryAccessAlignedMask) {
3568 memoryAccessOperands.push_back(spv::IdImmediate(false, alignment));
3572 (spv::MemoryAccessMakePointerAvailableKHRMask | spv::MemoryAccessMakePointerVisibleKHRMask)) {
3573 memoryAccessOperands.push_back(spv::IdImmediate(true,
3583 if (invertedType == spv::NoType && !builder.isSpvLvalue()) {
3590 spv::NoPrecision, spv::StorageClassFunction,
3629 spv::Id symId = getSymbolId(itNode->second);
3640 spv::Id symId = getSymbolId(itNode->second);
3644 operands.push_back(spv::NoResult);
3654 std::vector<spv::IdImmediate> idImmOps;
3656 idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf
3658 idImmOps.push_back(spv::IdImmediate(true, operands[3])); // matrixLayout
3659 idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride
3661 idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride
3662 idImmOps.push_back(spv::IdImmediate(true, operands[3])); // colMajor
3666 spv::Id typeId = builder.getContainedTypeId(builder.getTypeId(operands[0]));
3669 spv::Id result = node->getOp() == glslang::EOpCooperativeMatrixLoad
3670 ? builder.createOp(spv::OpCooperativeMatrixLoadKHR, typeId, idImmOps)
3671 : builder.createOp(spv::OpCooperativeMatrixLoadNV, typeId, idImmOps);
3677 std::vector<spv::IdImmediate> idImmOps;
3679 idImmOps.push_back(spv::IdImmediate(true, operands[1])); // buf
3680 idImmOps.push_back(spv::IdImmediate(true, operands[0])); // object
3682 idImmOps.push_back(spv::IdImmediate(true, operands[3])); // matrixLayout
3683 idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride
3685 idImmOps.push_back(spv::IdImmediate(true, operands[2])); // stride
3686 idImmOps.push_back(spv::IdImmediate(true, operands[3])); // colMajor
3691 builder.createNoResultOp(spv::OpCooperativeMatrixStoreKHR, idImmOps);
3693 builder.createNoResultOp(spv::OpCooperativeMatrixStoreNV, idImmOps);
3696 std::vector<spv::IdImmediate> idImmOps;
3698 idImmOps.push_back(spv::IdImmediate(true, operands[0])); // q
3699 idImmOps.push_back(spv::IdImmediate(true, operands[1])); // committed
3701 spv::Id typeId = builder.makeArrayType(builder.makeVectorType(builder.makeFloatType(32), 3),
3705 spv::Op spvOp = spv::OpRayQueryGetIntersectionTriangleVertexPositionsKHR;
3707 spv::Id result = builder.createOp(spvOp, typeId, idImmOps);
3721 matrixOperands |= spv::CooperativeMatrixOperandsMatrixASignedComponentsKHRMask;
3723 matrixOperands |= spv::CooperativeMatrixOperandsMatrixBSignedComponentsKHRMask;
3725 matrixOperands |= spv::CooperativeMatrixOperandsMatrixCSignedComponentsKHRMask;
3727 matrixOperands |= spv::CooperativeMatrixOperandsMatrixResultSignedComponentsKHRMask;
3729 std::vector<spv::IdImmediate> idImmOps;
3730 idImmOps.push_back(spv::IdImmediate(true, operands[0]));
3731 idImmOps.push_back(spv::IdImmediate(true, operands[1]));
3732 idImmOps.push_back(spv::IdImmediate(true, operands[2]));
3734 idImmOps.push_back(spv::IdImmediate(false, matrixOperands));
3736 result = builder.createOp(spv::OpCooperativeMatrixMulAddKHR, resultType(), idImmOps);
3746 std::vector<spv::IdImmediate> idImmOps;
3760 builder.createNoResultOp(static_cast<spv::Op>(spirvInst.id), idImmOps);
3762 result = builder.createOp(static_cast<spv::Op>(spirvInst.id), resultType(), idImmOps);
3773 result = builder.createBuiltinCall(builder.makeVoidType(), nonSemanticDebugPrintf, spv::NonSemanticDebugPrintfDebugPrintf, operands);
3774 builder.addExtension(spv::E_SPV_KHR_non_semantic_info);
3797 if (invertedType != spv::NoResult)
3802 builder.accessChainStore(builder.createLoad(temporaryLvalues[i], spv::NoPrecision),
3836 if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_4) {
3877 spv::Id result = spv::NoResult; // upcoming result selecting between trueValue and falseValue
3880 spv::Id condition = accessChainLoad(node->getCondition()->getType());
3885 spv::Id resultType = convertGlslangToSpvType(node->getType());
3887 spv::Id trueValue = accessChainLoad(node->getTrueBlock()->getAsTyped()->getType());
3889 spv::Id falseValue = accessChainLoad(node->getFalseBlock()->getAsTyped()->getType());
3905 if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_4 && builder.isVector(trueValue)) {
3906 condition = builder.smearScalar(spv::NoPrecision, condition,
3915 trueValue = builder.createUnaryOp(spv::OpCopyLogical, resultType, trueValue);
3918 falseValue = builder.createUnaryOp(spv::OpCopyLogical, resultType, falseValue);
3922 result = builder.createTriOp(spv::OpSelect, resultType, condition, trueValue, falseValue);
3930 spv::StorageClassFunction, resultType);
3933 const spv::SelectionControlMask control = TranslateSelectionControl(*node);
3936 spv::Builder::If ifBuilder(condition, control, builder);
3961 result = builder.createVariable(TranslatePrecisionDecoration(node->getType()), spv::StorageClassFunction,
3966 const spv::SelectionControlMask control = TranslateSelectionControl(*node);
3969 spv::Builder::If ifBuilder(condition, control, builder);
3974 if (result != spv::NoResult) {
3975 spv::Id load = accessChainLoad(node->getTrueBlock()->getAsTyped()->getType());
3987 if (result != spv::NoResult) {
3988 spv::Id load = accessChainLoad(node->getFalseBlock()->getAsTyped()->getType());
3999 if (result != spv::NoResult) {
4021 spv::Id selector = accessChainLoad(node->getCondition()->getAsTyped()->getType());
4024 const spv::SelectionControlMask control = TranslateSwitchControl(*node);
4051 std::vector<spv::Block*> segmentBlocks; // returned, as the blocks allocated in the call
4077 spv::Id constant = createSpvConstantFromConstUnionArray(node->getType(), node->getConstArray(), nextConst, false);
4090 const spv::LoopControlMask control = TranslateLoopControl(*node, operands);
4102 spv::Block& test = builder.makeNewBlock();
4107 spv::Id condition = accessChainLoad(node->getTest()->getType());
4137 spv::Id condition =
4161 if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
4163 builder.addCapability(spv::CapabilityDemoteToHelperInvocation);
4164 builder.createNoResultOp(spv::OpDemoteToHelperInvocationEXT);
4166 builder.makeStatementTerminator(spv::OpTerminateInvocation, "post-terminate-invocation");
4169 builder.makeStatementTerminator(spv::OpKill, "post-discard");
4173 builder.addExtension(spv::E_SPV_KHR_terminate_invocation);
4174 builder.makeStatementTerminator(spv::OpTerminateInvocation, "post-terminate-invocation");
4188 spv::Id returnId = accessChainLoad(glslangReturnType);
4192 spv::Id copyId = builder.createVariable(currentFunction->getReturnPrecision(),
4193 spv::StorageClassFunction, currentFunction->getReturnType());
4206 builder.createNoResultOp(spv::OpDemoteToHelperInvocationEXT);
4207 builder.addExtension(spv::E_SPV_EXT_demote_to_helper_invocation);
4208 builder.addCapability(spv::CapabilityDemoteToHelperInvocationEXT);
4211 builder.makeStatementTerminator(spv::OpTerminateRayKHR, "post-terminateRayKHR");
4214 builder.makeStatementTerminator(spv::OpIgnoreIntersectionKHR, "post-ignoreIntersectionKHR");
4225 spv::Id TGlslangToSpvTraverser::createSpvVariable(const glslang::TIntermSymbol* node, spv::Id forcedType)
4231 spv::Id result = createSpvConstant(*node);
4232 if (result != spv::NoResult)
4237 spv::StorageClass storageClass = TranslateStorageClass(node->getType());
4238 spv::Id spvType = forcedType == spv::NoType ? convertGlslangToSpvType(node->getType())
4245 case spv::StorageClassInput:
4246 case spv::StorageClassOutput:
4247 builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3);
4248 builder.addCapability(spv::CapabilityStorageInputOutput16);
4250 case spv::StorageClassUniform:
4251 builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3);
4253 builder.addCapability(spv::CapabilityStorageUniformBufferBlock16);
4255 builder.addCapability(spv::CapabilityStorageUniform16);
4257 case spv::StorageClassPushConstant:
4258 builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3);
4259 builder.addCapability(spv::CapabilityStoragePushConstant16);
4261 case spv::StorageClassStorageBuffer:
4262 case spv::StorageClassPhysicalStorageBufferEXT:
4263 builder.addIncorporatedExtension(spv::E_SPV_KHR_16bit_storage, spv::Spv_1_3);
4264 builder.addCapability(spv::CapabilityStorageUniformBufferBlock16);
4267 if (storageClass == spv::StorageClassWorkgroup &&
4269 builder.addCapability(spv::CapabilityWorkgroupMemoryExplicitLayout16BitAccessKHR);
4273 builder.addCapability(spv::CapabilityFloat16);
4275 builder.addCapability(spv::CapabilityInt16);
4281 if (storageClass == spv::StorageClassPushConstant) {
4282 builder.addIncorporatedExtension(spv::E_SPV_KHR_8bit_storage, spv::Spv_1_5);
4283 builder.addCapability(spv::CapabilityStoragePushConstant8);
4284 } else if (storageClass == spv::StorageClassUniform) {
4285 builder.addIncorporatedExtension(spv::E_SPV_KHR_8bit_storage, spv::Spv_1_5);
4286 builder.addCapability(spv::CapabilityUniformAndStorageBuffer8BitAccess);
4287 } else if (storageClass == spv::StorageClassStorageBuffer) {
4288 builder.addIncorporatedExtension(spv::E_SPV_KHR_8bit_storage, spv::Spv_1_5);
4289 builder.addCapability(spv::CapabilityStorageBuffer8BitAccess);
4290 } else if (storageClass == spv::StorageClassWorkgroup &&
4292 builder.addCapability(spv::CapabilityWorkgroupMemoryExplicitLayout8BitAccessKHR);
4294 builder.addCapability(spv::CapabilityInt8);
4302 spv::Id initializer = spv::NoResult;
4314 return builder.createVariable(spv::NoPrecision, storageClass, spvType, name, initializer, false);
4318 spv::Id TGlslangToSpvTraverser::getSampledType(const glslang::TSampler& sampler)
4325 builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float_fetch);
4326 builder.addCapability(spv::CapabilityFloat16ImageAMD);
4329 builder.addExtension(spv::E_SPV_EXT_shader_image_int64);
4330 builder.addCapability(spv::CapabilityInt64ImageEXT);
4333 builder.addExtension(spv::E_SPV_EXT_shader_image_int64);
4334 builder.addCapability(spv::CapabilityInt64ImageEXT);
4345 spv::Id TGlslangToSpvTraverser::getInvertedSwizzleType(const glslang::TIntermTyped& node)
4351 return spv::NoType;
4356 spv::Id TGlslangToSpvTraverser::createInvertedSwizzle(spv::Decoration precision, const glslang::TIntermTyped& node,
4357 spv::Id parentResult)
4375 spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& type, bool forwardReferenceOnly)
4380 spv::LinkageType TGlslangToSpvTraverser::convertGlslangLinkageToSpv(glslang::TLinkType linkType)
4384 return spv::LinkageTypeExport;
4386 return spv::LinkageTypeMax;
4393 spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& type,
4397 spv::Id spvType = spv::NoResult;
4446 builder.addCapability(spv::CapabilityAtomicStorage);
4463 builder.addExtension(spv::E_SPV_KHR_ray_query);
4464 builder.addCapability(spv::CapabilityRayQueryKHR);
4475 builder.addExtension(spv::E_SPV_KHR_ray_query);
4476 builder.addCapability(spv::CapabilityRayQueryKHR);
4486 spv::Id forwardId = builder.makeForwardPointer(spv::StorageClassPhysicalStorageBufferEXT);
4491 spv::Id referentType = convertGlslangToSpvType(*type.getReferentType());
4492 builder.makePointerFromForwardPointer(spv::StorageClassPhysicalStorageBufferEXT,
4509 (!sampler.isBuffer() || glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_6)) {
4527 if (spvType != spv::NoResult)
4541 builder.addExtension(spv::E_SPV_NV_shader_invocation_reorder);
4542 builder.addCapability(spv::CapabilityShaderInvocationReorderNV);
4551 std::vector<spv::IdImmediate> operands;
4607 spvType = builder.makeGenericType(static_cast<spv::Op>(spirvInst.id), operands);
4625 builder.addCapability(spv::CapabilityCooperativeMatrixNV);
4626 builder.addExtension(spv::E_SPV_NV_cooperative_matrix);
4629 builder.addCapability(spv::CapabilityFloat16);
4632 builder.addCapability(spv::CapabilityInt8);
4635 spv::Id scope = makeArraySizeId(*type.getTypeParameters()->arraySizes, 1);
4636 spv::Id rows = makeArraySizeId(*type.getTypeParameters()->arraySizes, 2);
4637 spv::Id cols = makeArraySizeId(*type.getTypeParameters()->arraySizes, 3);
4643 builder.addCapability(spv::CapabilityCooperativeMatrixKHR);
4644 builder.addExtension(spv::E_SPV_KHR_cooperative_matrix);
4647 builder.addCapability(spv::CapabilityFloat16);
4649 builder.addCapability(spv::CapabilityInt8);
4652 spv::Id scope = makeArraySizeId(*type.getTypeParameters()->arraySizes, 0);
4653 spv::Id rows = makeArraySizeId(*type.getTypeParameters()->arraySizes, 1);
4654 spv::Id cols = makeArraySizeId(*type.getTypeParameters()->arraySizes, 2);
4655 spv::Id use = builder.makeUintConstant(type.getCoopMatKHRuse());
4682 builder.addDecoration(spvType, spv::DecorationArrayStride, stride);
4699 builder.addIncorporatedExtension("SPV_EXT_descriptor_indexing", spv::Spv_1_5);
4700 builder.addCapability(spv::CapabilityRuntimeDescriptorArrayEXT);
4705 builder.addDecoration(spvType, spv::DecorationArrayStride, stride);
4713 void TGlslangToSpvTraverser::applySpirvDecorate(const glslang::TType& type, spv::Id id, std::optional<int> member)
4725 builder.addMemberDecoration(id, *member, static_cast<spv::Decoration>(decorate.first), literals);
4727 builder.addDecoration(id, static_cast<spv::Decoration>(decorate.first), literals);
4730 builder.addMemberDecoration(id, *member, static_cast<spv::Decoration>(decorate.first));
4732 builder.addDecoration(id, static_cast<spv::Decoration>(decorate.first));
4742 std::vector<spv::Id> operandIds;
4750 builder.addDecorationId(id, static_cast<spv::Decoration>(decorateId.first), operandIds);
4763 builder.addMemberDecoration(id, *member, static_cast<spv::Decoration>(decorateString.first), strings);
4765 builder.addDecoration(id, static_cast<spv::Decoration>(decorateString.first), strings);
4808 spv::Id TGlslangToSpvTraverser::convertGlslangStructToSpvType(const glslang::TType& type,
4814 std::vector<spv::Id> spvMembers;
4876 spv::Id spvType = builder.makeStructType(spvMembers, type.getTypeName().c_str(), false);
4895 spv::Id spvType,
4896 const std::vector<spv::Id>& spvMembers)
4939 std::vector<spv::Decoration> memory;
4950 builder.addMemberDecoration(spvType, member, spv::DecorationLocation, memberQualifier.layoutLocation);
4954 builder.addMemberDecoration(spvType, member, spv::DecorationComponent,
4957 builder.addMemberDecoration(spvType, member, spv::DecorationOffset,
4964 builder.addMemberDecoration(spvType, member, spv::DecorationOffset, offset);
4969 builder.addMemberDecoration(spvType, member, spv::DecorationMatrixStride,
4973 spv::BuiltIn builtIn = TranslateBuiltInDecoration(glslangMember.getQualifier().builtIn, true);
4974 if (builtIn != spv::BuiltInMax)
4975 builder.addMemberDecoration(spvType, member, spv::DecorationBuiltIn, (int)builtIn);
4982 builder.addMemberDecoration(spvType, member, (spv::Decoration)spv::DecorationHlslSemanticGOOGLE,
4986 if (builtIn == spv::BuiltInLayer) {
4989 builder.addMemberDecoration(spvType, member, (spv::Decoration)spv::DecorationViewportRelativeNV);
4990 builder.addCapability(spv::CapabilityShaderViewportMaskNV);
4991 builder.addExtension(spv::E_SPV_NV_viewport_array2);
4995 (spv::Decoration)spv::DecorationSecondaryViewportRelativeNV,
4997 builder.addCapability(spv::CapabilityShaderStereoViewNV);
4998 builder.addExtension(spv::E_SPV_NV_stereo_view_rendering);
5002 builder.addMemberDecoration(spvType, member, (spv::Decoration)spv::DecorationPassthroughNV);
5003 builder.addCapability(spv::CapabilityGeometryShaderPassthroughNV);
5004 builder.addExtension(spv::E_SPV_NV_geometry_shader_passthrough);
5019 const auto hasRuntimeArray = !spvMembers.empty() && builder.getOpCode(spvMembers.back()) == spv::OpTypeRuntimeArray;
5026 builder.addDecoration(spvType, spv::DecorationHitObjectShaderRecordBufferNV);
5033 spv::Id TGlslangToSpvTraverser::makeArraySizeId(const glslang::TArraySizes& arraySizes, int dim, bool allowZero)
5059 spv::Id TGlslangToSpvTraverser::accessChainLoad(const glslang::TType& type)
5061 spv::Id nominalTypeId = builder.accessChainGetInferredType();
5063 spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags;
5066 spv::MemoryAccessMask accessMask = spv::MemoryAccessMask(TranslateMemoryAccess(coherentFlags) & ~spv::MemoryAccessMakePointerAvailableKHRMask);
5072 glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
5073 accessMask = spv::MemoryAccessMask(accessMask | spv::MemoryAccessVolatileMask);
5079 spv::Id loadedId = builder.accessChainLoad(TranslatePrecisionDecoration(type),
5099 void TGlslangToSpvTraverser::accessChainStore(const glslang::TType& type, spv::Id rvalue)
5103 spv::Id nominalTypeId = builder.accessChainGetInferredType();
5107 spv::Id boolType = builder.makeBoolType();
5110 spv::Id one = builder.makeUintConstant(1);
5111 spv::Id zero = builder.makeUintConstant(0);
5112 rvalue = builder.createTriOp(spv::OpSelect, nominalTypeId, rvalue, one, zero);
5114 rvalue = builder.createBinOp(spv::OpINotEqual, boolType, rvalue, builder.makeUintConstant(0));
5118 spv::Id bvecType = builder.makeVectorType(builder.makeBoolType(), vecSize);
5121 spv::Id one = makeSmearedConstant(builder.makeUintConstant(1), vecSize);
5122 spv::Id zero = makeSmearedConstant(builder.makeUintConstant(0), vecSize);
5123 rvalue = builder.createTriOp(spv::OpSelect, nominalTypeId, rvalue, one, zero);
5125 rvalue = builder.createBinOp(spv::OpINotEqual, bvecType, rvalue,
5130 spv::Builder::AccessChain::CoherentFlags coherentFlags = builder.getAccessChain().coherentFlags;
5137 spv::MemoryAccessMask(TranslateMemoryAccess(coherentFlags) &
5138 ~spv::MemoryAccessMakePointerVisibleKHRMask),
5153 void TGlslangToSpvTraverser::multiTypeStore(const glslang::TType& type, spv::Id rValue)
5162 spv::Id rType = builder.getTypeId(rValue);
5163 spv::Id lValue = builder.accessChainGetLValue();
5164 spv::Id lType = builder.getContainedTypeId(builder.getTypeId(lValue));
5175 if (glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_4) {
5179 bool rBool = builder.containsType(builder.getTypeId(rValue), spv::OpTypeBool, 0);
5180 bool lBool = builder.containsType(lType, spv::OpTypeBool, 0);
5182 spv::Id logicalCopy = builder.createUnaryOp(spv::OpCopyLogical, lType, rValue);
5191 spv::Id elementRType = builder.getContainedTypeId(rType);
5194 spv::Id elementRValue = builder.createCompositeExtract(rValue, elementRType, index);
5214 spv::Id memberRType = builder.getContainedTypeId(rType, m);
5215 spv::Id memberRValue = builder.createCompositeExtract(rValue, memberRType, m);
5416 const auto getParamDecorations = [&](std::vector<spv::Decoration>& decorations, const glslang::TType& type,
5418 spv::Decoration paramPrecision = TranslatePrecisionDecoration(type);
5419 if (paramPrecision != spv::NoPrecision)
5428 decorations.push_back(type.getQualifier().isRestrict() ? spv::DecorationRestrict :
5429 spv::DecorationAliased);
5431 decorations.push_back(type.getQualifier().isRestrict() ? spv::DecorationRestrictPointerEXT :
5432 spv::DecorationAliasedPointerEXT);
5445 std::vector<spv::Id>(), // main function has no param
5464 std::vector<spv::Id> paramTypes;
5466 std::vector<std::vector<spv::Decoration>> paramDecorations; // list of decorations per parameter
5479 spv::Id typeId = convertGlslangToSpvType(paramType);
5483 typeId = builder.makePointer(spv::StorageClassFunction, typeId);
5494 spv::Block* functionBlock;
5495 spv::Function* function = builder.makeFunctionEntry(
5515 builder.addCapability(spv::CapabilityInt8);
5517 builder.addCapability(spv::CapabilityInt16);
5519 builder.addCapability(spv::CapabilityFloat16);
5591 spv::Block* functionBlock = currentFunction->getEntryBlock();
5596 void TGlslangToSpvTraverser::translateArguments(const glslang::TIntermAggregate& node, std::vector<spv::Id>& arguments,
5597 spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags)
5719 spv::Id lvalue_id = builder.accessChainGetLValue();
5729 void TGlslangToSpvTraverser::translateArguments(glslang::TIntermUnary& node, std::vector<spv::Id>& arguments)
5736 spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermOperator* node)
5739 return spv::NoResult;
5754 if (builder.getSpvVersion() >= spv::Spv_1_4) {
5756 return spv::ImageOperandsZeroExtendMask;
5758 return spv::ImageOperandsSignExtendMask;
5760 return spv::ImageOperandsMaskNone;
5763 spv::Builder::AccessChain::CoherentFlags lvalueCoherentFlags;
5765 std::vector<spv::Id> arguments;
5770 spv::Decoration precision = TranslatePrecisionDecoration(node->getType());
5772 spv::Builder::TextureParameters params = { };
5782 params.sampler = builder.createUnaryOp(spv::OpImage, builder.getImageType(params.sampler), params.sampler);
5784 builder.addDecoration(params.sampler, spv::DecorationNonUniformEXT);
5794 return builder.createTextureQueryCall(spv::OpImageQuerySizeLod, params, isUnsignedResult);
5796 return builder.createTextureQueryCall(spv::OpImageQuerySize, params, isUnsignedResult);
5799 return builder.createTextureQueryCall(spv::OpImageQuerySamples, params, isUnsignedResult);
5802 return builder.createTextureQueryCall(spv::OpImageQueryLod, params, isUnsignedResult);
5804 return builder.createTextureQueryCall(spv::OpImageQueryLevels, params, isUnsignedResult);
5806 return builder.createUnaryOp(spv::OpImageSparseTexelsResident, builder.makeBoolType(), arguments[0]);
5832 std::vector<spv::IdImmediate> operands;
5834 spv::IdImmediate image = { true, *(opIt++) };
5842 spv::Id zero = builder.makeIntConstant(0);
5843 std::vector<spv::Id> comps;
5846 spv::IdImmediate coord = { true,
5849 spv::IdImmediate imageOperands = { false, spv::ImageOperandsMaskNone };
5852 imageOperands.word = imageOperands.word | spv::ImageOperandsSampleMask;
5854 if (imageOperands.word != spv::ImageOperandsMaskNone) {
5857 spv::IdImmediate imageOperand = { true, *(opIt++) };
5861 spv::Id result = builder.createOp(spv::OpImageRead, resultType(), operands);
5868 spv::IdImmediate sample = { true, *opIt };
5871 spv::Id result = builder.createOp(spv::OpColorAttachmentReadEXT, resultType(), operands);
5872 builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
5877 spv::IdImmediate coord = { true, *(opIt++) };
5880 spv::ImageOperandsMask mask = spv::ImageOperandsMaskNone;
5882 mask = mask | spv::ImageOperandsSampleMask;
5885 builder.addExtension(spv::E_SPV_AMD_shader_image_load_store_lod);
5886 builder.addCapability(spv::CapabilityImageReadWriteLodAMD);
5887 mask = mask | spv::ImageOperandsLodMask;
5890 mask = (spv::ImageOperandsMask)(mask & ~spv::ImageOperandsMakeTexelAvailableKHRMask);
5892 if (mask != spv::ImageOperandsMaskNone) {
5893 spv::IdImmediate imageOperands = { false, (unsigned int)mask };
5896 if (mask & spv::ImageOperandsSampleMask) {
5897 spv::IdImmediate imageOperand = { true, *opIt++ };
5900 if (mask & spv::ImageOperandsLodMask) {
5901 spv::IdImmediate imageOperand = { true, *opIt++ };
5904 if (mask & spv::ImageOperandsMakeTexelVisibleKHRMask) {
5905 spv::IdImmediate imageOperand = { true,
5910 if (builder.getImageTypeFormat(builder.getImageType(operands.front().word)) == spv::ImageFormatUnknown)
5911 builder.addCapability(spv::CapabilityStorageImageReadWithoutFormat);
5913 std::vector<spv::Id> result(1, builder.createOp(spv::OpImageRead, resultType(), operands));
5925 spv::IdImmediate texel = { true, *(opIt + 1) };
5928 spv::IdImmediate texel = { true, *opIt };
5932 spv::ImageOperandsMask mask = spv::ImageOperandsMaskNone;
5934 mask = mask | spv::ImageOperandsSampleMask;
5937 builder.addExtension(spv::E_SPV_AMD_shader_image_load_store_lod);
5938 builder.addCapability(spv::CapabilityImageReadWriteLodAMD);
5939 mask = mask | spv::ImageOperandsLodMask;
5942 mask = (spv::ImageOperandsMask)(mask & ~spv::ImageOperandsMakeTexelVisibleKHRMask);
5944 if (mask != spv::ImageOperandsMaskNone) {
5945 spv::IdImmediate imageOperands = { false, (unsigned int)mask };
5948 if (mask & spv::ImageOperandsSampleMask) {
5949 spv::IdImmediate imageOperand = { true, *opIt++ };
5952 if (mask & spv::ImageOperandsLodMask) {
5953 spv::IdImmediate imageOperand = { true, *opIt++ };
5956 if (mask & spv::ImageOperandsMakeTexelAvailableKHRMask) {
5957 spv::IdImmediate imageOperand = { true,
5962 builder.createNoResultOp(spv::OpImageWrite, operands);
5963 if (builder.getImageTypeFormat(builder.getImageType(operands.front().word)) == spv::ImageFormatUnknown)
5964 builder.addCapability(spv::CapabilityStorageImageWriteWithoutFormat);
5965 return spv::NoResult;
5968 builder.addCapability(spv::CapabilitySparseResidency);
5969 if (builder.getImageTypeFormat(builder.getImageType(operands.front().word)) == spv::ImageFormatUnknown)
5970 builder.addCapability(spv::CapabilityStorageImageReadWithoutFormat);
5972 spv::ImageOperandsMask mask = spv::ImageOperandsMaskNone;
5974 mask = mask | spv::ImageOperandsSampleMask;
5977 builder.addExtension(spv::E_SPV_AMD_shader_image_load_store_lod);
5978 builder.addCapability(spv::CapabilityImageReadWriteLodAMD);
5980 mask = mask | spv::ImageOperandsLodMask;
5983 mask = (spv::ImageOperandsMask)(mask & ~spv::ImageOperandsMakeTexelAvailableKHRMask);
5985 if (mask != spv::ImageOperandsMaskNone) {
5986 spv::IdImmediate imageOperands = { false, (unsigned int)mask };
5989 if (mask & spv::ImageOperandsSampleMask) {
5990 spv::IdImmediate imageOperand = { true, *opIt++ };
5993 if (mask & spv::ImageOperandsLodMask) {
5994 spv::IdImmediate imageOperand = { true, *opIt++ };
5997 if (mask & spv::ImageOperandsMakeTexelVisibleKHRMask) {
5998 spv::IdImmediate imageOperand = { true, builder.makeUintConstant(TranslateMemoryScope(
6004 spv::Id texelOut = *opIt;
6005 spv::Id typeId0 = resultType();
6006 spv::Id typeId1 = builder.getDerefTypeId(texelOut);
6007 spv::Id resultTypeId = builder.makeStructResultType(typeId0, typeId1);
6009 spv::Id resultId = builder.createOp(spv::OpImageSparseRead, resultTypeId, operands);
6020 spv::IdImmediate sample = { true, sampler.isMultiSample() ? *(opIt++) : builder.makeUintConstant(0) };
6023 spv::Id resultTypeId;
6028 resultTypeId = builder.makePointer(spv::StorageClassImage, builder.getTypeId(*opIt));
6031 resultTypeId = builder.makePointer(spv::StorageClassImage, resultType());
6033 spv::Id pointer = builder.createOp(spv::OpImageTexelPointer, resultTypeId, operands);
6035 builder.addDecoration(pointer, spv::DecorationNonUniformEXT);
6038 std::vector<spv::Id> operands;
6053 std::vector<spv::Id> operands;
6060 spv::Id zero = builder.makeIntConstant(0);
6061 std::vector<spv::Id> comps;
6071 spv::Op fragMaskOp = spv::OpNop;
6073 fragMaskOp = spv::OpFragmentMaskFetchAMD;
6075 fragMaskOp = spv::OpFragmentFetchAMD;
6077 builder.addExtension(spv::E_SPV_AMD_shader_fragment_mask);
6078 builder.addCapability(spv::CapabilityFragmentMaskAMD);
6118 builder.addExtension(spv::E_SPV_AMD_texture_gather_bias_lod);
6119 builder.addCapability(spv::CapabilityImageGatherBiasLodAMD);
6137 std::vector<spv::Id> indexes;
6200 spv::Id resultStruct = spv::NoResult;
6217 builder.addExtension(spv::E_SPV_NV_shader_image_footprint);
6218 builder.addCapability(spv::CapabilityImageFootprintNV);
6237 spv::Id resultStructType = builder.getContainedTypeId(builder.getTypeId(resultStruct));
6247 std::vector<spv::Id> members;
6252 spv::Id resType = builder.makeStructType(members, "ResType");
6255 spv::Id res = builder.createTextureCall(precision, resType, sparse, cracked.fetch, cracked.proj,
6264 spv::Builder::AccessChain::CoherentFlags flags;
6290 spv::Id projComp = builder.createCompositeExtract(params.coords,
6307 std::vector<spv::Id> result( 1,
6318 spv::Id TGlslangToSpvTraverser::handleUserFunctionCall(const glslang::TIntermAggregate* node)
6321 spv::Function* function = functionMap[node->getName().c_str()];
6337 std::vector<spv::Builder::AccessChain> lValues;
6338 std::vector<spv::Id> rValues;
6362 std::vector<spv::Id> spvArgs;
6364 spv::Id arg;
6371 arg = builder.createVariable(function->getParamPrecision(a), spv::StorageClassFunction,
6376 spv::Id copy = accessChainLoad(*argTypes[a]);
6387 spv::Id argCopy = builder.createVariable(function->getParamPrecision(a), spv::StorageClassFunction, function->getParamType(a), "arg");
6400 spv::Id result = builder.createFunctionCall(function, spvArgs);
6411 spv::Id copy = builder.createLoad(spvArgs[a], spv::NoPrecision);
6424 spv::Id TGlslangToSpvTraverser::createBinaryOperation(glslang::TOperator op, OpDecorations& decorations,
6425 spv::Id typeId, spv::Id left, spv::Id right,
6432 spv::Op binOp = spv::OpNop;
6440 binOp = spv::OpFAdd;
6442 binOp = spv::OpIAdd;
6447 binOp = spv::OpFSub;
6449 binOp = spv::OpISub;
6454 binOp = spv::OpFMul;
6456 binOp = spv::OpIMul;
6465 binOp = spv::OpVectorTimesScalar;
6467 binOp = spv::OpFMul;
6469 binOp = spv::OpIMul;
6473 binOp = spv::OpVectorTimesMatrix;
6476 binOp = spv::OpMatrixTimesVector;
6480 binOp = spv::OpMatrixTimesScalar;
6484 binOp = spv::OpMatrixTimesMatrix;
6487 binOp = spv::OpOuterProduct;
6494 binOp = spv::OpFDiv;
6496 binOp = spv::OpUDiv;
6498 binOp = spv::OpSDiv;
6503 binOp = spv::OpFMod;
6505 binOp = spv::OpUMod;
6507 binOp = spv::OpSMod;
6512 binOp = spv::OpShiftRightLogical;
6514 binOp = spv::OpShiftRightArithmetic;
6518 binOp = spv::OpShiftLeftLogical;
6522 binOp = spv::OpBitwiseAnd;
6526 binOp = spv::OpLogicalAnd;
6530 binOp = spv::OpBitwiseOr;
6534 binOp = spv::OpLogicalOr;
6538 binOp = spv::OpBitwiseXor;
6542 binOp = spv::OpLogicalNotEqual;
6546 binOp = isUnsigned ? spv::OpAbsUSubINTEL : spv::OpAbsISubINTEL;
6550 binOp = isUnsigned ? spv::OpUAddSatINTEL : spv::OpIAddSatINTEL;
6554 binOp = isUnsigned ? spv::OpUSubSatINTEL : spv::OpISubSatINTEL;
6558 binOp = isUnsigned ? spv::OpUAverageINTEL : spv::OpIAverageINTEL;
6562 binOp = isUnsigned ? spv::OpUAverageRoundedINTEL : spv::OpIAverageRoundedINTEL;
6566 binOp = isUnsigned ? spv::OpUMul32x16INTEL : spv::OpIMul32x16INTEL;
6584 if (binOp != spv::OpNop) {
6594 spv::Id result = builder.createBinOp(binOp, typeId, left, right);
6607 spv::Id result = builder.createCompositeCompare(decorations.precision, left, right, op == glslang::EOpEqual);
6615 binOp = spv::OpFOrdLessThan;
6617 binOp = spv::OpULessThan;
6619 binOp = spv::OpSLessThan;
6623 binOp = spv::OpFOrdGreaterThan;
6625 binOp = spv::OpUGreaterThan;
6627 binOp = spv::OpSGreaterThan;
6631 binOp = spv::OpFOrdLessThanEqual;
6633 binOp = spv::OpULessThanEqual;
6635 binOp = spv::OpSLessThanEqual;
6639 binOp = spv::OpFOrdGreaterThanEqual;
6641 binOp = spv::OpUGreaterThanEqual;
6643 binOp = spv::OpSGreaterThanEqual;
6648 binOp = spv::OpFOrdEqual;
6650 binOp = spv::OpLogicalEqual;
6652 binOp = spv::OpIEqual;
6657 binOp = spv::OpFUnordNotEqual;
6659 binOp = spv::OpLogicalNotEqual;
6661 binOp = spv::OpINotEqual;
6667 if (binOp != spv::OpNop) {
6668 spv::Id result = builder.createBinOp(binOp, typeId, left, right);
6691 spv::Id TGlslangToSpvTraverser::createBinaryMatrixOperation(spv::Op op, OpDecorations& decorations, spv::Id typeId,
6692 spv::Id left, spv::Id right)
6698 case spv::OpFDiv:
6701 spv::Id resultType = builder.getTypeId(right);
6702 right = builder.createBinOp(spv::OpFDiv, resultType, builder.makeFpConstant(resultType, 1.0), right);
6703 op = spv::OpMatrixTimesScalar;
6707 case spv::OpMatrixTimesScalar:
6712 case spv::OpVectorTimesMatrix:
6716 case spv::OpMatrixTimesVector:
6720 case spv::OpMatrixTimesMatrix:
6733 spv::Id result = builder.createBinOp(op, typeId, left, right);
6747 case spv::OpFAdd:
6748 case spv::OpFSub:
6749 case spv::OpFDiv:
6750 case spv::OpFMod:
6751 case spv::OpFMul:
6758 spv::Id scalarType = builder.getScalarTypeId(typeId);
6759 spv::Id vecType = builder.makeVectorType(scalarType, numRows);
6760 std::vector<spv::Id> results;
6761 spv::Id smearVec = spv::NoResult;
6771 spv::Id leftVec = leftMat ? builder.createCompositeExtract( left, vecType, indexes) : smearVec;
6772 spv::Id rightVec = rightMat ? builder.createCompositeExtract(right, vecType, indexes) : smearVec;
6773 spv::Id result = builder.createBinOp(op, vecType, leftVec, rightVec);
6780 spv::Id result = builder.setPrecision(builder.createCompositeConstruct(typeId, results), decorations.precision);
6786 return spv::NoResult;
6790 spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, OpDecorations& decorations, spv::Id typeId,
6791 spv::Id operand, glslang::TBasicType typeProxy, const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags)
6793 spv::Op unaryOp = spv::OpNop;
6802 unaryOp = spv::OpFNegate;
6806 unaryOp = spv::OpSNegate;
6811 unaryOp = spv::OpLogicalNot;
6814 unaryOp = spv::OpNot;
6818 libCall = spv::GLSLstd450Determinant;
6821 libCall = spv::GLSLstd450MatrixInverse;
6824 unaryOp = spv::OpTranspose;
6828 libCall = spv::GLSLstd450Radians;
6831 libCall = spv::GLSLstd450Degrees;
6834 libCall = spv::GLSLstd450Sin;
6837 libCall = spv::GLSLstd450Cos;
6840 libCall = spv::GLSLstd450Tan;
6843 libCall = spv::GLSLstd450Acos;
6846 libCall = spv::GLSLstd450Asin;
6849 libCall = spv::GLSLstd450Atan;
6853 libCall = spv::GLSLstd450Acosh;
6856 libCall = spv::GLSLstd450Asinh;
6859 libCall = spv::GLSLstd450Atanh;
6862 libCall = spv::GLSLstd450Tanh;
6865 libCall = spv::GLSLstd450Cosh;
6868 libCall = spv::GLSLstd450Sinh;
6872 libCall = spv::GLSLstd450Length;
6875 libCall = spv::GLSLstd450Normalize;
6879 libCall = spv::GLSLstd450Exp;
6882 libCall = spv::GLSLstd450Log;
6885 libCall = spv::GLSLstd450Exp2;
6888 libCall = spv::GLSLstd450Log2;
6891 libCall = spv::GLSLstd450Sqrt;
6894 libCall = spv::GLSLstd450InverseSqrt;
6898 libCall = spv::GLSLstd450Floor;
6901 libCall = spv::GLSLstd450Trunc;
6904 libCall = spv::GLSLstd450Round;
6907 libCall = spv::GLSLstd450RoundEven;
6910 libCall = spv::GLSLstd450Ceil;
6913 libCall = spv::GLSLstd450Fract;
6917 unaryOp = spv::OpIsNan;
6920 unaryOp = spv::OpIsInf;
6923 unaryOp = spv::OpIsFinite;
6938 unaryOp = spv::OpBitcast;
6942 libCall = spv::GLSLstd450PackSnorm2x16;
6945 libCall = spv::GLSLstd450UnpackSnorm2x16;
6948 libCall = spv::GLSLstd450PackUnorm2x16;
6951 libCall = spv::GLSLstd450UnpackUnorm2x16;
6954 libCall = spv::GLSLstd450PackHalf2x16;
6957 libCall = spv::GLSLstd450UnpackHalf2x16;
6960 libCall = spv::GLSLstd450PackSnorm4x8;
6963 libCall = spv::GLSLstd450UnpackSnorm4x8;
6966 libCall = spv::GLSLstd450PackUnorm4x8;
6969 libCall = spv::GLSLstd450UnpackUnorm4x8;
6972 libCall = spv::GLSLstd450PackDouble2x32;
6975 libCall = spv::GLSLstd450UnpackDouble2x32;
6998 unaryOp = spv::OpBitcast;
7002 unaryOp = spv::OpDPdx;
7005 unaryOp = spv::OpDPdy;
7008 unaryOp = spv::OpFwidth;
7012 unaryOp = spv::OpAny;
7015 unaryOp = spv::OpAll;
7020 libCall = spv::GLSLstd450FAbs;
7022 libCall = spv::GLSLstd450SAbs;
7026 libCall = spv::GLSLstd450FSign;
7028 libCall = spv::GLSLstd450SSign;
7032 unaryOp = spv::OpDPdxFine;
7035 unaryOp = spv::OpDPdyFine;
7038 unaryOp = spv::OpFwidthFine;
7041 unaryOp = spv::OpDPdxCoarse;
7044 unaryOp = spv::OpDPdyCoarse;
7047 unaryOp = spv::OpFwidthCoarse;
7050 unaryOp = spv::OpRayQueryProceedKHR;
7053 unaryOp = spv::OpRayQueryGetRayTMinKHR;
7056 unaryOp = spv::OpRayQueryGetRayFlagsKHR;
7059 unaryOp = spv::OpRayQueryGetWorldRayOriginKHR;
7062 unaryOp = spv::OpRayQueryGetWorldRayDirectionKHR;
7065 unaryOp = spv::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR;
7069 builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float);
7070 libCall = spv::GLSLstd450InterpolateAtCentroid;
7077 std::vector<spv::Id> operands;
7083 unaryOp = spv::OpBitReverse;
7086 unaryOp = spv::OpBitCount;
7089 libCall = spv::GLSLstd450FindILsb;
7093 libCall = spv::GLSLstd450FindUMsb;
7095 libCall = spv::GLSLstd450FindSMsb;
7099 builder.addCapability(spv::CapabilityIntegerFunctions2INTEL);
7101 unaryOp = spv::OpUCountLeadingZerosINTEL;
7105 builder.addCapability(spv::CapabilityIntegerFunctions2INTEL);
7107 unaryOp = spv::OpUCountTrailingZerosINTEL;
7134 std::vector<spv::Id> operands;
7173 std::vector<spv::Id> operands;
7178 extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_ballot);
7179 libCall = spv::MbcntAMD;
7183 extBuiltins = getExtBuiltins(spv::E_SPV_AMD_gcn_shader);
7184 libCall = spv::CubeFaceIndexAMD;
7188 extBuiltins = getExtBuiltins(spv::E_SPV_AMD_gcn_shader);
7189 libCall = spv::CubeFaceCoordAMD;
7192 unaryOp = spv::OpGroupNonUniformPartitionNV;
7195 unaryOp = spv::OpBitcast;
7200 unaryOp = spv::OpConvertUToAccelerationStructureKHR;
7204 unaryOp = spv::OpHitObjectIsEmptyNV;
7208 unaryOp = spv::OpHitObjectIsMissNV;
7212 unaryOp = spv::OpHitObjectIsHitNV;
7216 unaryOp = spv::OpHitObjectGetObjectRayOriginNV;
7220 unaryOp = spv::OpHitObjectGetObjectRayDirectionNV;
7224 unaryOp = spv::OpHitObjectGetWorldRayOriginNV;
7228 unaryOp = spv::OpHitObjectGetWorldRayDirectionNV;
7232 unaryOp = spv::OpHitObjectGetObjectToWorldNV;
7236 unaryOp = spv::OpHitObjectGetWorldToObjectNV;
7240 unaryOp = spv::OpHitObjectGetRayTMinNV;
7244 unaryOp = spv::OpHitObjectGetRayTMaxNV;
7248 unaryOp = spv::OpHitObjectGetPrimitiveIndexNV;
7252 unaryOp = spv::OpHitObjectGetInstanceIdNV;
7256 unaryOp = spv::OpHitObjectGetInstanceCustomIndexNV;
7260 unaryOp = spv::OpHitObjectGetGeometryIndexNV;
7264 unaryOp = spv::OpHitObjectGetHitKindNV;
7268 unaryOp = spv::OpHitObjectGetCurrentTimeNV;
7272 unaryOp = spv::OpHitObjectGetShaderBindingTableRecordIndexNV;
7276 unaryOp = spv::OpHitObjectGetShaderRecordBufferHandleNV;
7280 unaryOp = spv::OpFetchMicroTriangleVertexPositionNV;
7284 unaryOp = spv::OpFetchMicroTriangleVertexBarycentricNV;
7288 unaryOp = spv::OpCopyObject;
7292 builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
7293 builder.addCapability(spv::CapabilityTileImageDepthReadAccessEXT);
7294 unaryOp = spv::OpDepthAttachmentReadEXT;
7295 decorations.precision = spv::NoPrecision;
7298 builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
7299 builder.addCapability(spv::CapabilityTileImageStencilReadAccessEXT);
7300 unaryOp = spv::OpStencilAttachmentReadEXT;
7301 decorations.precision = spv::DecorationRelaxedPrecision;
7308 spv::Id id;
7310 std::vector<spv::Id> args;
7323 spv::Id TGlslangToSpvTraverser::createUnaryMatrixOperation(spv::Op op, OpDecorations& decorations, spv::Id typeId,
7324 spv::Id operand, glslang::TBasicType /* typeProxy */)
7336 spv::Id srcVecType = builder.makeVectorType(builder.getScalarTypeId(builder.getTypeId(operand)), numRows);
7337 spv::Id destVecType = builder.makeVectorType(builder.getScalarTypeId(typeId), numRows);
7338 std::vector<spv::Id> results;
7344 spv::Id srcVec = builder.createCompositeExtract(operand, srcVecType, indexes);
7345 spv::Id destVec = builder.createUnaryOp(op, destVecType, srcVec);
7352 spv::Id result = builder.setPrecision(builder.createCompositeConstruct(typeId, results), decorations.precision);
7362 spv::Id TGlslangToSpvTraverser::createIntWidthConversion(glslang::TOperator op, spv::Id operand, int vectorSize, spv::Id destType)
7407 spv::Id type = spv::NoType;
7408 spv::Op convOp = spv::OpNop;
7422 convOp = spv::OpSConvert;
7426 convOp = spv::OpUConvert;
7433 else if (builder.getOpCode(destType) == spv::OpTypeCooperativeMatrixKHR ||
7434 builder.getOpCode(destType) == spv::OpTypeCooperativeMatrixNV) {
7442 spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, OpDecorations& decorations, spv::Id destType,
7443 spv::Id operand, glslang::TBasicType typeProxy)
7445 spv::Op convOp = spv::OpNop;
7446 spv::Id zero = 0;
7447 spv::Id one = 0;
7456 return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
7460 return builder.createBinOp(spv::OpFUnordNotEqual, destType, operand, zero);
7462 convOp = spv::OpSelect;
7477 convOp = spv::OpSelect;
7490 convOp = spv::OpSelect;
7505 convOp = spv::OpConvertSToF;
7520 convOp = spv::OpConvertUToF;
7535 convOp = spv::OpConvertFToS;
7560 return builder.createBinOp(spv::OpIAdd, destType, operand, zero);
7563 convOp = spv::OpBitcast;
7578 convOp = spv::OpConvertFToU;
7585 return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
7590 return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
7595 return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
7599 return builder.createBinOp(spv::OpFUnordNotEqual, destType, operand, zero);
7603 return builder.createBinOp(spv::OpFUnordNotEqual, destType, operand, zero);
7605 convOp = spv::OpSelect;
7610 convOp = spv::OpSelect;
7617 convOp = spv::OpSelect;
7622 convOp = spv::OpSelect;
7627 convOp = spv::OpSelect;
7632 convOp = spv::OpSelect;
7640 convOp = spv::OpFConvert;
7657 convOp = spv::OpSConvert;
7672 convOp = spv::OpUConvert;
7744 return builder.createBinOp(spv::OpIAdd, destType, operand, zero);
7747 convOp = spv::OpBitcast;
7750 convOp = spv::OpConvertUToPtr;
7753 convOp = spv::OpConvertPtrToU;
7757 convOp = spv::OpBitcast;
7764 spv::Id result = 0;
7765 if (convOp == spv::OpNop)
7768 if (convOp == spv::OpSelect) {
7780 spv::Id TGlslangToSpvTraverser::makeSmearedConstant(spv::Id constant, int vectorSize)
7785 spv::Id vectorTypeId = builder.makeVectorType(builder.getTypeId(constant), vectorSize);
7786 std::vector<spv::Id> components;
7793 spv::Id TGlslangToSpvTraverser::createAtomicOperation(glslang::TOperator op, spv::Decoration /*precision*/,
7794 spv::Id typeId, std::vector<spv::Id>& operands, glslang::TBasicType typeProxy,
7795 const spv::Builder::AccessChain::CoherentFlags &lvalueCoherentFlags)
7797 spv::Op opCode = spv::OpNop;
7803 opCode = spv::OpAtomicIAdd;
7805 opCode = spv::OpAtomicFAddEXT;
7806 builder.addExtension(spv::E_SPV_EXT_shader_atomic_float_add);
7808 builder.addExtension(spv::E_SPV_EXT_shader_atomic_float16_add);
7809 builder.addCapability(spv::CapabilityAtomicFloat16AddEXT);
7811 builder.addCapability(spv::CapabilityAtomicFloat32AddEXT);
7813 builder.addCapability(spv::CapabilityAtomicFloat64AddEXT);
7819 opCode = spv::OpAtomicISub;
7825 opCode = spv::OpAtomicFMinEXT;
7826 builder.addExtension(spv::E_SPV_EXT_shader_atomic_float_min_max);
7828 builder.addCapability(spv::CapabilityAtomicFloat16MinMaxEXT);
7830 builder.addCapability(spv::CapabilityAtomicFloat32MinMaxEXT);
7832 builder.addCapability(spv::CapabilityAtomicFloat64MinMaxEXT);
7834 opCode = spv::OpAtomicUMin;
7836 opCode = spv::OpAtomicSMin;
7843 opCode = spv::OpAtomicFMaxEXT;
7844 builder.addExtension(spv::E_SPV_EXT_shader_atomic_float_min_max);
7846 builder.addCapability(spv::CapabilityAtomicFloat16MinMaxEXT);
7848 builder.addCapability(spv::CapabilityAtomicFloat32MinMaxEXT);
7850 builder.addCapability(spv::CapabilityAtomicFloat64MinMaxEXT);
7852 opCode = spv::OpAtomicUMax;
7854 opCode = spv::OpAtomicSMax;
7860 opCode = spv::OpAtomicAnd;
7865 opCode = spv::OpAtomicOr;
7870 opCode = spv::OpAtomicXor;
7875 opCode = spv::OpAtomicExchange;
7880 opCode = spv::OpAtomicCompareExchange;
7883 opCode = spv::OpAtomicIIncrement;
7886 opCode = spv::OpAtomicIDecrement;
7891 opCode = spv::OpAtomicLoad;
7895 opCode = spv::OpAtomicStore;
7903 builder.addCapability(spv::CapabilityInt64Atomics);
7911 spv::Id pointerId = 0, compareId = 0, valueId = 0;
7913 spv::Id scopeId;
7915 scopeId = builder.makeUintConstant(spv::ScopeQueueFamilyKHR);
7917 scopeId = builder.makeUintConstant(spv::ScopeDevice);
7920 spv::Id semanticsId = builder.makeUintConstant(lvalueCoherentFlags.isVolatile() &&
7922 spv::MemorySemanticsVolatileMask :
7923 spv::MemorySemanticsMaskNone);
7924 spv::Id semanticsId2 = semanticsId;
7927 if (opCode == spv::OpAtomicIIncrement || opCode == spv::OpAtomicIDecrement) {
7929 } else if (opCode == spv::OpAtomicCompareExchange) {
7939 } else if (opCode == spv::OpAtomicLoad) {
7957 if (semanticsImmediate & (spv::MemorySemanticsMakeAvailableKHRMask |
7958 spv::MemorySemanticsMakeVisibleKHRMask |
7959 spv::MemorySemanticsOutputMemoryKHRMask |
7960 spv::MemorySemanticsVolatileMask)) {
7961 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
7964 if (builder.getConstantScalar(scopeId) == spv::ScopeQueueFamily) {
7965 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
7968 if (glslangIntermediate->usingVulkanMemoryModel() && builder.getConstantScalar(scopeId) == spv::ScopeDevice) {
7969 builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR);
7972 std::vector<spv::Id> spvAtomicOperands; // hold the spv operands
7976 if (opCode == spv::OpAtomicCompareExchange) {
7980 } else if (opCode != spv::OpAtomicLoad && opCode != spv::OpAtomicIIncrement && opCode != spv::OpAtomicIDecrement) {
7984 if (opCode == spv::OpAtomicStore) {
7988 spv::Id resultId = builder.createOp(opCode, typeId, spvAtomicOperands);
7993 resultId = builder.createBinOp(spv::OpISub, typeId, resultId, builder.makeIntConstant(1));
8000 spv::Id TGlslangToSpvTraverser::createInvocationsOperation(glslang::TOperator op, spv::Id typeId,
8001 std::vector<spv::Id>& operands, glslang::TBasicType typeProxy)
8006 spv::Op opCode = spv::OpNop;
8007 std::vector<spv::IdImmediate> spvGroupOperands;
8008 spv::GroupOperation groupOperation = spv::GroupOperationMax;
8012 builder.addExtension(spv::E_SPV_KHR_shader_ballot);
8013 builder.addCapability(spv::CapabilitySubgroupBallotKHR);
8017 builder.addExtension(spv::E_SPV_KHR_subgroup_vote);
8018 builder.addCapability(spv::CapabilitySubgroupVoteKHR);
8020 builder.addCapability(spv::CapabilityGroups);
8030 builder.addExtension(spv::E_SPV_AMD_shader_ballot);
8039 groupOperation = spv::GroupOperationReduce;
8047 groupOperation = spv::GroupOperationInclusiveScan;
8055 groupOperation = spv::GroupOperationExclusiveScan;
8060 spv::IdImmediate scope = { true, builder.makeUintConstant(spv::ScopeSubgroup) };
8062 if (groupOperation != spv::GroupOperationMax) {
8063 spv::IdImmediate groupOp = { false, (unsigned)groupOperation };
8069 spv::IdImmediate op = { true, *opIt };
8075 opCode = spv::OpSubgroupAnyKHR;
8078 opCode = spv::OpSubgroupAllKHR;
8081 opCode = spv::OpSubgroupAllEqualKHR;
8084 opCode = spv::OpSubgroupReadInvocationKHR;
8089 opCode = spv::OpSubgroupFirstInvocationKHR;
8101 spv::Id uintType = builder.makeUintType(32);
8102 spv::Id uvec4Type = builder.makeVectorType(uintType, 4);
8103 spv::Id result = builder.createOp(spv::OpSubgroupBallotKHR, uvec4Type, spvGroupOperands);
8105 std::vector<spv::Id> components;
8109 spv::Id uvec2Type = builder.makeVectorType(uintType, 2);
8110 return builder.createUnaryOp(spv::OpBitcast, typeId,
8127 opCode = spv::OpGroupFMin;
8130 opCode = spv::OpGroupUMin;
8132 opCode = spv::OpGroupSMin;
8138 opCode = spv::OpGroupFMax;
8141 opCode = spv::OpGroupUMax;
8143 opCode = spv::OpGroupSMax;
8147 opCode = spv::OpGroupFAdd;
8149 opCode = spv::OpGroupIAdd;
8169 opCode = spv::OpGroupFMinNonUniformAMD;
8172 opCode = spv::OpGroupUMinNonUniformAMD;
8174 opCode = spv::OpGroupSMinNonUniformAMD;
8181 opCode = spv::OpGroupFMaxNonUniformAMD;
8184 opCode = spv::OpGroupUMaxNonUniformAMD;
8186 opCode = spv::OpGroupSMaxNonUniformAMD;
8191 opCode = spv::OpGroupFAddNonUniformAMD;
8193 opCode = spv::OpGroupIAddNonUniformAMD;
8202 return spv::NoResult;
8205 assert(opCode != spv::OpNop);
8210 spv::Id TGlslangToSpvTraverser::CreateInvocationsVectorOperation(spv::Op op, spv::GroupOperation groupOperation,
8211 spv::Id typeId, std::vector<spv::Id>& operands)
8213 assert(op == spv::OpGroupFMin || op == spv::OpGroupUMin || op == spv::OpGroupSMin ||
8214 op == spv::OpGroupFMax || op == spv::OpGroupUMax || op == spv::OpGroupSMax ||
8215 op == spv::OpGroupFAdd || op == spv::OpGroupIAdd || op == spv::OpGroupBroadcast ||
8216 op == spv::OpSubgroupReadInvocationKHR || op == spv::OpSubgroupFirstInvocationKHR ||
8217 op == spv::OpGroupFMinNonUniformAMD || op == spv::OpGroupUMinNonUniformAMD ||
8218 op == spv::OpGroupSMinNonUniformAMD ||
8219 op == spv::OpGroupFMaxNonUniformAMD || op == spv::OpGroupUMaxNonUniformAMD ||
8220 op == spv::OpGroupSMaxNonUniformAMD ||
8221 op == spv::OpGroupFAddNonUniformAMD || op == spv::OpGroupIAddNonUniformAMD);
8232 spv::Id scalarType = builder.getScalarTypeId(builder.getTypeId(operands[0]));
8233 std::vector<spv::Id> results;
8239 spv::IdImmediate scalar = { true, builder.createCompositeExtract(operands[0], scalarType, indexes) };
8240 std::vector<spv::IdImmediate> spvGroupOperands;
8241 if (op == spv::OpSubgroupReadInvocationKHR) {
8243 spv::IdImmediate operand = { true, operands[1] };
8245 } else if (op == spv::OpSubgroupFirstInvocationKHR) {
8247 } else if (op == spv::OpGroupBroadcast) {
8248 spv::IdImmediate scope = { true, builder.makeUintConstant(spv::ScopeSubgroup) };
8251 spv::IdImmediate operand = { true, operands[1] };
8254 spv::IdImmediate scope = { true, builder.makeUintConstant(spv::ScopeSubgroup) };
8256 spv::IdImmediate groupOp = { false, (unsigned)groupOperation };
8269 spv::Id TGlslangToSpvTraverser::createSubgroupOperation(glslang::TOperator op, spv::Id typeId,
8270 std::vector<spv::Id>& operands, glslang::TBasicType typeProxy)
8275 builder.addCapability(spv::CapabilityGroupNonUniform);
8280 builder.addCapability(spv::CapabilityGroupNonUniform);
8281 builder.addCapability(spv::CapabilityGroupNonUniformVote);
8293 builder.addCapability(spv::CapabilityGroupNonUniform);
8294 builder.addCapability(spv::CapabilityGroupNonUniformBallot);
8298 builder.addCapability(spv::CapabilityGroupNonUniform);
8299 builder.addCapability(spv::CapabilityGroupNonUniformShuffle);
8303 builder.addCapability(spv::CapabilityGroupNonUniform);
8304 builder.addCapability(spv::CapabilityGroupNonUniformShuffleRelative);
8327 builder.addCapability(spv::CapabilityGroupNonUniform);
8328 builder.addCapability(spv::CapabilityGroupNonUniformArithmetic);
8337 builder.addCapability(spv::CapabilityGroupNonUniform);
8338 builder.addCapability(spv::CapabilityGroupNonUniformClustered);
8344 builder.addCapability(spv::CapabilityGroupNonUniform);
8345 builder.addCapability(spv::CapabilityGroupNonUniformQuad);
8368 builder.addExtension(spv::E_SPV_NV_shader_subgroup_partitioned);
8369 builder.addCapability(spv::CapabilityGroupNonUniformPartitionedNV);
8379 spv::Op opCode = spv::OpNop;
8383 case glslang::EOpSubgroupElect: opCode = spv::OpGroupNonUniformElect; break;
8384 case glslang::EOpSubgroupAll: opCode = spv::OpGroupNonUniformAll; break;
8385 case glslang::EOpSubgroupAny: opCode = spv::OpGroupNonUniformAny; break;
8386 case glslang::EOpSubgroupAllEqual: opCode = spv::OpGroupNonUniformAllEqual; break;
8387 case glslang::EOpSubgroupBroadcast: opCode = spv::OpGroupNonUniformBroadcast; break;
8388 case glslang::EOpSubgroupBroadcastFirst: opCode = spv::OpGroupNonUniformBroadcastFirst; break;
8389 case glslang::EOpSubgroupBallot: opCode = spv::OpGroupNonUniformBallot; break;
8390 case glslang::EOpSubgroupInverseBallot: opCode = spv::OpGroupNonUniformInverseBallot; break;
8391 case glslang::EOpSubgroupBallotBitExtract: opCode = spv::OpGroupNonUniformBallotBitExtract; break;
8394 case glslang::EOpSubgroupBallotExclusiveBitCount: opCode = spv::OpGroupNonUniformBallotBitCount; break;
8395 case glslang::EOpSubgroupBallotFindLSB: opCode = spv::OpGroupNonUniformBallotFindLSB; break;
8396 case glslang::EOpSubgroupBallotFindMSB: opCode = spv::OpGroupNonUniformBallotFindMSB; break;
8397 case glslang::EOpSubgroupShuffle: opCode = spv::OpGroupNonUniformShuffle; break;
8398 case glslang::EOpSubgroupShuffleXor: opCode = spv::OpGroupNonUniformShuffleXor; break;
8399 case glslang::EOpSubgroupShuffleUp: opCode = spv::OpGroupNonUniformShuffleUp; break;
8400 case glslang::EOpSubgroupShuffleDown: opCode = spv::OpGroupNonUniformShuffleDown; break;
8409 opCode = spv::OpGroupNonUniformFAdd;
8411 opCode = spv::OpGroupNonUniformIAdd;
8422 opCode = spv::OpGroupNonUniformFMul;
8424 opCode = spv::OpGroupNonUniformIMul;
8435 opCode = spv::OpGroupNonUniformFMin;
8437 opCode = spv::OpGroupNonUniformUMin;
8439 opCode = spv::OpGroupNonUniformSMin;
8450 opCode = spv::OpGroupNonUniformFMax;
8452 opCode = spv::OpGroupNonUniformUMax;
8454 opCode = spv::OpGroupNonUniformSMax;
8465 opCode = spv::OpGroupNonUniformLogicalAnd;
8467 opCode = spv::OpGroupNonUniformBitwiseAnd;
8478 opCode = spv::OpGroupNonUniformLogicalOr;
8480 opCode = spv::OpGroupNonUniformBitwiseOr;
8491 opCode = spv::OpGroupNonUniformLogicalXor;
8493 opCode = spv::OpGroupNonUniformBitwiseXor;
8496 case glslang::EOpSubgroupQuadBroadcast: opCode = spv::OpGroupNonUniformQuadBroadcast; break;
8499 case glslang::EOpSubgroupQuadSwapDiagonal: opCode = spv::OpGroupNonUniformQuadSwap; break;
8504 spv::GroupOperation groupOperation = spv::GroupOperationMax;
8516 groupOperation = spv::GroupOperationReduce;
8526 groupOperation = spv::GroupOperationInclusiveScan;
8536 groupOperation = spv::GroupOperationExclusiveScan;
8545 groupOperation = spv::GroupOperationClusteredReduce;
8554 groupOperation = spv::GroupOperationPartitionedReduceNV;
8563 groupOperation = spv::GroupOperationPartitionedInclusiveScanNV;
8572 groupOperation = spv::GroupOperationPartitionedExclusiveScanNV;
8577 std::vector<spv::IdImmediate> spvGroupOperands;
8580 spv::IdImmediate executionScope = { true, builder.makeUintConstant(spv::ScopeSubgroup) };
8584 if (groupOperation != spv::GroupOperationMax) {
8585 spv::IdImmediate groupOperand = { false, (unsigned)groupOperation };
8591 spv::IdImmediate operand = { true, *opIt };
8596 spv::Id directionId = spv::NoResult;
8603 if (directionId != spv::NoResult) {
8604 spv::IdImmediate direction = { true, directionId };
8611 spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::Decoration precision,
8612 spv::Id typeId, std::vector<spv::Id>& operands, glslang::TBasicType typeProxy)
8617 spv::Op opCode = spv::OpNop;
8621 spv::Id typeId0 = 0;
8624 spv::Id typeId1 = 0;
8627 spv::Id frexpIntType = 0;
8632 libCall = nanMinMaxClamp ? spv::GLSLstd450NMin : spv::GLSLstd450FMin;
8634 libCall = spv::GLSLstd450UMin;
8636 libCall = spv::GLSLstd450SMin;
8640 libCall = spv::GLSLstd450Modf;
8644 libCall = nanMinMaxClamp ? spv::GLSLstd450NMax : spv::GLSLstd450FMax;
8646 libCall = spv::GLSLstd450UMax;
8648 libCall = spv::GLSLstd450SMax;
8652 libCall = spv::GLSLstd450Pow;
8655 opCode = spv::OpDot;
8658 libCall = spv::GLSLstd450Atan2;
8663 libCall = nanMinMaxClamp ? spv::GLSLstd450NClamp : spv::GLSLstd450FClamp;
8665 libCall = spv::GLSLstd450UClamp;
8667 libCall = spv::GLSLstd450SClamp;
8674 libCall = spv::GLSLstd450FMix;
8676 opCode = spv::OpSelect;
8682 libCall = spv::GLSLstd450Step;
8686 libCall = spv::GLSLstd450SmoothStep;
8692 libCall = spv::GLSLstd450Distance;
8695 libCall = spv::GLSLstd450Cross;
8698 libCall = spv::GLSLstd450FaceForward;
8701 libCall = spv::GLSLstd450Reflect;
8704 libCall = spv::GLSLstd450Refract;
8714 builder.createControlBarrier((spv::Scope)executionScope, (spv::Scope)memoryScope,
8715 (spv::MemorySemanticsMask)semantics);
8716 if (semantics & (spv::MemorySemanticsMakeAvailableKHRMask |
8717 spv::MemorySemanticsMakeVisibleKHRMask |
8718 spv::MemorySemanticsOutputMemoryKHRMask |
8719 spv::MemorySemanticsVolatileMask)) {
8720 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
8722 if (glslangIntermediate->usingVulkanMemoryModel() && (executionScope == spv::ScopeDevice ||
8723 memoryScope == spv::ScopeDevice)) {
8724 builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR);
8736 builder.createMemoryBarrier((spv::Scope)memoryScope, (spv::MemorySemanticsMask)semantics);
8737 if (semantics & (spv::MemorySemanticsMakeAvailableKHRMask |
8738 spv::MemorySemanticsMakeVisibleKHRMask |
8739 spv::MemorySemanticsOutputMemoryKHRMask |
8740 spv::MemorySemanticsVolatileMask)) {
8741 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
8743 if (glslangIntermediate->usingVulkanMemoryModel() && memoryScope == spv::ScopeDevice) {
8744 builder.addCapability(spv::CapabilityVulkanMemoryModelDeviceScopeKHR);
8752 builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float);
8753 libCall = spv::GLSLstd450InterpolateAtSample;
8757 builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float);
8758 libCall = spv::GLSLstd450InterpolateAtOffset;
8761 opCode = spv::OpIAddCarry;
8766 opCode = spv::OpISubBorrow;
8771 opCode = spv::OpUMulExtended;
8776 opCode = spv::OpSMulExtended;
8782 opCode = spv::OpBitFieldUExtract;
8784 opCode = spv::OpBitFieldSExtract;
8787 opCode = spv::OpBitFieldInsert;
8791 libCall = spv::GLSLstd450Fma;
8795 libCall = spv::GLSLstd450FrexpStruct;
8801 builder.addExtension(spv::E_SPV_AMD_gpu_shader_int16);
8812 libCall = spv::GLSLstd450Ldexp;
8856 extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_ballot);
8857 libCall = spv::SwizzleInvocationsAMD;
8860 extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_ballot);
8861 libCall = spv::SwizzleInvocationsMaskedAMD;
8864 extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_ballot);
8865 libCall = spv::WriteInvocationAMD;
8869 extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_trinary_minmax);
8871 libCall = spv::FMin3AMD;
8874 libCall = spv::UMin3AMD;
8876 libCall = spv::SMin3AMD;
8880 extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_trinary_minmax);
8882 libCall = spv::FMax3AMD;
8885 libCall = spv::UMax3AMD;
8887 libCall = spv::SMax3AMD;
8891 extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_trinary_minmax);
8893 libCall = spv::FMid3AMD;
8896 libCall = spv::UMid3AMD;
8898 libCall = spv::SMid3AMD;
8904 builder.addExtension(spv::E_SPV_AMD_gpu_shader_half_float);
8905 extBuiltins = getExtBuiltins(spv::E_SPV_AMD_shader_explicit_vertex_parameter);
8906 libCall = spv::InterpolateAtVertexAMD;
8911 opCode = spv::OpReportIntersectionKHR;
8914 builder.createNoResultOp(spv::OpTraceNV, operands);
8917 builder.addExtension(spv::E_SPV_NV_ray_tracing_motion_blur);
8918 builder.addCapability(spv::CapabilityRayTracingMotionBlurNV);
8919 builder.createNoResultOp(spv::OpTraceRayMotionNV, operands);
8922 builder.createNoResultOp(spv::OpTraceRayKHR, operands);
8925 builder.createNoResultOp(spv::OpExecuteCallableNV, operands);
8928 builder.createNoResultOp(spv::OpExecuteCallableKHR, operands);
8932 builder.createNoResultOp(spv::OpRayQueryInitializeKHR, operands);
8935 builder.createNoResultOp(spv::OpRayQueryTerminateKHR, operands);
8938 builder.createNoResultOp(spv::OpRayQueryGenerateIntersectionKHR, operands);
8941 builder.createNoResultOp(spv::OpRayQueryConfirmIntersectionKHR, operands);
8945 opCode = spv::OpRayQueryProceedKHR;
8949 opCode = spv::OpRayQueryGetIntersectionTypeKHR;
8953 opCode = spv::OpRayQueryGetRayTMinKHR;
8957 opCode = spv::OpRayQueryGetRayFlagsKHR;
8961 opCode = spv::OpRayQueryGetIntersectionTKHR;
8965 opCode = spv::OpRayQueryGetIntersectionInstanceCustomIndexKHR;
8969 opCode = spv::OpRayQueryGetIntersectionInstanceIdKHR;
8973 opCode = spv::OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR;
8977 opCode = spv::OpRayQueryGetIntersectionGeometryIndexKHR;
8981 opCode = spv::OpRayQueryGetIntersectionPrimitiveIndexKHR;
8985 opCode = spv::OpRayQueryGetIntersectionBarycentricsKHR;
8989 opCode = spv::OpRayQueryGetIntersectionFrontFaceKHR;
8993 opCode = spv::OpRayQueryGetIntersectionCandidateAABBOpaqueKHR;
8997 opCode = spv::OpRayQueryGetIntersectionObjectRayDirectionKHR;
9001 opCode = spv::OpRayQueryGetIntersectionObjectRayOriginKHR;
9005 opCode = spv::OpRayQueryGetWorldRayDirectionKHR;
9009 opCode = spv::OpRayQueryGetWorldRayOriginKHR;
9013 opCode = spv::OpRayQueryGetIntersectionObjectToWorldKHR;
9017 opCode = spv::OpRayQueryGetIntersectionWorldToObjectKHR;
9020 builder.createNoResultOp(spv::OpWritePackedPrimitiveIndices4x8NV, operands);
9026 builder.makeStatementTerminator(spv::OpEmitMeshTasksEXT, operands, "post-OpEmitMeshTasksEXT");
9029 builder.createNoResultOp(spv::OpSetMeshOutputsEXT, operands);
9032 opCode = spv::OpCooperativeMatrixMulAddNV;
9035 builder.createNoResultOp(spv::OpHitObjectTraceRayNV, operands);
9038 builder.createNoResultOp(spv::OpHitObjectTraceRayMotionNV, operands);
9041 builder.createNoResultOp(spv::OpHitObjectRecordHitNV, operands);
9044 builder.createNoResultOp(spv::OpHitObjectRecordHitMotionNV, operands);
9047 builder.createNoResultOp(spv::OpHitObjectRecordHitWithIndexNV, operands);
9050 builder.createNoResultOp(spv::OpHitObjectRecordHitWithIndexMotionNV, operands);
9053 builder.createNoResultOp(spv::OpHitObjectRecordMissNV, operands);
9056 builder.createNoResultOp(spv::OpHitObjectRecordMissMotionNV, operands);
9059 builder.createNoResultOp(spv::OpHitObjectExecuteShaderNV, operands);
9063 opCode = spv::OpHitObjectIsEmptyNV;
9067 opCode = spv::OpHitObjectIsMissNV;
9071 opCode = spv::OpHitObjectIsHitNV;
9075 opCode = spv::OpHitObjectGetRayTMinNV;
9079 opCode = spv::OpHitObjectGetRayTMaxNV;
9083 opCode = spv::OpHitObjectGetObjectRayOriginNV;
9087 opCode = spv::OpHitObjectGetObjectRayDirectionNV;
9091 opCode = spv::OpHitObjectGetWorldRayOriginNV;
9095 opCode = spv::OpHitObjectGetWorldRayDirectionNV;
9099 opCode = spv::OpHitObjectGetWorldToObjectNV;
9103 opCode = spv::OpHitObjectGetObjectToWorldNV;
9107 opCode = spv::OpHitObjectGetInstanceCustomIndexNV;
9111 opCode = spv::OpHitObjectGetInstanceIdNV;
9115 opCode = spv::OpHitObjectGetGeometryIndexNV;
9119 opCode = spv::OpHitObjectGetPrimitiveIndexNV;
9123 opCode = spv::OpHitObjectGetHitKindNV;
9127 opCode = spv::OpHitObjectGetCurrentTimeNV;
9131 opCode = spv::OpHitObjectGetShaderBindingTableRecordIndexNV;
9134 builder.createNoResultOp(spv::OpHitObjectGetAttributesNV, operands);
9138 opCode = spv::OpHitObjectGetShaderRecordBufferHandleNV;
9142 builder.createNoResultOp(spv::OpReorderThreadWithHintNV, operands);
9144 builder.createNoResultOp(spv::OpReorderThreadWithHitObjectNV, operands);
9152 opCode = spv::OpImageSampleWeightedQCOM;
9153 addImageProcessingQCOMDecoration(operands[2], spv::DecorationWeightTextureQCOM);
9157 opCode = spv::OpImageBoxFilterQCOM;
9161 opCode = spv::OpImageBlockMatchSADQCOM;
9162 addImageProcessingQCOMDecoration(operands[0], spv::DecorationBlockMatchTextureQCOM);
9163 addImageProcessingQCOMDecoration(operands[2], spv::DecorationBlockMatchTextureQCOM);
9167 opCode = spv::OpImageBlockMatchSSDQCOM;
9168 addImageProcessingQCOMDecoration(operands[0], spv::DecorationBlockMatchTextureQCOM);
9169 addImageProcessingQCOMDecoration(operands[2], spv::DecorationBlockMatchTextureQCOM);
9174 opCode = spv::OpFetchMicroTriangleVertexBarycentricNV;
9179 opCode = spv::OpFetchMicroTriangleVertexPositionNV;
9186 spv::Id id = 0;
9191 std::vector<spv::Id> callArguments(operands.begin(), operands.begin() + consumedOperands);
9193 } else if (opCode == spv::OpDot && !isFloat) {
9197 spv::Id mulOp = builder.createBinOp(spv::OpIMul, builder.getTypeId(operands[0]), operands[0], operands[1]);
9202 id = builder.createBinOp(spv::OpIAdd, typeId, id, builder.createCompositeExtract(mulOp, typeId, i));
9242 spv::Id member1 = builder.createCompositeExtract(id, frexpIntType, 1);
9243 member1 = builder.createUnaryOp(spv::OpConvertSToF, typeId1, member1);
9259 spv::Id TGlslangToSpvTraverser::createNoArgOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId)
9262 spv::Scope memoryBarrierScope = glslangIntermediate->usingVulkanMemoryModel() ?
9263 spv::ScopeQueueFamilyKHR : spv::ScopeDevice;
9269 builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup,
9270 spv::MemorySemanticsOutputMemoryKHRMask |
9271 spv::MemorySemanticsAcquireReleaseMask);
9272 builder.addCapability(spv::CapabilityVulkanMemoryModelKHR);
9274 builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeInvocation, spv::MemorySemanticsMaskNone);
9277 builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup,
9278 spv::MemorySemanticsWorkgroupMemoryMask |
9279 spv::MemorySemanticsAcquireReleaseMask);
9283 builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsAllMemory |
9284 spv::MemorySemanticsAcquireReleaseMask);
9287 builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsUniformMemoryMask |
9288 spv::MemorySemanticsAcquireReleaseMask);
9291 builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsWorkgroupMemoryMask |
9292 spv::MemorySemanticsAcquireReleaseMask);
9295 builder.createMemoryBarrier(spv::ScopeWorkgroup, spv::MemorySemanticsAllMemory |
9296 spv::MemorySemanticsAcquireReleaseMask);
9299 builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsAtomicCounterMemoryMask |
9300 spv::MemorySemanticsAcquireReleaseMask);
9303 builder.createMemoryBarrier(memoryBarrierScope, spv::MemorySemanticsImageMemoryMask |
9304 spv::MemorySemanticsAcquireReleaseMask);
9307 builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeDevice,
9308 spv::MemorySemanticsAllMemory |
9309 spv::MemorySemanticsAcquireReleaseMask);
9312 builder.createMemoryBarrier(spv::ScopeDevice, spv::MemorySemanticsUniformMemoryMask |
9313 spv::MemorySemanticsImageMemoryMask |
9314 spv::MemorySemanticsAcquireReleaseMask);
9317 builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeDevice, spv::MemorySemanticsUniformMemoryMask |
9318 spv::MemorySemanticsImageMemoryMask |
9319 spv::MemorySemanticsAcquireReleaseMask);
9322 builder.createMemoryBarrier(spv::ScopeWorkgroup, spv::MemorySemanticsWorkgroupMemoryMask |
9323 spv::MemorySemanticsAcquireReleaseMask);
9326 builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup,
9327 spv::MemorySemanticsWorkgroupMemoryMask |
9328 spv::MemorySemanticsAcquireReleaseMask);
9331 builder.createControlBarrier(spv::ScopeSubgroup, spv::ScopeSubgroup, spv::MemorySemanticsAllMemory |
9332 spv::MemorySemanticsAcquireReleaseMask);
9333 return spv::NoResult;
9335 builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsAllMemory |
9336 spv::MemorySemanticsAcquireReleaseMask);
9337 return spv::NoResult;
9339 builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsUniformMemoryMask |
9340 spv::MemorySemanticsAcquireReleaseMask);
9341 return spv::NoResult;
9343 builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsImageMemoryMask |
9344 spv::MemorySemanticsAcquireReleaseMask);
9345 return spv::NoResult;
9347 builder.createMemoryBarrier(spv::ScopeSubgroup, spv::MemorySemanticsWorkgroupMemoryMask |
9348 spv::MemorySemanticsAcquireReleaseMask);
9349 return spv::NoResult;
9352 builder.createNoResultOp(spv::OpEmitVertex);
9355 builder.createNoResultOp(spv::OpEndPrimitive);
9359 std::vector<spv::Id> operands;
9364 std::vector<spv::Id> args; // Dummy arguments
9365 spv::Id id = builder.createBuiltinCall(typeId, getExtBuiltins(spv::E_SPV_AMD_gcn_shader), spv::TimeAMD, args);
9369 builder.createNoResultOp(spv::OpIgnoreIntersectionNV);
9372 builder.createNoResultOp(spv::OpTerminateRayNV);
9375 builder.createNoResultOp(spv::OpRayQueryInitializeKHR);
9378 builder.createNoResultOp(spv::OpRayQueryTerminateKHR);
9381 builder.createNoResultOp(spv::OpRayQueryGenerateIntersectionKHR);
9384 builder.createNoResultOp(spv::OpRayQueryConfirmIntersectionKHR);
9387 builder.createNoResultOp(spv::OpBeginInvocationInterlockEXT);
9390 builder.createNoResultOp(spv::OpEndInvocationInterlockEXT);
9395 std::vector<spv::Id> args; // Dummy arguments
9396 builder.addExtension(spv::E_SPV_EXT_demote_to_helper_invocation);
9397 builder.addCapability(spv::CapabilityDemoteToHelperInvocationEXT);
9398 return builder.createOp(spv::OpIsHelperInvocationEXT, typeId, args);
9402 std::vector<spv::Id> args;
9403 args.push_back(builder.makeUintConstant(spv::ScopeSubgroup));
9404 builder.addExtension(spv::E_SPV_KHR_shader_clock);
9405 builder.addCapability(spv::CapabilityShaderClockKHR);
9406 return builder.createOp(spv::OpReadClockKHR, typeId, args);
9410 std::vector<spv::Id> args;
9411 args.push_back(builder.makeUintConstant(spv::ScopeDevice));
9412 builder.addExtension(spv::E_SPV_KHR_shader_clock);
9413 builder.addCapability(spv::CapabilityShaderClockKHR);
9414 return builder.createOp(spv::OpReadClockKHR, typeId, args);
9419 builder.addExtension(spv::E_SPV_EXT_shader_tile_image);
9421 spv::Decoration precision;
9422 spv::Op spv_op;
9425 precision = spv::DecorationRelaxedPrecision;
9426 spv_op = spv::OpStencilAttachmentReadEXT;
9427 builder.addCapability(spv::CapabilityTileImageStencilReadAccessEXT);
9431 precision = spv::NoPrecision;
9432 spv_op = spv::OpDepthAttachmentReadEXT;
9433 builder.addCapability(spv::CapabilityTileImageDepthReadAccessEXT);
9436 std::vector<spv::Id> args; // Dummy args
9437 spv::Id result = builder.createOp(spv_op, typeId, args);
9449 spv::Id TGlslangToSpvTraverser::getSymbolId(const glslang::TIntermSymbol* symbol)
9452 spv::Id id;
9459 spv::BuiltIn builtIn = TranslateBuiltInDecoration(symbol->getQualifier().builtIn, false);
9467 builtIn == spv::BuiltInObjectToWorldKHR ||
9468 builtIn == spv::BuiltInWorldToObjectKHR;
9475 if (forcedType.second != spv::NoType)
9488 if (forcedType.second != spv::NoType)
9497 builder.addDecoration(id, spv::DecorationComponent, symbol->getQualifier().layoutComponent);
9499 builder.addDecoration(id, spv::DecorationIndex, symbol->getQualifier().layoutIndex);
9501 builder.addDecoration(id, spv::DecorationSpecId, symbol->getType().getQualifier().layoutSpecConstantId);
9504 builder.addDecoration(id, spv::DecorationOffset, symbol->getQualifier().layoutOffset);
9511 && (builder.getStorageClass(id) == spv::StorageClassRayPayloadKHR ||
9512 builder.getStorageClass(id) == spv::StorageClassIncomingRayPayloadKHR ||
9513 builder.getStorageClass(id) == spv::StorageClassCallableDataKHR ||
9514 builder.getStorageClass(id) == spv::StorageClassIncomingCallableDataKHR ||
9515 builder.getStorageClass(id) == spv::StorageClassHitObjectAttributeNV))) {
9519 builder.addDecoration(id, spv::DecorationLocation, symbol->getQualifier().layoutLocation);
9525 builder.addCapability(spv::CapabilityGeometryStreams);
9526 builder.addDecoration(id, spv::DecorationStream, symbol->getQualifier().layoutStream);
9529 builder.addDecoration(id, spv::DecorationDescriptorSet, symbol->getQualifier().layoutSet);
9532 builder.addDecoration(id, spv::DecorationDescriptorSet, 0);
9535 builder.addDecoration(id, spv::DecorationBinding, symbol->getQualifier().layoutBinding);
9538 builder.addDecoration(id, spv::DecorationBinding, 0);
9541 builder.addDecoration(id, spv::DecorationInputAttachmentIndex, symbol->getQualifier().layoutAttachment);
9543 builder.addCapability(spv::CapabilityTransformFeedback);
9545 builder.addDecoration(id, spv::DecorationXfbBuffer, symbol->getQualifier().layoutXfbBuffer);
9548 builder.addDecoration(id, spv::DecorationXfbStride, stride);
9551 builder.addDecoration(id, spv::DecorationOffset, symbol->getQualifier().layoutXfbOffset);
9555 if (builtIn != spv::BuiltInMax) {
9557 if (glslangIntermediate->getSpv().spv < glslang::EShTargetSpv_1_6 ||
9558 builtIn != spv::BuiltInWorkgroupSize)
9559 builder.addDecoration(id, spv::DecorationBuiltIn, (int)builtIn);
9563 if (builtIn == spv::BuiltInHelperInvocation &&
9565 glslangIntermediate->getSpv().spv >= glslang::EShTargetSpv_1_6) {
9566 builder.addDecoration(id, spv::DecorationVolatile);
9571 std::vector<spv::Decoration> memory;
9578 if (builtIn == spv::BuiltInSampleMask) {
9579 spv::Decoration decoration;
9582 decoration = (spv::Decoration)spv::DecorationOverrideCoverageNV;
9584 decoration = (spv::Decoration)spv::DecorationMax;
9586 if (decoration != spv::DecorationMax) {
9587 builder.addCapability(spv::CapabilitySampleMaskOverrideCoverageNV);
9588 builder.addExtension(spv::E_SPV_NV_sample_mask_override_coverage);
9591 else if (builtIn == spv::BuiltInLayer) {
9594 builder.addDecoration(id, (spv::Decoration)spv::DecorationViewportRelativeNV);
9595 builder.addCapability(spv::CapabilityShaderViewportMaskNV);
9596 builder.addExtension(spv::E_SPV_NV_viewport_array2);
9599 builder.addDecoration(id, (spv::Decoration)spv::DecorationSecondaryViewportRelativeNV,
9601 builder.addCapability(spv::CapabilityShaderStereoViewNV);
9602 builder.addExtension(spv::E_SPV_NV_stereo_view_rendering);
9607 builder.addDecoration(id, spv::DecorationPassthroughNV);
9608 builder.addCapability(spv::CapabilityGeometryShaderPassthroughNV);
9609 builder.addExtension(spv::E_SPV_NV_geometry_shader_passthrough);
9612 builder.addDecoration(id, spv::DecorationPerVertexNV);
9613 builder.addCapability(spv::CapabilityFragmentBarycentricNV);
9614 builder.addExtension(spv::E_SPV_NV_fragment_shader_barycentric);
9618 builder.addDecoration(id, spv::DecorationPerVertexKHR);
9619 builder.addCapability(spv::CapabilityFragmentBarycentricKHR);
9620 builder.addExtension(spv::E_SPV_KHR_fragment_shader_barycentric);
9625 builder.addDecoration(id, (spv::Decoration)spv::DecorationHlslSemanticGOOGLE,
9631 spv::DecorationRestrictPointerEXT : spv::DecorationAliasedPointerEXT);
9642 void TGlslangToSpvTraverser::addMeshNVDecoration(spv::Id id, int member, const glslang::TQualifier& qualifier)
9653 builder.addCapability(spv::CapabilityMeshShadingEXT);
9654 builder.addExtension(spv::E_SPV_EXT_mesh_shader);
9656 builder.addCapability(spv::CapabilityMeshShadingNV);
9657 builder.addExtension(spv::E_SPV_NV_mesh_shader);
9660 builder.addMemberDecoration(id, (unsigned)member, spv::DecorationPerPrimitiveNV);
9663 builder.addMemberDecoration(id, (unsigned)member, spv::DecorationPerViewNV);
9665 builder.addMemberDecoration(id, (unsigned)member, spv::DecorationPerTaskNV);
9672 builder.addCapability(spv::CapabilityMeshShadingEXT);
9673 builder.addExtension(spv::E_SPV_EXT_mesh_shader);
9675 builder.addCapability(spv::CapabilityMeshShadingNV);
9676 builder.addExtension(spv::E_SPV_NV_mesh_shader);
9679 builder.addDecoration(id, spv::DecorationPerPrimitiveNV);
9682 builder.addDecoration(id, spv::DecorationPerViewNV);
9684 builder.addDecoration(id, spv::DecorationPerTaskNV);
9688 void TGlslangToSpvTraverser::addImageProcessingQCOMDecoration(spv::Id id, spv::Decoration decor)
9690 spv::Op opc = builder.getOpCode(id);
9691 if (opc == spv::OpSampledImage) {
9696 if (opc == spv::OpLoad) {
9697 spv::Id texid = builder.getIdOperand(id, 0);
9712 spv::Id TGlslangToSpvTraverser::createSpvConstant(const glslang::TIntermTyped& node)
9730 builder.addCapability(spv::CapabilityInt8);
9732 builder.addCapability(spv::CapabilityFloat16);
9734 builder.addCapability(spv::CapabilityInt16);
9736 builder.addCapability(spv::CapabilityInt64);
9738 builder.addCapability(spv::CapabilityFloat64);
9743 std::vector<spv::Id> dimConstId;
9748 builder.addDecoration(dimConstId.back(), spv::DecorationSpecId,
9758 spv::Id result;
9770 return spv::NoResult;
9779 return spv::NoResult;
9788 spv::Id TGlslangToSpvTraverser::createSpvConstantFromConstUnionArray(const glslang::TType& glslangType,
9792 std::vector<spv::Id> spvConsts;
9795 spv::Id typeId = convertGlslangToSpvType(glslangType);
9829 builder.addCapability(spv::CapabilityInt8);
9833 builder.addCapability(spv::CapabilityInt8);
9837 builder.addCapability(spv::CapabilityInt16);
9841 builder.addCapability(spv::CapabilityInt16);
9854 builder.addCapability(spv::CapabilityFloat16);
9866 spv::Id scalar = 0;
9881 builder.addCapability(spv::CapabilityInt8);
9885 builder.addCapability(spv::CapabilityInt8);
9889 builder.addCapability(spv::CapabilityInt16);
9893 builder.addCapability(spv::CapabilityInt16);
9906 builder.addCapability(spv::CapabilityFloat16);
9911 scalar = builder.createUnaryOp(spv::OpBitcast, typeId, scalar);
10016 spv::Id TGlslangToSpvTraverser::createShortCircuit(glslang::TOperator op, glslang::TIntermTyped& left,
10019 spv::Id boolTypeId = builder.makeBoolType();
10024 spv::Id leftId = accessChainLoad(left.getType());
10027 std::vector<spv::Id> phiOperands;
10039 leftId = builder.createUnaryOp(spv::OpLogicalNot, boolTypeId, leftId);
10042 spv::Builder::If ifBuilder(leftId, spv::SelectionControlMaskNone, builder);
10047 spv::Id rightId = accessChainLoad(right.getType());
10057 return builder.createOp(spv::OpPhi, boolTypeId, phiOperands);
10062 spv::Id TGlslangToSpvTraverser::getExtBuiltins(const char* name)
10068 spv::Id extBuiltins = builder.import(name);
10082 snprintf(buf, bufSize, "0x%08x, Revision %d", spv::Version, spv::Revision);
10164 spv::SpvBuildLogger logger;
10169 spv::SpvBuildLogger* logger, SpvOptions* options)
10182 TGlslangToSpvTraverser it(intermediate.getSpv().spv, &intermediate, logger, *options);