Line data Source code
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 :
34 0 : inline const char* getPrecisionString(TPrecision p)
35 : {
36 0 : switch(p)
37 : {
38 0 : case EbpHigh: return "highp";
39 0 : case EbpMedium: return "mediump";
40 0 : case EbpLow: return "lowp";
41 0 : default: return "mediump"; // Safest fallback
42 : }
43 : }
44 :
45 : //
46 : // Basic type. Arrays, vectors, etc., are orthogonal to this.
47 : //
48 : enum TBasicType
49 : {
50 : EbtVoid,
51 : EbtFloat,
52 : EbtInt,
53 : EbtUInt,
54 : EbtBool,
55 : EbtGVec4, // non type: represents vec4, ivec4, and uvec4
56 : EbtGenType, // non type: represents float, vec2, vec3, and vec4
57 : EbtGenIType, // non type: represents int, ivec2, ivec3, and ivec4
58 : EbtGenUType, // non type: represents uint, uvec2, uvec3, and uvec4
59 : EbtGenBType, // non type: represents bool, bvec2, bvec3, and bvec4
60 : EbtVec, // non type: represents vec2, vec3, and vec4
61 : EbtIVec, // non type: represents ivec2, ivec3, and ivec4
62 : EbtUVec, // non type: represents uvec2, uvec3, and uvec4
63 : EbtBVec, // non type: represents bvec2, bvec3, and bvec4
64 : EbtGuardSamplerBegin, // non type: see implementation of IsSampler()
65 : EbtSampler2D,
66 : EbtSampler3D,
67 : EbtSamplerCube,
68 : EbtSampler2DArray,
69 : EbtSamplerExternalOES, // Only valid if OES_EGL_image_external exists.
70 : EbtSampler2DRect, // Only valid if GL_ARB_texture_rectangle exists.
71 : EbtISampler2D,
72 : EbtISampler3D,
73 : EbtISamplerCube,
74 : EbtISampler2DArray,
75 : EbtUSampler2D,
76 : EbtUSampler3D,
77 : EbtUSamplerCube,
78 : EbtUSampler2DArray,
79 : EbtSampler2DShadow,
80 : EbtSamplerCubeShadow,
81 : EbtSampler2DArrayShadow,
82 : EbtGuardSamplerEnd, // non type: see implementation of IsSampler()
83 : EbtGSampler2D, // non type: represents sampler2D, isampler2D, and usampler2D
84 : EbtGSampler3D, // non type: represents sampler3D, isampler3D, and usampler3D
85 : EbtGSamplerCube, // non type: represents samplerCube, isamplerCube, and usamplerCube
86 : EbtGSampler2DArray, // non type: represents sampler2DArray, isampler2DArray, and
87 : // usampler2DArray
88 :
89 : // images
90 : EbtGuardImageBegin,
91 : EbtImage2D,
92 : EbtIImage2D,
93 : EbtUImage2D,
94 : EbtImage3D,
95 : EbtIImage3D,
96 : EbtUImage3D,
97 : EbtImage2DArray,
98 : EbtIImage2DArray,
99 : EbtUImage2DArray,
100 : EbtImageCube,
101 : EbtIImageCube,
102 : EbtUImageCube,
103 : EbtGuardImageEnd,
104 :
105 : EbtGuardGImageBegin,
106 : EbtGImage2D, // non type: represents image2D, uimage2D, iimage2D
107 : EbtGImage3D, // non type: represents image3D, uimage3D, iimage3D
108 : EbtGImage2DArray, // non type: represents image2DArray, uimage2DArray, iimage2DArray
109 : EbtGImageCube, // non type: represents imageCube, uimageCube, iimageCube
110 : EbtGuardGImageEnd,
111 :
112 : EbtStruct,
113 : EbtInterfaceBlock,
114 : EbtAddress, // should be deprecated??
115 :
116 : // end of list
117 : EbtLast
118 : };
119 :
120 0 : inline TBasicType convertGImageToFloatImage(TBasicType type)
121 : {
122 0 : switch (type)
123 : {
124 : case EbtGImage2D:
125 0 : return EbtImage2D;
126 : case EbtGImage3D:
127 0 : return EbtImage3D;
128 : case EbtGImage2DArray:
129 0 : return EbtImage2DArray;
130 : case EbtGImageCube:
131 0 : return EbtImageCube;
132 : default:
133 0 : UNREACHABLE();
134 : }
135 : return EbtLast;
136 : }
137 :
138 0 : inline TBasicType convertGImageToIntImage(TBasicType type)
139 : {
140 0 : switch (type)
141 : {
142 : case EbtGImage2D:
143 0 : return EbtIImage2D;
144 : case EbtGImage3D:
145 0 : return EbtIImage3D;
146 : case EbtGImage2DArray:
147 0 : return EbtIImage2DArray;
148 : case EbtGImageCube:
149 0 : return EbtIImageCube;
150 : default:
151 0 : UNREACHABLE();
152 : }
153 : return EbtLast;
154 : }
155 :
156 0 : inline TBasicType convertGImageToUnsignedImage(TBasicType type)
157 : {
158 0 : switch (type)
159 : {
160 : case EbtGImage2D:
161 0 : return EbtUImage2D;
162 : case EbtGImage3D:
163 0 : return EbtUImage3D;
164 : case EbtGImage2DArray:
165 0 : return EbtUImage2DArray;
166 : case EbtGImageCube:
167 0 : return EbtUImageCube;
168 : default:
169 0 : UNREACHABLE();
170 : }
171 : return EbtLast;
172 : }
173 :
174 : const char* getBasicString(TBasicType t);
175 :
176 0 : inline bool IsSampler(TBasicType type)
177 : {
178 0 : return type > EbtGuardSamplerBegin && type < EbtGuardSamplerEnd;
179 : }
180 :
181 0 : inline bool IsImage(TBasicType type)
182 : {
183 0 : return type > EbtGuardImageBegin && type < EbtGuardImageEnd;
184 : }
185 :
186 0 : inline bool IsGImage(TBasicType type)
187 : {
188 0 : return type > EbtGuardGImageBegin && type < EbtGuardGImageEnd;
189 : }
190 :
191 0 : inline bool IsOpaqueType(TBasicType type)
192 : {
193 : // TODO (mradev): add atomic types as opaque.
194 0 : return IsSampler(type) || IsImage(type);
195 : }
196 :
197 0 : inline bool IsIntegerSampler(TBasicType type)
198 : {
199 0 : switch (type)
200 : {
201 : case EbtISampler2D:
202 : case EbtISampler3D:
203 : case EbtISamplerCube:
204 : case EbtISampler2DArray:
205 : case EbtUSampler2D:
206 : case EbtUSampler3D:
207 : case EbtUSamplerCube:
208 : case EbtUSampler2DArray:
209 0 : return true;
210 : case EbtSampler2D:
211 : case EbtSampler3D:
212 : case EbtSamplerCube:
213 : case EbtSamplerExternalOES:
214 : case EbtSampler2DRect:
215 : case EbtSampler2DArray:
216 : case EbtSampler2DShadow:
217 : case EbtSamplerCubeShadow:
218 : case EbtSampler2DArrayShadow:
219 0 : return false;
220 : default:
221 0 : assert(!IsSampler(type));
222 : }
223 :
224 0 : return false;
225 : }
226 :
227 0 : inline bool IsFloatImage(TBasicType type)
228 : {
229 0 : switch (type)
230 : {
231 : case EbtImage2D:
232 : case EbtImage3D:
233 : case EbtImage2DArray:
234 : case EbtImageCube:
235 0 : return true;
236 : default:
237 0 : break;
238 : }
239 :
240 0 : return false;
241 : }
242 :
243 0 : inline bool IsIntegerImage(TBasicType type)
244 : {
245 :
246 0 : switch (type)
247 : {
248 : case EbtIImage2D:
249 : case EbtIImage3D:
250 : case EbtIImage2DArray:
251 : case EbtIImageCube:
252 0 : return true;
253 : default:
254 0 : break;
255 : }
256 :
257 0 : return false;
258 : }
259 :
260 0 : inline bool IsUnsignedImage(TBasicType type)
261 : {
262 :
263 0 : switch (type)
264 : {
265 : case EbtUImage2D:
266 : case EbtUImage3D:
267 : case EbtUImage2DArray:
268 : case EbtUImageCube:
269 0 : return true;
270 : default:
271 0 : break;
272 : }
273 :
274 0 : return false;
275 : }
276 :
277 0 : inline bool IsSampler2D(TBasicType type)
278 : {
279 0 : switch (type)
280 : {
281 : case EbtSampler2D:
282 : case EbtISampler2D:
283 : case EbtUSampler2D:
284 : case EbtSampler2DArray:
285 : case EbtISampler2DArray:
286 : case EbtUSampler2DArray:
287 : case EbtSampler2DRect:
288 : case EbtSamplerExternalOES:
289 : case EbtSampler2DShadow:
290 : case EbtSampler2DArrayShadow:
291 0 : return true;
292 : case EbtSampler3D:
293 : case EbtISampler3D:
294 : case EbtUSampler3D:
295 : case EbtISamplerCube:
296 : case EbtUSamplerCube:
297 : case EbtSamplerCube:
298 : case EbtSamplerCubeShadow:
299 0 : return false;
300 : default:
301 0 : assert(!IsSampler(type));
302 : }
303 :
304 0 : return false;
305 : }
306 :
307 0 : inline bool IsSamplerCube(TBasicType type)
308 : {
309 0 : switch (type)
310 : {
311 : case EbtSamplerCube:
312 : case EbtISamplerCube:
313 : case EbtUSamplerCube:
314 : case EbtSamplerCubeShadow:
315 0 : return true;
316 : case EbtSampler2D:
317 : case EbtSampler3D:
318 : case EbtSamplerExternalOES:
319 : case EbtSampler2DRect:
320 : case EbtSampler2DArray:
321 : case EbtISampler2D:
322 : case EbtISampler3D:
323 : case EbtISampler2DArray:
324 : case EbtUSampler2D:
325 : case EbtUSampler3D:
326 : case EbtUSampler2DArray:
327 : case EbtSampler2DShadow:
328 : case EbtSampler2DArrayShadow:
329 0 : return false;
330 : default:
331 0 : assert(!IsSampler(type));
332 : }
333 :
334 0 : return false;
335 : }
336 :
337 0 : inline bool IsSampler3D(TBasicType type)
338 : {
339 0 : switch (type)
340 : {
341 : case EbtSampler3D:
342 : case EbtISampler3D:
343 : case EbtUSampler3D:
344 0 : return true;
345 : case EbtSampler2D:
346 : case EbtSamplerCube:
347 : case EbtSamplerExternalOES:
348 : case EbtSampler2DRect:
349 : case EbtSampler2DArray:
350 : case EbtISampler2D:
351 : case EbtISamplerCube:
352 : case EbtISampler2DArray:
353 : case EbtUSampler2D:
354 : case EbtUSamplerCube:
355 : case EbtUSampler2DArray:
356 : case EbtSampler2DShadow:
357 : case EbtSamplerCubeShadow:
358 : case EbtSampler2DArrayShadow:
359 0 : return false;
360 : default:
361 0 : assert(!IsSampler(type));
362 : }
363 :
364 0 : return false;
365 : }
366 :
367 0 : inline bool IsSamplerArray(TBasicType type)
368 : {
369 0 : switch (type)
370 : {
371 : case EbtSampler2DArray:
372 : case EbtISampler2DArray:
373 : case EbtUSampler2DArray:
374 : case EbtSampler2DArrayShadow:
375 0 : return true;
376 : case EbtSampler2D:
377 : case EbtISampler2D:
378 : case EbtUSampler2D:
379 : case EbtSampler2DRect:
380 : case EbtSamplerExternalOES:
381 : case EbtSampler3D:
382 : case EbtISampler3D:
383 : case EbtUSampler3D:
384 : case EbtISamplerCube:
385 : case EbtUSamplerCube:
386 : case EbtSamplerCube:
387 : case EbtSampler2DShadow:
388 : case EbtSamplerCubeShadow:
389 0 : return false;
390 : default:
391 0 : assert(!IsSampler(type));
392 : }
393 :
394 0 : return false;
395 : }
396 :
397 0 : inline bool IsShadowSampler(TBasicType type)
398 : {
399 0 : switch (type)
400 : {
401 : case EbtSampler2DShadow:
402 : case EbtSamplerCubeShadow:
403 : case EbtSampler2DArrayShadow:
404 0 : return true;
405 : case EbtISampler2D:
406 : case EbtISampler3D:
407 : case EbtISamplerCube:
408 : case EbtISampler2DArray:
409 : case EbtUSampler2D:
410 : case EbtUSampler3D:
411 : case EbtUSamplerCube:
412 : case EbtUSampler2DArray:
413 : case EbtSampler2D:
414 : case EbtSampler3D:
415 : case EbtSamplerCube:
416 : case EbtSamplerExternalOES:
417 : case EbtSampler2DRect:
418 : case EbtSampler2DArray:
419 0 : return false;
420 : default:
421 0 : assert(!IsSampler(type));
422 : }
423 :
424 0 : return false;
425 : }
426 :
427 0 : inline bool IsInteger(TBasicType type)
428 : {
429 0 : return type == EbtInt || type == EbtUInt;
430 : }
431 :
432 0 : inline bool SupportsPrecision(TBasicType type)
433 : {
434 0 : return type == EbtFloat || type == EbtInt || type == EbtUInt || IsOpaqueType(type);
435 : }
436 :
437 : //
438 : // Qualifiers and built-ins. These are mainly used to see what can be read
439 : // or written, and by the machine dependent translator to know which registers
440 : // to allocate variables in. Since built-ins tend to go to different registers
441 : // than varying or uniform, it makes sense they are peers, not sub-classes.
442 : //
443 : enum TQualifier
444 : {
445 : EvqTemporary, // For temporaries (within a function), read/write
446 : EvqGlobal, // For globals read/write
447 : EvqConst, // User defined constants and non-output parameters in functions
448 : EvqAttribute, // Readonly
449 : EvqVaryingIn, // readonly, fragment shaders only
450 : EvqVaryingOut, // vertex shaders only read/write
451 : EvqUniform, // Readonly, vertex and fragment
452 :
453 : EvqVertexIn, // Vertex shader input
454 : EvqFragmentOut, // Fragment shader output
455 : EvqVertexOut, // Vertex shader output
456 : EvqFragmentIn, // Fragment shader input
457 :
458 : // parameters
459 : EvqIn,
460 : EvqOut,
461 : EvqInOut,
462 : EvqConstReadOnly,
463 :
464 : // built-ins read by vertex shader
465 : EvqInstanceID,
466 : EvqVertexID,
467 :
468 : // built-ins written by vertex shader
469 : EvqPosition,
470 : EvqPointSize,
471 :
472 : // built-ins read by fragment shader
473 : EvqFragCoord,
474 : EvqFrontFacing,
475 : EvqPointCoord,
476 :
477 : // built-ins written by fragment shader
478 : EvqFragColor,
479 : EvqFragData,
480 :
481 : EvqFragDepth, // gl_FragDepth for ESSL300.
482 : EvqFragDepthEXT, // gl_FragDepthEXT for ESSL100, EXT_frag_depth.
483 :
484 : EvqSecondaryFragColorEXT, // EXT_blend_func_extended
485 : EvqSecondaryFragDataEXT, // EXT_blend_func_extended
486 :
487 : // built-ins written by the shader_framebuffer_fetch extension(s)
488 : EvqLastFragColor,
489 : EvqLastFragData,
490 :
491 : // GLSL ES 3.0 vertex output and fragment input
492 : EvqSmooth, // Incomplete qualifier, smooth is the default
493 : EvqFlat, // Incomplete qualifier
494 : EvqCentroid, // Incomplete qualifier
495 : EvqSmoothOut,
496 : EvqFlatOut,
497 : EvqCentroidOut, // Implies smooth
498 : EvqSmoothIn,
499 : EvqFlatIn,
500 : EvqCentroidIn, // Implies smooth
501 :
502 : // GLSL ES 3.1 compute shader special variables
503 : EvqComputeIn,
504 : EvqNumWorkGroups,
505 : EvqWorkGroupSize,
506 : EvqWorkGroupID,
507 : EvqLocalInvocationID,
508 : EvqGlobalInvocationID,
509 : EvqLocalInvocationIndex,
510 :
511 : // GLSL ES 3.1 memory qualifiers
512 : EvqReadOnly,
513 : EvqWriteOnly,
514 : EvqCoherent,
515 : EvqRestrict,
516 : EvqVolatile,
517 :
518 : // end of list
519 : EvqLast
520 : };
521 :
522 0 : inline bool IsQualifierUnspecified(TQualifier qualifier)
523 : {
524 0 : return (qualifier == EvqTemporary || qualifier == EvqGlobal);
525 : }
526 :
527 : enum TLayoutImageInternalFormat
528 : {
529 : EiifUnspecified,
530 : EiifRGBA32F,
531 : EiifRGBA16F,
532 : EiifR32F,
533 : EiifRGBA32UI,
534 : EiifRGBA16UI,
535 : EiifRGBA8UI,
536 : EiifR32UI,
537 : EiifRGBA32I,
538 : EiifRGBA16I,
539 : EiifRGBA8I,
540 : EiifR32I,
541 : EiifRGBA8,
542 : EiifRGBA8_SNORM
543 : };
544 :
545 : enum TLayoutMatrixPacking
546 : {
547 : EmpUnspecified,
548 : EmpRowMajor,
549 : EmpColumnMajor
550 : };
551 :
552 : enum TLayoutBlockStorage
553 : {
554 : EbsUnspecified,
555 : EbsShared,
556 : EbsPacked,
557 : EbsStd140
558 : };
559 :
560 : struct TLayoutQualifier
561 : {
562 : int location;
563 : unsigned int locationsSpecified;
564 : TLayoutMatrixPacking matrixPacking;
565 : TLayoutBlockStorage blockStorage;
566 :
567 : // Compute shader layout qualifiers.
568 : sh::WorkGroupSize localSize;
569 :
570 : // Image format layout qualifier
571 : TLayoutImageInternalFormat imageInternalFormat;
572 :
573 0 : static TLayoutQualifier create()
574 : {
575 : TLayoutQualifier layoutQualifier;
576 :
577 0 : layoutQualifier.location = -1;
578 0 : layoutQualifier.locationsSpecified = 0;
579 0 : layoutQualifier.matrixPacking = EmpUnspecified;
580 0 : layoutQualifier.blockStorage = EbsUnspecified;
581 :
582 0 : layoutQualifier.localSize.fill(-1);
583 :
584 0 : layoutQualifier.imageInternalFormat = EiifUnspecified;
585 0 : return layoutQualifier;
586 : }
587 :
588 0 : bool isEmpty() const
589 : {
590 0 : return location == -1 && matrixPacking == EmpUnspecified &&
591 0 : blockStorage == EbsUnspecified && !localSize.isAnyValueSet() &&
592 0 : imageInternalFormat == EiifUnspecified;
593 : }
594 :
595 0 : bool isCombinationValid() const
596 : {
597 0 : bool workSizeSpecified = localSize.isAnyValueSet();
598 : bool otherLayoutQualifiersSpecified =
599 0 : (location != -1 || matrixPacking != EmpUnspecified || blockStorage != EbsUnspecified ||
600 0 : imageInternalFormat != EiifUnspecified);
601 :
602 : // we can have either the work group size specified, or the other layout qualifiers
603 0 : return !(workSizeSpecified && otherLayoutQualifiersSpecified);
604 : }
605 :
606 0 : bool isLocalSizeEqual(const sh::WorkGroupSize &localSizeIn) const
607 : {
608 0 : return localSize.isWorkGroupSizeMatching(localSizeIn);
609 : }
610 : };
611 :
612 : struct TMemoryQualifier
613 : {
614 : // GLSL ES 3.10 Revision 4, 4.9 Memory Access Qualifiers
615 : // An image can be qualified as both readonly and writeonly. It still can be can be used with
616 : // imageSize().
617 : bool readonly;
618 : bool writeonly;
619 : bool coherent;
620 :
621 : // restrict and volatile are reserved keywords in C/C++
622 : bool restrictQualifier;
623 : bool volatileQualifier;
624 0 : static TMemoryQualifier create()
625 : {
626 : TMemoryQualifier memoryQualifier;
627 :
628 0 : memoryQualifier.readonly = false;
629 0 : memoryQualifier.writeonly = false;
630 0 : memoryQualifier.coherent = false;
631 0 : memoryQualifier.restrictQualifier = false;
632 0 : memoryQualifier.volatileQualifier = false;
633 :
634 0 : return memoryQualifier;
635 : }
636 :
637 : bool isEmpty()
638 : {
639 : return !readonly && !writeonly && !coherent && !restrictQualifier && !volatileQualifier;
640 : }
641 : };
642 :
643 0 : inline const char *getWorkGroupSizeString(size_t dimension)
644 : {
645 0 : switch (dimension)
646 : {
647 : case 0u:
648 0 : return "local_size_x";
649 : case 1u:
650 0 : return "local_size_y";
651 : case 2u:
652 0 : return "local_size_z";
653 : default:
654 0 : UNREACHABLE();
655 : return "dimension out of bounds";
656 : }
657 : }
658 :
659 : //
660 : // This is just for debug print out, carried along with the definitions above.
661 : //
662 0 : inline const char* getQualifierString(TQualifier q)
663 : {
664 : // clang-format off
665 0 : switch(q)
666 : {
667 0 : case EvqTemporary: return "Temporary";
668 0 : case EvqGlobal: return "Global";
669 0 : case EvqConst: return "const";
670 0 : case EvqAttribute: return "attribute";
671 0 : case EvqVaryingIn: return "varying";
672 0 : case EvqVaryingOut: return "varying";
673 0 : case EvqUniform: return "uniform";
674 0 : case EvqVertexIn: return "in";
675 0 : case EvqFragmentOut: return "out";
676 0 : case EvqVertexOut: return "out";
677 0 : case EvqFragmentIn: return "in";
678 0 : case EvqIn: return "in";
679 0 : case EvqOut: return "out";
680 0 : case EvqInOut: return "inout";
681 0 : case EvqConstReadOnly: return "const";
682 0 : case EvqInstanceID: return "InstanceID";
683 0 : case EvqVertexID: return "VertexID";
684 0 : case EvqPosition: return "Position";
685 0 : case EvqPointSize: return "PointSize";
686 0 : case EvqFragCoord: return "FragCoord";
687 0 : case EvqFrontFacing: return "FrontFacing";
688 0 : case EvqPointCoord: return "PointCoord";
689 0 : case EvqFragColor: return "FragColor";
690 0 : case EvqFragData: return "FragData";
691 0 : case EvqFragDepthEXT: return "FragDepth";
692 0 : case EvqFragDepth: return "FragDepth";
693 0 : case EvqSecondaryFragColorEXT: return "SecondaryFragColorEXT";
694 0 : case EvqSecondaryFragDataEXT: return "SecondaryFragDataEXT";
695 0 : case EvqLastFragColor: return "LastFragColor";
696 0 : case EvqLastFragData: return "LastFragData";
697 0 : case EvqSmoothOut: return "smooth out";
698 0 : case EvqCentroidOut: return "smooth centroid out";
699 0 : case EvqFlatOut: return "flat out";
700 0 : case EvqSmoothIn: return "smooth in";
701 0 : case EvqFlatIn: return "flat in";
702 0 : case EvqCentroidIn: return "smooth centroid in";
703 0 : case EvqCentroid: return "centroid";
704 0 : case EvqFlat: return "flat";
705 0 : case EvqSmooth: return "smooth";
706 0 : case EvqComputeIn: return "in";
707 0 : case EvqNumWorkGroups: return "NumWorkGroups";
708 0 : case EvqWorkGroupSize: return "WorkGroupSize";
709 0 : case EvqWorkGroupID: return "WorkGroupID";
710 0 : case EvqLocalInvocationID: return "LocalInvocationID";
711 0 : case EvqGlobalInvocationID: return "GlobalInvocationID";
712 0 : case EvqLocalInvocationIndex: return "LocalInvocationIndex";
713 0 : case EvqReadOnly: return "readonly";
714 0 : case EvqWriteOnly: return "writeonly";
715 0 : default: UNREACHABLE(); return "unknown qualifier";
716 : }
717 : // clang-format on
718 : }
719 :
720 0 : inline const char* getMatrixPackingString(TLayoutMatrixPacking mpq)
721 : {
722 0 : switch (mpq)
723 : {
724 0 : case EmpUnspecified: return "mp_unspecified";
725 0 : case EmpRowMajor: return "row_major";
726 0 : case EmpColumnMajor: return "column_major";
727 0 : default: UNREACHABLE(); return "unknown matrix packing";
728 : }
729 : }
730 :
731 0 : inline const char* getBlockStorageString(TLayoutBlockStorage bsq)
732 : {
733 0 : switch (bsq)
734 : {
735 0 : case EbsUnspecified: return "bs_unspecified";
736 0 : case EbsShared: return "shared";
737 0 : case EbsPacked: return "packed";
738 0 : case EbsStd140: return "std140";
739 0 : default: UNREACHABLE(); return "unknown block storage";
740 : }
741 : }
742 :
743 0 : inline const char *getImageInternalFormatString(TLayoutImageInternalFormat iifq)
744 : {
745 0 : switch (iifq)
746 : {
747 : case EiifRGBA32F:
748 0 : return "rgba32f";
749 : case EiifRGBA16F:
750 0 : return "rgba16f";
751 : case EiifR32F:
752 0 : return "r32f";
753 : case EiifRGBA32UI:
754 0 : return "rgba32ui";
755 : case EiifRGBA16UI:
756 0 : return "rgba16ui";
757 : case EiifRGBA8UI:
758 0 : return "rgba8ui";
759 : case EiifR32UI:
760 0 : return "r32ui";
761 : case EiifRGBA32I:
762 0 : return "rgba32i";
763 : case EiifRGBA16I:
764 0 : return "rgba16i";
765 : case EiifRGBA8I:
766 0 : return "rgba8i";
767 : case EiifR32I:
768 0 : return "r32i";
769 : case EiifRGBA8:
770 0 : return "rgba8";
771 : case EiifRGBA8_SNORM:
772 0 : return "rgba8_snorm";
773 : default:
774 0 : UNREACHABLE();
775 : return "unknown internal image format";
776 : }
777 : }
778 :
779 : } // namespace sh
780 :
781 : #endif // COMPILER_TRANSLATOR_BASETYPES_H_
|
