1 //
2 // Copyright 2002 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6
7 #ifndef COMPILER_TRANSLATOR_BASETYPES_H_
8 #define COMPILER_TRANSLATOR_BASETYPES_H_
9
10 #include <algorithm>
11 #include <array>
12
13 #include "GLSLANG/ShaderLang.h"
14 #include "common/debug.h"
15 #include "compiler/translator/ImmutableString.h"
16
17 namespace sh
18 {
19
20 //
21 // Precision qualifiers
22 //
23 enum TPrecision
24 {
25 // These need to be kept sorted
26 EbpUndefined,
27 EbpLow,
28 EbpMedium,
29 EbpHigh,
30
31 // end of list
32 EbpLast
33 };
34
getPrecisionString(TPrecision p)35 inline const char *getPrecisionString(TPrecision p)
36 {
37 switch (p)
38 {
39 case EbpHigh:
40 return "highp";
41 case EbpMedium:
42 return "mediump";
43 case EbpLow:
44 return "lowp";
45 default:
46 return "mediump"; // Safest fallback
47 }
48 }
49
50 //
51 // Basic type. Arrays, vectors, etc., are orthogonal to this.
52 //
53 enum TBasicType
54 {
55 EbtVoid,
56 EbtFloat,
57 EbtInt,
58 EbtUInt,
59 EbtBool,
60
61 EbtAtomicCounter,
62 EbtYuvCscStandardEXT, // Only valid if EXT_YUV_target exists.
63
64 EbtGuardSamplerBegin, // non type: see implementation of IsSampler()
65 EbtSampler2D = EbtGuardSamplerBegin,
66 EbtSampler3D,
67 EbtSamplerCube,
68 EbtSampler2DArray,
69 EbtSamplerExternalOES, // Only valid if OES_EGL_image_external exists.
70 EbtSamplerExternal2DY2YEXT, // Only valid if GL_EXT_YUV_target exists.
71 EbtSampler2DRect, // Only valid if GL_ARB_texture_rectangle exists.
72 EbtSampler2DMS,
73 EbtSampler2DMSArray,
74 EbtISampler2D,
75 EbtISampler3D,
76 EbtISamplerCube,
77 EbtISampler2DArray,
78 EbtISampler2DMS,
79 EbtISampler2DMSArray,
80 EbtUSampler2D,
81 EbtUSampler3D,
82 EbtUSamplerCube,
83 EbtUSampler2DArray,
84 EbtUSampler2DMS,
85 EbtUSampler2DMSArray,
86 EbtSampler2DShadow,
87 EbtSamplerCubeShadow,
88 EbtSampler2DArrayShadow,
89 EbtGuardSamplerEnd = EbtSampler2DArrayShadow, // non type: see implementation of IsSampler()
90
91 // images
92 EbtGuardImageBegin,
93 EbtImage2D = EbtGuardImageBegin,
94 EbtIImage2D,
95 EbtUImage2D,
96 EbtImage3D,
97 EbtIImage3D,
98 EbtUImage3D,
99 EbtImage2DArray,
100 EbtIImage2DArray,
101 EbtUImage2DArray,
102 EbtImageCube,
103 EbtIImageCube,
104 EbtUImageCube,
105 EbtGuardImageEnd = EbtUImageCube,
106
107 EbtLastSimpleType = EbtGuardImageEnd,
108
109 EbtStruct,
110 EbtInterfaceBlock,
111
112 // end of list
113 EbtLast = EbtInterfaceBlock
114 };
115
116 class TBasicMangledName
117 {
118 public:
TBasicMangledName(TBasicType t)119 constexpr TBasicMangledName(TBasicType t) : mName{'\0', '\0'}
120 {
121 if (t > EbtLastSimpleType)
122 {
123 mName[0] = '{';
124 mName[1] = '\0';
125 }
126 else if (t < 26)
127 {
128 mName[0] = '0';
129 mName[1] = static_cast<char>('A' + t);
130 }
131 else if (t < 52)
132 {
133 mName[0] = '0';
134 mName[1] = static_cast<char>('a' - 26 + t);
135 }
136 }
137
getName()138 constexpr char *getName() { return mName; }
139
140 static constexpr int mangledNameSize = 2;
141
142 private:
143 char mName[mangledNameSize];
144 };
145
146 const char *getBasicString(TBasicType t);
147
IsSampler(TBasicType type)148 inline bool IsSampler(TBasicType type)
149 {
150 return type >= EbtGuardSamplerBegin && type <= EbtGuardSamplerEnd;
151 }
152
IsImage(TBasicType type)153 inline bool IsImage(TBasicType type)
154 {
155 return type >= EbtGuardImageBegin && type <= EbtGuardImageEnd;
156 }
157
IsAtomicCounter(TBasicType type)158 inline bool IsAtomicCounter(TBasicType type)
159 {
160 return type == EbtAtomicCounter;
161 }
162
IsOpaqueType(TBasicType type)163 inline bool IsOpaqueType(TBasicType type)
164 {
165 return IsSampler(type) || IsImage(type) || IsAtomicCounter(type);
166 }
167
IsIntegerSampler(TBasicType type)168 inline bool IsIntegerSampler(TBasicType type)
169 {
170 switch (type)
171 {
172 case EbtISampler2D:
173 case EbtISampler3D:
174 case EbtISamplerCube:
175 case EbtISampler2DArray:
176 case EbtISampler2DMS:
177 case EbtISampler2DMSArray:
178 case EbtUSampler2D:
179 case EbtUSampler3D:
180 case EbtUSamplerCube:
181 case EbtUSampler2DArray:
182 case EbtUSampler2DMS:
183 case EbtUSampler2DMSArray:
184 return true;
185 case EbtSampler2D:
186 case EbtSampler3D:
187 case EbtSamplerCube:
188 case EbtSamplerExternalOES:
189 case EbtSamplerExternal2DY2YEXT:
190 case EbtSampler2DRect:
191 case EbtSampler2DArray:
192 case EbtSampler2DShadow:
193 case EbtSamplerCubeShadow:
194 case EbtSampler2DArrayShadow:
195 case EbtSampler2DMS:
196 case EbtSampler2DMSArray:
197 return false;
198 default:
199 assert(!IsSampler(type));
200 }
201
202 return false;
203 }
204
IsIntegerSamplerUnsigned(TBasicType type)205 inline bool IsIntegerSamplerUnsigned(TBasicType type)
206 {
207 switch (type)
208 {
209 case EbtISampler2D:
210 case EbtISampler3D:
211 case EbtISamplerCube:
212 case EbtISampler2DArray:
213 case EbtISampler2DMS:
214 case EbtISampler2DMSArray:
215 return false;
216 case EbtUSampler2D:
217 case EbtUSampler3D:
218 case EbtUSamplerCube:
219 case EbtUSampler2DArray:
220 case EbtUSampler2DMS:
221 case EbtUSampler2DMSArray:
222 return true;
223 default:
224 assert(!IsIntegerSampler(type));
225 }
226
227 return false;
228 }
229
IsSampler2DMS(TBasicType type)230 inline bool IsSampler2DMS(TBasicType type)
231 {
232 switch (type)
233 {
234 case EbtSampler2DMS:
235 case EbtISampler2DMS:
236 case EbtUSampler2DMS:
237 return true;
238 default:
239 return false;
240 }
241 }
242
IsSampler2DMSArray(TBasicType type)243 inline bool IsSampler2DMSArray(TBasicType type)
244 {
245 switch (type)
246 {
247 case EbtSampler2DMSArray:
248 case EbtISampler2DMSArray:
249 case EbtUSampler2DMSArray:
250 return true;
251 default:
252 return false;
253 }
254 }
255
IsFloatImage(TBasicType type)256 inline bool IsFloatImage(TBasicType type)
257 {
258 switch (type)
259 {
260 case EbtImage2D:
261 case EbtImage3D:
262 case EbtImage2DArray:
263 case EbtImageCube:
264 return true;
265 default:
266 break;
267 }
268
269 return false;
270 }
271
IsIntegerImage(TBasicType type)272 inline bool IsIntegerImage(TBasicType type)
273 {
274
275 switch (type)
276 {
277 case EbtIImage2D:
278 case EbtIImage3D:
279 case EbtIImage2DArray:
280 case EbtIImageCube:
281 return true;
282 default:
283 break;
284 }
285
286 return false;
287 }
288
IsUnsignedImage(TBasicType type)289 inline bool IsUnsignedImage(TBasicType type)
290 {
291
292 switch (type)
293 {
294 case EbtUImage2D:
295 case EbtUImage3D:
296 case EbtUImage2DArray:
297 case EbtUImageCube:
298 return true;
299 default:
300 break;
301 }
302
303 return false;
304 }
305
306 // Samplers are divided into 4 disjoint categories: 2D, cube, 3D, and array.
307 // Array samplers are not 2D samplers.
IsSampler2D(TBasicType type)308 inline bool IsSampler2D(TBasicType type)
309 {
310 switch (type)
311 {
312 case EbtSampler2D:
313 case EbtISampler2D:
314 case EbtUSampler2D:
315 case EbtSampler2DRect:
316 case EbtSamplerExternalOES:
317 case EbtSamplerExternal2DY2YEXT:
318 case EbtSampler2DShadow:
319 case EbtSampler2DMS:
320 case EbtISampler2DMS:
321 case EbtUSampler2DMS:
322 return true;
323 case EbtSampler2DArray:
324 case EbtISampler2DArray:
325 case EbtUSampler2DArray:
326 case EbtSampler2DMSArray:
327 case EbtISampler2DMSArray:
328 case EbtUSampler2DMSArray:
329 case EbtSampler2DArrayShadow:
330 case EbtSampler3D:
331 case EbtISampler3D:
332 case EbtUSampler3D:
333 case EbtISamplerCube:
334 case EbtUSamplerCube:
335 case EbtSamplerCube:
336 case EbtSamplerCubeShadow:
337 return false;
338 default:
339 assert(!IsSampler(type));
340 }
341
342 return false;
343 }
344
IsSamplerCube(TBasicType type)345 inline bool IsSamplerCube(TBasicType type)
346 {
347 switch (type)
348 {
349 case EbtSamplerCube:
350 case EbtISamplerCube:
351 case EbtUSamplerCube:
352 case EbtSamplerCubeShadow:
353 return true;
354 case EbtSampler2D:
355 case EbtSampler3D:
356 case EbtSamplerExternalOES:
357 case EbtSamplerExternal2DY2YEXT:
358 case EbtSampler2DRect:
359 case EbtSampler2DArray:
360 case EbtSampler2DMS:
361 case EbtSampler2DMSArray:
362 case EbtISampler2D:
363 case EbtISampler3D:
364 case EbtISampler2DArray:
365 case EbtISampler2DMS:
366 case EbtISampler2DMSArray:
367 case EbtUSampler2D:
368 case EbtUSampler3D:
369 case EbtUSampler2DArray:
370 case EbtUSampler2DMS:
371 case EbtUSampler2DMSArray:
372 case EbtSampler2DShadow:
373 case EbtSampler2DArrayShadow:
374 return false;
375 default:
376 assert(!IsSampler(type));
377 }
378
379 return false;
380 }
381
IsSampler3D(TBasicType type)382 inline bool IsSampler3D(TBasicType type)
383 {
384 switch (type)
385 {
386 case EbtSampler3D:
387 case EbtISampler3D:
388 case EbtUSampler3D:
389 return true;
390 case EbtSampler2D:
391 case EbtSamplerCube:
392 case EbtSamplerExternalOES:
393 case EbtSamplerExternal2DY2YEXT:
394 case EbtSampler2DRect:
395 case EbtSampler2DArray:
396 case EbtSampler2DMS:
397 case EbtSampler2DMSArray:
398 case EbtISampler2D:
399 case EbtISamplerCube:
400 case EbtISampler2DArray:
401 case EbtISampler2DMS:
402 case EbtISampler2DMSArray:
403 case EbtUSampler2D:
404 case EbtUSamplerCube:
405 case EbtUSampler2DArray:
406 case EbtUSampler2DMS:
407 case EbtUSampler2DMSArray:
408 case EbtSampler2DShadow:
409 case EbtSamplerCubeShadow:
410 case EbtSampler2DArrayShadow:
411 return false;
412 default:
413 assert(!IsSampler(type));
414 }
415
416 return false;
417 }
418
IsSamplerArray(TBasicType type)419 inline bool IsSamplerArray(TBasicType type)
420 {
421 switch (type)
422 {
423 case EbtSampler2DArray:
424 case EbtISampler2DArray:
425 case EbtUSampler2DArray:
426 case EbtSampler2DMSArray:
427 case EbtISampler2DMSArray:
428 case EbtUSampler2DMSArray:
429 case EbtSampler2DArrayShadow:
430 return true;
431 case EbtSampler2D:
432 case EbtISampler2D:
433 case EbtUSampler2D:
434 case EbtSampler2DRect:
435 case EbtSamplerExternalOES:
436 case EbtSamplerExternal2DY2YEXT:
437 case EbtSampler3D:
438 case EbtISampler3D:
439 case EbtUSampler3D:
440 case EbtISamplerCube:
441 case EbtUSamplerCube:
442 case EbtSamplerCube:
443 case EbtSampler2DShadow:
444 case EbtSamplerCubeShadow:
445 case EbtSampler2DMS:
446 case EbtISampler2DMS:
447 case EbtUSampler2DMS:
448 return false;
449 default:
450 assert(!IsSampler(type));
451 }
452
453 return false;
454 }
455
IsShadowSampler(TBasicType type)456 inline bool IsShadowSampler(TBasicType type)
457 {
458 switch (type)
459 {
460 case EbtSampler2DShadow:
461 case EbtSamplerCubeShadow:
462 case EbtSampler2DArrayShadow:
463 return true;
464 case EbtISampler2D:
465 case EbtISampler3D:
466 case EbtISamplerCube:
467 case EbtISampler2DArray:
468 case EbtISampler2DMS:
469 case EbtISampler2DMSArray:
470 case EbtUSampler2D:
471 case EbtUSampler3D:
472 case EbtUSamplerCube:
473 case EbtUSampler2DArray:
474 case EbtUSampler2DMS:
475 case EbtUSampler2DMSArray:
476 case EbtSampler2D:
477 case EbtSampler3D:
478 case EbtSamplerCube:
479 case EbtSamplerExternalOES:
480 case EbtSamplerExternal2DY2YEXT:
481 case EbtSampler2DRect:
482 case EbtSampler2DArray:
483 case EbtSampler2DMS:
484 case EbtSampler2DMSArray:
485 return false;
486 default:
487 assert(!IsSampler(type));
488 }
489
490 return false;
491 }
492
IsImage2D(TBasicType type)493 inline bool IsImage2D(TBasicType type)
494 {
495 switch (type)
496 {
497 case EbtImage2D:
498 case EbtIImage2D:
499 case EbtUImage2D:
500 return true;
501 case EbtImage3D:
502 case EbtIImage3D:
503 case EbtUImage3D:
504 case EbtImage2DArray:
505 case EbtIImage2DArray:
506 case EbtUImage2DArray:
507 case EbtImageCube:
508 case EbtIImageCube:
509 case EbtUImageCube:
510 return false;
511 default:
512 assert(!IsImage(type));
513 }
514
515 return false;
516 }
517
IsImage3D(TBasicType type)518 inline bool IsImage3D(TBasicType type)
519 {
520 switch (type)
521 {
522 case EbtImage3D:
523 case EbtIImage3D:
524 case EbtUImage3D:
525 return true;
526 case EbtImage2D:
527 case EbtIImage2D:
528 case EbtUImage2D:
529 case EbtImage2DArray:
530 case EbtIImage2DArray:
531 case EbtUImage2DArray:
532 case EbtImageCube:
533 case EbtIImageCube:
534 case EbtUImageCube:
535 return false;
536 default:
537 assert(!IsImage(type));
538 }
539
540 return false;
541 }
542
IsImage2DArray(TBasicType type)543 inline bool IsImage2DArray(TBasicType type)
544 {
545 switch (type)
546 {
547 case EbtImage2DArray:
548 case EbtIImage2DArray:
549 case EbtUImage2DArray:
550 return true;
551 case EbtImage2D:
552 case EbtIImage2D:
553 case EbtUImage2D:
554 case EbtImage3D:
555 case EbtIImage3D:
556 case EbtUImage3D:
557 case EbtImageCube:
558 case EbtIImageCube:
559 case EbtUImageCube:
560 return false;
561 default:
562 assert(!IsImage(type));
563 }
564
565 return false;
566 }
567
IsImageCube(TBasicType type)568 inline bool IsImageCube(TBasicType type)
569 {
570 switch (type)
571 {
572 case EbtImageCube:
573 case EbtIImageCube:
574 case EbtUImageCube:
575 return true;
576 case EbtImage2D:
577 case EbtIImage2D:
578 case EbtUImage2D:
579 case EbtImage3D:
580 case EbtIImage3D:
581 case EbtUImage3D:
582 case EbtImage2DArray:
583 case EbtIImage2DArray:
584 case EbtUImage2DArray:
585 return false;
586 default:
587 assert(!IsImage(type));
588 }
589
590 return false;
591 }
592
IsInteger(TBasicType type)593 inline bool IsInteger(TBasicType type)
594 {
595 return type == EbtInt || type == EbtUInt;
596 }
597
SupportsPrecision(TBasicType type)598 inline bool SupportsPrecision(TBasicType type)
599 {
600 return type == EbtFloat || type == EbtInt || type == EbtUInt || IsOpaqueType(type);
601 }
602
603 //
604 // Qualifiers and built-ins. These are mainly used to see what can be read
605 // or written, and by the machine dependent translator to know which registers
606 // to allocate variables in. Since built-ins tend to go to different registers
607 // than varying or uniform, it makes sense they are peers, not sub-classes.
608 //
609 enum TQualifier
610 {
611 EvqTemporary, // For temporaries (within a function), read/write
612 EvqGlobal, // For globals read/write
613 EvqConst, // User defined constants and non-output parameters in functions
614 EvqAttribute, // Readonly
615 EvqVaryingIn, // readonly, fragment shaders only
616 EvqVaryingOut, // vertex shaders only read/write
617 EvqUniform, // Readonly, vertex and fragment
618 EvqBuffer, // read/write, vertex, fragment and compute shader
619
620 EvqVertexIn, // Vertex shader input
621 EvqFragmentOut, // Fragment shader output
622 EvqVertexOut, // Vertex shader output
623 EvqFragmentIn, // Fragment shader input
624
625 // parameters
626 EvqIn,
627 EvqOut,
628 EvqInOut,
629 EvqConstReadOnly,
630
631 // built-ins read by vertex shader
632 EvqInstanceID,
633 EvqVertexID,
634
635 // built-ins written by vertex shader
636 EvqPosition,
637 EvqPointSize,
638
639 EvqDrawID, // ANGLE_multi_draw
640
641 EvqBaseVertex, // ANGLE_base_vertex_base_instance
642 EvqBaseInstance, // ANGLE_base_vertex_base_instance
643
644 // built-ins read by fragment shader
645 EvqFragCoord,
646 EvqFrontFacing,
647 EvqPointCoord,
648
649 // built-ins written by fragment shader
650 EvqFragColor,
651 EvqFragData,
652
653 EvqFragDepth, // gl_FragDepth for ESSL300.
654 EvqFragDepthEXT, // gl_FragDepthEXT for ESSL100, EXT_frag_depth.
655
656 EvqSecondaryFragColorEXT, // EXT_blend_func_extended
657 EvqSecondaryFragDataEXT, // EXT_blend_func_extended
658
659 EvqViewIDOVR, // OVR_multiview
660 EvqViewportIndex, // gl_ViewportIndex
661
662 // built-ins written by the shader_framebuffer_fetch extension(s)
663 EvqLastFragColor,
664 EvqLastFragData,
665
666 // GLSL ES 3.0 vertex output and fragment input
667 EvqSmooth, // Incomplete qualifier, smooth is the default
668 EvqFlat, // Incomplete qualifier
669 EvqCentroid, // Incomplete qualifier
670 EvqSmoothOut,
671 EvqFlatOut,
672 EvqCentroidOut, // Implies smooth
673 EvqSmoothIn,
674 EvqFlatIn,
675 EvqCentroidIn, // Implies smooth
676
677 // GLSL ES 3.1 compute shader special variables
678 EvqShared,
679 EvqComputeIn,
680 EvqNumWorkGroups,
681 EvqWorkGroupSize,
682 EvqWorkGroupID,
683 EvqLocalInvocationID,
684 EvqGlobalInvocationID,
685 EvqLocalInvocationIndex,
686
687 // GLSL ES 3.1 memory qualifiers
688 EvqReadOnly,
689 EvqWriteOnly,
690 EvqCoherent,
691 EvqRestrict,
692 EvqVolatile,
693
694 // GLSL ES 3.1 extension EXT_geometry_shader qualifiers
695 EvqGeometryIn,
696 EvqGeometryOut,
697 EvqPerVertexIn, // gl_in
698 EvqPrimitiveIDIn, // gl_PrimitiveIDIn
699 EvqInvocationID, // gl_InvocationID
700 EvqPrimitiveID, // gl_PrimitiveID
701 EvqLayer, // gl_Layer
702
703 // end of list
704 EvqLast
705 };
706
IsQualifierUnspecified(TQualifier qualifier)707 inline bool IsQualifierUnspecified(TQualifier qualifier)
708 {
709 return (qualifier == EvqTemporary || qualifier == EvqGlobal);
710 }
711
IsStorageBuffer(TQualifier qualifier)712 inline bool IsStorageBuffer(TQualifier qualifier)
713 {
714 return qualifier == EvqBuffer;
715 }
716
717 enum TLayoutImageInternalFormat
718 {
719 EiifUnspecified,
720 EiifRGBA32F,
721 EiifRGBA16F,
722 EiifR32F,
723 EiifRGBA32UI,
724 EiifRGBA16UI,
725 EiifRGBA8UI,
726 EiifR32UI,
727 EiifRGBA32I,
728 EiifRGBA16I,
729 EiifRGBA8I,
730 EiifR32I,
731 EiifRGBA8,
732 EiifRGBA8_SNORM
733 };
734
735 enum TLayoutMatrixPacking
736 {
737 EmpUnspecified,
738 EmpRowMajor,
739 EmpColumnMajor
740 };
741
742 enum TLayoutBlockStorage
743 {
744 EbsUnspecified,
745 EbsShared,
746 EbsPacked,
747 EbsStd140,
748 EbsStd430
749 };
750
751 enum TYuvCscStandardEXT
752 {
753 EycsUndefined,
754 EycsItu601,
755 EycsItu601FullRange,
756 EycsItu709
757 };
758
759 enum TLayoutPrimitiveType
760 {
761 EptUndefined,
762 EptPoints,
763 EptLines,
764 EptLinesAdjacency,
765 EptTriangles,
766 EptTrianglesAdjacency,
767 EptLineStrip,
768 EptTriangleStrip
769 };
770
771 struct TLayoutQualifier
772 {
773 // Must have a trivial default constructor since it is used in YYSTYPE.
774 TLayoutQualifier() = default;
775
CreateTLayoutQualifier776 constexpr static TLayoutQualifier Create() { return TLayoutQualifier(0); }
777
isEmptyTLayoutQualifier778 bool isEmpty() const
779 {
780 return location == -1 && binding == -1 && offset == -1 && numViews == -1 && yuv == false &&
781 matrixPacking == EmpUnspecified && blockStorage == EbsUnspecified &&
782 !localSize.isAnyValueSet() && imageInternalFormat == EiifUnspecified &&
783 primitiveType == EptUndefined && invocations == 0 && maxVertices == -1 &&
784 index == -1;
785 }
786
isCombinationValidTLayoutQualifier787 bool isCombinationValid() const
788 {
789 bool workSizeSpecified = localSize.isAnyValueSet();
790 bool numViewsSet = (numViews != -1);
791 bool geometryShaderSpecified =
792 (primitiveType != EptUndefined) || (invocations != 0) || (maxVertices != -1);
793 bool otherLayoutQualifiersSpecified =
794 (location != -1 || binding != -1 || index != -1 || matrixPacking != EmpUnspecified ||
795 blockStorage != EbsUnspecified || imageInternalFormat != EiifUnspecified);
796
797 // we can have either the work group size specified, or number of views,
798 // or yuv layout qualifier, or the other layout qualifiers.
799 return (workSizeSpecified ? 1 : 0) + (numViewsSet ? 1 : 0) + (yuv ? 1 : 0) +
800 (otherLayoutQualifiersSpecified ? 1 : 0) + (geometryShaderSpecified ? 1 : 0) <=
801 1;
802 }
803
isLocalSizeEqualTLayoutQualifier804 bool isLocalSizeEqual(const WorkGroupSize &localSizeIn) const
805 {
806 return localSize.isWorkGroupSizeMatching(localSizeIn);
807 }
808
809 int location;
810 unsigned int locationsSpecified;
811 TLayoutMatrixPacking matrixPacking;
812 TLayoutBlockStorage blockStorage;
813
814 // Compute shader layout qualifiers.
815 WorkGroupSize localSize;
816
817 int binding;
818 int offset;
819
820 // Image format layout qualifier
821 TLayoutImageInternalFormat imageInternalFormat;
822
823 // OVR_multiview num_views.
824 int numViews;
825
826 // EXT_YUV_target yuv layout qualifier.
827 bool yuv;
828
829 // OES_geometry_shader layout qualifiers.
830 TLayoutPrimitiveType primitiveType;
831 int invocations;
832 int maxVertices;
833
834 // EXT_blend_func_extended fragment output layout qualifier
835 int index;
836
837 private:
TLayoutQualifierTLayoutQualifier838 explicit constexpr TLayoutQualifier(int /*placeholder*/)
839 : location(-1),
840 locationsSpecified(0),
841 matrixPacking(EmpUnspecified),
842 blockStorage(EbsUnspecified),
843 localSize(-1),
844 binding(-1),
845 offset(-1),
846 imageInternalFormat(EiifUnspecified),
847 numViews(-1),
848 yuv(false),
849 primitiveType(EptUndefined),
850 invocations(0),
851 maxVertices(-1),
852 index(-1)
853 {}
854 };
855
856 struct TMemoryQualifier
857 {
858 // Must have a trivial default constructor since it is used in YYSTYPE.
859 TMemoryQualifier() = default;
860
isEmptyTMemoryQualifier861 bool isEmpty() const
862 {
863 return !readonly && !writeonly && !coherent && !restrictQualifier && !volatileQualifier;
864 }
865
CreateTMemoryQualifier866 constexpr static TMemoryQualifier Create() { return TMemoryQualifier(0); }
867
868 // GLSL ES 3.10 Revision 4, 4.9 Memory Access Qualifiers
869 // An image can be qualified as both readonly and writeonly. It still can be can be used with
870 // imageSize().
871 bool readonly;
872 bool writeonly;
873 bool coherent;
874
875 // restrict and volatile are reserved keywords in C/C++
876 bool restrictQualifier;
877 bool volatileQualifier;
878
879 private:
TMemoryQualifierTMemoryQualifier880 explicit constexpr TMemoryQualifier(int /*placeholder*/)
881 : readonly(false),
882 writeonly(false),
883 coherent(false),
884 restrictQualifier(false),
885 volatileQualifier(false)
886 {}
887 };
888
getWorkGroupSizeString(size_t dimension)889 inline const char *getWorkGroupSizeString(size_t dimension)
890 {
891 switch (dimension)
892 {
893 case 0u:
894 return "local_size_x";
895 case 1u:
896 return "local_size_y";
897 case 2u:
898 return "local_size_z";
899 default:
900 UNREACHABLE();
901 return "dimension out of bounds";
902 }
903 }
904
905 //
906 // This is just for debug and error message print out, carried along with the definitions above.
907 //
getQualifierString(TQualifier q)908 inline const char *getQualifierString(TQualifier q)
909 {
910 // clang-format off
911 switch(q)
912 {
913 case EvqTemporary: return "Temporary";
914 case EvqGlobal: return "Global";
915 case EvqConst: return "const";
916 case EvqAttribute: return "attribute";
917 case EvqVaryingIn: return "varying";
918 case EvqVaryingOut: return "varying";
919 case EvqUniform: return "uniform";
920 case EvqBuffer: return "buffer";
921 case EvqVertexIn: return "in";
922 case EvqFragmentOut: return "out";
923 case EvqVertexOut: return "out";
924 case EvqFragmentIn: return "in";
925 case EvqIn: return "in";
926 case EvqOut: return "out";
927 case EvqInOut: return "inout";
928 case EvqConstReadOnly: return "const";
929 case EvqInstanceID: return "InstanceID";
930 case EvqVertexID: return "VertexID";
931 case EvqPosition: return "Position";
932 case EvqPointSize: return "PointSize";
933 case EvqDrawID: return "DrawID";
934 case EvqBaseVertex: return "BaseVertex";
935 case EvqBaseInstance: return "BaseInstance";
936 case EvqFragCoord: return "FragCoord";
937 case EvqFrontFacing: return "FrontFacing";
938 case EvqPointCoord: return "PointCoord";
939 case EvqFragColor: return "FragColor";
940 case EvqFragData: return "FragData";
941 case EvqFragDepthEXT: return "FragDepth";
942 case EvqFragDepth: return "FragDepth";
943 case EvqSecondaryFragColorEXT: return "SecondaryFragColorEXT";
944 case EvqSecondaryFragDataEXT: return "SecondaryFragDataEXT";
945 case EvqViewIDOVR: return "ViewIDOVR";
946 case EvqViewportIndex: return "ViewportIndex";
947 case EvqLayer: return "Layer";
948 case EvqLastFragColor: return "LastFragColor";
949 case EvqLastFragData: return "LastFragData";
950 case EvqSmoothOut: return "smooth out";
951 case EvqCentroidOut: return "smooth centroid out";
952 case EvqFlatOut: return "flat out";
953 case EvqSmoothIn: return "smooth in";
954 case EvqFlatIn: return "flat in";
955 case EvqCentroidIn: return "smooth centroid in";
956 case EvqCentroid: return "centroid";
957 case EvqFlat: return "flat";
958 case EvqSmooth: return "smooth";
959 case EvqShared: return "shared";
960 case EvqComputeIn: return "in";
961 case EvqNumWorkGroups: return "NumWorkGroups";
962 case EvqWorkGroupSize: return "WorkGroupSize";
963 case EvqWorkGroupID: return "WorkGroupID";
964 case EvqLocalInvocationID: return "LocalInvocationID";
965 case EvqGlobalInvocationID: return "GlobalInvocationID";
966 case EvqLocalInvocationIndex: return "LocalInvocationIndex";
967 case EvqReadOnly: return "readonly";
968 case EvqWriteOnly: return "writeonly";
969 case EvqGeometryIn: return "in";
970 case EvqGeometryOut: return "out";
971 case EvqPerVertexIn: return "gl_in";
972 default: UNREACHABLE(); return "unknown qualifier";
973 }
974 // clang-format on
975 }
976
getMatrixPackingString(TLayoutMatrixPacking mpq)977 inline const char *getMatrixPackingString(TLayoutMatrixPacking mpq)
978 {
979 switch (mpq)
980 {
981 case EmpUnspecified:
982 return "mp_unspecified";
983 case EmpRowMajor:
984 return "row_major";
985 case EmpColumnMajor:
986 return "column_major";
987 default:
988 UNREACHABLE();
989 return "unknown matrix packing";
990 }
991 }
992
getBlockStorageString(TLayoutBlockStorage bsq)993 inline const char *getBlockStorageString(TLayoutBlockStorage bsq)
994 {
995 switch (bsq)
996 {
997 case EbsUnspecified:
998 return "bs_unspecified";
999 case EbsShared:
1000 return "shared";
1001 case EbsPacked:
1002 return "packed";
1003 case EbsStd140:
1004 return "std140";
1005 case EbsStd430:
1006 return "std430";
1007 default:
1008 UNREACHABLE();
1009 return "unknown block storage";
1010 }
1011 }
1012
getImageInternalFormatString(TLayoutImageInternalFormat iifq)1013 inline const char *getImageInternalFormatString(TLayoutImageInternalFormat iifq)
1014 {
1015 switch (iifq)
1016 {
1017 case EiifRGBA32F:
1018 return "rgba32f";
1019 case EiifRGBA16F:
1020 return "rgba16f";
1021 case EiifR32F:
1022 return "r32f";
1023 case EiifRGBA32UI:
1024 return "rgba32ui";
1025 case EiifRGBA16UI:
1026 return "rgba16ui";
1027 case EiifRGBA8UI:
1028 return "rgba8ui";
1029 case EiifR32UI:
1030 return "r32ui";
1031 case EiifRGBA32I:
1032 return "rgba32i";
1033 case EiifRGBA16I:
1034 return "rgba16i";
1035 case EiifRGBA8I:
1036 return "rgba8i";
1037 case EiifR32I:
1038 return "r32i";
1039 case EiifRGBA8:
1040 return "rgba8";
1041 case EiifRGBA8_SNORM:
1042 return "rgba8_snorm";
1043 default:
1044 UNREACHABLE();
1045 return "unknown internal image format";
1046 }
1047 }
1048
getYuvCscStandardEXT(const ImmutableString & str)1049 inline TYuvCscStandardEXT getYuvCscStandardEXT(const ImmutableString &str)
1050 {
1051 if (str == "itu_601")
1052 return EycsItu601;
1053 else if (str == "itu_601_full_range")
1054 return EycsItu601FullRange;
1055 else if (str == "itu_709")
1056 return EycsItu709;
1057 return EycsUndefined;
1058 }
1059
getYuvCscStandardEXTString(TYuvCscStandardEXT ycsq)1060 inline const char *getYuvCscStandardEXTString(TYuvCscStandardEXT ycsq)
1061 {
1062 switch (ycsq)
1063 {
1064 case EycsItu601:
1065 return "itu_601";
1066 case EycsItu601FullRange:
1067 return "itu_601_full_range";
1068 case EycsItu709:
1069 return "itu_709";
1070 default:
1071 UNREACHABLE();
1072 return "unknown color space conversion standard";
1073 }
1074 }
1075
getGeometryShaderPrimitiveTypeString(TLayoutPrimitiveType primitiveType)1076 inline const char *getGeometryShaderPrimitiveTypeString(TLayoutPrimitiveType primitiveType)
1077 {
1078 switch (primitiveType)
1079 {
1080 case EptPoints:
1081 return "points";
1082 case EptLines:
1083 return "lines";
1084 case EptTriangles:
1085 return "triangles";
1086 case EptLinesAdjacency:
1087 return "lines_adjacency";
1088 case EptTrianglesAdjacency:
1089 return "triangles_adjacency";
1090 case EptLineStrip:
1091 return "line_strip";
1092 case EptTriangleStrip:
1093 return "triangle_strip";
1094 default:
1095 UNREACHABLE();
1096 return "unknown geometry shader primitive type";
1097 }
1098 }
1099
1100 } // namespace sh
1101
1102 #endif // COMPILER_TRANSLATOR_BASETYPES_H_
1103