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