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