Lines Matching refs:spv
44 namespace spv {
72 SpecConstantOpModeGuard(spv::Builder* builder)
85 spv::Builder* builder_;
97 TGlslangToSpvTraverser(const glslang::TIntermediate*, spv::SpvBuildLogger* logger);
113 spv::Decoration TranslateAuxiliaryStorageDecoration(const glslang::TQualifier& qualifier);
114 spv::BuiltIn TranslateBuiltInDecoration(glslang::TBuiltInVariable, bool memberDeclaration);
115 spv::ImageFormat TranslateImageFormat(const glslang::TType& type);
116 spv::Id createSpvVariable(const glslang::TIntermSymbol*);
117 spv::Id getSampledType(const glslang::TSampler&);
118 spv::Id convertGlslangToSpvType(const glslang::TType& type);
119 spv::Id convertGlslangToSpvType(const glslang::TType& type, glslang::TLayoutPacking, const glslang::TQualifier&);
120 spv::Id convertGlslangStructToSpvType(const glslang::TType&, const glslang::TTypeList* glslangStruct,
123 const glslang::TQualifier&, spv::Id);
124 spv::Id makeArraySizeId(const glslang::TArraySizes&, int dim);
125 spv::Id accessChainLoad(const glslang::TType& type);
126 void accessChainStore(const glslang::TType& type, spv::Id rvalue);
138 void translateArguments(const glslang::TIntermAggregate& node, std::vector<spv::Id>& arguments);
139 void translateArguments(glslang::TIntermUnary& node, std::vector<spv::Id>& arguments);
140 spv::Id createImageTextureFunctionCall(glslang::TIntermOperator* node);
141 spv::Id handleUserFunctionCall(const glslang::TIntermAggregate*);
143 spv::Id createBinaryOperation(glslang::TOperator op, spv::Decoration precision, spv::Decoration noContraction, spv::Id typeId, spv::Id left, spv::Id right, glslang::TBasicType typeProxy, bool reduceComparison = true);
144 spv::Id createBinaryMatrixOperation(spv::Op, spv::Decoration precision, spv::Decoration noContraction, spv::Id typeId, spv::Id left, spv::Id right);
145 spv::Id createUnaryOperation(glslang::TOperator op, spv::Decoration precision, spv::Decoration noContraction, spv::Id typeId, spv::Id operand,glslang::TBasicType typeProxy);
146 spv::Id createUnaryMatrixOperation(spv::Op, spv::Decoration precision, spv::Decoration noContraction, spv::Id typeId, spv::Id operand,glslang::TBasicType typeProxy);
147 spv::Id createConversion(glslang::TOperator op, spv::Decoration precision, spv::Decoration noContraction, spv::Id destTypeId, spv::Id operand, glslang::TBasicType typeProxy);
148 spv::Id makeSmearedConstant(spv::Id constant, int vectorSize);
149 spv::Id createAtomicOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId, std::vector<spv::Id>& operands, glslang::TBasicType typeProxy);
150 spv::Id createInvocationsOperation(glslang::TOperator, spv::Id typeId, spv::Id operand);
151 spv::Id createMiscOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId, std::vector<spv::Id>& operands, glslang::TBasicType typeProxy);
152 spv::Id createNoArgOperation(glslang::TOperator op);
153 spv::Id getSymbolId(const glslang::TIntermSymbol* node);
154 void addDecoration(spv::Id id, spv::Decoration dec);
155 void addDecoration(spv::Id id, spv::Decoration dec, unsigned value);
156 void addMemberDecoration(spv::Id id, int member, spv::Decoration dec);
157 void addMemberDecoration(spv::Id id, int member, spv::Decoration dec, unsigned value);
158 spv::Id createSpvConstant(const glslang::TIntermTyped&);
159 spv::Id createSpvConstantFromConstUnionArray(const glslang::TType& type, const glslang::TConstUnionArray&, int& nextConst, bool specConstant);
162 spv::Id createShortCircuit(glslang::TOperator, glslang::TIntermTyped& left, glslang::TIntermTyped& right);
164 spv::Function* shaderEntry;
165 spv::Instruction* entryPoint;
168 spv::SpvBuildLogger* logger;
170 // There is a 1:1 mapping between a spv builder and a module; this is thread safe
171 spv::Builder builder;
175 std::set<spv::Id> iOSet; // all input/output variables from either static use or declaration of interface
177 spv::Id stdBuiltins;
179 std::unordered_map<int, spv::Id> symbolValues;
181 std::unordered_map<std::string, spv::Function*> functionMap;
182 std::unordered_map<const glslang::TTypeList*, spv::Id> structMap[glslang::ElpCount][glslang::ElmCount];
183 std::unordered_map<const glslang::TTypeList*, std::vector<int> > memberRemapper; // for mapping glslang block indices to spv indices (e.g., due to hidden members)
192 spv::SourceLanguage TranslateSourceLanguage(glslang::EShSource source, EProfile profile)
200 return spv::SourceLanguageGLSL;
202 return spv::SourceLanguageESSL;
204 return spv::SourceLanguageUnknown;
207 return spv::SourceLanguageHLSL;
209 return spv::SourceLanguageUnknown;
214 spv::ExecutionModel TranslateExecutionModel(EShLanguage stage)
217 case EShLangVertex: return spv::ExecutionModelVertex;
218 case EShLangTessControl: return spv::ExecutionModelTessellationControl;
219 case EShLangTessEvaluation: return spv::ExecutionModelTessellationEvaluation;
220 case EShLangGeometry: return spv::ExecutionModelGeometry;
221 case EShLangFragment: return spv::ExecutionModelFragment;
222 case EShLangCompute: return spv::ExecutionModelGLCompute;
225 return spv::ExecutionModelFragment;
230 spv::StorageClass TranslateStorageClass(const glslang::TType& type)
233 return spv::StorageClassInput;
235 return spv::StorageClassOutput;
237 return spv::StorageClassUniformConstant;
239 return spv::StorageClassAtomicCounter;
242 return spv::StorageClassPushConstant;
244 return spv::StorageClassUniform;
246 return spv::StorageClassUniformConstant;
250 case glslang::EvqShared: return spv::StorageClassWorkgroup; break;
251 case glslang::EvqGlobal: return spv::StorageClassPrivate;
252 case glslang::EvqConstReadOnly: return spv::StorageClassFunction;
253 case glslang::EvqTemporary: return spv::StorageClassFunction;
256 return spv::StorageClassFunction;
262 spv::Dim TranslateDimensionality(const glslang::TSampler& sampler)
265 case glslang::Esd1D: return spv::Dim1D;
266 case glslang::Esd2D: return spv::Dim2D;
267 case glslang::Esd3D: return spv::Dim3D;
268 case glslang::EsdCube: return spv::DimCube;
269 case glslang::EsdRect: return spv::DimRect;
270 case glslang::EsdBuffer: return spv::DimBuffer;
271 case glslang::EsdSubpass: return spv::DimSubpassData;
274 return spv::Dim2D;
279 spv::Decoration TranslatePrecisionDecoration(const glslang::TType& type)
282 case glslang::EpqLow: return spv::DecorationRelaxedPrecision;
283 case glslang::EpqMedium: return spv::DecorationRelaxedPrecision;
285 return spv::NoPrecision;
290 spv::Decoration TranslateBlockDecoration(const glslang::TType& type)
294 case glslang::EvqUniform: return spv::DecorationBlock;
295 case glslang::EvqBuffer: return spv::DecorationBufferBlock;
296 case glslang::EvqVaryingIn: return spv::DecorationBlock;
297 case glslang::EvqVaryingOut: return spv::DecorationBlock;
304 return spv::DecorationMax;
308 void TranslateMemoryDecoration(const glslang::TQualifier& qualifier, std::vector<spv::Decoration>& memory)
311 memory.push_back(spv::DecorationCoherent);
313 memory.push_back(spv::DecorationVolatile);
315 memory.push_back(spv::DecorationRestrict);
317 memory.push_back(spv::DecorationNonWritable);
319 memory.push_back(spv::DecorationNonReadable);
323 spv::Decoration TranslateLayoutDecoration(const glslang::TType& type, glslang::TLayoutMatrix matrixLayout)
328 return spv::DecorationRowMajor;
330 return spv::DecorationColMajor;
333 return spv::DecorationMax;
338 return spv::DecorationMax;
345 case glslang::ElpShared: return spv::DecorationGLSLShared;
346 case glslang::ElpPacked: return spv::DecorationGLSLPacked;
348 return spv::DecorationMax;
353 return spv::DecorationMax;
356 return spv::DecorationMax;
363 // Returns spv::DecorationMax when no decoration
365 spv
369 return spv::DecorationMax;
371 return spv::DecorationNoPerspective;
373 return spv::DecorationFlat;
375 return spv::DecorationMax;
379 // Returns spv::DecorationMax when no decoration
381 spv::Decoration TGlslangToSpvTraverser::TranslateAuxiliaryStorageDecoration(const glslang::TQualifier& qualifier)
384 return spv::DecorationPatch;
386 return spv::DecorationCentroid;
388 builder.addCapability(spv::CapabilitySampleRateShading);
389 return spv::DecorationSample;
391 return spv::DecorationMax;
395 spv::Decoration TranslateInvariantDecoration(const glslang::TQualifier& qualifier)
398 return spv::DecorationInvariant;
400 return spv::DecorationMax;
404 spv::Decoration TranslateNoContractionDecoration(const glslang::TQualifier& qualifier)
407 return spv::DecorationNoContraction;
409 return spv::DecorationMax;
417 spv::BuiltIn TGlslangToSpvTraverser::TranslateBuiltInDecoration(glslang::TBuiltInVariable builtIn, bool memberDeclaration)
425 builder.addCapability(spv::CapabilityGeometryPointSize);
429 builder.addCapability(spv::CapabilityTessellationPointSize);
435 return spv::BuiltInPointSize;
445 builder.addCapability(spv::CapabilityClipDistance);
446 return spv::BuiltInClipDistance;
450 builder.addCapability(spv::CapabilityCullDistance);
451 return spv::BuiltInCullDistance;
454 builder.addCapability(spv::CapabilityMultiViewport);
455 return spv::BuiltInViewportIndex;
458 builder.addCapability(spv::CapabilitySampleRateShading);
459 return spv::BuiltInSampleId;
462 builder.addCapability(spv::CapabilitySampleRateShading);
463 return spv::BuiltInSamplePosition;
466 builder.addCapability(spv::CapabilitySampleRateShading);
467 return spv::BuiltInSampleMask;
470 builder.addCapability(spv::CapabilityGeometry);
471 return spv::BuiltInLayer;
473 case glslang::EbvPosition: return spv::BuiltInPosition;
474 case glslang::EbvVertexId: return spv::BuiltInVertexId;
475 case glslang::EbvInstanceId: return spv::BuiltInInstanceId;
476 case glslang::EbvVertexIndex: return spv::BuiltInVertexIndex;
477 case glslang::EbvInstanceIndex: return spv::BuiltInInstanceIndex;
483 return spv::BuiltInMax;
484 case glslang::EbvPrimitiveId: return spv::BuiltInPrimitiveId;
485 case glslang::EbvInvocationId: return spv::BuiltInInvocationId;
486 case glslang::EbvTessLevelInner: return spv::BuiltInTessLevelInner;
487 case glslang::EbvTessLevelOuter: return spv::BuiltInTessLevelOuter;
488 case glslang::EbvTessCoord: return spv::BuiltInTessCoord;
489 case glslang::EbvPatchVertices: return spv::BuiltInPatchVertices;
490 case glslang::EbvFragCoord: return spv::BuiltInFragCoord;
491 case glslang::EbvPointCoord: return spv::BuiltInPointCoord;
492 case glslang::EbvFace: return spv::BuiltInFrontFacing;
493 case glslang::EbvFragDepth: return spv::BuiltInFragDepth;
494 case glslang::EbvHelperInvocation: return spv::BuiltInHelperInvocation;
495 case glslang::EbvNumWorkGroups: return spv::BuiltInNumWorkgroups;
496 case glslang::EbvWorkGroupSize: return spv::BuiltInWorkgroupSize;
497 case glslang::EbvWorkGroupId: return spv::BuiltInWorkgroupId;
498 case glslang::EbvLocalInvocationId: return spv::BuiltInLocalInvocationId;
499 case glslang::EbvLocalInvocationIndex: return spv::BuiltInLocalInvocationIndex;
500 case glslang::EbvGlobalInvocationId: return spv::BuiltInGlobalInvocationId;
510 return spv::BuiltInMax;
511 default: return spv::BuiltInMax;
516 spv::ImageFormat TGlslangToSpvTraverser::TranslateImageFormat(const glslang::TType& type)
550 builder.addCapability(spv::CapabilityStorageImageExtendedFormats);
559 case glslang::ElfNone: return spv::ImageFormatUnknown;
560 case glslang::ElfRgba32f: return spv::ImageFormatRgba32f;
561 case glslang::ElfRgba16f: return spv::ImageFormatRgba16f;
562 case glslang::ElfR32f: return spv::ImageFormatR32f;
563 case glslang::ElfRgba8: return spv::ImageFormatRgba8;
564 case glslang::ElfRgba8Snorm: return spv::ImageFormatRgba8Snorm;
565 case glslang::ElfRg32f: return spv::ImageFormatRg32f;
566 case glslang::ElfRg16f: return spv::ImageFormatRg16f;
567 case glslang::ElfR11fG11fB10f: return spv::ImageFormatR11fG11fB10f;
568 case glslang::ElfR16f: return spv::ImageFormatR16f;
569 case glslang::ElfRgba16: return spv::ImageFormatRgba16;
570 case glslang::ElfRgb10A2: return spv::ImageFormatRgb10A2;
571 case glslang::ElfRg16: return spv::ImageFormatRg16;
572 case glslang::ElfRg8: return spv::ImageFormatRg8;
573 case glslang::ElfR16: return spv::ImageFormatR16;
574 case glslang::ElfR8: return spv::ImageFormatR8;
575 case glslang::ElfRgba16Snorm: return spv::ImageFormatRgba16Snorm;
576 case glslang::ElfRg16Snorm: return spv::ImageFormatRg16Snorm;
577 case glslang::ElfRg8Snorm: return spv::ImageFormatRg8Snorm;
578 case glslang::ElfR16Snorm: return spv::ImageFormatR16Snorm;
579 case glslang::ElfR8Snorm: return spv::ImageFormatR8Snorm;
580 case glslang::ElfRgba32i: return spv::ImageFormatRgba32i;
581 case glslang::ElfRgba16i: return spv::ImageFormatRgba16i;
582 case glslang::ElfRgba8i: return spv::ImageFormatRgba8i;
583 case glslang::ElfR32i: return spv::ImageFormatR32i;
584 case glslang::ElfRg32i: return spv::ImageFormatRg32i;
585 case glslang::ElfRg16i: return spv::ImageFormatRg16i;
586 case glslang::ElfRg8i: return spv::ImageFormatRg8i;
587 case glslang::ElfR16i: return spv::ImageFormatR16i;
588 case glslang::ElfR8i: return spv::ImageFormatR8i;
589 case glslang::ElfRgba32ui: return spv::ImageFormatRgba32ui;
590 case glslang::ElfRgba16ui: return spv::ImageFormatRgba16ui;
591 case glslang::ElfRgba8ui: return spv::ImageFormatRgba8ui;
592 case glslang::ElfR32ui: return spv::ImageFormatR32ui;
593 case glslang::ElfRg32ui: return spv::ImageFormatRg32ui;
594 case glslang::ElfRg16ui: return spv::ImageFormatRg16ui;
595 case glslang::ElfRgb10a2ui: return spv::ImageFormatRgb10a2ui;
596 case glslang::ElfRg8ui: return spv::ImageFormatRg8ui;
597 case glslang::ElfR16ui: return spv::ImageFormatR16ui;
598 case glslang::ElfR8ui: return spv::ImageFormatR8ui;
599 default: return spv::ImageFormatMax;
664 TGlslangToSpvTraverser::TGlslangToSpvTraverser(const glslang::TIntermediate* glslangIntermediate, spv::SpvBuildLogger* buildLogger)
670 spv::ExecutionModel executionModel = TranslateExecutionModel(glslangIntermediate->getStage());
675 builder.setMemoryModel(spv::AddressingModelLogical, spv::MemoryModelGLSL450);
687 builder.addCapability(spv::CapabilityTransformFeedback);
688 builder.addExecutionMode(shaderEntry, spv::ExecutionModeXfb);
694 builder.addCapability(spv::CapabilityShader);
698 builder.addCapability(spv::CapabilityTessellation);
699 builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputVertices, glslangIntermediate->getVertices());
703 builder.addCapability(spv::CapabilityTessellation);
705 case glslang::ElgTriangles: mode = spv::ExecutionModeTriangles; break;
706 case glslang::ElgQuads: mode = spv::ExecutionModeQuads; break;
707 case glslang::ElgIsolines: mode = spv::ExecutionModeIsolines; break;
708 default: mode = spv::ExecutionModeMax; break;
710 if (mode != spv::ExecutionModeMax)
711 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
714 case glslang::EvsEqual: mode = spv::ExecutionModeSpacingEqual; break;
715 case glslang::EvsFractionalEven: mode = spv::ExecutionModeSpacingFractionalEven; break;
716 case glslang::EvsFractionalOdd: mode = spv::ExecutionModeSpacingFractionalOdd; break;
717 default: mode = spv::ExecutionModeMax; break;
719 if (mode != spv::ExecutionModeMax)
720 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
723 case glslang::EvoCw: mode = spv::ExecutionModeVertexOrderCw; break;
724 case glslang::EvoCcw: mode = spv::ExecutionModeVertexOrderCcw; break;
725 default: mode = spv::ExecutionModeMax; break;
727 if (mode != spv::ExecutionModeMax)
728 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
731 builder.addExecutionMode(shaderEntry, spv::ExecutionModePointMode);
735 builder.addCapability(spv::CapabilityGeometry);
737 spv::ExecutionModeInputPoints; break;
738 case glslang::ElgLines: mode = spv::ExecutionModeInputLines; break;
739 case glslang::ElgLinesAdjacency: mode = spv::ExecutionModeInputLinesAdjacency; break;
740 case glslang::ElgTriangles: mode = spv::ExecutionModeTriangles; break;
741 case glslang::ElgTrianglesAdjacency: mode = spv::ExecutionModeInputTrianglesAdjacency; break;
742 default: mode = spv::ExecutionModeMax; break;
744 if (mode != spv::ExecutionModeMax)
745 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
747 builder.addExecutionMode(shaderEntry, spv::ExecutionModeInvocations, glslangIntermediate->getInvocations());
750 case glslang::ElgPoints: mode = spv::ExecutionModeOutputPoints; break;
751 case glslang::ElgLineStrip: mode = spv::ExecutionModeOutputLineStrip; break;
752 case glslang::ElgTriangleStrip: mode = spv::ExecutionModeOutputTriangleStrip; break;
753 default: mode = spv::ExecutionModeMax; break;
755 if (mode != spv::ExecutionModeMax)
756 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
757 builder.addExecutionMode(shaderEntry, spv::ExecutionModeOutputVertices, glslangIntermediate->getVertices());
761 builder.addCapability(spv::CapabilityShader);
763 builder.addExecutionMode(shaderEntry, spv::ExecutionModePixelCenterInteger);
766 builder.addExecutionMode(shaderEntry, spv::ExecutionModeOriginUpperLeft);
768 builder.addExecutionMode(shaderEntry, spv::ExecutionModeOriginLowerLeft);
771 builder.addExecutionMode(shaderEntry, spv::ExecutionModeEarlyFragmentTests);
774 case glslang::EldGreater: mode = spv::ExecutionModeDepthGreater; break;
775 case glslang::EldLess: mode = spv::ExecutionModeDepthLess; break;
776 default: mode = spv::ExecutionModeMax; break;
778 if (mode != spv::ExecutionModeMax)
779 builder.addExecutionMode(shaderEntry, (spv::ExecutionMode)mode);
782 builder.addExecutionMode(shaderEntry, spv::ExecutionModeDepthReplacing);
786 builder.addCapability(spv::CapabilityShader);
787 builder.addExecutionMode(shaderEntry, spv::ExecutionModeLocalSize, glslangIntermediate->getLocalSize(0),
801 // finish off the entry-point SPV instruction by adding the Input/Output <id>
812 spv::Block* lastMainBlock = shaderEntry->getLastBlock();
841 spv::Id id = getSymbolId(symbol);
845 spv::StorageClass sc = builder.getStorageClass(id);
846 if (sc == spv::StorageClassInput || sc == spv::StorageClassOutput)
905 spv::Builder::AccessChain lValue = builder.getAccessChain();
910 spv::Id rValue = accessChainLoad(node->getRight()->getType());
915 spv::Id leftRValue = accessChainLoad(node->getLeft()->getType());
924 assert(rValue != spv::NoResult);
987 spv::Builder::AccessChain partial = builder.getAccessChain();
992 spv::Id index = accessChainLoad(node->getRight()->getType());
1023 spv::Id result = createShortCircuit(node->getOp(), *node->getLeft()->getAsTyped(), *node->getRight()->getAsTyped());
1037 spv::Id left = accessChainLoad(node->getLeft()->getType());
1042 spv::Id right = accessChainLoad(node->getRight()->getType());
1045 spv::Id result = createBinaryOperation(node->getOp(), TranslatePrecisionDecoration(node->getType()),
1066 spv::Id result = spv::NoResult;
1070 if (result != spv::NoResult) {
1084 // SPV wants "block" and member number as the operands, go get them.
1089 spv::Id length = builder.createArrayLength(builder.accessChainGetLValue(), member);
1102 spvspv::NoResult;
1112 spv::Decoration precision = TranslatePrecisionDecoration(node->getType());
1113 spv::Decoration noContraction = TranslateNoContractionDecoration(node->getType().getQualifier());
1138 spv::Id one = 0;
1152 spv::Id result = createBinaryOperation(op, TranslatePrecisionDecoration(node->getType()),
1156 assert(result != spv::NoResult);
1172 builder.createNoResultOp(spv::OpEmitStreamVertex, operand);
1175 builder.createNoResultOp(spv::OpEndStreamPrimitive, operand);
1190 spv::Id result = spv::NoResult;
1194 if (result != spv::NoResult) {
1212 spv::Decoration precision = TranslatePrecisionDecoration(node->getType());
1345 std::vector<spv::Id> arguments;
1347 spv::Id resultTypeId = convertGlslangToSpvType(node->getType());
1348 spv::Id constructed;
1350 constructed = builder.createOp(spv::OpSampledImage, resultTypeId, arguments);
1352 std::vector<spv::Id> constituents;
1450 spv::Id leftId = accessChainLoad(left->getType());
1454 spv::Id rightId = accessChainLoad(right->getType());
1461 assert(result != spv::NoResult);
1472 std::vector<spv::Id> operands;
1560 spv::Id result = 0;
1564 result = builder.createVariable(spv::StorageClassFunction, convertGlslangToSpvType(node->getType()));
1571 spv::Builder::If ifBuilder(accessChainLoad(node->getCondition()->getType()), builder);
1606 spv::Id selector = accessChainLoad(node->getCondition()->getAsTyped()->getType());
1632 std::vector<spv::Block*> segmentBlocks; // returned, as the blocks allocated in the call
1654 spv::Id constant = createSpvConstantFromConstUnionArray(node->getType(), node->getConstArray(), nextConst, false);
1671 builder.createLoopMerge(&blocks.merge, &blocks.continue_target, spv::LoopControlMaskNone);
1673 spv::Block& test = builder.makeNewBlock();
1678 spv::Id condition =
1708 spv::Id condition =
1758 spv::Id TGlslangToSpvTraverser::createSpvVariable(const glslang::TIntermSymbol* node)
1768 spv::StorageClass storageClass = TranslateStorageClass(node->getType());
1769 spv::Id spvType = convertGlslangToSpvType(node->getType());
1779 spv::Id TGlslangToSpvTraverser::getSampledType(const glslang::TSampler& sampler)
1791 // Convert from a glslang type to an SPV type, by calling into a
1794 spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& type)
1802 spv::Id TGlslangToSpvTraverser::convertGlslangToSpvType(const glslang::TType& type, glslang::TLayoutPacking explicitLayout, const glslang::TQualifier& qualifier)
1804 spv::Id spvType = spv::NoResult;
1832 builder.addCapability(spv::CapabilityInt64);
1836 builder.addCapability(spv::CapabilityInt64);
1840 builder.addCapability(spv::CapabilityAtomicStorage);
1870 if (spvType != spv::NoResult)
1914 builder.addDecoration(spvType, spv::DecorationArrayStride, stride);
1933 builder.addDecoration(spvType, spv::DecorationArrayStride, stride);
1943 spv::Id TGlslangToSpvTraverser::convertGlslangStructToSpvType(const glslang::TType& type,
1949 std::vector<spv::Id> spvMembers;
1977 spv::Id spvType = builder.makeStructType(spvMembers, type.getTypeName().c_str());
1991 spv::Id spvType)
2021 std::vector<spv::Decoration> memory;
2049 builder.addMemberDecoration(spvType, member, spv::DecorationLocation, location);
2056 builder.addMemberDecoration(spvType, member, spv::DecorationComponent, glslangMember.getQualifier().layoutComponent);
2058 builder.addMemberDecoration(spvType, member, spv::DecorationOffset, glslangMember.getQualifier().layoutXfbOffset);
2064 builder.addMemberDecoration(spvType, member, spv::DecorationOffset, offset);
2069 builder.addMemberDecoration(spvType, member, spv::DecorationMatrixStride, getMatrixStride(glslangMember, explicitLayout, memberQualifier.layoutMatrix));
2072 spv::BuiltIn builtIn = TranslateBuiltInDecoration(glslangMember.getQualifier().builtIn, true);
2073 if (builtIn != spv::BuiltInMax)
2074 addMemberDecoration(spvType, member, spv::DecorationBuiltIn, (int)builtIn);
2082 builder.addCapability(spv::CapabilityGeometryStreams);
2083 builder.addDecoration(spvType, spv::DecorationStream, type.getQualifier().layoutStream);
2086 builder.addCapability(spv::CapabilityTransformFeedback);
2088 builder.addDecoration(spvType, spv::DecorationXfbStride, type.getQualifier().layoutXfbStride);
2090 builder.addDecoration(spvType, spv::DecorationXfbBuffer, type.getQualifier().layoutXfbBuffer);
2098 spv::Id TGlslangToSpvTraverser::makeArraySizeId(const glslang::TArraySizes& arraySizes, int dim)
2119 spv::Id TGlslangToSpvTraverser::accessChainLoad(const glslang::TType& type)
2121 spv::Id nominalTypeId = builder.accessChainGetInferredType();
2122 spv::Id loadedId = builder.accessChainLoad(TranslatePrecisionDecoration(type), nominalTypeId);
2128 spv::Id boolType = builder.makeBoolType();
2130 loadedId = builder.createBinOp(spv::OpINotEqual, boolType, loadedId, builder.makeUintConstant(0));
2134 spv::Id bvecType = builder.makeVectorType(builder.makeBoolType(), vecSize);
2136 loadedId = builder.createBinOp(spv::OpINotEqual, bvecType, loadedId, makeSmearedConstant(builder.makeUintConstant(0), vecSize));
2145 void TGlslangToSpvTraverser::accessChainStore(const glslang::TType& type, spv::Id rvalue)
2149 spv::Id nominalTypeId = builder.accessChainGetInferredType();
2153 spv::Id boolType = builder.makeBoolType();
2155 spv::Id zero = builder.makeUintConstant(0);
2156 spv::Id one = builder.makeUintConstant(1);
2157 rvalue = builder.createTriOp(spv::OpSelect, nominalTypeId, rvalue, one, zero);
2162 spv::Id bvecType = builder.makeVectorType(builder.makeBoolType(), vecSize);
2164 spv::Id zero = makeSmearedConstant(builder.makeUintConstant(0), vecSize);
2165 spv::Id one = makeSmearedConstant(builder.makeUintConstant(1), vecSize);
2166 rvalue = builder.createTriOp(spv::OpSelect, nominalTypeId, rvalue, one, zero);
2314 std::vector<spv::Id> paramTypes;
2315 std::vector<spv::Decoration> paramPrecisions;
2320 spv::Id typeId = convertGlslangToSpvType(paramType);
2324 typeId = builder.makePointer(spv::StorageClassFunction, typeId);
2331 spv::Block* functionBlock;
2332 spv::Function *function = builder.makeFunctionEntry(TranslatePrecisionDecoration(glslFunction->getType()),
2377 spv::Function* function = functionMap[node->getName().c_str()];
2378 spv::Block* functionBlock = function->getEntryBlock();
2382 void TGlslangToSpvTraverser::translateArguments(const glslang::TIntermAggregate& node, std::vector<spv::Id>& arguments)
2471 void TGlslangToSpvTraverser::translateArguments(glslang::TIntermUnary& node, std::vector<spv::Id>& arguments)
2478 spv::Id TGlslangToSpvTraverser::createImageTextureFunctionCall(glslang::TIntermOperator* node)
2481 return spv::NoResult;
2484 // Process a GLSL texturing op (will be SPV image)
2487 std::vector<spv::Id> arguments;
2492 spv::Decoration precision = TranslatePrecisionDecoration(node->getType());
2494 spv::Builder::TextureParameters params = { };
2504 params.sampler = builder.createUnaryOp(spv::OpImage, builder.getImageType(params.sampler), params.sampler);
2510 return builder.createTextureQueryCall(spv::OpImageQuerySizeLod, params);
2512 return builder.createTextureQueryCall(spv::OpImageQuerySize, params);
2515 return builder.createTextureQueryCall(spv::OpImageQuerySamples, params);
2518 return builder.createTextureQueryCall(spv::OpImageQueryLod, params);
2520 return builder.createTextureQueryCall(spv::OpImageQueryLevels, params);
2522 return builder.createUnaryOp(spv::OpImageSparseTexelsResident, builder.makeBoolType(), arguments[0]);
2531 std::vector<spv::Id> operands;
2540 spv::Id zero = builder.makeIntConstant(0);
2541 std::vector<spv::Id> comps;
2546 operands.push_back(spv::ImageOperandsSampleMask);
2549 return builder.createOp(spv::OpImageRead, convertGlslangToSpvType(node->getType()), operands);
2555 operands.push_back(spv::ImageOperandsSampleMask);
2558 if (builder.getImageTypeFormat(builder.getImageType(operands.front())) == spv::ImageFormatUnknown)
2559 builder.addCapability(spv::CapabilityStorageImageReadWithoutFormat);
2560 return builder.createOp(spv::OpImageRead, convertGlslangToSpvType(node->getType()), operands);
2564 operands.push_back(spv::ImageOperandsSampleMask);
2568 builder.createNoResultOp(spv::OpImageWrite, operands);
2569 if (builder.getImageTypeFormat(builder.getImageType(operands.front())) == spv::ImageFormatUnknown)
2570 builder.addCapability(spv::CapabilityStorageImageWriteWithoutFormat);
2571 return spv::NoResult;
2573 builder.addCapability(spv::CapabilitySparseResidency);
2574 if (builder.getImageTypeFormat(builder.getImageType(operands.front())) == spv::ImageFormatUnknown)
2575 builder.addCapability(spv::CapabilityStorageImageReadWithoutFormat);
2578 operands.push_back(spv::ImageOperandsSampleMask);
2583 spv::Id texelOut = *opIt;
2584 spv::Id typeId0 = convertGlslangToSpvType(node->getType());
2585 spv::Id typeId1 = builder.getDerefTypeId(texelOut);
2586 spv::Id resultTypeId = builder.makeStructResultType(typeId0, typeId1);
2588 spv::Id resultId = builder.createOp(spv::OpImageSparseRead, resultTypeId, operands);
2600 spv::Id resultTypeId = builder.makePointer(spv::StorageClassImage, convertGlslangToSpvType(node->getType()));
2601 spv::Id pointer = builder.createOp(spv::OpImageTexelPointer, resultTypeId, operands);
2603 std::vector<spv::Id> operands;
2633 // See if the sampler param should really be just the SPV image part
2637 params.sampler = builder.createUnaryOp(spv::OpImage, builder.getImageType(params.sampler), params.sampler);
2654 std::vector<spv::Id> indexes;
2740 spv::Id projComp = builder.createCompositeExtract(params.coords,
2751 spv::Id TGlslangToSpvTraverser::handleUserFunctionCall(const glslang::TIntermAggregate* node)
2754 spv::Function* function = functionMap[node->getName().c_str()];
2770 std::vector<spv::Builder::AccessChain> lValues;
2771 std::vector<spv::Id> rValues;
2795 std::vector<spv::Id> spvArgs;
2798 spv::Id arg;
2805 arg = builder.createVariable(spv::StorageClassFunction, convertGlslangToSpvType(paramType), "param");
2809 spv::Id copy = accessChainLoad(*argTypes[a]);
2821 spv::Id result = builder.createFunctionCall(function, spvArgs);
2829 spv::Id copy = builder.createLoad(spvArgs[a]);
2840 // Translate AST operation to SPV operation, already having SPV-based operands/types.
2841 spv::Id TGlslangToSpvTraverser::createBinaryOperation(glslang::TOperator op, spv::Decoration precision,
2842 spv::Decoration noContraction,
2843 spv::Id typeId, spv::Id left, spv::Id right,
2850 spv::Op binOp = spv::OpNop;
2858 binOp = spv::OpFAdd;
2860 binOp = spv::OpIAdd;
2865 binOp = spv::OpFSub;
2867 binOp = spv::OpISub;
2872 binOp = spv::OpFMul;
2874 binOp = spv::OpIMul;
2883 binOp = spv::OpVectorTimesScalar;
2885 binOp = spv::OpIMul;
2889 binOp = spv::OpVectorTimesMatrix;
2892 binOp = spv::OpMatrixTimesVector;
2896 binOp = spv::OpMatrixTimesScalar;
2900 binOp = spv::OpMatrixTimesMatrix;
2903 binOp = spv::OpOuterProduct;
2910 binOp = spv::OpFDiv;
2912 binOp = spv::OpUDiv;
2914 binOp = spv::OpSDiv;
2919 binOp = spv::OpFMod;
2921 binOp = spv::OpUMod;
2923 binOp = spv::OpSMod;
2928 binOp = spv::OpShiftRightLogical;
2930 binOp = spv::OpShiftRightArithmetic;
2934 binOp = spv::OpShiftLeftLogical;
2938 binOp = spv::OpBitwiseAnd;
2942 binOp = spv::OpLogicalAnd;
2946 binOp = spv::OpBitwiseOr;
2950 binOp = spv::OpLogicalOr;
2954 binOp = spv::OpBitwiseXor;
2958 binOp = spv::OpLogicalNotEqual;
2976 if (binOp != spv::OpNop) {
2985 spv::Id result = builder.createBinOp(binOp, typeId, left, right);
3004 binOp = spv::OpFOrdLessThan;
3006 binOp = spv::OpULessThan;
3008 binOp = spv::OpSLessThan;
3012 binOp = spv::OpFOrdGreaterThan;
3014 binOp = spv::OpUGreaterThan;
3016 binOp = spv::OpSGreaterThan;
3020 binOp = spv::OpFOrdLessThanEqual;
3022 binOp = spv::OpULessThanEqual;
3024 binOp = spv::OpSLessThanEqual;
3028 binOp = spv::OpFOrdGreaterThanEqual;
3030 binOp = spv::OpUGreaterThanEqual;
3032 binOp = spv::OpSGreaterThanEqual;
3037 binOp = spv::OpFOrdEqual;
3039 binOp = spv::OpLogicalEqual;
3041 binOp = spv::OpIEqual;
3046 binOp = spv::OpFOrdNotEqual;
3048 binOp = spv::OpLogicalNotEqual;
3050 binOp = spv::OpINotEqual;
3056 if (binOp != spv::OpNop) {
3057 spv::Id result = builder.createBinOp(binOp, typeId, left, right);
3066 // Translate AST matrix operation to SPV operation, already having SPV-based operands/types.
3079 spv::Id TGlslangToSpvTraverser::createBinaryMatrixOperation(spv::Op op, spv::Decoration precision, spv::Decoration noContraction, spv::Id typeId, spv::Id left, spv::Id right)
3085 case spv::OpFDiv:
3088 right = builder.createBinOp(spv::OpFDiv, builder.getTypeId(right), builder.makeFloatConstant(1.0F), right);
3089 op = spv::OpMatrixTimesScalar;
3093 spv::OpMatrixTimesScalar:
3098 case spv::OpVectorTimesMatrix:
3102 case spv::OpMatrixTimesVector:
3106 case spv::OpMatrixTimesMatrix:
3116 spv::Id result = builder.createBinOp(op, typeId, left, right);
3129 case spv::OpFAdd:
3130 case spv::OpFSub:
3131 case spv::OpFDiv:
3132 case spv::OpFMod:
3133 case spv::OpFMul:
3140 spv::Id scalarType = builder.getScalarTypeId(typeId);
3141 spv::Id vecType = builder.makeVectorType(scalarType, numRows);
3142 std::vector<spv::Id> results;
3143 spv::Id smearVec = spv::NoResult;
3153 spv::Id leftVec = leftMat ? builder.createCompositeExtract( left, vecType, indexes) : smearVec;
3154 spv::Id rightVec = rightMat ? builder.createCompositeExtract(right, vecType, indexes) : smearVec;
3155 spv::Id result = builder.createBinOp(op, vecType, leftVec, rightVec);
3165 return spv::NoResult;
3169 spv::Id TGlslangToSpvTraverser::createUnaryOperation(glslang::TOperator op, spv::Decoration precision, spv::Decoration noContraction, spv::Id typeId, spv::Id operand, glslang::TBasicType typeProxy)
3171 spv::Op unaryOp = spv::OpNop;
3179 unaryOp = spv::OpFNegate;
3183 unaryOp = spv::OpSNegate;
3188 unaryOp = spv::OpLogicalNot;
3191 unaryOp = spv::OpNot;
3195 libCall = spv::GLSLstd450Determinant;
3198 libCall = spv::GLSLstd450MatrixInverse;
3201 unaryOp = spv::OpTranspose;
3205 libCall = spv::GLSLstd450Radians;
3208 libCall = spv::GLSLstd450Degrees;
3211 libCall = spv::GLSLstd450Sin;
3214 libCall = spv::GLSLstd450Cos;
3217 libCall = spv::GLSLstd450Tan;
3220 libCall = spv::GLSLstd450Acos;
3223 libCall = spv::GLSLstd450Asin;
3226 libCall = spv::GLSLstd450Atan;
3230 libCall = spv::GLSLstd450Acosh;
3233 libCall = spv::GLSLstd450Asinh;
3236 libCall = spv::GLSLstd450Atanh;
3239 libCall = spv::GLSLstd450Tanh;
3242 libCall = spv::GLSLstd450Cosh;
3245 libCall = spv::GLSLstd450Sinh;
3249 libCall = spv::GLSLstd450Length;
3252 libCall = spv::GLSLstd450Normalize;
3256 libCall = spv::GLSLstd450Exp;
3259 libCall = spv::GLSLstd450Log;
3262 libCall = spv::GLSLstd450Exp2;
3265 libCall = spv::GLSLstd450Log2;
3268 libCall = spv::GLSLstd450Sqrt;
3271 libCall = spv::GLSLstd450InverseSqrt;
3275 libCall = spv::GLSLstd450Floor;
3278 libCall = spv::GLSLstd450Trunc;
3281 libCall = spv::GLSLstd450Round;
3284 libCall = spv::GLSLstd450RoundEven;
3287 libCall = spv::GLSLstd450Ceil;
3290 libCall = spv::GLSLstd450Fract;
3294 unaryOp = spv::OpIsNan;
3297 unaryOp = spv::OpIsInf;
3300 unaryOp = spv::OpIsFinite;
3311 unaryOp = spv::OpBitcast;
3315 libCall = spv::GLSLstd450PackSnorm2x16;
3318 libCall = spv::GLSLstd450UnpackSnorm2x16;
3321 libCall = spv::GLSLstd450PackUnorm2x16;
3324 libCall = spv::GLSLstd450UnpackUnorm2x16;
3327 libCall = spv::GLSLstd450PackHalf2x16;
3330 libCall = spv::GLSLstd450UnpackHalf2x16;
3333 libCall = spv::GLSLstd450PackSnorm4x8;
3336 libCall = spv::GLSLstd450UnpackSnorm4x8;
3339 libCall = spv::GLSLstd450PackUnorm4x8;
3342 libCall = spv::GLSLstd450UnpackUnorm4x8;
3345 libCall = spv::GLSLstd450PackDouble2x32;
3348 libCall = spv::GLSLstd450UnpackDouble2x32;
3356 libCall = spv::GLSLstd450Bad; // TODO: This is a placeholder.
3360 unaryOp = spv::OpDPdx;
3363 unaryOp = spv::OpDPdy;
3366 unaryOp = spv::OpFwidth;
3369 builder.addCapability(spv::CapabilityDerivativeControl);
3370 unaryOp = spv::OpDPdxFine;
3373 builder.addCapability(spv::CapabilityDerivativeControl);
3374 unaryOp = spv::OpDPdyFine;
3377 builder.addCapability(spv::CapabilityDerivativeControl);
3378 unaryOp = spv::OpFwidthFine;
3381 builder.addCapability(spv::CapabilityDerivativeControl);
3382 unaryOp = spv::OpDPdxCoarse;
3385 builder.addCapability(spv::CapabilityDerivativeControl);
3386 unaryOp = spv::OpDPdyCoarse;
3389 builder.addCapability(spv::CapabilityDerivativeControl);
3390 unaryOp = spv::OpFwidthCoarse;
3393 builder.addCapability(spv::CapabilityInterpolationFunction);
3394 libCall = spv::GLSLstd450InterpolateAtCentroid;
3397 unaryOp = spv::OpAny;
3400 unaryOp = spv::OpAll;
3405 libCall = spv::GLSLstd450FAbs;
3407 libCall = spv::GLSLstd450SAbs;
3411 libCall = spv::GLSLstd450FSign;
3413 libCall = spv::GLSLstd450SSign;
3421 std::vector<spv::Id> operands;
3427 unaryOp = spv::OpBitReverse;
3430 unaryOp = spv::OpBitCount;
3433 libCall = spv::GLSLstd450FindILsb;
3437 libCall = spv::GLSLstd450FindUMsb;
3439 libCall = spv::GLSLstd450FindSMsb;
3445 libCall = spv::GLSLstd450Bad;
3457 spv::Id id;
3459 std::vector<spv::Id> args;
3471 spv::Id TGlslangToSpvTraverser::createUnaryMatrixOperation(spv::Op op, spv::Decoration precision, spv::Decoration noContraction, spv::Id typeId, spv::Id operand, glslang::TBasicType /* typeProxy */)
3483 spv::Id srcVecType = builder.makeVectorType(builder.getScalarTypeId(builder.getTypeId(operand)), numRows);
3484 spv::Id destVecType = builder.makeVectorType(builder.getScalarTypeId(typeId), numRows);
3485 std::vector<spv::Id> results;
3491 spv::Id srcVec = builder.createCompositeExtract(operand, srcVecType, indexes);
3492 spv::Id destVec = builder.createUnaryOp(op, destVecType, srcVec);
3501 spv::Id TGlslangToSpvTraverser::createConversion(glslang::TOperator op, spv::Decoration precision, spv::Decoration noContraction, spv::Id destType, spv::Id operand, glslang::TBasicType typeProxy)
3503 spv::Op convOp = spv::OpNop;
3504 spv::Id zero = 0;
3505 spv::Id one = 0;
3506 spv::Id type = 0;
3518 return builder.createBinOp(spv::OpINotEqual, destType, operand, zero);
3523 return builder.createBinOp(spv::OpFOrdNotEqual, destType, operand, zero);
3528 return builder.createBinOp(spv::OpFOrdNotEqual, destType, operand, zero);
3531 convOp = spv::OpSelect;
3536 convOp = spv::OpSelect;
3544 convOp = spv::OpSelect;
3550 convOp = spv::OpSelect;
3557 convOp = spv::OpConvertSToF;
3564 convOp = spv::OpConvertUToF;
3569 convOp = spv::OpFConvert;
3578 convOp = spv::OpConvertFToS;
3592 return builder.createBinOp(spv::OpIAdd, destType, operand, zero);
3595 convOp = spv::OpBitcast;
3602 convOp = spv::OpConvertFToU;
3607 convOp = spv::OpSConvert;
3612 convOp = spv::OpUConvert;
3622 convOp = spv::OpSConvert;
3626 convOp = spv::OpSConvert;
3630 convOp = spv::OpUConvert;
3634 convOp = spv::OpUConvert;
3654 return builder.createBinOp(spv::OpIAdd, destType, operand, zero);
3657 convOp = spv::OpBitcast;
3663 spv::Id result = 0;
3664 if (convOp == spv::OpNop)
3667 if (convOp == spv::OpSelect) {
3677 spv::Id TGlslangToSpvTraverser::makeSmearedConstant(spv::Id constant, int vectorSize)
3682 spv::Id vectorTypeId = builder.makeVectorType(builder.getTypeId(constant), vectorSize);
3683 std::vector<spv::Id> components;
3689 // For glslang ops that map to SPV atomic opCodes
3690 spv::Id TGlslangToSpvTraverser::createAtomicOperation(glslang::TOperator op, spv::Decoration /*precision*/, spv::Id typeId, std::vector<spv::Id>& operands, glslang::TBasicType typeProxy)
3692 spv::Op opCode = spv::OpNop;
3697 opCode = spv::OpAtomicIAdd;
3701 opCode = typeProxy == glslang::EbtUint ? spv::OpAtomicUMin : spv::OpAtomicSMin;
3705 opCode = typeProxy == glslang::EbtUint ? spv::OpAtomicUMax : spv::OpAtomicSMax;
3709 opCode = spv::OpAtomicAnd;
3713 opCode = spv::OpAtomicOr;
3717 opCode = spv::OpAtomicXor;
3721 opCode = spv::OpAtomicExchange;
3725 opCode = spv::OpAtomicCompareExchange;
3728 opCode = spv::OpAtomicIIncrement;
3731 opCode = spv::OpAtomicIDecrement;
3734 opCode = spv::OpAtomicLoad;
3742 // - mapping from glslang -> SPV
3743 // - there are extra SPV operands with no glslang source
3746 std::vector<spv::Id> spvAtomicOperands; // hold the spv operands
3749 spvAtomicOperands.push_back(builder.makeUintConstant(spv::ScopeDevice)); // TBD: what is the correct scope?
3750 spvAtomicOperands.push_back(builder.makeUintConstant(spv::MemorySemanticsMaskNone)); // TBD: what are the correct memory semantics?
3751 if (opCode == spv::OpAtomicCompareExchange) {
3754 spvAtomicOperands.push_back(builder.makeUintConstant(spv::MemorySemanticsMaskNone));
3768 spv::Id TGlslangToSpvTraverser::createInvocationsOperation(glslang::TOperator op, spv::Id typeId, spv::Id operand)
3770 builder.addCapability(spv::CapabilityGroups);
3772 std::vector<spv::Id> operands;
3773 operands.push_back(builder.makeUintConstant(spv::ScopeSubgroup));
3779 return builder.createOp(op == glslang::EOpAnyInvocation ? spv::OpGroupAny : spv::OpGroupAll, typeId, operands);
3783 spv::Id groupAll = builder.createOp(spv::OpGroupAll, typeId, operands);
3784 spv::Id groupAny = builder.createOp(spv::OpGroupAny, typeId, operands);
3786 return builder.createBinOp(spv::OpLogicalOr, typeId, groupAll,
3787 builder.createUnaryOp(spv::OpLogicalNot, typeId, groupAny));
3791 return spv::NoResult;
3795 spv::Id TGlslangToSpvTraverser::createMiscOperation(glslang::TOperator op, spv::Decoration precision, spv::Id typeId, std::vector<spv::Id>& operands, glslang::TBasicType typeProxy)
3800 spv::Op opCode = spv::OpNop;
3803 spv::Id typeId0 = 0;
3806 spv::Id frexpIntType = 0;
3811 libCall = spv::GLSLstd450FMin;
3813 libCall = spv::GLSLstd450UMin;
3815 libCall = spv::GLSLstd450SMin;
3819 libCall = spv::GLSLstd450Modf;
3823 libCall = spv::GLSLstd450FMax;
3825 libCall = spv::GLSLstd450UMax;
3827 libCall = spv::GLSLstd450SMax;
3831 libCall = spv::GLSLstd450Pow;
3834 opCode = spv::OpDot;
3837 libCall = spv::GLSLstd450Atan2;
3842 libCall = spv::GLSLstd450FClamp;
3844 libCall = spv::GLSLstd450UClamp;
3846 libCall = spv::GLSLstd450SClamp;
3853 libCall = spv::GLSLstd450FMix;
3855 opCode = spv::OpSelect;
3861 libCall = spv::GLSLstd450Step;
3865 libCall = spv::GLSLstd450SmoothStep;
3871 libCall = spv::GLSLstd450Distance;
3874 libCall = spv::GLSLstd450Cross;
3877 libCall = spv::GLSLstd450FaceForward;
3880 libCall = spv::GLSLstd450Reflect;
3883 libCall = spv::GLSLstd450Refract;
3886 builder.addCapability(spv::CapabilityInterpolationFunction);
3887 libCall = spv::GLSLstd450InterpolateAtSample;
3890 builder.addCapability(spv::CapabilityInterpolationFunction);
3891 libCall = spv::GLSLstd450InterpolateAtOffset;
3894 opCode = spv::OpIAddCarry;
3899 opCode = spv::OpISubBorrow;
3904 opCode = spv::OpUMulExtended;
3909 opCode = spv::OpSMulExtended;
3915 opCode = spv::OpBitFieldUExtract;
3917 opCode = spv::OpBitFieldSExtract;
3920 opCode = spv::OpBitFieldInsert;
3924 libCall = spv::GLSLstd450Fma;
3927 libCall = spv::GLSLstd450FrexpStruct;
3936 libCall = spv::GLSLstd450Ldexp;
3941 libCall = spv::GLSLstd450Bad;
3948 spv::Id id = 0;
3953 std::vector<spv::Id> callArguments(operands.begin(), operands.begin() + consumedOperands);
4001 spv::Id TGlslangToSpvTraverser::createNoArgOperation(glslang::TOperator op)
4007 builder.createNoResultOp(spv::OpEmitVertex);
4010 builder.createNoResultOp(spv::OpEndPrimitive);
4013 builder.createControlBarrier(spv::ScopeDevice, spv::ScopeDevice, spv::MemorySemanticsMaskNone);
4016 builder.createMemoryBarrier(spv::ScopeDevice, spv::MemorySemanticsAllMemory);
4019 spv::ScopeDevice, spv::MemorySemanticsAtomicCounterMemoryMask);
4022 builder.createMemoryBarrier(spv::ScopeDevice, spv::MemorySemanticsUniformMemoryMask);
4025 builder.createMemoryBarrier(spv::ScopeDevice, spv::MemorySemanticsImageMemoryMask);
4028 builder.createMemoryBarrier(spv::ScopeDevice, spv::MemorySemanticsWorkgroupMemoryMask);
4031 builder.createMemoryBarrier(spv::ScopeDevice, spv::MemorySemanticsCrossWorkgroupMemoryMask);
4035 builder.createControlBarrier(spv::ScopeDevice, spv::ScopeDevice, spv::MemorySemanticsAllMemory);
4039 builder.createControlBarrier(spv::ScopeDevice, spv::ScopeDevice, spv::MemorySemanticsCrossWorkgroupMemoryMask);
4042 builder.createMemoryBarrier(spv::ScopeWorkgroup, spv::MemorySemanticsWorkgroupMemoryMask);
4046 builder.createControlBarrier(spv::ScopeWorkgroup, spv::ScopeWorkgroup, spv::MemorySemanticsWorkgroupMemoryMask);
4054 spv::Id TGlslangToSpvTraverser::getSymbolId(const glslang::TIntermSymbol* symbol)
4057 spv::Id id;
4072 addDecoration(id, spv::DecorationSpecId, symbol->getType().getQualifier().layoutSpecConstantId);
4074 builder.addDecoration(id, spv::DecorationIndex, symbol->getQualifier().layoutIndex);
4076 builder.addDecoration(id, spv::DecorationComponent, symbol->getQualifier().layoutComponent);
4078 builder.addCapability(spv::CapabilityTransformFeedback);
4080 builder.addDecoration(id, spv::DecorationXfbStride, symbol->getQualifier().layoutXfbStride);
4082 builder.addDecoration(id, spv::DecorationXfbBuffer, symbol->getQualifier().layoutXfbBuffer);
4084 builder.addDecoration(id, spv::DecorationOffset, symbol->getQualifier().layoutXfbOffset);
4088 builder.addDecoration(id, spv::DecorationOffset, symbol->getQualifier().layoutOffset);
4092 builder.addDecoration(id, spv::DecorationLocation, symbol->getQualifier().layoutLocation);
4095 builder.addCapability(spv::CapabilityGeometryStreams);
4096 builder.addDecoration(id, spv::DecorationStream, symbol->getQualifier().layoutStream);
4099 builder.addDecoration(id, spv::DecorationDescriptorSet, symbol->getQualifier().layoutSet);
4102 builder.addDecoration(id, spv::DecorationDescriptorSet, 0);
4105 builder.addDecoration(id, spv::DecorationBinding, symbol->getQualifier().layoutBinding);
4107 builder.addDecoration(id, spv::DecorationInputAttachmentIndex, symbol->getQualifier().layoutAttachment);
4109 builder.addCapability(spv::CapabilityTransformFeedback);
4111 builder.addDecoration(id, spv::DecorationXfbStride, symbol->getQualifier().layoutXfbStride);
4113 builder.addDecoration(id, spv::DecorationXfbBuffer, symbol->getQualifier().layoutXfbBuffer);
4117 std::vector<spv::Decoration> memory;
4124 spv::BuiltIn builtIn = TranslateBuiltInDecoration(symbol->getQualifier().builtIn, false);
4125 if (builtIn != spv::BuiltInMax)
4126 addDecoration(id, spv::DecorationBuiltIn, (int)builtIn);
4132 void TGlslangToSpvTraverser::addDecoration(spv::Id id, spv::Decoration dec)
4134 if (dec != spv::DecorationMax)
4139 void TGlslangToSpvTraverser::addDecoration(spv::Id id, spv::Decoration dec, unsigned value)
4141 if (dec != spv::DecorationMax)
4146 void TGlslangToSpvTraverser::addMemberDecoration(spv::Id id, int member, spv::Decoration dec)
4148 if (dec != spv::DecorationMax)
4153 void TGlslangToSpvTraverser::addMemberDecoration(spv::Id id, int member, spv::Decoration dec, unsigned value)
4155 if (dec != spv::DecorationMax)
4169 spv::Id TGlslangToSpvTraverser::createSpvConstant(const glslang::TIntermTyped& node)
4187 std::vector<spv::Id> dimConstId;
4192 addDecoration(dimConstId.back(), spv::DecorationSpecId, glslangIntermediate->getLocalSizeSpecId(dim));
4216 return spv::NoResult;
4225 spv::Id TGlslangToSpvTraverser::createSpvConstantFromConstUnionArray(const glslang::TType& glslangType, const glslang::TConstUnionArray& consts, int& nextConst, bool specConstant)
4228 std::vector<spv::Id> spvConsts;
4231 spv::Id typeId = convertGlslangToSpvType(glslangType);
4279 spv::Id scalar = 0;
4397 spv::Id TGlslangToSpvTraverser::createShortCircuit(glslang::TOperator op, glslang::TIntermTyped& left, glslang::TIntermTyped& right)
4399 spv::Id boolTypeId = builder.makeBoolType();
4404 spv::Id leftId = accessChainLoad(left.getType());
4407 std::vector<spv::Id> phiOperands;
4419 leftId = builder.createUnaryOp(spv::OpLogicalNot, boolTypeId, leftId);
4422 spv::Builder::If ifBuilder(leftId, builder);
4427 spv::Id rightId = accessChainLoad(right.getType());
4437 return builder.createOp(spv::OpPhi, boolTypeId, phiOperands);
4448 snprintf(buf, bufSize, "0x%08x, Revision %d", spv::Version, spv::Revision);
4490 spv::SpvBuildLogger logger;
4494 void GlslangToSpv(const glslang::TIntermediate& intermediate, std::vector<unsigned int>& spirv, spv::SpvBuildLogger* logger)
