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