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 EbtDouble,
58 EbtInt,
59 EbtUInt,
60 EbtBool,
61
62 EbtAtomicCounter,
63 EbtYuvCscStandardEXT, // Only valid if EXT_YUV_target exists.
64
65 EbtGuardSamplerBegin, // non type: see implementation of IsSampler()
66 EbtSampler2D = EbtGuardSamplerBegin,
67 EbtSampler3D,
68 EbtSamplerCube,
69 EbtSampler2DArray,
70 EbtSamplerExternalOES, // Only valid if OES_EGL_image_external exists.
71 EbtSamplerExternal2DY2YEXT, // Only valid if GL_EXT_YUV_target exists.
72 EbtSampler2DRect, // Only valid if GL_ARB_texture_rectangle exists.
73 EbtSampler2DMS,
74 EbtSampler2DMSArray,
75 EbtISampler2D,
76 EbtISampler3D,
77 EbtISamplerCube,
78 EbtISampler2DArray,
79 EbtISampler2DMS,
80 EbtISampler2DMSArray,
81 EbtUSampler2D,
82 EbtUSampler3D,
83 EbtUSamplerCube,
84 EbtUSampler2DArray,
85 EbtUSampler2DMS,
86 EbtUSampler2DMSArray,
87 EbtSampler2DShadow,
88 EbtSamplerCubeShadow,
89 EbtSampler2DArrayShadow,
90 EbtSampler1D, // Desktop GLSL sampler types
91 EbtSampler1DArray,
92 EbtSampler1DArrayShadow,
93 EbtSamplerBuffer,
94 EbtSamplerCubeArray,
95 EbtSamplerCubeArrayShadow,
96 EbtSampler1DShadow,
97 EbtSampler2DRectShadow,
98 EbtISampler1D,
99 EbtISampler1DArray,
100 EbtISampler2DRect,
101 EbtISamplerBuffer,
102 EbtISamplerCubeArray,
103 EbtUSampler1D,
104 EbtUSampler1DArray,
105 EbtUSampler2DRect,
106 EbtUSamplerBuffer,
107 EbtUSamplerCubeArray,
108 EbtSamplerVideoWEBGL,
109 EbtGuardSamplerEnd = EbtSamplerVideoWEBGL, // non type: see implementation of IsSampler()
110
111 // images
112 EbtGuardImageBegin,
113 EbtImage2D = EbtGuardImageBegin,
114 EbtIImage2D,
115 EbtUImage2D,
116 EbtImage3D,
117 EbtIImage3D,
118 EbtUImage3D,
119 EbtImage2DArray,
120 EbtIImage2DArray,
121 EbtUImage2DArray,
122 EbtImageCube,
123 EbtIImageCube,
124 EbtUImageCube,
125 EbtImage1D, // Desktop GLSL image types
126 EbtIImage1D,
127 EbtUImage1D,
128 EbtImage1DArray,
129 EbtIImage1DArray,
130 EbtUImage1DArray,
131 EbtImage2DMS,
132 EbtIImage2DMS,
133 EbtUImage2DMS,
134 EbtImage2DMSArray,
135 EbtIImage2DMSArray,
136 EbtUImage2DMSArray,
137 EbtImage2DRect,
138 EbtIImage2DRect,
139 EbtUImage2DRect,
140 EbtImageCubeArray,
141 EbtIImageCubeArray,
142 EbtUImageCubeArray,
143 EbtImageRect,
144 EbtIImageRect,
145 EbtUImageRect,
146 EbtImageBuffer,
147 EbtIImageBuffer,
148 EbtUImageBuffer,
149 EbtGuardImageEnd = EbtUImageBuffer,
150
151 EbtSubpassInput,
152 EbtISubpassInput,
153 EbtUSubpassInput,
154 EbtSubpassInputMS,
155 EbtISubpassInputMS,
156 EbtUSubpassInputMS,
157
158 EbtLastSimpleType = EbtUSubpassInputMS,
159
160 EbtStruct,
161 EbtInterfaceBlock,
162
163 // end of list
164 EbtLast = EbtInterfaceBlock
165 };
166
167 class TBasicMangledName
168 {
169 public:
TBasicMangledName(TBasicType t)170 constexpr TBasicMangledName(TBasicType t) : mName{'\0', '\0'}
171 {
172 if (t > EbtLastSimpleType)
173 {
174 mName[0] = '{';
175 mName[1] = '\0';
176 }
177 else if (t < 26)
178 {
179 mName[0] = '0';
180 mName[1] = static_cast<char>('A' + t);
181 }
182 else if (t < 52)
183 {
184 mName[0] = '0';
185 mName[1] = static_cast<char>('a' - 26 + t);
186 }
187 else if (t < 78)
188 {
189 mName[0] = '1';
190 mName[1] = static_cast<char>('A' - 52 + t);
191 }
192 else if (t < 104)
193 {
194 mName[0] = '1';
195 mName[1] = static_cast<char>('a' - 78 + t);
196 }
197 }
198
getName()199 constexpr char *getName() { return mName; }
200
201 static constexpr int mangledNameSize = 2;
202
203 private:
204 char mName[mangledNameSize];
205 };
206
207 const char *getBasicString(TBasicType t);
208
IsSampler(TBasicType type)209 inline bool IsSampler(TBasicType type)
210 {
211 return type >= EbtGuardSamplerBegin && type <= EbtGuardSamplerEnd;
212 }
213
IsImage(TBasicType type)214 inline bool IsImage(TBasicType type)
215 {
216 return type >= EbtGuardImageBegin && type <= EbtGuardImageEnd;
217 }
218
IsAtomicCounter(TBasicType type)219 inline bool IsAtomicCounter(TBasicType type)
220 {
221 return type == EbtAtomicCounter;
222 }
223
IsOpaqueType(TBasicType type)224 inline bool IsOpaqueType(TBasicType type)
225 {
226 return IsSampler(type) || IsImage(type) || IsAtomicCounter(type);
227 }
228
IsIntegerSampler(TBasicType type)229 inline bool IsIntegerSampler(TBasicType type)
230 {
231 switch (type)
232 {
233 case EbtISampler2D:
234 case EbtISampler3D:
235 case EbtISamplerCube:
236 case EbtISampler2DArray:
237 case EbtISampler2DMS:
238 case EbtISampler2DMSArray:
239 case EbtUSampler2D:
240 case EbtUSampler3D:
241 case EbtUSamplerCube:
242 case EbtUSampler2DArray:
243 case EbtUSampler2DMS:
244 case EbtUSampler2DMSArray:
245 case EbtISampler1D:
246 case EbtISampler1DArray:
247 case EbtISampler2DRect:
248 case EbtISamplerBuffer:
249 case EbtISamplerCubeArray:
250 case EbtUSampler1D:
251 case EbtUSampler1DArray:
252 case EbtUSampler2DRect:
253 case EbtUSamplerBuffer:
254 case EbtUSamplerCubeArray:
255 return true;
256 case EbtSampler2D:
257 case EbtSampler3D:
258 case EbtSamplerCube:
259 case EbtSamplerExternalOES:
260 case EbtSamplerExternal2DY2YEXT:
261 case EbtSampler2DRect:
262 case EbtSampler2DArray:
263 case EbtSampler2DShadow:
264 case EbtSamplerCubeShadow:
265 case EbtSampler2DArrayShadow:
266 case EbtSampler2DMS:
267 case EbtSampler2DMSArray:
268 case EbtSampler1D:
269 case EbtSampler1DArray:
270 case EbtSampler1DArrayShadow:
271 case EbtSamplerBuffer:
272 case EbtSamplerCubeArray:
273 case EbtSamplerCubeArrayShadow:
274 case EbtSampler1DShadow:
275 case EbtSampler2DRectShadow:
276 case EbtSamplerVideoWEBGL:
277 return false;
278 default:
279 ASSERT(!IsSampler(type));
280 }
281
282 return false;
283 }
284
IsIntegerSamplerUnsigned(TBasicType type)285 inline bool IsIntegerSamplerUnsigned(TBasicType type)
286 {
287 switch (type)
288 {
289 case EbtISampler2D:
290 case EbtISampler3D:
291 case EbtISamplerCube:
292 case EbtISampler2DArray:
293 case EbtISampler2DMS:
294 case EbtISampler2DMSArray:
295 case EbtISampler1D:
296 case EbtISampler1DArray:
297 case EbtISampler2DRect:
298 case EbtISamplerBuffer:
299 case EbtISamplerCubeArray:
300 return false;
301 case EbtUSampler2D:
302 case EbtUSampler3D:
303 case EbtUSamplerCube:
304 case EbtUSampler2DArray:
305 case EbtUSampler2DMS:
306 case EbtUSampler2DMSArray:
307 case EbtUSampler1D:
308 case EbtUSampler1DArray:
309 case EbtUSampler2DRect:
310 case EbtUSamplerBuffer:
311 case EbtUSamplerCubeArray:
312 return true;
313 default:
314 ASSERT(!IsIntegerSampler(type));
315 }
316
317 return false;
318 }
319
IsSampler2DMS(TBasicType type)320 inline bool IsSampler2DMS(TBasicType type)
321 {
322 switch (type)
323 {
324 case EbtSampler2DMS:
325 case EbtISampler2DMS:
326 case EbtUSampler2DMS:
327 return true;
328 default:
329 return false;
330 }
331 }
332
IsSampler2DMSArray(TBasicType type)333 inline bool IsSampler2DMSArray(TBasicType type)
334 {
335 switch (type)
336 {
337 case EbtSampler2DMSArray:
338 case EbtISampler2DMSArray:
339 case EbtUSampler2DMSArray:
340 return true;
341 default:
342 return false;
343 }
344 }
345
IsFloatImage(TBasicType type)346 inline bool IsFloatImage(TBasicType type)
347 {
348 switch (type)
349 {
350 case EbtImage1D:
351 case EbtImage2D:
352 case EbtImage3D:
353 case EbtImage1DArray:
354 case EbtImage2DArray:
355 case EbtImageCube:
356 case EbtImage2DMS:
357 case EbtImage2DMSArray:
358 case EbtImage2DRect:
359 case EbtImageCubeArray:
360 case EbtImageRect:
361 case EbtImageBuffer:
362 return true;
363 default:
364 break;
365 }
366
367 return false;
368 }
369
IsIntegerImage(TBasicType type)370 inline bool IsIntegerImage(TBasicType type)
371 {
372
373 switch (type)
374 {
375 case EbtIImage1D:
376 case EbtIImage2D:
377 case EbtIImage3D:
378 case EbtIImage1DArray:
379 case EbtIImage2DArray:
380 case EbtIImageCube:
381 case EbtIImage2DMS:
382 case EbtIImage2DMSArray:
383 case EbtIImage2DRect:
384 case EbtIImageCubeArray:
385 case EbtIImageRect:
386 case EbtIImageBuffer:
387 return true;
388 default:
389 break;
390 }
391
392 return false;
393 }
394
IsUnsignedImage(TBasicType type)395 inline bool IsUnsignedImage(TBasicType type)
396 {
397
398 switch (type)
399 {
400 case EbtUImage1D:
401 case EbtUImage2D:
402 case EbtUImage3D:
403 case EbtUImage1DArray:
404 case EbtUImage2DArray:
405 case EbtUImageCube:
406 case EbtUImage2DMS:
407 case EbtUImage2DMSArray:
408 case EbtUImage2DRect:
409 case EbtUImageCubeArray:
410 case EbtUImageRect:
411 case EbtUImageBuffer:
412 return true;
413 default:
414 break;
415 }
416
417 return false;
418 }
419
420 // Samplers are divided into 4 disjoint categories: 2D, cube, 3D, and array.
421 // Array samplers are not 2D samplers.
IsSampler2D(TBasicType type)422 inline bool IsSampler2D(TBasicType type)
423 {
424 switch (type)
425 {
426 case EbtSampler2D:
427 case EbtISampler2D:
428 case EbtUSampler2D:
429 case EbtSampler2DRect:
430 case EbtISampler2DRect:
431 case EbtUSampler2DRect:
432 case EbtSampler2DRectShadow:
433 case EbtSamplerExternalOES:
434 case EbtSamplerExternal2DY2YEXT:
435 case EbtSampler2DShadow:
436 case EbtSampler2DMS:
437 case EbtISampler2DMS:
438 case EbtUSampler2DMS:
439 case EbtSamplerVideoWEBGL:
440 return true;
441 case EbtSampler2DArray:
442 case EbtISampler2DArray:
443 case EbtUSampler2DArray:
444 case EbtSampler2DMSArray:
445 case EbtISampler2DMSArray:
446 case EbtUSampler2DMSArray:
447 case EbtSampler2DArrayShadow:
448 case EbtSampler3D:
449 case EbtISampler3D:
450 case EbtUSampler3D:
451 case EbtISamplerCube:
452 case EbtUSamplerCube:
453 case EbtSamplerCube:
454 case EbtSamplerCubeShadow:
455 case EbtSampler1D:
456 case EbtSampler1DArray:
457 case EbtSampler1DArrayShadow:
458 case EbtSamplerBuffer:
459 case EbtSamplerCubeArray:
460 case EbtSamplerCubeArrayShadow:
461 case EbtSampler1DShadow:
462 case EbtISampler1D:
463 case EbtISampler1DArray:
464 case EbtISamplerBuffer:
465 case EbtISamplerCubeArray:
466 case EbtUSampler1D:
467 case EbtUSampler1DArray:
468 case EbtUSamplerBuffer:
469 case EbtUSamplerCubeArray:
470 return false;
471 default:
472 ASSERT(!IsSampler(type));
473 }
474
475 return false;
476 }
477
IsSamplerCube(TBasicType type)478 inline bool IsSamplerCube(TBasicType type)
479 {
480 switch (type)
481 {
482 case EbtSamplerCube:
483 case EbtISamplerCube:
484 case EbtUSamplerCube:
485 case EbtSamplerCubeShadow:
486 return true;
487 case EbtSampler2D:
488 case EbtSampler3D:
489 case EbtSamplerExternalOES:
490 case EbtSamplerExternal2DY2YEXT:
491 case EbtSampler2DRect:
492 case EbtSampler2DArray:
493 case EbtSampler2DMS:
494 case EbtSampler2DMSArray:
495 case EbtISampler2D:
496 case EbtISampler3D:
497 case EbtISampler2DArray:
498 case EbtISampler2DMS:
499 case EbtISampler2DMSArray:
500 case EbtUSampler2D:
501 case EbtUSampler3D:
502 case EbtUSampler2DArray:
503 case EbtUSampler2DMS:
504 case EbtUSampler2DMSArray:
505 case EbtSampler2DShadow:
506 case EbtSampler2DArrayShadow:
507 case EbtSampler1D:
508 case EbtSampler1DArray:
509 case EbtSampler1DArrayShadow:
510 case EbtSamplerBuffer:
511 case EbtSamplerCubeArray:
512 case EbtSamplerCubeArrayShadow:
513 case EbtSampler1DShadow:
514 case EbtSampler2DRectShadow:
515 case EbtISampler1D:
516 case EbtISampler1DArray:
517 case EbtISampler2DRect:
518 case EbtISamplerBuffer:
519 case EbtISamplerCubeArray:
520 case EbtUSampler1D:
521 case EbtUSampler1DArray:
522 case EbtUSampler2DRect:
523 case EbtUSamplerBuffer:
524 case EbtUSamplerCubeArray:
525 case EbtSamplerVideoWEBGL:
526 return false;
527 default:
528 ASSERT(!IsSampler(type));
529 }
530
531 return false;
532 }
533
IsSampler3D(TBasicType type)534 inline bool IsSampler3D(TBasicType type)
535 {
536 switch (type)
537 {
538 case EbtSampler3D:
539 case EbtISampler3D:
540 case EbtUSampler3D:
541 return true;
542 case EbtSampler2D:
543 case EbtSamplerCube:
544 case EbtSamplerExternalOES:
545 case EbtSamplerExternal2DY2YEXT:
546 case EbtSampler2DRect:
547 case EbtSampler2DArray:
548 case EbtSampler2DMS:
549 case EbtSampler2DMSArray:
550 case EbtISampler2D:
551 case EbtISamplerCube:
552 case EbtISampler2DArray:
553 case EbtISampler2DMS:
554 case EbtISampler2DMSArray:
555 case EbtUSampler2D:
556 case EbtUSamplerCube:
557 case EbtUSampler2DArray:
558 case EbtUSampler2DMS:
559 case EbtUSampler2DMSArray:
560 case EbtSampler2DShadow:
561 case EbtSamplerCubeShadow:
562 case EbtSampler2DArrayShadow:
563 case EbtSampler1D:
564 case EbtSampler1DArray:
565 case EbtSampler1DArrayShadow:
566 case EbtSamplerBuffer:
567 case EbtSamplerCubeArray:
568 case EbtSamplerCubeArrayShadow:
569 case EbtSampler1DShadow:
570 case EbtSampler2DRectShadow:
571 case EbtISampler1D:
572 case EbtISampler1DArray:
573 case EbtISampler2DRect:
574 case EbtISamplerBuffer:
575 case EbtISamplerCubeArray:
576 case EbtUSampler1D:
577 case EbtUSampler1DArray:
578 case EbtUSampler2DRect:
579 case EbtUSamplerBuffer:
580 case EbtUSamplerCubeArray:
581 case EbtSamplerVideoWEBGL:
582 return false;
583 default:
584 ASSERT(!IsSampler(type));
585 }
586
587 return false;
588 }
589
IsSamplerArray(TBasicType type)590 inline bool IsSamplerArray(TBasicType type)
591 {
592 switch (type)
593 {
594 case EbtSampler1DArray:
595 case EbtISampler1DArray:
596 case EbtUSampler1DArray:
597 case EbtSampler1DArrayShadow:
598 case EbtSampler2DArray:
599 case EbtISampler2DArray:
600 case EbtUSampler2DArray:
601 case EbtSampler2DMSArray:
602 case EbtISampler2DMSArray:
603 case EbtUSampler2DMSArray:
604 case EbtSampler2DArrayShadow:
605 case EbtSamplerCubeArray:
606 case EbtISamplerCubeArray:
607 case EbtUSamplerCubeArray:
608 case EbtSamplerCubeArrayShadow:
609 return true;
610 case EbtSampler2D:
611 case EbtISampler2D:
612 case EbtUSampler2D:
613 case EbtSampler2DRect:
614 case EbtSamplerExternalOES:
615 case EbtSamplerExternal2DY2YEXT:
616 case EbtSampler3D:
617 case EbtISampler3D:
618 case EbtUSampler3D:
619 case EbtISamplerCube:
620 case EbtUSamplerCube:
621 case EbtSamplerCube:
622 case EbtSampler2DShadow:
623 case EbtSamplerCubeShadow:
624 case EbtSampler2DMS:
625 case EbtISampler2DMS:
626 case EbtUSampler2DMS:
627 case EbtSampler1D:
628 case EbtSamplerBuffer:
629 case EbtSampler1DShadow:
630 case EbtSampler2DRectShadow:
631 case EbtISampler1D:
632 case EbtISampler2DRect:
633 case EbtISamplerBuffer:
634 case EbtUSampler1D:
635 case EbtUSampler2DRect:
636 case EbtUSamplerBuffer:
637 case EbtSamplerVideoWEBGL:
638 return false;
639 default:
640 ASSERT(!IsSampler(type));
641 }
642
643 return false;
644 }
645
IsShadowSampler(TBasicType type)646 inline bool IsShadowSampler(TBasicType type)
647 {
648 switch (type)
649 {
650 case EbtSampler1DShadow:
651 case EbtSampler2DShadow:
652 case EbtSamplerCubeShadow:
653 case EbtSampler1DArrayShadow:
654 case EbtSampler2DArrayShadow:
655 case EbtSamplerCubeArrayShadow:
656 case EbtSampler2DRectShadow:
657 return true;
658 case EbtISampler2D:
659 case EbtISampler3D:
660 case EbtISamplerCube:
661 case EbtISampler2DArray:
662 case EbtISampler2DMS:
663 case EbtISampler2DMSArray:
664 case EbtUSampler2D:
665 case EbtUSampler3D:
666 case EbtUSamplerCube:
667 case EbtUSampler2DArray:
668 case EbtUSampler2DMS:
669 case EbtUSampler2DMSArray:
670 case EbtSampler2D:
671 case EbtSampler3D:
672 case EbtSamplerCube:
673 case EbtSamplerExternalOES:
674 case EbtSamplerExternal2DY2YEXT:
675 case EbtSampler2DRect:
676 case EbtSampler2DArray:
677 case EbtSampler2DMS:
678 case EbtSampler2DMSArray:
679 case EbtSampler1D:
680 case EbtSampler1DArray:
681 case EbtSamplerBuffer:
682 case EbtSamplerCubeArray:
683 case EbtISampler1D:
684 case EbtISampler1DArray:
685 case EbtISampler2DRect:
686 case EbtISamplerBuffer:
687 case EbtISamplerCubeArray:
688 case EbtUSampler1D:
689 case EbtUSampler1DArray:
690 case EbtUSampler2DRect:
691 case EbtUSamplerBuffer:
692 case EbtUSamplerCubeArray:
693 case EbtSamplerVideoWEBGL:
694 return false;
695 default:
696 ASSERT(!IsSampler(type));
697 }
698
699 return false;
700 }
701
IsImage2D(TBasicType type)702 inline bool IsImage2D(TBasicType type)
703 {
704 switch (type)
705 {
706 case EbtImage2D:
707 case EbtIImage2D:
708 case EbtUImage2D:
709 case EbtImage2DRect:
710 case EbtIImage2DRect:
711 case EbtUImage2DRect:
712 case EbtImage2DMS:
713 case EbtIImage2DMS:
714 case EbtUImage2DMS:
715 return true;
716 case EbtImage3D:
717 case EbtIImage3D:
718 case EbtUImage3D:
719 case EbtImage2DArray:
720 case EbtIImage2DArray:
721 case EbtUImage2DArray:
722 case EbtImageCube:
723 case EbtIImageCube:
724 case EbtUImageCube:
725 case EbtImage1D:
726 case EbtIImage1D:
727 case EbtUImage1D:
728 case EbtImage1DArray:
729 case EbtIImage1DArray:
730 case EbtUImage1DArray:
731 case EbtImage2DMSArray:
732 case EbtIImage2DMSArray:
733 case EbtUImage2DMSArray:
734 case EbtImageCubeArray:
735 case EbtIImageCubeArray:
736 case EbtUImageCubeArray:
737 case EbtImageRect:
738 case EbtIImageRect:
739 case EbtUImageRect:
740 case EbtImageBuffer:
741 case EbtIImageBuffer:
742 case EbtUImageBuffer:
743 return false;
744 default:
745 ASSERT(!IsImage(type));
746 }
747
748 return false;
749 }
750
IsImage3D(TBasicType type)751 inline bool IsImage3D(TBasicType type)
752 {
753 switch (type)
754 {
755 case EbtImage3D:
756 case EbtIImage3D:
757 case EbtUImage3D:
758 return true;
759 case EbtImage2D:
760 case EbtIImage2D:
761 case EbtUImage2D:
762 case EbtImage2DArray:
763 case EbtIImage2DArray:
764 case EbtUImage2DArray:
765 case EbtImageCube:
766 case EbtIImageCube:
767 case EbtUImageCube:
768 case EbtImage1D:
769 case EbtIImage1D:
770 case EbtUImage1D:
771 case EbtImage1DArray:
772 case EbtIImage1DArray:
773 case EbtUImage1DArray:
774 case EbtImage2DMS:
775 case EbtIImage2DMS:
776 case EbtUImage2DMS:
777 case EbtImage2DMSArray:
778 case EbtIImage2DMSArray:
779 case EbtUImage2DMSArray:
780 case EbtImage2DRect:
781 case EbtIImage2DRect:
782 case EbtUImage2DRect:
783 case EbtImageCubeArray:
784 case EbtIImageCubeArray:
785 case EbtUImageCubeArray:
786 case EbtImageRect:
787 case EbtIImageRect:
788 case EbtUImageRect:
789 case EbtImageBuffer:
790 case EbtIImageBuffer:
791 case EbtUImageBuffer:
792 return false;
793 default:
794 ASSERT(!IsImage(type));
795 }
796
797 return false;
798 }
799
IsImage2DArray(TBasicType type)800 inline bool IsImage2DArray(TBasicType type)
801 {
802 switch (type)
803 {
804 case EbtImage2DArray:
805 case EbtIImage2DArray:
806 case EbtUImage2DArray:
807 case EbtImage2DMSArray:
808 case EbtIImage2DMSArray:
809 case EbtUImage2DMSArray:
810 return true;
811 case EbtImage2D:
812 case EbtIImage2D:
813 case EbtUImage2D:
814 case EbtImage3D:
815 case EbtIImage3D:
816 case EbtUImage3D:
817 case EbtImageCube:
818 case EbtIImageCube:
819 case EbtUImageCube:
820 case EbtImage1D:
821 case EbtIImage1D:
822 case EbtUImage1D:
823 case EbtImage1DArray:
824 case EbtIImage1DArray:
825 case EbtUImage1DArray:
826 case EbtImage2DMS:
827 case EbtIImage2DMS:
828 case EbtUImage2DMS:
829 case EbtImage2DRect:
830 case EbtIImage2DRect:
831 case EbtUImage2DRect:
832 case EbtImageCubeArray:
833 case EbtIImageCubeArray:
834 case EbtUImageCubeArray:
835 case EbtImageRect:
836 case EbtIImageRect:
837 case EbtUImageRect:
838 case EbtImageBuffer:
839 case EbtIImageBuffer:
840 case EbtUImageBuffer:
841 return false;
842 default:
843 ASSERT(!IsImage(type));
844 }
845
846 return false;
847 }
848
IsImageCube(TBasicType type)849 inline bool IsImageCube(TBasicType type)
850 {
851 switch (type)
852 {
853 case EbtImageCube:
854 case EbtIImageCube:
855 case EbtUImageCube:
856 return true;
857 case EbtImage2D:
858 case EbtIImage2D:
859 case EbtUImage2D:
860 case EbtImage3D:
861 case EbtIImage3D:
862 case EbtUImage3D:
863 case EbtImage2DArray:
864 case EbtIImage2DArray:
865 case EbtUImage2DArray:
866 case EbtImage1D:
867 case EbtIImage1D:
868 case EbtUImage1D:
869 case EbtImage1DArray:
870 case EbtIImage1DArray:
871 case EbtUImage1DArray:
872 case EbtImage2DMS:
873 case EbtIImage2DMS:
874 case EbtUImage2DMS:
875 case EbtImage2DMSArray:
876 case EbtIImage2DMSArray:
877 case EbtUImage2DMSArray:
878 case EbtImage2DRect:
879 case EbtIImage2DRect:
880 case EbtUImage2DRect:
881 case EbtImageCubeArray:
882 case EbtIImageCubeArray:
883 case EbtUImageCubeArray:
884 case EbtImageRect:
885 case EbtIImageRect:
886 case EbtUImageRect:
887 case EbtImageBuffer:
888 case EbtIImageBuffer:
889 case EbtUImageBuffer:
890 return false;
891 default:
892 ASSERT(!IsImage(type));
893 }
894
895 return false;
896 }
897
IsInteger(TBasicType type)898 inline bool IsInteger(TBasicType type)
899 {
900 return type == EbtInt || type == EbtUInt;
901 }
902
SupportsPrecision(TBasicType type)903 inline bool SupportsPrecision(TBasicType type)
904 {
905 return type == EbtFloat || type == EbtInt || type == EbtUInt || IsOpaqueType(type);
906 }
907
908 //
909 // Qualifiers and built-ins. These are mainly used to see what can be read
910 // or written, and by the machine dependent translator to know which registers
911 // to allocate variables in. Since built-ins tend to go to different registers
912 // than varying or uniform, it makes sense they are peers, not sub-classes.
913 //
914 enum TQualifier
915 {
916 EvqTemporary, // For temporaries (within a function), read/write
917 EvqGlobal, // For globals read/write
918 EvqConst, // User defined constants and non-output parameters in functions
919 EvqAttribute, // Readonly
920 EvqVaryingIn, // readonly, fragment shaders only
921 EvqVaryingOut, // vertex shaders only read/write
922 EvqUniform, // Readonly, vertex and fragment
923 EvqBuffer, // read/write, vertex, fragment and compute shader
924
925 EvqVertexIn, // Vertex shader input
926 EvqFragmentOut, // Fragment shader output
927 EvqVertexOut, // Vertex shader output
928 EvqFragmentIn, // Fragment shader input
929
930 // parameters
931 EvqIn,
932 EvqOut,
933 EvqInOut,
934 EvqConstReadOnly,
935
936 // built-ins read by vertex shader
937 EvqInstanceID,
938 EvqVertexID,
939
940 // built-ins written by vertex shader
941 EvqPosition,
942 EvqPointSize,
943
944 EvqDrawID, // ANGLE_multi_draw
945
946 EvqBaseVertex, // ANGLE_base_vertex_base_instance
947 EvqBaseInstance, // ANGLE_base_vertex_base_instance
948
949 // built-ins read by fragment shader
950 EvqFragCoord,
951 EvqFrontFacing,
952 EvqPointCoord,
953 EvqHelperInvocation,
954
955 // built-ins written by fragment shader
956 EvqFragColor,
957 EvqFragData,
958
959 EvqFragDepth, // gl_FragDepth for ESSL300.
960 EvqFragDepthEXT, // gl_FragDepthEXT for ESSL100, EXT_frag_depth.
961
962 EvqSecondaryFragColorEXT, // EXT_blend_func_extended
963 EvqSecondaryFragDataEXT, // EXT_blend_func_extended
964
965 EvqViewIDOVR, // OVR_multiview
966 EvqViewportIndex, // gl_ViewportIndex
967
968 EvqClipDistance, // APPLE_clip_distance/EXT_clip_cull_distance
969
970 // built-ins written by the shader_framebuffer_fetch extension(s)
971 EvqLastFragColor,
972 EvqLastFragData,
973
974 // GLSL ES 3.0 vertex output and fragment input
975 EvqSmooth, // Incomplete qualifier, smooth is the default
976 EvqFlat, // Incomplete qualifier
977 EvqNoPerspective, // Incomplete qualifier
978 EvqCentroid, // Incomplete qualifier
979 EvqSample,
980 EvqSmoothOut,
981 EvqFlatOut,
982 EvqNoPerspectiveOut,
983 EvqCentroidOut, // Implies smooth
984 EvqSampleOut,
985 EvqSmoothIn,
986 EvqFlatIn,
987 EvqNoPerspectiveIn,
988 EvqCentroidIn, // Implies smooth
989 EvqSampleIn,
990
991 // GLSL ES 3.1 compute shader special variables
992 EvqShared,
993 EvqComputeIn,
994 EvqNumWorkGroups,
995 EvqWorkGroupSize,
996 EvqWorkGroupID,
997 EvqLocalInvocationID,
998 EvqGlobalInvocationID,
999 EvqLocalInvocationIndex,
1000
1001 // GLSL ES 3.1 memory qualifiers
1002 EvqReadOnly,
1003 EvqWriteOnly,
1004 EvqCoherent,
1005 EvqRestrict,
1006 EvqVolatile,
1007
1008 // GLSL ES 3.1 extension EXT_geometry_shader qualifiers
1009 EvqGeometryIn,
1010 EvqGeometryOut,
1011 EvqPerVertexIn, // gl_in
1012 EvqPrimitiveIDIn, // gl_PrimitiveIDIn
1013 EvqInvocationID, // gl_InvocationID
1014 EvqPrimitiveID, // gl_PrimitiveID
1015 EvqLayer, // gl_Layer
1016
1017 // GLSL ES 3.1 extension EXT_gpu_shader5 qualifiers
1018 EvqPrecise,
1019
1020 // end of list
1021 EvqLast
1022 };
1023
IsQualifierUnspecified(TQualifier qualifier)1024 inline bool IsQualifierUnspecified(TQualifier qualifier)
1025 {
1026 return (qualifier == EvqTemporary || qualifier == EvqGlobal);
1027 }
1028
IsStorageBuffer(TQualifier qualifier)1029 inline bool IsStorageBuffer(TQualifier qualifier)
1030 {
1031 return qualifier == EvqBuffer;
1032 }
1033
IsShaderIn(TQualifier qualifier)1034 inline bool IsShaderIn(TQualifier qualifier)
1035 {
1036 switch (qualifier)
1037 {
1038 case EvqVertexIn:
1039 case EvqGeometryIn:
1040 case EvqFragmentIn:
1041 case EvqAttribute:
1042 case EvqVaryingIn:
1043 case EvqSmoothIn:
1044 case EvqFlatIn:
1045 case EvqNoPerspectiveIn:
1046 case EvqCentroidIn:
1047 case EvqSampleIn:
1048 return true;
1049 default:
1050 return false;
1051 }
1052 }
1053
IsShaderOut(TQualifier qualifier)1054 inline bool IsShaderOut(TQualifier qualifier)
1055 {
1056 switch (qualifier)
1057 {
1058 case EvqVertexOut:
1059 case EvqGeometryOut:
1060 case EvqFragmentOut:
1061 case EvqVaryingOut:
1062 case EvqSmoothOut:
1063 case EvqFlatOut:
1064 case EvqNoPerspectiveOut:
1065 case EvqCentroidOut:
1066 case EvqSampleOut:
1067 return true;
1068 default:
1069 return false;
1070 }
1071 }
1072
1073 enum TLayoutImageInternalFormat
1074 {
1075 EiifUnspecified,
1076 EiifRGBA32F,
1077 EiifRGBA16F,
1078 EiifR32F,
1079 EiifRGBA32UI,
1080 EiifRGBA16UI,
1081 EiifRGBA8UI,
1082 EiifR32UI,
1083 EiifRGBA32I,
1084 EiifRGBA16I,
1085 EiifRGBA8I,
1086 EiifR32I,
1087 EiifRGBA8,
1088 EiifRGBA8_SNORM
1089 };
1090
1091 enum TLayoutMatrixPacking
1092 {
1093 EmpUnspecified,
1094 EmpRowMajor,
1095 EmpColumnMajor
1096 };
1097
1098 enum TLayoutBlockStorage
1099 {
1100 EbsUnspecified,
1101 EbsShared,
1102 EbsPacked,
1103 EbsStd140,
1104 EbsStd430
1105 };
1106
1107 enum TYuvCscStandardEXT
1108 {
1109 EycsUndefined,
1110 EycsItu601,
1111 EycsItu601FullRange,
1112 EycsItu709
1113 };
1114
1115 enum TLayoutPrimitiveType
1116 {
1117 EptUndefined,
1118 EptPoints,
1119 EptLines,
1120 EptLinesAdjacency,
1121 EptTriangles,
1122 EptTrianglesAdjacency,
1123 EptLineStrip,
1124 EptTriangleStrip
1125 };
1126
1127 struct TLayoutQualifier
1128 {
1129 // Must have a trivial default constructor since it is used in YYSTYPE.
1130 TLayoutQualifier() = default;
1131
CreateTLayoutQualifier1132 constexpr static TLayoutQualifier Create() { return TLayoutQualifier(0); }
1133
isEmptyTLayoutQualifier1134 bool isEmpty() const
1135 {
1136 return location == -1 && binding == -1 && offset == -1 && numViews == -1 && yuv == false &&
1137 earlyFragmentTests == false && matrixPacking == EmpUnspecified &&
1138 blockStorage == EbsUnspecified && !localSize.isAnyValueSet() &&
1139 imageInternalFormat == EiifUnspecified && primitiveType == EptUndefined &&
1140 invocations == 0 && maxVertices == -1 && index == -1;
1141 }
1142
isCombinationValidTLayoutQualifier1143 bool isCombinationValid() const
1144 {
1145 bool workGroupSizeSpecified = localSize.isAnyValueSet();
1146 bool numViewsSet = (numViews != -1);
1147 bool geometryShaderSpecified =
1148 (primitiveType != EptUndefined) || (invocations != 0) || (maxVertices != -1);
1149 bool otherLayoutQualifiersSpecified =
1150 (location != -1 || binding != -1 || index != -1 || matrixPacking != EmpUnspecified ||
1151 blockStorage != EbsUnspecified || imageInternalFormat != EiifUnspecified);
1152
1153 // we can have either the work group size specified, or number of views,
1154 // or yuv layout qualifier, or early_fragment_tests layout qualifier, or the other layout
1155 // qualifiers.
1156 return (workGroupSizeSpecified ? 1 : 0) + (numViewsSet ? 1 : 0) + (yuv ? 1 : 0) +
1157 (earlyFragmentTests ? 1 : 0) + (otherLayoutQualifiersSpecified ? 1 : 0) +
1158 (geometryShaderSpecified ? 1 : 0) <=
1159 1;
1160 }
1161
isLocalSizeEqualTLayoutQualifier1162 bool isLocalSizeEqual(const WorkGroupSize &localSizeIn) const
1163 {
1164 return localSize.isWorkGroupSizeMatching(localSizeIn);
1165 }
1166
1167 int location;
1168 unsigned int locationsSpecified;
1169 TLayoutMatrixPacking matrixPacking;
1170 TLayoutBlockStorage blockStorage;
1171
1172 // Compute shader layout qualifiers.
1173 WorkGroupSize localSize;
1174
1175 int binding;
1176 int offset;
1177
1178 // Image format layout qualifier
1179 TLayoutImageInternalFormat imageInternalFormat;
1180
1181 // OVR_multiview num_views.
1182 int numViews;
1183
1184 // EXT_YUV_target yuv layout qualifier.
1185 bool yuv;
1186
1187 // early_fragment_tests qualifier.
1188 bool earlyFragmentTests;
1189
1190 // OES_geometry_shader layout qualifiers.
1191 TLayoutPrimitiveType primitiveType;
1192 int invocations;
1193 int maxVertices;
1194
1195 // EXT_blend_func_extended fragment output layout qualifier
1196 int index;
1197
1198 private:
TLayoutQualifierTLayoutQualifier1199 explicit constexpr TLayoutQualifier(int /*placeholder*/)
1200 : location(-1),
1201 locationsSpecified(0),
1202 matrixPacking(EmpUnspecified),
1203 blockStorage(EbsUnspecified),
1204 localSize(-1),
1205 binding(-1),
1206 offset(-1),
1207 imageInternalFormat(EiifUnspecified),
1208 numViews(-1),
1209 yuv(false),
1210 earlyFragmentTests(false),
1211 primitiveType(EptUndefined),
1212 invocations(0),
1213 maxVertices(-1),
1214 index(-1)
1215 {}
1216 };
1217
1218 struct TMemoryQualifier
1219 {
1220 // Must have a trivial default constructor since it is used in YYSTYPE.
1221 TMemoryQualifier() = default;
1222
isEmptyTMemoryQualifier1223 bool isEmpty() const
1224 {
1225 return !readonly && !writeonly && !coherent && !restrictQualifier && !volatileQualifier;
1226 }
1227
CreateTMemoryQualifier1228 constexpr static TMemoryQualifier Create() { return TMemoryQualifier(0); }
1229
1230 // GLSL ES 3.10 Revision 4, 4.9 Memory Access Qualifiers
1231 // An image can be qualified as both readonly and writeonly. It still can be can be used with
1232 // imageSize().
1233 bool readonly;
1234 bool writeonly;
1235 bool coherent;
1236
1237 // restrict and volatile are reserved keywords in C/C++
1238 bool restrictQualifier;
1239 bool volatileQualifier;
1240
1241 private:
TMemoryQualifierTMemoryQualifier1242 explicit constexpr TMemoryQualifier(int /*placeholder*/)
1243 : readonly(false),
1244 writeonly(false),
1245 coherent(false),
1246 restrictQualifier(false),
1247 volatileQualifier(false)
1248 {}
1249 };
1250
getWorkGroupSizeString(size_t dimension)1251 inline const char *getWorkGroupSizeString(size_t dimension)
1252 {
1253 switch (dimension)
1254 {
1255 case 0u:
1256 return "local_size_x";
1257 case 1u:
1258 return "local_size_y";
1259 case 2u:
1260 return "local_size_z";
1261 default:
1262 UNREACHABLE();
1263 return "dimension out of bounds";
1264 }
1265 }
1266
1267 //
1268 // This is just for debug and error message print out, carried along with the definitions above.
1269 //
getQualifierString(TQualifier q)1270 inline const char *getQualifierString(TQualifier q)
1271 {
1272 // clang-format off
1273 switch(q)
1274 {
1275 case EvqTemporary: return "Temporary";
1276 case EvqGlobal: return "Global";
1277 case EvqConst: return "const";
1278 case EvqAttribute: return "attribute";
1279 case EvqVaryingIn: return "varying";
1280 case EvqVaryingOut: return "varying";
1281 case EvqUniform: return "uniform";
1282 case EvqBuffer: return "buffer";
1283 case EvqVertexIn: return "in";
1284 case EvqFragmentOut: return "out";
1285 case EvqVertexOut: return "out";
1286 case EvqFragmentIn: return "in";
1287 case EvqIn: return "in";
1288 case EvqOut: return "out";
1289 case EvqInOut: return "inout";
1290 case EvqConstReadOnly: return "const";
1291 case EvqInstanceID: return "InstanceID";
1292 case EvqVertexID: return "VertexID";
1293 case EvqPosition: return "Position";
1294 case EvqPointSize: return "PointSize";
1295 case EvqDrawID: return "DrawID";
1296 case EvqBaseVertex: return "BaseVertex";
1297 case EvqBaseInstance: return "BaseInstance";
1298 case EvqFragCoord: return "FragCoord";
1299 case EvqFrontFacing: return "FrontFacing";
1300 case EvqHelperInvocation: return "HelperInvocation";
1301 case EvqPointCoord: return "PointCoord";
1302 case EvqFragColor: return "FragColor";
1303 case EvqFragData: return "FragData";
1304 case EvqFragDepthEXT: return "FragDepth";
1305 case EvqFragDepth: return "FragDepth";
1306 case EvqSecondaryFragColorEXT: return "SecondaryFragColorEXT";
1307 case EvqSecondaryFragDataEXT: return "SecondaryFragDataEXT";
1308 case EvqViewIDOVR: return "ViewIDOVR";
1309 case EvqViewportIndex: return "ViewportIndex";
1310 case EvqLayer: return "Layer";
1311 case EvqLastFragColor: return "LastFragColor";
1312 case EvqLastFragData: return "LastFragData";
1313 case EvqSmoothOut: return "smooth out";
1314 case EvqCentroidOut: return "smooth centroid out";
1315 case EvqFlatOut: return "flat out";
1316 case EvqNoPerspectiveOut: return "noperspective out";
1317 case EvqSmoothIn: return "smooth in";
1318 case EvqFlatIn: return "flat in";
1319 case EvqNoPerspectiveIn: return "noperspective in";
1320 case EvqCentroidIn: return "smooth centroid in";
1321 case EvqCentroid: return "centroid";
1322 case EvqFlat: return "flat";
1323 case EvqNoPerspective: return "noperspective";
1324 case EvqSmooth: return "smooth";
1325 case EvqShared: return "shared";
1326 case EvqComputeIn: return "in";
1327 case EvqNumWorkGroups: return "NumWorkGroups";
1328 case EvqWorkGroupSize: return "WorkGroupSize";
1329 case EvqWorkGroupID: return "WorkGroupID";
1330 case EvqLocalInvocationID: return "LocalInvocationID";
1331 case EvqGlobalInvocationID: return "GlobalInvocationID";
1332 case EvqLocalInvocationIndex: return "LocalInvocationIndex";
1333 case EvqReadOnly: return "readonly";
1334 case EvqWriteOnly: return "writeonly";
1335 case EvqGeometryIn: return "in";
1336 case EvqGeometryOut: return "out";
1337 case EvqPerVertexIn: return "gl_in";
1338 case EvqPrecise: return "precise";
1339 case EvqClipDistance: return "ClipDistance";
1340 case EvqSample: return "sample";
1341 case EvqSampleIn: return "sample in";
1342 case EvqSampleOut: return "sample out";
1343 default: UNREACHABLE(); return "unknown qualifier";
1344 }
1345 // clang-format on
1346 }
1347
getMatrixPackingString(TLayoutMatrixPacking mpq)1348 inline const char *getMatrixPackingString(TLayoutMatrixPacking mpq)
1349 {
1350 switch (mpq)
1351 {
1352 case EmpUnspecified:
1353 return "mp_unspecified";
1354 case EmpRowMajor:
1355 return "row_major";
1356 case EmpColumnMajor:
1357 return "column_major";
1358 default:
1359 UNREACHABLE();
1360 return "unknown matrix packing";
1361 }
1362 }
1363
getBlockStorageString(TLayoutBlockStorage bsq)1364 inline const char *getBlockStorageString(TLayoutBlockStorage bsq)
1365 {
1366 switch (bsq)
1367 {
1368 case EbsUnspecified:
1369 return "bs_unspecified";
1370 case EbsShared:
1371 return "shared";
1372 case EbsPacked:
1373 return "packed";
1374 case EbsStd140:
1375 return "std140";
1376 case EbsStd430:
1377 return "std430";
1378 default:
1379 UNREACHABLE();
1380 return "unknown block storage";
1381 }
1382 }
1383
getImageInternalFormatString(TLayoutImageInternalFormat iifq)1384 inline const char *getImageInternalFormatString(TLayoutImageInternalFormat iifq)
1385 {
1386 switch (iifq)
1387 {
1388 case EiifRGBA32F:
1389 return "rgba32f";
1390 case EiifRGBA16F:
1391 return "rgba16f";
1392 case EiifR32F:
1393 return "r32f";
1394 case EiifRGBA32UI:
1395 return "rgba32ui";
1396 case EiifRGBA16UI:
1397 return "rgba16ui";
1398 case EiifRGBA8UI:
1399 return "rgba8ui";
1400 case EiifR32UI:
1401 return "r32ui";
1402 case EiifRGBA32I:
1403 return "rgba32i";
1404 case EiifRGBA16I:
1405 return "rgba16i";
1406 case EiifRGBA8I:
1407 return "rgba8i";
1408 case EiifR32I:
1409 return "r32i";
1410 case EiifRGBA8:
1411 return "rgba8";
1412 case EiifRGBA8_SNORM:
1413 return "rgba8_snorm";
1414 default:
1415 UNREACHABLE();
1416 return "unknown internal image format";
1417 }
1418 }
1419
getYuvCscStandardEXT(const ImmutableString & str)1420 inline TYuvCscStandardEXT getYuvCscStandardEXT(const ImmutableString &str)
1421 {
1422 if (str == "itu_601")
1423 return EycsItu601;
1424 else if (str == "itu_601_full_range")
1425 return EycsItu601FullRange;
1426 else if (str == "itu_709")
1427 return EycsItu709;
1428 return EycsUndefined;
1429 }
1430
getYuvCscStandardEXTString(TYuvCscStandardEXT ycsq)1431 inline const char *getYuvCscStandardEXTString(TYuvCscStandardEXT ycsq)
1432 {
1433 switch (ycsq)
1434 {
1435 case EycsItu601:
1436 return "itu_601";
1437 case EycsItu601FullRange:
1438 return "itu_601_full_range";
1439 case EycsItu709:
1440 return "itu_709";
1441 default:
1442 UNREACHABLE();
1443 return "unknown color space conversion standard";
1444 }
1445 }
1446
getGeometryShaderPrimitiveTypeString(TLayoutPrimitiveType primitiveType)1447 inline const char *getGeometryShaderPrimitiveTypeString(TLayoutPrimitiveType primitiveType)
1448 {
1449 switch (primitiveType)
1450 {
1451 case EptPoints:
1452 return "points";
1453 case EptLines:
1454 return "lines";
1455 case EptTriangles:
1456 return "triangles";
1457 case EptLinesAdjacency:
1458 return "lines_adjacency";
1459 case EptTrianglesAdjacency:
1460 return "triangles_adjacency";
1461 case EptLineStrip:
1462 return "line_strip";
1463 case EptTriangleStrip:
1464 return "triangle_strip";
1465 default:
1466 UNREACHABLE();
1467 return "unknown geometry shader primitive type";
1468 }
1469 }
1470
1471 } // namespace sh
1472
1473 #endif // COMPILER_TRANSLATOR_BASETYPES_H_
1474