1 //===-- SPIRVBaseInfo.cpp -  Top level definitions for SPIRV ----*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains small standalone helper functions and enum definitions for
10 // the SPIRV target useful for the compiler back-end and the MC libraries.
11 // As such, it deliberately does not include references to LLVM core
12 // code gen types, passes, etc..
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #include "SPIRVBaseInfo.h"
17 #include "llvm/Support/ErrorHandling.h"
18 
19 namespace llvm {
20 namespace SPIRV {
21 
22 #define CASE(CLASS, ATTR)                                                      \
23   case CLASS::ATTR:                                                            \
24     return #ATTR;
25 #define CASE_SUF(CLASS, SF, ATTR)                                              \
26   case CLASS::SF##_##ATTR:                                                     \
27     return #ATTR;
28 
29 // Implement getEnumName(Enum e) helper functions.
30 // TODO: re-implement all the functions using TableGen.
31 StringRef getCapabilityName(Capability e) {
32   switch (e) {
33     CASE(Capability, Matrix)
34     CASE(Capability, Shader)
35     CASE(Capability, Geometry)
36     CASE(Capability, Tessellation)
37     CASE(Capability, Addresses)
38     CASE(Capability, Linkage)
39     CASE(Capability, Kernel)
40     CASE(Capability, Vector16)
41     CASE(Capability, Float16Buffer)
42     CASE(Capability, Float16)
43     CASE(Capability, Float64)
44     CASE(Capability, Int64)
45     CASE(Capability, Int64Atomics)
46     CASE(Capability, ImageBasic)
47     CASE(Capability, ImageReadWrite)
48     CASE(Capability, ImageMipmap)
49     CASE(Capability, Pipes)
50     CASE(Capability, Groups)
51     CASE(Capability, DeviceEnqueue)
52     CASE(Capability, LiteralSampler)
53     CASE(Capability, AtomicStorage)
54     CASE(Capability, Int16)
55     CASE(Capability, TessellationPointSize)
56     CASE(Capability, GeometryPointSize)
57     CASE(Capability, ImageGatherExtended)
58     CASE(Capability, StorageImageMultisample)
59     CASE(Capability, UniformBufferArrayDynamicIndexing)
60     CASE(Capability, SampledImageArrayDymnamicIndexing)
61     CASE(Capability, ClipDistance)
62     CASE(Capability, CullDistance)
63     CASE(Capability, ImageCubeArray)
64     CASE(Capability, SampleRateShading)
65     CASE(Capability, ImageRect)
66     CASE(Capability, SampledRect)
67     CASE(Capability, GenericPointer)
68     CASE(Capability, Int8)
69     CASE(Capability, InputAttachment)
70     CASE(Capability, SparseResidency)
71     CASE(Capability, MinLod)
72     CASE(Capability, Sampled1D)
73     CASE(Capability, Image1D)
74     CASE(Capability, SampledCubeArray)
75     CASE(Capability, SampledBuffer)
76     CASE(Capability, ImageBuffer)
77     CASE(Capability, ImageMSArray)
78     CASE(Capability, StorageImageExtendedFormats)
79     CASE(Capability, ImageQuery)
80     CASE(Capability, DerivativeControl)
81     CASE(Capability, InterpolationFunction)
82     CASE(Capability, TransformFeedback)
83     CASE(Capability, GeometryStreams)
84     CASE(Capability, StorageImageReadWithoutFormat)
85     CASE(Capability, StorageImageWriteWithoutFormat)
86     CASE(Capability, MultiViewport)
87     CASE(Capability, SubgroupDispatch)
88     CASE(Capability, NamedBarrier)
89     CASE(Capability, PipeStorage)
90     CASE(Capability, GroupNonUniform)
91     CASE(Capability, GroupNonUniformVote)
92     CASE(Capability, GroupNonUniformArithmetic)
93     CASE(Capability, GroupNonUniformBallot)
94     CASE(Capability, GroupNonUniformShuffle)
95     CASE(Capability, GroupNonUniformShuffleRelative)
96     CASE(Capability, GroupNonUniformClustered)
97     CASE(Capability, GroupNonUniformQuad)
98     CASE(Capability, SubgroupBallotKHR)
99     CASE(Capability, DrawParameters)
100     CASE(Capability, SubgroupVoteKHR)
101     CASE(Capability, StorageBuffer16BitAccess)
102     CASE(Capability, StorageUniform16)
103     CASE(Capability, StoragePushConstant16)
104     CASE(Capability, StorageInputOutput16)
105     CASE(Capability, DeviceGroup)
106     CASE(Capability, MultiView)
107     CASE(Capability, VariablePointersStorageBuffer)
108     CASE(Capability, VariablePointers)
109     CASE(Capability, AtomicStorageOps)
110     CASE(Capability, SampleMaskPostDepthCoverage)
111     CASE(Capability, StorageBuffer8BitAccess)
112     CASE(Capability, UniformAndStorageBuffer8BitAccess)
113     CASE(Capability, StoragePushConstant8)
114     CASE(Capability, DenormPreserve)
115     CASE(Capability, DenormFlushToZero)
116     CASE(Capability, SignedZeroInfNanPreserve)
117     CASE(Capability, RoundingModeRTE)
118     CASE(Capability, RoundingModeRTZ)
119     CASE(Capability, Float16ImageAMD)
120     CASE(Capability, ImageGatherBiasLodAMD)
121     CASE(Capability, FragmentMaskAMD)
122     CASE(Capability, StencilExportEXT)
123     CASE(Capability, ImageReadWriteLodAMD)
124     CASE(Capability, SampleMaskOverrideCoverageNV)
125     CASE(Capability, GeometryShaderPassthroughNV)
126     CASE(Capability, ShaderViewportIndexLayerEXT)
127     CASE(Capability, ShaderViewportMaskNV)
128     CASE(Capability, ShaderStereoViewNV)
129     CASE(Capability, PerViewAttributesNV)
130     CASE(Capability, FragmentFullyCoveredEXT)
131     CASE(Capability, MeshShadingNV)
132     CASE(Capability, ShaderNonUniformEXT)
133     CASE(Capability, RuntimeDescriptorArrayEXT)
134     CASE(Capability, InputAttachmentArrayDynamicIndexingEXT)
135     CASE(Capability, UniformTexelBufferArrayDynamicIndexingEXT)
136     CASE(Capability, StorageTexelBufferArrayDynamicIndexingEXT)
137     CASE(Capability, UniformBufferArrayNonUniformIndexingEXT)
138     CASE(Capability, SampledImageArrayNonUniformIndexingEXT)
139     CASE(Capability, StorageBufferArrayNonUniformIndexingEXT)
140     CASE(Capability, StorageImageArrayNonUniformIndexingEXT)
141     CASE(Capability, InputAttachmentArrayNonUniformIndexingEXT)
142     CASE(Capability, UniformTexelBufferArrayNonUniformIndexingEXT)
143     CASE(Capability, StorageTexelBufferArrayNonUniformIndexingEXT)
144     CASE(Capability, RayTracingNV)
145     CASE(Capability, SubgroupShuffleINTEL)
146     CASE(Capability, SubgroupBufferBlockIOINTEL)
147     CASE(Capability, SubgroupImageBlockIOINTEL)
148     CASE(Capability, SubgroupImageMediaBlockIOINTEL)
149     CASE(Capability, SubgroupAvcMotionEstimationINTEL)
150     CASE(Capability, SubgroupAvcMotionEstimationIntraINTEL)
151     CASE(Capability, SubgroupAvcMotionEstimationChromaINTEL)
152     CASE(Capability, GroupNonUniformPartitionedNV)
153     CASE(Capability, VulkanMemoryModelKHR)
154     CASE(Capability, VulkanMemoryModelDeviceScopeKHR)
155     CASE(Capability, ImageFootprintNV)
156     CASE(Capability, FragmentBarycentricNV)
157     CASE(Capability, ComputeDerivativeGroupQuadsNV)
158     CASE(Capability, ComputeDerivativeGroupLinearNV)
159     CASE(Capability, FragmentDensityEXT)
160     CASE(Capability, PhysicalStorageBufferAddressesEXT)
161     CASE(Capability, CooperativeMatrixNV)
162   default:
163     break;
164   }
165   llvm_unreachable("Unexpected operand");
166 }
167 
168 StringRef getSourceLanguageName(SourceLanguage e) {
169   switch (e) {
170     CASE(SourceLanguage, Unknown)
171     CASE(SourceLanguage, ESSL)
172     CASE(SourceLanguage, GLSL)
173     CASE(SourceLanguage, OpenCL_C)
174     CASE(SourceLanguage, OpenCL_CPP)
175     CASE(SourceLanguage, HLSL)
176   default:
177     break;
178   }
179   llvm_unreachable("Unexpected operand");
180 }
181 
182 StringRef getExecutionModelName(ExecutionModel e) {
183   switch (e) {
184     CASE(ExecutionModel, Vertex)
185     CASE(ExecutionModel, TessellationControl)
186     CASE(ExecutionModel, TessellationEvaluation)
187     CASE(ExecutionModel, Geometry)
188     CASE(ExecutionModel, Fragment)
189     CASE(ExecutionModel, GLCompute)
190     CASE(ExecutionModel, Kernel)
191     CASE(ExecutionModel, TaskNV)
192     CASE(ExecutionModel, MeshNV)
193     CASE(ExecutionModel, RayGenerationNV)
194     CASE(ExecutionModel, IntersectionNV)
195     CASE(ExecutionModel, AnyHitNV)
196     CASE(ExecutionModel, ClosestHitNV)
197     CASE(ExecutionModel, MissNV)
198     CASE(ExecutionModel, CallableNV)
199   default:
200     break;
201   }
202   llvm_unreachable("Unexpected operand");
203 }
204 
205 StringRef getAddressingModelName(AddressingModel e) {
206   switch (e) {
207     CASE(AddressingModel, Logical)
208     CASE(AddressingModel, Physical32)
209     CASE(AddressingModel, Physical64)
210     CASE(AddressingModel, PhysicalStorageBuffer64EXT)
211   default:
212     break;
213   }
214   llvm_unreachable("Unexpected operand");
215 }
216 
217 StringRef getMemoryModelName(MemoryModel e) {
218   switch (e) {
219     CASE(MemoryModel, Simple)
220     CASE(MemoryModel, GLSL450)
221     CASE(MemoryModel, OpenCL)
222     CASE(MemoryModel, VulkanKHR)
223   default:
224     break;
225   }
226   llvm_unreachable("Unexpected operand");
227 }
228 
229 StringRef getExecutionModeName(ExecutionMode e) {
230   switch (e) {
231     CASE(ExecutionMode, Invocations)
232     CASE(ExecutionMode, SpacingEqual)
233     CASE(ExecutionMode, SpacingFractionalEven)
234     CASE(ExecutionMode, SpacingFractionalOdd)
235     CASE(ExecutionMode, VertexOrderCw)
236     CASE(ExecutionMode, VertexOrderCcw)
237     CASE(ExecutionMode, PixelCenterInteger)
238     CASE(ExecutionMode, OriginUpperLeft)
239     CASE(ExecutionMode, OriginLowerLeft)
240     CASE(ExecutionMode, EarlyFragmentTests)
241     CASE(ExecutionMode, PointMode)
242     CASE(ExecutionMode, Xfb)
243     CASE(ExecutionMode, DepthReplacing)
244     CASE(ExecutionMode, DepthGreater)
245     CASE(ExecutionMode, DepthLess)
246     CASE(ExecutionMode, DepthUnchanged)
247     CASE(ExecutionMode, LocalSize)
248     CASE(ExecutionMode, LocalSizeHint)
249     CASE(ExecutionMode, InputPoints)
250     CASE(ExecutionMode, InputLinesAdjacency)
251     CASE(ExecutionMode, Triangles)
252     CASE(ExecutionMode, InputTrianglesAdjacency)
253     CASE(ExecutionMode, Quads)
254     CASE(ExecutionMode, Isolines)
255     CASE(ExecutionMode, OutputVertices)
256     CASE(ExecutionMode, OutputPoints)
257     CASE(ExecutionMode, OutputLineStrip)
258     CASE(ExecutionMode, OutputTriangleStrip)
259     CASE(ExecutionMode, VecTypeHint)
260     CASE(ExecutionMode, ContractionOff)
261     CASE(ExecutionMode, Initializer)
262     CASE(ExecutionMode, Finalizer)
263     CASE(ExecutionMode, SubgroupSize)
264     CASE(ExecutionMode, SubgroupsPerWorkgroup)
265     CASE(ExecutionMode, SubgroupsPerWorkgroupId)
266     CASE(ExecutionMode, LocalSizeId)
267     CASE(ExecutionMode, LocalSizeHintId)
268     CASE(ExecutionMode, PostDepthCoverage)
269     CASE(ExecutionMode, DenormPreserve)
270     CASE(ExecutionMode, DenormFlushToZero)
271     CASE(ExecutionMode, SignedZeroInfNanPreserve)
272     CASE(ExecutionMode, RoundingModeRTE)
273     CASE(ExecutionMode, RoundingModeRTZ)
274     CASE(ExecutionMode, StencilRefReplacingEXT)
275     CASE(ExecutionMode, OutputLinesNV)
276     CASE(ExecutionMode, DerivativeGroupQuadsNV)
277     CASE(ExecutionMode, DerivativeGroupLinearNV)
278     CASE(ExecutionMode, OutputTrianglesNV)
279   default:
280     break;
281   }
282   llvm_unreachable("Unexpected operand");
283 }
284 
285 StringRef getStorageClassName(StorageClass e) {
286   switch (e) {
287     CASE(StorageClass, UniformConstant)
288     CASE(StorageClass, Input)
289     CASE(StorageClass, Uniform)
290     CASE(StorageClass, Output)
291     CASE(StorageClass, Workgroup)
292     CASE(StorageClass, CrossWorkgroup)
293     CASE(StorageClass, Private)
294     CASE(StorageClass, Function)
295     CASE(StorageClass, Generic)
296     CASE(StorageClass, PushConstant)
297     CASE(StorageClass, AtomicCounter)
298     CASE(StorageClass, Image)
299     CASE(StorageClass, StorageBuffer)
300     CASE(StorageClass, CallableDataNV)
301     CASE(StorageClass, IncomingCallableDataNV)
302     CASE(StorageClass, RayPayloadNV)
303     CASE(StorageClass, HitAttributeNV)
304     CASE(StorageClass, IncomingRayPayloadNV)
305     CASE(StorageClass, ShaderRecordBufferNV)
306     CASE(StorageClass, PhysicalStorageBufferEXT)
307   default:
308     break;
309   }
310   llvm_unreachable("Unexpected operand");
311 }
312 
313 StringRef getDimName(Dim dim) {
314   switch (dim) {
315     CASE_SUF(Dim, DIM, 1D)
316     CASE_SUF(Dim, DIM, 2D)
317     CASE_SUF(Dim, DIM, 3D)
318     CASE_SUF(Dim, DIM, Cube)
319     CASE_SUF(Dim, DIM, Rect)
320     CASE_SUF(Dim, DIM, Buffer)
321     CASE_SUF(Dim, DIM, SubpassData)
322   default:
323     break;
324   }
325   llvm_unreachable("Unexpected operand");
326 }
327 
328 StringRef getSamplerAddressingModeName(SamplerAddressingMode e) {
329   switch (e) {
330     CASE(SamplerAddressingMode, None)
331     CASE(SamplerAddressingMode, ClampToEdge)
332     CASE(SamplerAddressingMode, Clamp)
333     CASE(SamplerAddressingMode, Repeat)
334     CASE(SamplerAddressingMode, RepeatMirrored)
335   default:
336     break;
337   }
338   llvm_unreachable("Unexpected operand");
339 }
340 
341 StringRef getSamplerFilterModeName(SamplerFilterMode e) {
342   switch (e) {
343     CASE(SamplerFilterMode, Nearest)
344     CASE(SamplerFilterMode, Linear)
345   default:
346     break;
347   }
348   llvm_unreachable("Unexpected operand");
349 }
350 
351 StringRef getImageFormatName(ImageFormat e) {
352   switch (e) {
353     CASE(ImageFormat, Unknown)
354     CASE(ImageFormat, Rgba32f)
355     CASE(ImageFormat, Rgba16f)
356     CASE(ImageFormat, R32f)
357     CASE(ImageFormat, Rgba8)
358     CASE(ImageFormat, Rgba8Snorm)
359     CASE(ImageFormat, Rg32f)
360     CASE(ImageFormat, Rg16f)
361     CASE(ImageFormat, R11fG11fB10f)
362     CASE(ImageFormat, R16f)
363     CASE(ImageFormat, Rgba16)
364     CASE(ImageFormat, Rgb10A2)
365     CASE(ImageFormat, Rg16)
366     CASE(ImageFormat, Rg8)
367     CASE(ImageFormat, R16)
368     CASE(ImageFormat, R8)
369     CASE(ImageFormat, Rgba16Snorm)
370     CASE(ImageFormat, Rg16Snorm)
371     CASE(ImageFormat, Rg8Snorm)
372     CASE(ImageFormat, R16Snorm)
373     CASE(ImageFormat, R8Snorm)
374     CASE(ImageFormat, Rgba32i)
375     CASE(ImageFormat, Rgba16i)
376     CASE(ImageFormat, Rgba8i)
377     CASE(ImageFormat, R32i)
378     CASE(ImageFormat, Rg32i)
379     CASE(ImageFormat, Rg16i)
380     CASE(ImageFormat, Rg8i)
381     CASE(ImageFormat, R16i)
382     CASE(ImageFormat, R8i)
383     CASE(ImageFormat, Rgba32ui)
384     CASE(ImageFormat, Rgba16ui)
385     CASE(ImageFormat, Rgba8ui)
386     CASE(ImageFormat, R32ui)
387     CASE(ImageFormat, Rgb10a2ui)
388     CASE(ImageFormat, Rg32ui)
389     CASE(ImageFormat, Rg16ui)
390     CASE(ImageFormat, Rg8ui)
391     CASE(ImageFormat, R16ui)
392     CASE(ImageFormat, R8ui)
393   default:
394     break;
395   }
396   llvm_unreachable("Unexpected operand");
397 }
398 
399 StringRef getImageChannelOrderName(ImageChannelOrder e) {
400   switch (e) {
401     CASE(ImageChannelOrder, R)
402     CASE(ImageChannelOrder, A)
403     CASE(ImageChannelOrder, RG)
404     CASE(ImageChannelOrder, RA)
405     CASE(ImageChannelOrder, RGB)
406     CASE(ImageChannelOrder, RGBA)
407     CASE(ImageChannelOrder, BGRA)
408     CASE(ImageChannelOrder, ARGB)
409     CASE(ImageChannelOrder, Intensity)
410     CASE(ImageChannelOrder, Luminance)
411     CASE(ImageChannelOrder, Rx)
412     CASE(ImageChannelOrder, RGx)
413     CASE(ImageChannelOrder, RGBx)
414     CASE(ImageChannelOrder, Depth)
415     CASE(ImageChannelOrder, DepthStencil)
416     CASE(ImageChannelOrder, sRGB)
417     CASE(ImageChannelOrder, sRGBx)
418     CASE(ImageChannelOrder, sRGBA)
419     CASE(ImageChannelOrder, sBGRA)
420     CASE(ImageChannelOrder, ABGR)
421   default:
422     break;
423   }
424   llvm_unreachable("Unexpected operand");
425 }
426 
427 StringRef getImageChannelDataTypeName(ImageChannelDataType e) {
428   switch (e) {
429     CASE(ImageChannelDataType, SnormInt8)
430     CASE(ImageChannelDataType, SnormInt16)
431     CASE(ImageChannelDataType, UnormInt8)
432     CASE(ImageChannelDataType, UnormInt16)
433     CASE(ImageChannelDataType, UnormShort565)
434     CASE(ImageChannelDataType, UnormShort555)
435     CASE(ImageChannelDataType, UnormInt101010)
436     CASE(ImageChannelDataType, SignedInt8)
437     CASE(ImageChannelDataType, SignedInt16)
438     CASE(ImageChannelDataType, SignedInt32)
439     CASE(ImageChannelDataType, UnsignedInt8)
440     CASE(ImageChannelDataType, UnsignedInt16)
441     CASE(ImageChannelDataType, UnsigendInt32)
442     CASE(ImageChannelDataType, HalfFloat)
443     CASE(ImageChannelDataType, Float)
444     CASE(ImageChannelDataType, UnormInt24)
445     CASE(ImageChannelDataType, UnormInt101010_2)
446   default:
447     break;
448   }
449   llvm_unreachable("Unexpected operand");
450 }
451 
452 std::string getImageOperandName(uint32_t e) {
453   std::string nameString = "";
454   std::string sep = "";
455   if (e == static_cast<uint32_t>(ImageOperand::None))
456     return "None";
457   if (e == static_cast<uint32_t>(ImageOperand::Bias))
458     return "Bias";
459   if (e & static_cast<uint32_t>(ImageOperand::Bias)) {
460     nameString += sep + "Bias";
461     sep = "|";
462   }
463   if (e == static_cast<uint32_t>(ImageOperand::Lod))
464     return "Lod";
465   if (e & static_cast<uint32_t>(ImageOperand::Lod)) {
466     nameString += sep + "Lod";
467     sep = "|";
468   }
469   if (e == static_cast<uint32_t>(ImageOperand::Grad))
470     return "Grad";
471   if (e & static_cast<uint32_t>(ImageOperand::Grad)) {
472     nameString += sep + "Grad";
473     sep = "|";
474   }
475   if (e == static_cast<uint32_t>(ImageOperand::ConstOffset))
476     return "ConstOffset";
477   if (e & static_cast<uint32_t>(ImageOperand::ConstOffset)) {
478     nameString += sep + "ConstOffset";
479     sep = "|";
480   }
481   if (e == static_cast<uint32_t>(ImageOperand::Offset))
482     return "Offset";
483   if (e & static_cast<uint32_t>(ImageOperand::Offset)) {
484     nameString += sep + "Offset";
485     sep = "|";
486   }
487   if (e == static_cast<uint32_t>(ImageOperand::ConstOffsets))
488     return "ConstOffsets";
489   if (e & static_cast<uint32_t>(ImageOperand::ConstOffsets)) {
490     nameString += sep + "ConstOffsets";
491     sep = "|";
492   }
493   if (e == static_cast<uint32_t>(ImageOperand::Sample))
494     return "Sample";
495   if (e & static_cast<uint32_t>(ImageOperand::Sample)) {
496     nameString += sep + "Sample";
497     sep = "|";
498   }
499   if (e == static_cast<uint32_t>(ImageOperand::MinLod))
500     return "MinLod";
501   if (e & static_cast<uint32_t>(ImageOperand::MinLod)) {
502     nameString += sep + "MinLod";
503     sep = "|";
504   }
505   if (e == static_cast<uint32_t>(ImageOperand::MakeTexelAvailableKHR))
506     return "MakeTexelAvailableKHR";
507   if (e & static_cast<uint32_t>(ImageOperand::MakeTexelAvailableKHR)) {
508     nameString += sep + "MakeTexelAvailableKHR";
509     sep = "|";
510   }
511   if (e == static_cast<uint32_t>(ImageOperand::MakeTexelVisibleKHR))
512     return "MakeTexelVisibleKHR";
513   if (e & static_cast<uint32_t>(ImageOperand::MakeTexelVisibleKHR)) {
514     nameString += sep + "MakeTexelVisibleKHR";
515     sep = "|";
516   }
517   if (e == static_cast<uint32_t>(ImageOperand::NonPrivateTexelKHR))
518     return "NonPrivateTexelKHR";
519   if (e & static_cast<uint32_t>(ImageOperand::NonPrivateTexelKHR)) {
520     nameString += sep + "NonPrivateTexelKHR";
521     sep = "|";
522   }
523   if (e == static_cast<uint32_t>(ImageOperand::VolatileTexelKHR))
524     return "VolatileTexelKHR";
525   if (e & static_cast<uint32_t>(ImageOperand::VolatileTexelKHR)) {
526     nameString += sep + "VolatileTexelKHR";
527     sep = "|";
528   }
529   if (e == static_cast<uint32_t>(ImageOperand::SignExtend))
530     return "SignExtend";
531   if (e & static_cast<uint32_t>(ImageOperand::SignExtend)) {
532     nameString += sep + "SignExtend";
533     sep = "|";
534   }
535   if (e == static_cast<uint32_t>(ImageOperand::ZeroExtend))
536     return "ZeroExtend";
537   if (e & static_cast<uint32_t>(ImageOperand::ZeroExtend)) {
538     nameString += sep + "ZeroExtend";
539     sep = "|";
540   };
541   return nameString;
542 }
543 
544 std::string getFPFastMathModeName(uint32_t e) {
545   std::string nameString = "";
546   std::string sep = "";
547   if (e == static_cast<uint32_t>(FPFastMathMode::None))
548     return "None";
549   if (e == static_cast<uint32_t>(FPFastMathMode::NotNaN))
550     return "NotNaN";
551   if (e & static_cast<uint32_t>(FPFastMathMode::NotNaN)) {
552     nameString += sep + "NotNaN";
553     sep = "|";
554   }
555   if (e == static_cast<uint32_t>(FPFastMathMode::NotInf))
556     return "NotInf";
557   if (e & static_cast<uint32_t>(FPFastMathMode::NotInf)) {
558     nameString += sep + "NotInf";
559     sep = "|";
560   }
561   if (e == static_cast<uint32_t>(FPFastMathMode::NSZ))
562     return "NSZ";
563   if (e & static_cast<uint32_t>(FPFastMathMode::NSZ)) {
564     nameString += sep + "NSZ";
565     sep = "|";
566   }
567   if (e == static_cast<uint32_t>(FPFastMathMode::AllowRecip))
568     return "AllowRecip";
569   if (e & static_cast<uint32_t>(FPFastMathMode::AllowRecip)) {
570     nameString += sep + "AllowRecip";
571     sep = "|";
572   }
573   if (e == static_cast<uint32_t>(FPFastMathMode::Fast))
574     return "Fast";
575   if (e & static_cast<uint32_t>(FPFastMathMode::Fast)) {
576     nameString += sep + "Fast";
577     sep = "|";
578   };
579   return nameString;
580 }
581 
582 StringRef getFPRoundingModeName(FPRoundingMode e) {
583   switch (e) {
584     CASE(FPRoundingMode, RTE)
585     CASE(FPRoundingMode, RTZ)
586     CASE(FPRoundingMode, RTP)
587     CASE(FPRoundingMode, RTN)
588   default:
589     break;
590   }
591   llvm_unreachable("Unexpected operand");
592 }
593 
594 StringRef getLinkageTypeName(LinkageType e) {
595   switch (e) {
596     CASE(LinkageType, Export)
597     CASE(LinkageType, Import)
598   default:
599     break;
600   }
601   llvm_unreachable("Unexpected operand");
602 }
603 
604 StringRef getAccessQualifierName(AccessQualifier e) {
605   switch (e) {
606     CASE(AccessQualifier, ReadOnly)
607     CASE(AccessQualifier, WriteOnly)
608     CASE(AccessQualifier, ReadWrite)
609   default:
610     break;
611   }
612   llvm_unreachable("Unexpected operand");
613 }
614 
615 StringRef getFunctionParameterAttributeName(FunctionParameterAttribute e) {
616   switch (e) {
617     CASE(FunctionParameterAttribute, Zext)
618     CASE(FunctionParameterAttribute, Sext)
619     CASE(FunctionParameterAttribute, ByVal)
620     CASE(FunctionParameterAttribute, Sret)
621     CASE(FunctionParameterAttribute, NoAlias)
622     CASE(FunctionParameterAttribute, NoCapture)
623     CASE(FunctionParameterAttribute, NoWrite)
624     CASE(FunctionParameterAttribute, NoReadWrite)
625   default:
626     break;
627   }
628   llvm_unreachable("Unexpected operand");
629 }
630 
631 StringRef getDecorationName(Decoration e) {
632   switch (e) {
633     CASE(Decoration, RelaxedPrecision)
634     CASE(Decoration, SpecId)
635     CASE(Decoration, Block)
636     CASE(Decoration, BufferBlock)
637     CASE(Decoration, RowMajor)
638     CASE(Decoration, ColMajor)
639     CASE(Decoration, ArrayStride)
640     CASE(Decoration, MatrixStride)
641     CASE(Decoration, GLSLShared)
642     CASE(Decoration, GLSLPacked)
643     CASE(Decoration, CPacked)
644     CASE(Decoration, BuiltIn)
645     CASE(Decoration, NoPerspective)
646     CASE(Decoration, Flat)
647     CASE(Decoration, Patch)
648     CASE(Decoration, Centroid)
649     CASE(Decoration, Sample)
650     CASE(Decoration, Invariant)
651     CASE(Decoration, Restrict)
652     CASE(Decoration, Aliased)
653     CASE(Decoration, Volatile)
654     CASE(Decoration, Constant)
655     CASE(Decoration, Coherent)
656     CASE(Decoration, NonWritable)
657     CASE(Decoration, NonReadable)
658     CASE(Decoration, Uniform)
659     CASE(Decoration, UniformId)
660     CASE(Decoration, SaturatedConversion)
661     CASE(Decoration, Stream)
662     CASE(Decoration, Location)
663     CASE(Decoration, Component)
664     CASE(Decoration, Index)
665     CASE(Decoration, Binding)
666     CASE(Decoration, DescriptorSet)
667     CASE(Decoration, Offset)
668     CASE(Decoration, XfbBuffer)
669     CASE(Decoration, XfbStride)
670     CASE(Decoration, FuncParamAttr)
671     CASE(Decoration, FPRoundingMode)
672     CASE(Decoration, FPFastMathMode)
673     CASE(Decoration, LinkageAttributes)
674     CASE(Decoration, NoContraction)
675     CASE(Decoration, InputAttachmentIndex)
676     CASE(Decoration, Alignment)
677     CASE(Decoration, MaxByteOffset)
678     CASE(Decoration, AlignmentId)
679     CASE(Decoration, MaxByteOffsetId)
680     CASE(Decoration, NoSignedWrap)
681     CASE(Decoration, NoUnsignedWrap)
682     CASE(Decoration, ExplicitInterpAMD)
683     CASE(Decoration, OverrideCoverageNV)
684     CASE(Decoration, PassthroughNV)
685     CASE(Decoration, ViewportRelativeNV)
686     CASE(Decoration, SecondaryViewportRelativeNV)
687     CASE(Decoration, PerPrimitiveNV)
688     CASE(Decoration, PerViewNV)
689     CASE(Decoration, PerVertexNV)
690     CASE(Decoration, NonUniformEXT)
691     CASE(Decoration, CountBuffer)
692     CASE(Decoration, UserSemantic)
693     CASE(Decoration, RestrictPointerEXT)
694     CASE(Decoration, AliasedPointerEXT)
695   default:
696     break;
697   }
698   llvm_unreachable("Unexpected operand");
699 }
700 
701 StringRef getBuiltInName(BuiltIn e) {
702   switch (e) {
703     CASE(BuiltIn, Position)
704     CASE(BuiltIn, PointSize)
705     CASE(BuiltIn, ClipDistance)
706     CASE(BuiltIn, CullDistance)
707     CASE(BuiltIn, VertexId)
708     CASE(BuiltIn, InstanceId)
709     CASE(BuiltIn, PrimitiveId)
710     CASE(BuiltIn, InvocationId)
711     CASE(BuiltIn, Layer)
712     CASE(BuiltIn, ViewportIndex)
713     CASE(BuiltIn, TessLevelOuter)
714     CASE(BuiltIn, TessLevelInner)
715     CASE(BuiltIn, TessCoord)
716     CASE(BuiltIn, PatchVertices)
717     CASE(BuiltIn, FragCoord)
718     CASE(BuiltIn, PointCoord)
719     CASE(BuiltIn, FrontFacing)
720     CASE(BuiltIn, SampleId)
721     CASE(BuiltIn, SamplePosition)
722     CASE(BuiltIn, SampleMask)
723     CASE(BuiltIn, FragDepth)
724     CASE(BuiltIn, HelperInvocation)
725     CASE(BuiltIn, NumWorkgroups)
726     CASE(BuiltIn, WorkgroupSize)
727     CASE(BuiltIn, WorkgroupId)
728     CASE(BuiltIn, LocalInvocationId)
729     CASE(BuiltIn, GlobalInvocationId)
730     CASE(BuiltIn, LocalInvocationIndex)
731     CASE(BuiltIn, WorkDim)
732     CASE(BuiltIn, GlobalSize)
733     CASE(BuiltIn, EnqueuedWorkgroupSize)
734     CASE(BuiltIn, GlobalOffset)
735     CASE(BuiltIn, GlobalLinearId)
736     CASE(BuiltIn, SubgroupSize)
737     CASE(BuiltIn, SubgroupMaxSize)
738     CASE(BuiltIn, NumSubgroups)
739     CASE(BuiltIn, NumEnqueuedSubgroups)
740     CASE(BuiltIn, SubgroupId)
741     CASE(BuiltIn, SubgroupLocalInvocationId)
742     CASE(BuiltIn, VertexIndex)
743     CASE(BuiltIn, InstanceIndex)
744     CASE(BuiltIn, SubgroupEqMask)
745     CASE(BuiltIn, SubgroupGeMask)
746     CASE(BuiltIn, SubgroupGtMask)
747     CASE(BuiltIn, SubgroupLeMask)
748     CASE(BuiltIn, SubgroupLtMask)
749     CASE(BuiltIn, BaseVertex)
750     CASE(BuiltIn, BaseInstance)
751     CASE(BuiltIn, DrawIndex)
752     CASE(BuiltIn, DeviceIndex)
753     CASE(BuiltIn, ViewIndex)
754     CASE(BuiltIn, BaryCoordNoPerspAMD)
755     CASE(BuiltIn, BaryCoordNoPerspCentroidAMD)
756     CASE(BuiltIn, BaryCoordNoPerspSampleAMD)
757     CASE(BuiltIn, BaryCoordSmoothAMD)
758     CASE(BuiltIn, BaryCoordSmoothCentroid)
759     CASE(BuiltIn, BaryCoordSmoothSample)
760     CASE(BuiltIn, BaryCoordPullModel)
761     CASE(BuiltIn, FragStencilRefEXT)
762     CASE(BuiltIn, ViewportMaskNV)
763     CASE(BuiltIn, SecondaryPositionNV)
764     CASE(BuiltIn, SecondaryViewportMaskNV)
765     CASE(BuiltIn, PositionPerViewNV)
766     CASE(BuiltIn, ViewportMaskPerViewNV)
767     CASE(BuiltIn, FullyCoveredEXT)
768     CASE(BuiltIn, TaskCountNV)
769     CASE(BuiltIn, PrimitiveCountNV)
770     CASE(BuiltIn, PrimitiveIndicesNV)
771     CASE(BuiltIn, ClipDistancePerViewNV)
772     CASE(BuiltIn, CullDistancePerViewNV)
773     CASE(BuiltIn, LayerPerViewNV)
774     CASE(BuiltIn, MeshViewCountNV)
775     CASE(BuiltIn, MeshViewIndices)
776     CASE(BuiltIn, BaryCoordNV)
777     CASE(BuiltIn, BaryCoordNoPerspNV)
778     CASE(BuiltIn, FragSizeEXT)
779     CASE(BuiltIn, FragInvocationCountEXT)
780     CASE(BuiltIn, LaunchIdNV)
781     CASE(BuiltIn, LaunchSizeNV)
782     CASE(BuiltIn, WorldRayOriginNV)
783     CASE(BuiltIn, WorldRayDirectionNV)
784     CASE(BuiltIn, ObjectRayOriginNV)
785     CASE(BuiltIn, ObjectRayDirectionNV)
786     CASE(BuiltIn, RayTminNV)
787     CASE(BuiltIn, RayTmaxNV)
788     CASE(BuiltIn, InstanceCustomIndexNV)
789     CASE(BuiltIn, ObjectToWorldNV)
790     CASE(BuiltIn, WorldToObjectNV)
791     CASE(BuiltIn, HitTNV)
792     CASE(BuiltIn, HitKindNV)
793     CASE(BuiltIn, IncomingRayFlagsNV)
794   default:
795     break;
796   }
797   llvm_unreachable("Unexpected operand");
798 }
799 
800 std::string getSelectionControlName(uint32_t e) {
801   std::string nameString = "";
802   std::string sep = "";
803   if (e == static_cast<uint32_t>(SelectionControl::None))
804     return "None";
805   if (e == static_cast<uint32_t>(SelectionControl::Flatten))
806     return "Flatten";
807   if (e & static_cast<uint32_t>(SelectionControl::Flatten)) {
808     nameString += sep + "Flatten";
809     sep = "|";
810   }
811   if (e == static_cast<uint32_t>(SelectionControl::DontFlatten))
812     return "DontFlatten";
813   if (e & static_cast<uint32_t>(SelectionControl::DontFlatten)) {
814     nameString += sep + "DontFlatten";
815     sep = "|";
816   };
817   return nameString;
818 }
819 
820 std::string getLoopControlName(uint32_t e) {
821   std::string nameString = "";
822   std::string sep = "";
823   if (e == static_cast<uint32_t>(LoopControl::None))
824     return "None";
825   if (e == static_cast<uint32_t>(LoopControl::Unroll))
826     return "Unroll";
827   if (e & static_cast<uint32_t>(LoopControl::Unroll)) {
828     nameString += sep + "Unroll";
829     sep = "|";
830   }
831   if (e == static_cast<uint32_t>(LoopControl::DontUnroll))
832     return "DontUnroll";
833   if (e & static_cast<uint32_t>(LoopControl::DontUnroll)) {
834     nameString += sep + "DontUnroll";
835     sep = "|";
836   }
837   if (e == static_cast<uint32_t>(LoopControl::DependencyInfinite))
838     return "DependencyInfinite";
839   if (e & static_cast<uint32_t>(LoopControl::DependencyInfinite)) {
840     nameString += sep + "DependencyInfinite";
841     sep = "|";
842   }
843   if (e == static_cast<uint32_t>(LoopControl::DependencyLength))
844     return "DependencyLength";
845   if (e & static_cast<uint32_t>(LoopControl::DependencyLength)) {
846     nameString += sep + "DependencyLength";
847     sep = "|";
848   }
849   if (e == static_cast<uint32_t>(LoopControl::MinIterations))
850     return "MinIterations";
851   if (e & static_cast<uint32_t>(LoopControl::MinIterations)) {
852     nameString += sep + "MinIterations";
853     sep = "|";
854   }
855   if (e == static_cast<uint32_t>(LoopControl::MaxIterations))
856     return "MaxIterations";
857   if (e & static_cast<uint32_t>(LoopControl::MaxIterations)) {
858     nameString += sep + "MaxIterations";
859     sep = "|";
860   }
861   if (e == static_cast<uint32_t>(LoopControl::IterationMultiple))
862     return "IterationMultiple";
863   if (e & static_cast<uint32_t>(LoopControl::IterationMultiple)) {
864     nameString += sep + "IterationMultiple";
865     sep = "|";
866   }
867   if (e == static_cast<uint32_t>(LoopControl::PeelCount))
868     return "PeelCount";
869   if (e & static_cast<uint32_t>(LoopControl::PeelCount)) {
870     nameString += sep + "PeelCount";
871     sep = "|";
872   }
873   if (e == static_cast<uint32_t>(LoopControl::PartialCount))
874     return "PartialCount";
875   if (e & static_cast<uint32_t>(LoopControl::PartialCount)) {
876     nameString += sep + "PartialCount";
877     sep = "|";
878   };
879   return nameString;
880 }
881 
882 std::string getFunctionControlName(uint32_t e) {
883   std::string nameString = "";
884   std::string sep = "";
885   if (e == static_cast<uint32_t>(FunctionControl::None))
886     return "None";
887   if (e == static_cast<uint32_t>(FunctionControl::Inline))
888     return "Inline";
889   if (e & static_cast<uint32_t>(FunctionControl::Inline)) {
890     nameString += sep + "Inline";
891     sep = "|";
892   }
893   if (e == static_cast<uint32_t>(FunctionControl::DontInline))
894     return "DontInline";
895   if (e & static_cast<uint32_t>(FunctionControl::DontInline)) {
896     nameString += sep + "DontInline";
897     sep = "|";
898   }
899   if (e == static_cast<uint32_t>(FunctionControl::Pure))
900     return "Pure";
901   if (e & static_cast<uint32_t>(FunctionControl::Pure)) {
902     nameString += sep + "Pure";
903     sep = "|";
904   }
905   if (e == static_cast<uint32_t>(FunctionControl::Const))
906     return "Const";
907   if (e & static_cast<uint32_t>(FunctionControl::Const)) {
908     nameString += sep + "Const";
909     sep = "|";
910   };
911   return nameString;
912 }
913 
914 std::string getMemorySemanticsName(uint32_t e) {
915   std::string nameString = "";
916   std::string sep = "";
917   if (e == static_cast<uint32_t>(MemorySemantics::None))
918     return "None";
919   if (e == static_cast<uint32_t>(MemorySemantics::Acquire))
920     return "Acquire";
921   if (e & static_cast<uint32_t>(MemorySemantics::Acquire)) {
922     nameString += sep + "Acquire";
923     sep = "|";
924   }
925   if (e == static_cast<uint32_t>(MemorySemantics::Release))
926     return "Release";
927   if (e & static_cast<uint32_t>(MemorySemantics::Release)) {
928     nameString += sep + "Release";
929     sep = "|";
930   }
931   if (e == static_cast<uint32_t>(MemorySemantics::AcquireRelease))
932     return "AcquireRelease";
933   if (e & static_cast<uint32_t>(MemorySemantics::AcquireRelease)) {
934     nameString += sep + "AcquireRelease";
935     sep = "|";
936   }
937   if (e == static_cast<uint32_t>(MemorySemantics::SequentiallyConsistent))
938     return "SequentiallyConsistent";
939   if (e & static_cast<uint32_t>(MemorySemantics::SequentiallyConsistent)) {
940     nameString += sep + "SequentiallyConsistent";
941     sep = "|";
942   }
943   if (e == static_cast<uint32_t>(MemorySemantics::UniformMemory))
944     return "UniformMemory";
945   if (e & static_cast<uint32_t>(MemorySemantics::UniformMemory)) {
946     nameString += sep + "UniformMemory";
947     sep = "|";
948   }
949   if (e == static_cast<uint32_t>(MemorySemantics::SubgroupMemory))
950     return "SubgroupMemory";
951   if (e & static_cast<uint32_t>(MemorySemantics::SubgroupMemory)) {
952     nameString += sep + "SubgroupMemory";
953     sep = "|";
954   }
955   if (e == static_cast<uint32_t>(MemorySemantics::WorkgroupMemory))
956     return "WorkgroupMemory";
957   if (e & static_cast<uint32_t>(MemorySemantics::WorkgroupMemory)) {
958     nameString += sep + "WorkgroupMemory";
959     sep = "|";
960   }
961   if (e == static_cast<uint32_t>(MemorySemantics::CrossWorkgroupMemory))
962     return "CrossWorkgroupMemory";
963   if (e & static_cast<uint32_t>(MemorySemantics::CrossWorkgroupMemory)) {
964     nameString += sep + "CrossWorkgroupMemory";
965     sep = "|";
966   }
967   if (e == static_cast<uint32_t>(MemorySemantics::AtomicCounterMemory))
968     return "AtomicCounterMemory";
969   if (e & static_cast<uint32_t>(MemorySemantics::AtomicCounterMemory)) {
970     nameString += sep + "AtomicCounterMemory";
971     sep = "|";
972   }
973   if (e == static_cast<uint32_t>(MemorySemantics::ImageMemory))
974     return "ImageMemory";
975   if (e & static_cast<uint32_t>(MemorySemantics::ImageMemory)) {
976     nameString += sep + "ImageMemory";
977     sep = "|";
978   }
979   if (e == static_cast<uint32_t>(MemorySemantics::OutputMemoryKHR))
980     return "OutputMemoryKHR";
981   if (e & static_cast<uint32_t>(MemorySemantics::OutputMemoryKHR)) {
982     nameString += sep + "OutputMemoryKHR";
983     sep = "|";
984   }
985   if (e == static_cast<uint32_t>(MemorySemantics::MakeAvailableKHR))
986     return "MakeAvailableKHR";
987   if (e & static_cast<uint32_t>(MemorySemantics::MakeAvailableKHR)) {
988     nameString += sep + "MakeAvailableKHR";
989     sep = "|";
990   }
991   if (e == static_cast<uint32_t>(MemorySemantics::MakeVisibleKHR))
992     return "MakeVisibleKHR";
993   if (e & static_cast<uint32_t>(MemorySemantics::MakeVisibleKHR)) {
994     nameString += sep + "MakeVisibleKHR";
995     sep = "|";
996   };
997   return nameString;
998 }
999 
1000 std::string getMemoryOperandName(uint32_t e) {
1001   std::string nameString = "";
1002   std::string sep = "";
1003   if (e == static_cast<uint32_t>(MemoryOperand::None))
1004     return "None";
1005   if (e == static_cast<uint32_t>(MemoryOperand::Volatile))
1006     return "Volatile";
1007   if (e & static_cast<uint32_t>(MemoryOperand::Volatile)) {
1008     nameString += sep + "Volatile";
1009     sep = "|";
1010   }
1011   if (e == static_cast<uint32_t>(MemoryOperand::Aligned))
1012     return "Aligned";
1013   if (e & static_cast<uint32_t>(MemoryOperand::Aligned)) {
1014     nameString += sep + "Aligned";
1015     sep = "|";
1016   }
1017   if (e == static_cast<uint32_t>(MemoryOperand::Nontemporal))
1018     return "Nontemporal";
1019   if (e & static_cast<uint32_t>(MemoryOperand::Nontemporal)) {
1020     nameString += sep + "Nontemporal";
1021     sep = "|";
1022   }
1023   if (e == static_cast<uint32_t>(MemoryOperand::MakePointerAvailableKHR))
1024     return "MakePointerAvailableKHR";
1025   if (e & static_cast<uint32_t>(MemoryOperand::MakePointerAvailableKHR)) {
1026     nameString += sep + "MakePointerAvailableKHR";
1027     sep = "|";
1028   }
1029   if (e == static_cast<uint32_t>(MemoryOperand::MakePointerVisibleKHR))
1030     return "MakePointerVisibleKHR";
1031   if (e & static_cast<uint32_t>(MemoryOperand::MakePointerVisibleKHR)) {
1032     nameString += sep + "MakePointerVisibleKHR";
1033     sep = "|";
1034   }
1035   if (e == static_cast<uint32_t>(MemoryOperand::NonPrivatePointerKHR))
1036     return "NonPrivatePointerKHR";
1037   if (e & static_cast<uint32_t>(MemoryOperand::NonPrivatePointerKHR)) {
1038     nameString += sep + "NonPrivatePointerKHR";
1039     sep = "|";
1040   };
1041   return nameString;
1042 }
1043 
1044 StringRef getScopeName(Scope e) {
1045   switch (e) {
1046     CASE(Scope, CrossDevice)
1047     CASE(Scope, Device)
1048     CASE(Scope, Workgroup)
1049     CASE(Scope, Subgroup)
1050     CASE(Scope, Invocation)
1051     CASE(Scope, QueueFamilyKHR)
1052   default:
1053     break;
1054   }
1055   llvm_unreachable("Unexpected operand");
1056 }
1057 
1058 StringRef getGroupOperationName(GroupOperation e) {
1059   switch (e) {
1060     CASE(GroupOperation, Reduce)
1061     CASE(GroupOperation, InclusiveScan)
1062     CASE(GroupOperation, ExclusiveScan)
1063     CASE(GroupOperation, ClusteredReduce)
1064     CASE(GroupOperation, PartitionedReduceNV)
1065     CASE(GroupOperation, PartitionedInclusiveScanNV)
1066     CASE(GroupOperation, PartitionedExclusiveScanNV)
1067   default:
1068     break;
1069   }
1070   llvm_unreachable("Unexpected operand");
1071 }
1072 
1073 StringRef getKernelEnqueueFlagsName(KernelEnqueueFlags e) {
1074   switch (e) {
1075     CASE(KernelEnqueueFlags, NoWait)
1076     CASE(KernelEnqueueFlags, WaitKernel)
1077     CASE(KernelEnqueueFlags, WaitWorkGroup)
1078   default:
1079     break;
1080   }
1081   llvm_unreachable("Unexpected operand");
1082 }
1083 
1084 StringRef getKernelProfilingInfoName(KernelProfilingInfo e) {
1085   switch (e) {
1086     CASE(KernelProfilingInfo, None)
1087     CASE(KernelProfilingInfo, CmdExecTime)
1088   default:
1089     break;
1090   }
1091   llvm_unreachable("Unexpected operand");
1092 }
1093 } // namespace SPIRV
1094 } // namespace llvm
1095