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