yum-mirror/slang

Making it easier to work with shaders

git clone https://git.yummers.dev/yum-mirror/slang

Yong HeDefer immutable buffer loads when emitting spirv. (#7579)c701ec00c

master
branchesmasterall refs →
42.2 KiB1130 linesraw
1//TEST:SIMPLE(filecheck=CHECK_GLSL): -allow-glsl -stage compute -entry computeMain -target glsl
2//TEST:SIMPLE(filecheck=CHECK_GLSL_SPIRV): -allow-glsl -stage compute -entry computeMain -target spirv -emit-spirv-via-glsl
3//TEST:SIMPLE(filecheck=CHECK_SPIR): -allow-glsl -stage compute -entry computeMain -target spirv -emit-spirv-directly
4//TEST:SIMPLE(filecheck=CHECK_HLSL): -allow-glsl -stage compute -entry computeMain -target hlsl
5
6//TEST(compute, vulkan):COMPARE_COMPUTE(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl -output-using-type -emit-spirv-via-glsl
7//TEST(compute, vulkan):COMPARE_COMPUTE(filecheck-buffer=BUF):-vk -compute -entry computeMain -allow-glsl -output-using-type -emit-spirv-directly
8
9//TEST_INPUT:ubuffer(data=[0 1 -1], stride=4):name=inputBuffer
10buffer MyBlockName1
11{
12    int data[10];
13} inputBuffer;
14
15//TEST_INPUT:ubuffer(data=[0], stride=4):out,name=outputBuffer
16buffer MyBlockName2
17{
18    int result;
19} outputBuffer;
20
21
22__generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
23bool equals(matrix<T, N, M> lhs, matrix<T, N, M> rhs)
24{
25    for (int i = 0; i < N; ++i)
26    {
27        for (int j = 0; j < M; ++j)
28        {
29            if (lhs[i][j] != rhs[i][j])
30            {
31                return false;
32            }
33        }
34    }
35    return true;
36}
37
38bool Test_ScalarType()
39{
40    // CHECK_GLSL-LABEL: Test_ScalarType
41
42    typealias genFType = float;
43    typealias genDType = double;
44    typealias genIType = int;
45    typealias genUType = uint;
46    typealias genBType = bool;
47
48    // Temporary variables
49    genFType outGenFType;
50    genDType outGenDType;
51    genIType outGenIType, outGenIType2;
52    genUType outGenUType, outGenUType2;
53
54    constexpr const float epsilon = 0.000001;
55    const mat2 identity2x2 = mat2(vec2(1,0),vec2(0,1));
56    const mat3 identity3x3 = mat3(vec3(1,0,0),vec3(0,1,0),vec3(0,0,1));
57    const mat4 identity4x4 = mat4(vec4(1,0,0,0),vec4(0,1,0,0),vec4(0,0,1,0),vec4(0,0,0,1));
58
59    // CHECK_SPIR-LABEL: Op{{.*}}AccessChain {{.*}} %inputBuffer
60    const int zero = inputBuffer.data[0];
61    const int one = inputBuffer.data[1];
62    const int negaOne = inputBuffer.data[2];
63
64    bool voidResults = true;
65
66    // 8.8. Integer Functions
67
68    // CHECK_GLSL: umulExtended(
69    // CHECK_SPIR: OpUMulExtended{{ }}
70    umulExtended(genUType(zero), genUType(zero), outGenUType, outGenUType2);
71    voidResults = voidResults && genUType(0) == outGenUType;
72    voidResults = voidResults && genUType(0) == outGenUType2;
73
74    // CHECK_GLSL: imulExtended(
75    // CHECK_SPIR: OpSMulExtended{{ }}
76    imulExtended(genIType(zero), genIType(zero), outGenIType, outGenIType2);
77    voidResults = voidResults && genIType(0) == outGenIType;
78    voidResults = voidResults && genIType(0) == outGenIType2;
79
80    return voidResults
81        // 8.1. Angle and Trigonometry Functions
82
83        // CHECK_GLSL: radians(
84        // CHECK_SPIR: Radians{{ }}
85        && genFType(0) == radians(genFType(zero))
86
87        // CHECK_GLSL: degrees(
88        // CHECK_SPIR: Degrees{{ }}
89        && genFType(0) == degrees(genFType(zero))
90
91        // CHECK_GLSL: sin(
92        // CHECK_SPIR: Sin{{ }}
93        && genFType(0) == sin(genFType(zero))
94
95        // CHECK_GLSL: cos(
96        // CHECK_SPIR: Cos{{ }}
97        && genFType(1) == cos(genFType(zero))
98
99        // CHECK_GLSL: tan(
100        // CHECK_SPIR: Tan{{ }}
101        && genFType(0) == tan(genFType(zero))
102
103        // CHECK_GLSL: asin(
104        // CHECK_SPIR: Asin{{ }}
105        && genFType(0) == asin(genFType(zero))
106
107        // CHECK_GLSL: acos(
108        // CHECK_SPIR: Acos{{ }}
109        && genFType(0) == acos(genFType(one))
110
111        // CHECK_GLSL-COUNT-2: atan(
112        // CHECK_SPIR: Atan2{{ }}
113        // CHECK_SPIR: Atan{{ }}
114        && genFType(0) == atan(genFType(zero), genFType(zero))
115        && genFType(0) == atan(genFType(zero))
116
117        // CHECK_GLSL: sinh(
118        // CHECK_SPIR: Sinh{{ }}
119        && genFType(0) == sinh(genFType(zero))
120
121        // CHECK_GLSL: cosh(
122        // CHECK_SPIR: Cosh{{ }}
123        && genFType(1) == cosh(genFType(zero))
124
125        // CHECK_GLSL: tanh(
126        // CHECK_SPIR: Tanh{{ }}
127        && genFType(0) == tanh(genFType(zero))
128
129        // CHECK_GLSL: asinh(
130        // CHECK_SPIR: Asinh{{ }}
131        && genFType(0) == asinh(genFType(zero))
132
133        // CHECK_GLSL: acosh(
134        // CHECK_SPIR: Acosh{{ }}
135        && genFType(0) == acosh(genFType(one))
136
137        // CHECK_GLSL: atanh(
138        // CHECK_SPIR: Atanh{{ }}
139        && genFType(0) == atanh(genFType(zero))
140
141        // 8.2. Exponential Functions
142
143        // CHECK_GLSL: pow(
144        // CHECK_SPIR: Pow{{ }}
145        && genFType(1) == pow(genFType(one), genFType(zero))
146
147        // CHECK_GLSL: exp(
148        // CHECK_SPIR: Exp{{ }}
149        && genFType(1) == exp(genFType(zero))
150
151        // CHECK_GLSL: log(
152        // CHECK_SPIR: Log{{ }}
153        && genFType(0) == log(genFType(one))
154
155        // CHECK_GLSL: exp2(
156        // CHECK_SPIR: Exp2{{ }}
157        && genFType(1) == exp2(genFType(zero))
158
159        // CHECK_GLSL: log2(
160        // CHECK_SPIR: Log2{{ }}
161        && genFType(0) == log2(genFType(one))
162
163        // CHECK_GLSL-COUNT-2: sqrt(
164        // CHECK_SPIR-COUNT-2: Sqrt{{ }}
165        && genFType(0) == sqrt(genFType(zero))
166        && genDType(0) == sqrt(genDType(zero))
167
168        // CHECK_GLSL-COUNT-2: inversesqrt(
169        // CHECK_SPIR-COUNT-2: InverseSqrt{{ }}
170        && genFType(1) == inversesqrt(genFType(one))
171        && genDType(1) == inversesqrt(genDType(one))
172
173        // 8.3. Common Functions
174
175        // CHECK_GLSL-COUNT-3: abs(
176        // CHECK_SPIR: FAbs{{ }}
177        // CHECK_SPIR: SAbs{{ }}
178        // CHECK_SPIR: FAbs{{ }}
179        && genFType(0) == abs(genFType(zero))
180        && genIType(0) == abs(genIType(zero))
181        && genDType(0) == abs(genDType(zero))
182
183        // CHECK_GLSL-COUNT-3: sign(
184        // CHECK_SPIR: FSign{{ }}
185        // CHECK_SPIR: SSign{{ }}
186        // CHECK_SPIR: FSign{{ }}
187        && genFType(0) == sign(genFType(zero))
188#if !defined(TARGET_CUDA)
189        && genIType(0) == sign(genIType(zero))
190#endif // #if !defined(TARGET_CUDA)
191        && genDType(0) == sign(genDType(zero))
192
193        // CHECK_GLSL-COUNT-2: floor(
194        // CHECK_SPIR-COUNT-2: Floor{{ }}
195        && genFType(0) == floor(genFType(zero))
196        && genDType(0) == floor(genDType(zero))
197
198        // CHECK_GLSL-COUNT-2: trunc(
199        // CHECK_SPIR-COUNT-2: Trunc{{ }}
200        && genFType(0) == trunc(genFType(zero))
201        && genDType(0) == trunc(genDType(zero))
202
203        // CHECK_GLSL-COUNT-2: round(
204        // CHECK_SPIR-COUNT-2: Round{{ }}
205        && genFType(0) == round(genFType(zero))
206        && genDType(0) == round(genDType(zero))
207
208        // CHECK_GLSL-COUNT-2: roundEven(
209        // CHECK_SPIR-COUNT-2: RoundEven{{ }}
210        && genFType(0) == roundEven(genFType(zero))
211        && genDType(0) == roundEven(genDType(zero))
212
213        // CHECK_GLSL-COUNT-2: ceil(
214        // CHECK_SPIR-COUNT-2: Ceil{{ }}
215        && genFType(0) == ceil(genFType(zero))
216        && genDType(0) == ceil(genDType(zero))
217
218        // CHECK_GLSL-COUNT-2: fract(
219        // CHECK_SPIR-COUNT-2: Fract{{ }}
220        && genFType(0) == fract(genFType(zero))
221        && genDType(0) == fract(genDType(zero))
222
223        // CHECK_GLSL-COUNT-2: mod(
224        // CHECK_SPIR-COUNT-2: Floor{{ }}
225        && genFType(0) == mod(genFType(zero), genFType(one))
226        && genDType(0) == mod(genDType(zero), genDType(one))
227
228        // CHECK_GLSL-COUNT-2: modf(
229        // CHECK_SPIR-COUNT-2: Modf{{ }}
230        && genFType(0) == modf(genFType(zero), outGenFType) && 0 == outGenFType
231        && genDType(0) == modf(genDType(zero), outGenDType) && 0 == outGenDType
232
233        // CHECK_GLSL-COUNT-4: min(
234        // CHECK_SPIR-COUNT-2: FMin{{ }}
235        // CHECK_SPIR: SMin{{ }}
236        // CHECK_SPIR: UMin{{ }}
237        && genFType(0) == min(genFType(zero), genFType(zero))
238        && genDType(0) == min(genDType(zero), genDType(zero))
239        && genIType(0) == min(genIType(zero), genIType(zero))
240        && genUType(0) == min(genUType(zero), genUType(zero))
241
242        // CHECK_GLSL-COUNT-4: max(
243        // CHECK_SPIR-COUNT-2: FMax{{ }}
244        // CHECK_SPIR: SMax{{ }}
245        // CHECK_SPIR: UMax{{ }}
246        && genFType(0) == max(genFType(zero), genFType(zero))
247        && genDType(0) == max(genDType(zero), genDType(zero))
248        && genIType(0) == max(genIType(zero), genIType(zero))
249        && genUType(0) == max(genUType(zero), genUType(zero))
250
251        // CHECK_GLSL-COUNT-4: clamp(
252        // CHECK_SPIR-COUNT-2: FClamp{{ }}
253        // CHECK_SPIR: SClamp{{ }}
254        // CHECK_SPIR: UClamp{{ }}
255        && genFType(0) == clamp(genFType(zero), genFType(zero), genFType(zero))
256        && genDType(0) == clamp(genDType(zero), genDType(zero), genDType(zero))
257        && genIType(0) == clamp(genIType(zero), genIType(zero), genIType(zero))
258        && genUType(0) == clamp(genUType(zero), genUType(zero), genUType(zero))
259
260        // CHECK_GLSL-COUNT-2: mix(
261        // CHECK_SPIR-COUNT-2: FMix{{ }}
262        && genFType(0) == mix(genFType(zero), genFType(zero), genFType(zero))
263        && genDType(0) == mix(genDType(zero), genDType(zero), genDType(zero))
264
265        // CHECK_GLSL-COUNT-5: mix(
266        // C-HECK_SPIR-COUNT-5: OpSelect{{ }}
267        && genFType(0) == mix(genFType(zero), genFType(zero), genBType(zero))
268        && genDType(0) == mix(genDType(zero), genDType(zero), genBType(zero))
269        && genIType(0) == mix(genIType(zero), genIType(zero), genBType(zero))
270        && genUType(0) == mix(genUType(zero), genUType(zero), genBType(zero))
271        && genBType(0) == mix(genBType(zero), genBType(zero), genBType(zero))
272
273        // CHECK_GLSL-COUNT-4: step(
274        // CHECK_SPIR-COUNT-4: Step{{ }}
275        && genFType(0) == step(genFType(one), genFType(zero))
276        && genFType(0) == step(float(one), genFType(zero))
277        && genDType(0) == step(genDType(one), genDType(zero))
278        && genDType(0) == step(double(one), genDType(zero))
279
280        // CHECK_GLSL-COUNT-4: smoothstep(
281        // CHECK_SPIR-COUNT-4: SmoothStep{{ }}
282        && genFType(0) == smoothstep(genFType(zero), genFType(one), genFType(zero))
283        && genFType(0) == smoothstep(float(zero), float(one), genFType(zero))
284        && genDType(0) == smoothstep(genDType(zero), genDType(one), genDType(zero))
285        && genDType(0) == smoothstep(double(zero), double(one), genDType(zero))
286
287        // CHECK_GLSL-COUNT-2: isnan(
288        // CHECK_SPIR-COUNT-2: OpIsNan{{ }}
289        && genBType(0) == isnan(genFType(zero))
290        && genBType(0) == isnan(genDType(zero))
291
292        // CHECK_GLSL-COUNT-2: isinf(
293        // CHECK_SPIR-COUNT-2: OpIsInf{{ }}
294        && genBType(0) == isinf(genFType(zero))
295        && genBType(0) == isinf(genDType(zero))
296
297        // CHECK_GLSL: floatBitsToInt(
298        // CHECK_SPIR: OpBitcast{{ }}
299        && genIType(0) == floatBitsToInt(genFType(zero))
300
301        // CHECK_GLSL: floatBitsToUint(
302        // CHECK_SPIR: OpBitcast{{ }}
303        && genUType(0) == floatBitsToUint(genFType(zero))
304
305        // CHECK_GLSL: intBitsToFloat(
306        // CHECK_SPIR: OpBitcast{{ }}
307        && genFType(0) == intBitsToFloat(genIType(zero))
308
309        // CHECK_GLSL: uintBitsToFloat(
310        // CHECK_SPIR: OpBitcast{{ }}
311        && genFType(0) == uintBitsToFloat(genUType(zero))
312
313        // CHECK_GLSL-COUNT-2: fma(
314        // CHECK_SPIR-COUNT-2: Fma{{ }}
315        && genFType(0) == fma(genFType(zero), genFType(zero), genFType(zero))
316        && genDType(0) == fma(genDType(zero), genDType(zero), genDType(zero))
317
318        // CHECK_GLSL-COUNT-2: frexp(
319        // CHECK_SPIR-COUNT-2: Frexp{{ }}
320        && genFType(0) == frexp(genFType(zero), outGenIType) && genIType(0) == outGenIType
321        && genDType(0) == frexp(genDType(zero), outGenIType) && genIType(0) == outGenIType
322
323        // CHECK_GLSL-COUNT-2: ldexp(
324        // CHECK_SPIR-COUNT-2: Ldexp{{ }}
325        && genFType(0) == ldexp(genFType(zero), genIType(zero))
326        && genDType(0) == ldexp(genDType(zero), genIType(zero))
327
328        // 8.4. Floating-Point Pack and Unpack Functions
329
330        // CHECK_GLSL: packUnorm2x16(
331        // CHECK_SPIR: PackUnorm2x16{{ }}
332        && uint(0)  == packUnorm2x16(vec2(zero))
333
334        // CHECK_GLSL: packSnorm2x16(
335        // CHECK_SPIR: PackSnorm2x16{{ }}
336        && uint(0)  == packSnorm2x16(vec2(zero))
337
338        // CHECK_GLSL: packUnorm4x8(
339        // CHECK_SPIR: PackUnorm4x8{{ }}
340        && uint(0)  == packUnorm4x8(vec4(zero))
341
342        // CHECK_GLSL: packSnorm4x8(
343        // CHECK_SPIR: PackSnorm4x8{{ }}
344        && uint(0)  == packSnorm4x8(vec4(zero))
345
346        // CHECK_GLSL: unpackUnorm2x16(
347        // CHECK_SPIR: UnpackUnorm2x16{{ }}
348        && vec2(0)  == unpackUnorm2x16(uint(zero))
349
350        // CHECK_GLSL: unpackSnorm2x16(
351        // CHECK_SPIR: UnpackSnorm2x16{{ }}
352        && vec2(0)  == unpackSnorm2x16(uint(zero))
353
354        // CHECK_GLSL: unpackUnorm4x8(
355        // CHECK_SPIR: UnpackUnorm4x8{{ }}
356        && vec4(0)  == unpackUnorm4x8(uint(zero))
357
358        // CHECK_GLSL: unpackSnorm4x8(
359        // CHECK_SPIR: UnpackSnorm4x8{{ }}
360        && vec4(0)  == unpackSnorm4x8(uint(zero))
361
362        // CHECK_GLSL: packHalf2x16(
363        // CHECK_SPIR: PackHalf2x16{{ }}
364        && uint(0)  == packHalf2x16(vec2(zero))
365
366        // CHECK_GLSL: unpackHalf2x16(
367        // CHECK_SPIR: UnpackHalf2x16{{ }}
368        && vec2(0)  == unpackHalf2x16(uint(zero))
369
370        // CHECK_GLSL: packDouble2x32(
371        // CHECK_SPIR: PackDouble2x32{{ }}
372        && double(0) == packDouble2x32(uvec2(zero))
373
374        // CHECK_GLSL: unpackDouble2x32(
375        // CHECK_SPIR: UnpackDouble2x32{{ }}
376        && uvec2(0) == unpackDouble2x32(packDouble2x32(uvec2(zero)))
377
378        // 8.5. Geometric Functions
379
380        // CHECK_GLSL-COUNT-2: length(
381        // CHECK_SPIR-COUNT-2: Length{{ }}
382        && float(0)  == length(genFType(zero))
383        && double(0) == length(genDType(zero))
384
385        // CHECK_GLSL-COUNT-2: distance(
386        // CHECK_SPIR-COUNT-2: Distance{{ }}
387        && float(0)  == distance(genFType(zero), genFType(zero))
388        && double(0) == distance(genDType(zero), genDType(zero))
389
390        // CHECK_GLSL-COUNT-2: dot(
391        // SPIR-V doesn't have OpDot for scalar types
392        && float(0)  == dot(genFType(zero), genFType(zero))
393        && double(0) == dot(genDType(zero), genDType(zero))
394
395        // CHECK_GLSL-COUNT-2: cross(
396        // CHECK_SPIR-COUNT-2: Cross{{ }}
397        && vec3(0)  == cross(vec3(0), vec3(zero))
398        && dvec3(0) == cross(dvec3(0), dvec3(zero))
399
400        // CHECK_GLSL-COUNT-2: normalize(
401        // CHECK_SPIR-COUNT-2: Normalize{{ }}
402        && (abs(float(1)  - length(normalize(genFType(one)))) < epsilon)
403        && (abs(double(1) - length(normalize(genDType(one)))) < double(epsilon))
404
405        // CHECK_GLSL-COUNT-2: faceforward(
406        // CHECK_SPIR-COUNT-2: FaceForward{{ }}
407        && genFType(1) == faceforward(genFType(one), genFType(one), genFType(negaOne))
408        && genDType(1) == faceforward(genDType(one), genDType(one), genDType(negaOne))
409
410        // CHECK_GLSL-COUNT-2: reflect(
411        // CHECK_SPIR-COUNT-2: Reflect{{ }}
412        && genFType(0) == reflect(genFType(zero), genFType(zero))
413        && genDType(0) == reflect(genDType(zero), genDType(zero))
414
415        // CHECK_GLSL-COUNT-2: refract(
416        // CHECK_SPIR-COUNT-2: Refract{{ }}
417        && genFType(0) == refract(genFType(zero), genFType(zero), float(zero))
418        && genDType(0) == refract(genDType(zero), genDType(zero), double(zero))
419
420        // 8.6. Matrix Functions
421
422        // CHECK_GLSL-COUNT-9: matrixCompMult(
423        && equals(mat2x2(0), matrixCompMult(mat2x2(0), mat2x2(zero)))
424        && equals(mat2x3(0), matrixCompMult(mat2x3(0), mat2x3(zero)))
425        && equals(mat2x4(0), matrixCompMult(mat2x4(0), mat2x4(zero)))
426        && equals(mat3x2(0), matrixCompMult(mat3x2(0), mat3x2(zero)))
427        && equals(mat3x3(0), matrixCompMult(mat3x3(0), mat3x3(zero)))
428        && equals(mat3x4(0), matrixCompMult(mat3x4(0), mat3x4(zero)))
429        && equals(mat4x2(0), matrixCompMult(mat4x2(0), mat4x2(zero)))
430        && equals(mat4x3(0), matrixCompMult(mat4x3(0), mat4x3(zero)))
431        && equals(mat4x4(0), matrixCompMult(mat4x4(0), mat4x4(zero)))
432
433        // CHECK_GLSL-COUNT-4: outerProduct(
434        // CHECK_SPIR-COUNT-4: OpOuterProduct{{ }}
435        && equals(mat2(0), outerProduct(vec2(0), vec2(zero)))
436        && equals(mat3(0), outerProduct(vec3(0), vec3(zero)))
437        && equals(mat4(0), outerProduct(vec4(0), vec4(zero)))
438        && equals(mat2x3(0), outerProduct(vec3(0), vec2(zero)))
439        && equals(mat3x2(0), outerProduct(vec2(0), vec3(zero)))
440        && equals(mat2x4(0), outerProduct(vec4(0), vec2(zero)))
441        && equals(mat4x2(0), outerProduct(vec2(0), vec4(zero)))
442        && equals(mat3x4(0), outerProduct(vec4(0), vec3(zero)))
443        && equals(mat4x3(0), outerProduct(vec3(0), vec4(zero)))
444
445        // CHECK_GLSL-COUNT-9: transpose(
446        // CHECK_SPIR-COUNT-9: OpTranspose{{ }}
447        && equals(mat2(0), transpose(mat2(zero)))
448        && equals(mat3(0), transpose(mat3(zero)))
449        && equals(mat4(0), transpose(mat4(zero)))
450        && equals(mat2x3(0), transpose(mat3x2(zero)))
451        && equals(mat3x2(0), transpose(mat2x3(zero)))
452        && equals(mat2x4(0), transpose(mat4x2(zero)))
453        && equals(mat4x2(0), transpose(mat2x4(zero)))
454        && equals(mat3x4(0), transpose(mat4x3(zero)))
455        && equals(mat4x3(0), transpose(mat3x4(zero)))
456
457        // CHECK_GLSL-COUNT-3: determinant(
458        // CHECK_SPIR-COUNT-3: Determinant{{ }}
459        && float(0) == determinant(mat2(zero))
460        && float(0) == determinant(mat3(zero))
461        && float(0) == determinant(mat4(zero))
462
463        // CHECK_GLSL-COUNT-3: inverse(
464        // CHECK_SPIR-COUNT-3: MatrixInverse{{ }}
465        && equals(identity2x2, inverse(identity2x2))
466        && equals(identity3x3, inverse(identity3x3))
467        && equals(identity4x4, inverse(identity4x4))
468
469        // 8.8. Integer Functions
470
471        // CHECK_GLSL: uaddCarry(
472        // CHECK_SPIR: OpIAddCarry{{ }}
473        && genUType(0) == uaddCarry(genUType(zero), genUType(zero), outGenUType) && genUType(0) == outGenUType
474
475        // CHECK_GLSL: usubBorrow(
476        // CHECK_SPIR: OpISubBorrow{{ }}
477        && genUType(0) == usubBorrow(genUType(zero), genUType(zero), outGenUType) && genUType(0) == outGenUType
478
479        // CHECK_GLSL-COUNT-2: bitfieldExtract(
480        // CHECK_SPIR: OpBitFieldSExtract{{ }}
481        // CHECK_SPIR: OpBitFieldUExtract{{ }}
482        && genIType(0) == bitfieldExtract(genIType(zero), uint(zero), uint(zero))
483        && genUType(0) == bitfieldExtract(genUType(zero), uint(zero), uint(zero))
484
485        // CHECK_GLSL-COUNT-2: bitfieldInsert(
486        // CHECK_SPIR-COUNT-2: OpBitFieldInsert{{ }}
487        && genIType(0) == bitfieldInsert(genIType(zero), genIType(zero), uint(zero), uint(zero))
488        && genUType(0) == bitfieldInsert(genUType(zero), genUType(zero), uint(zero), uint(zero))
489
490        // CHECK_GLSL-COUNT-2: bitfieldReverse(
491        // CHECK_SPIR-COUNT-2: OpBitReverse{{ }}
492        && genIType(0) == bitfieldReverse(genIType(zero))
493        && genUType(0) == bitfieldReverse(genUType(zero))
494
495        // CHECK_GLSL-COUNT-2: bitCount(
496        // CHECK_SPIR-COUNT-2: OpBitCount{{ }}
497        && genIType(0) == bitCount(genIType(zero))
498        && genIType(0) == bitCount(genUType(zero))
499
500        // CHECK_GLSL-COUNT-2: findLSB(
501        // CHECK_SPIR-COUNT-2: FindILsb{{ }}
502        && genIType(-1) == findLSB(genIType(zero))
503        && genIType(-1) == findLSB(genUType(zero))
504
505        // CHECK_GLSL-COUNT-2: findMSB(
506        // CHECK_SPIR: FindSMsb{{ }}
507        // CHECK_SPIR: FindUMsb{{ }}
508        && genIType(-1) == findMSB(genIType(zero))
509        && genIType(-1) == findMSB(genUType(zero))
510        ;
511}
512
513__generic<let N : int>
514bool Test_VectorType()
515{
516    // CHECK_GLSL-LABEL: bool Test_VectorType_0
517
518    // The following type names are what OpenGL document
519    // uses to refer variants of the vector types.
520    // The difference between `genFType` and `vec` is that
521    // `genFType` includes a scalar type, which is just
522    // `float` whereas `vec` doesn't include it.
523    //
524    typealias genFType = vector<float, N>;
525    typealias genDType = vector<double, N>;
526    typealias genIType = vector<int, N>;
527    typealias genUType = vector<uint, N>;
528    typealias genBType = vector<bool, N>;
529    typealias vec      = vector<float, N>;
530    typealias ivec     = vector<int, N>;
531    typealias uvec     = vector<uint, N>;
532    typealias bvec     = vector<bool, N>;
533
534    // Temporary variables
535    genFType outGenFType;
536    genDType outGenDType;
537    genIType outGenIType, outGenIType2;
538    genUType outGenUType, outGenUType2;
539
540    constexpr const float epsilon = 0.000001;
541
542    // CHECK_SPIR-LABEL: Op{{.*}}AccessChain {{.*}} %inputBuffer
543    const int zero = inputBuffer.data[0];
544    const int one = inputBuffer.data[1];
545    const int negaOne = inputBuffer.data[2];
546
547    bool voidResults = true;
548
549    // Note: "CHECK_SPIR-NOT:" testing is to detect cases where a scalar
550    // version of the function is called when it should use a vector version.
551
552    // 8.8. Integer Functions
553
554    // CHECK_GLSL: umulExtended(
555    // CHECK_GLSL-NOT: umulExtended(
556    // CHECK_SPIR: OpUMulExtended{{ }}
557    // CHECK_SPIR-NOT: OpUMulExtended{{ }}
558    umulExtended(genUType(zero), genUType(zero), outGenUType, outGenUType2);
559    voidResults = voidResults && genUType(0) == outGenUType;
560    voidResults = voidResults && genUType(0) == outGenUType2;
561
562    // CHECK_GLSL: imulExtended(
563    // CHECK_GLSL-NOT: imulExtended(
564    // CHECK_SPIR: OpSMulExtended{{ }}
565    // CHECK_SPIR-NOT: OpSMulExtended{{ }}
566    imulExtended(genIType(zero), genIType(zero), outGenIType, outGenIType2);
567    voidResults = voidResults && genIType(0) == outGenIType;
568    voidResults = voidResults && genIType(0) == outGenIType2;
569
570    return voidResults
571        // 8.1. Angle and Trigonometry Functions
572
573        // CHECK_GLSL: radians(
574        // CHECK_GLSL-NOT: radians(
575        // CHECK_SPIR: Radians{{ }}
576        // CHECK_SPIR-NOT: Radians{{ }}
577        && genFType(0) == radians(genFType(zero))
578
579        // CHECK_GLSL: degrees(
580        // CHECK_GLSL-NOT: degrees(
581        // CHECK_SPIR: Degrees{{ }}
582        // CHECK_SPIR-NOT: Degrees{{ }}
583        && genFType(0) == degrees(genFType(zero))
584
585        // CHECK_GLSL: sin(
586        // CHECK_GLSL-NOT: sin(
587        // CHECK_SPIR: Sin{{ }}
588        // CHECK_SPIR-NOT: Sin{{ }}
589        && genFType(0) == sin(genFType(zero))
590
591        // CHECK_GLSL: cos(
592        // CHECK_GLSL-NOT: cos(
593        // CHECK_SPIR: Cos{{ }}
594        // CHECK_SPIR-NOT: Cos{{ }}
595        && genFType(1) == cos(genFType(zero))
596
597        // CHECK_GLSL: tan(
598        // CHECK_GLSL-NOT: tan(
599        // CHECK_SPIR: Tan{{ }}
600        // CHECK_SPIR-NOT: Tan{{ }}
601        && genFType(0) == tan(genFType(zero))
602
603        // CHECK_GLSL: asin(
604        // CHECK_GLSL-NOT: asin(
605        // CHECK_SPIR: Asin{{ }}
606        // CHECK_SPIR-NOT: Asin{{ }}
607        && genFType(0) == asin(genFType(zero))
608
609        // CHECK_GLSL: acos(
610        // CHECK_GLSL-NOT: acos(
611        // CHECK_SPIR: Acos{{ }}
612        // CHECK_SPIR-NOT: Acos{{ }}
613        && genFType(0) == acos(genFType(one))
614
615        // CHECK_GLSL-COUNT-2: atan(
616        // CHECK_GLSL-NOT: atan(
617        // CHECK_SPIR: Atan2{{ }}
618        // CHECK_SPIR-NOT: Atan2{{ }}
619        // CHECK_SPIR: Atan{{ }}
620        // CHECK_SPIR-NOT: Atan{{ }}
621        && genFType(0) == atan(genFType(zero), genFType(zero))
622        && genFType(0) == atan(genFType(zero))
623
624        // CHECK_GLSL: sinh(
625        // CHECK_GLSL-NOT: sinh(
626        // CHECK_SPIR: Sinh{{ }}
627        // CHECK_SPIR-NOT: Sinh{{ }}
628        && genFType(0) == sinh(genFType(zero))
629
630        // CHECK_GLSL: cosh(
631        // CHECK_GLSL-NOT: cosh(
632        // CHECK_SPIR: Cosh{{ }}
633        // CHECK_SPIR-NOT: Cosh{{ }}
634        && genFType(1) == cosh(genFType(zero))
635
636        // CHECK_GLSL: tanh(
637        // CHECK_GLSL-NOT: tanh(
638        // CHECK_SPIR: Tanh{{ }}
639        // CHECK_SPIR-NOT: Tanh{{ }}
640        && genFType(0) == tanh(genFType(zero))
641
642#if !defined(TARGET_CUDA)
643        // CHECK_GLSL: asinh(
644        // CHECK_GLSL-NOT: asinh(
645        // CHECK_SPIR: Asinh{{ }}
646        // CHECK_SPIR-NOT: Asinh{{ }}
647        && genFType(0) == asinh(genFType(zero))
648
649        // CHECK_GLSL: acosh(
650        // CHECK_GLSL-NOT: acosh(
651        // CHECK_SPIR: Acosh{{ }}
652        // CHECK_SPIR-NOT: Acosh{{ }}
653        && genFType(0) == acosh(genFType(one))
654
655        // CHECK_GLSL: atanh(
656        // CHECK_GLSL-NOT: atanh(
657        // CHECK_SPIR: Atanh{{ }}
658        // CHECK_SPIR-NOT: Atanh{{ }}
659        && genFType(0) == atanh(genFType(zero))
660#endif // #if !defined(TARGET_CUDA)
661
662        // 8.2. Exponential Functions
663
664        // CHECK_GLSL: pow(
665        // CHECK_GLSL-NOT: pow(
666        // CHECK_SPIR: Pow{{ }}
667        // CHECK_SPIR-NOT: Pow{{ }}
668        && genFType(1) == pow(genFType(one), genFType(zero))
669
670        // CHECK_GLSL: exp(
671        // CHECK_GLSL-NOT: exp(
672        // CHECK_SPIR: Exp{{ }}
673        // CHECK_SPIR-NOT: Exp{{ }}
674        && genFType(1) == exp(genFType(zero))
675
676        // CHECK_GLSL: log(
677        // CHECK_GLSL-NOT: log(
678        // CHECK_SPIR: Log{{ }}
679        // CHECK_SPIR-NOT: Log{{ }}
680        && genFType(0) == log(genFType(one))
681
682        // CHECK_GLSL: exp2(
683        // CHECK_GLSL-NOT: exp2(
684        // CHECK_SPIR: Exp2{{ }}
685        // CHECK_SPIR-NOT: Exp2{{ }}
686        && genFType(1) == exp2(genFType(zero))
687
688        // CHECK_GLSL: log2(
689        // CHECK_GLSL-NOT: log2(
690        // CHECK_SPIR: Log2{{ }}
691        // CHECK_SPIR-NOT: Log2{{ }}
692        && genFType(0) == log2(genFType(one))
693
694        // CHECK_GLSL-COUNT-2: sqrt(
695        // CHECK_GLSL-NOT: sqrt(
696        // CHECK_SPIR-COUNT-2: Sqrt{{ }}
697        // CHECK_SPIR-NOT: Sqrt{{ }}
698        && genFType(0) == sqrt(genFType(zero))
699        && genDType(0) == sqrt(genDType(zero))
700
701        // CHECK_GLSL-COUNT-2: inversesqrt(
702        // CHECK_GLSL-NOT: inversesqrt(
703        // CHECK_SPIR-COUNT-2: InverseSqrt{{ }}
704        // CHECK_SPIR-NOT: InverseSqrt{{ }}
705        && genFType(1) == inversesqrt(genFType(one))
706        && genDType(1) == inversesqrt(genDType(one))
707
708        // 8.3. Common Functions
709
710        // CHECK_GLSL-COUNT-3: abs(
711        // CHECK_GLSL-NOT: abs(
712        // CHECK_SPIR: FAbs{{ }}
713        // CHECK_SPIR-NOT: FAbs{{ }}
714        // CHECK_SPIR: SAbs{{ }}
715        // CHECK_SPIR-NOT: SAbs{{ }}
716        // CHECK_SPIR: FAbs{{ }}
717        // CHECK_SPIR-NOT: FAbs{{ }}
718        && genFType(0) == abs(genFType(zero))
719        && genIType(0) == abs(genIType(zero))
720        && genDType(0) == abs(genDType(zero))
721
722        // CHECK_GLSL-COUNT-3: sign(
723        // CHECK_GLSL-NOT: sign(
724        // CHECK_SPIR: FSign{{ }}
725        // CHECK_SPIR-NOT: FSign{{ }}
726        // CHECK_SPIR: SSign{{ }}
727        // CHECK_SPIR-NOT: SSign{{ }}
728        // CHECK_SPIR: FSign{{ }}
729        // CHECK_SPIR-NOT: FSign{{ }}
730        && genFType(0) == sign(genFType(zero))
731#if !defined(TARGET_CUDA)
732        && genIType(0) == sign(genIType(zero))
733#endif // #if !defined(TARGET_CUDA)
734        && genDType(0) == sign(genDType(zero))
735
736        // CHECK_GLSL-COUNT-2: floor(
737        // CHECK_GLSL-NOT: floor(
738        // CHECK_SPIR-COUNT-2: Floor{{ }}
739        // CHECK_SPIR-NOT: Floor{{ }}
740        && genFType(0) == floor(genFType(zero))
741        && genDType(0) == floor(genDType(zero))
742
743        // CHECK_GLSL-COUNT-2: trunc(
744        // CHECK_GLSL-NOT: trunc(
745        // CHECK_SPIR-COUNT-2: Trunc{{ }}
746        // CHECK_SPIR-NOT: Trunc{{ }}
747        && genFType(0) == trunc(genFType(zero))
748        && genDType(0) == trunc(genDType(zero))
749
750        // CHECK_GLSL-COUNT-2: round(
751        // CHECK_GLSL-NOT: round(
752        // CHECK_SPIR-COUNT-2: Round{{ }}
753        // CHECK_SPIR-NOT: Round{{ }}
754        && genFType(0) == round(genFType(zero))
755        && genDType(0) == round(genDType(zero))
756
757        // CHECK_GLSL-COUNT-2: roundEven(
758        // CHECK_GLSL-NOT: roundEven(
759        // CHECK_SPIR-COUNT-2: RoundEven{{ }}
760        // CHECK_SPIR-NOT: RoundEven{{ }}
761        && genFType(0) == roundEven(genFType(zero))
762        && genDType(0) == roundEven(genDType(zero))
763
764        // CHECK_GLSL-COUNT-2: ceil(
765        // CHECK_GLSL-NOT: ceil(
766        // CHECK_SPIR-COUNT-2: Ceil{{ }}
767        // CHECK_SPIR-NOT: Ceil{{ }}
768        && genFType(0) == ceil(genFType(zero))
769        && genDType(0) == ceil(genDType(zero))
770
771        // CHECK_GLSL-COUNT-2: fract(
772        // CHECK_GLSL-NOT: fract(
773        // CHECK_SPIR-COUNT-2: Fract{{ }}
774        // CHECK_SPIR-NOT: Fract{{ }}
775        && genFType(0) == fract(genFType(zero))
776        && genDType(0) == fract(genDType(zero))
777
778        // CHECK_GLSL-COUNT-4: mod(
779        // CHECK_GLSL-NOT: mod(
780        // CHECK_SPIR-COUNT-4: Floor{{ }}
781        // CHECK_SPIR-NOT: Floor{{ }}
782        && genFType(0) == mod(genFType(zero), float(one))
783        && genFType(0) == mod(genFType(zero), genFType(one))
784        && genDType(0) == mod(genDType(zero), double(one))
785        && genDType(0) == mod(genDType(zero), genDType(one))
786
787        // CHECK_GLSL-COUNT-2: modf(
788        // CHECK_GLSL-NOT: modf(
789        // CHECK_SPIR-COUNT-2: Modf{{ }}
790        // CHECK_SPIR-NOT: Modf{{ }}
791        && genFType(0) == modf(genFType(zero), outGenFType) && genFType(0) == outGenFType
792        && genDType(0) == modf(genDType(zero), outGenDType) && genDType(0) == outGenDType
793
794        // CHECK_GLSL-COUNT-8: min(
795        // CHECK_GLSL-NOT: min(
796        // CHECK_SPIR-COUNT-4: FMin{{ }}
797        // CHECK_SPIR-NOT: FMin{{ }}
798        // CHECK_SPIR-COUNT-2: SMin{{ }}
799        // CHECK_SPIR-NOT: SMin{{ }}
800        // CHECK_SPIR-COUNT-2: UMin{{ }}
801        // CHECK_SPIR-NOT: UMin{{ }}
802        && genFType(0) == min(genFType(zero), genFType(zero))
803        && genFType(0) == min(genFType(zero), float(zero))
804        && genDType(0) == min(genDType(zero), genDType(zero))
805        && genDType(0) == min(genDType(zero), double(zero))
806        && genIType(0) == min(genIType(zero), genIType(zero))
807        && genIType(0) == min(genIType(zero), int(zero))
808        && genUType(0) == min(genUType(zero), genUType(zero))
809        && genUType(0) == min(genUType(zero), uint(zero))
810
811        // CHECK_GLSL-COUNT-8: max(
812        // CHECK_GLSL-NOT: max(
813        // CHECK_SPIR-COUNT-4: FMax{{ }}
814        // CHECK_SPIR-NOT: FMax{{ }}
815        // CHECK_SPIR-COUNT-2: SMax{{ }}
816        // CHECK_SPIR-NOT: SMax{{ }}
817        // CHECK_SPIR-COUNT-2: UMax{{ }}
818        // CHECK_SPIR-NOT: UMax{{ }}
819        && genFType(0) == max(genFType(zero), genFType(zero))
820        && genFType(0) == max(genFType(zero), float(zero))
821        && genDType(0) == max(genDType(zero), genDType(zero))
822        && genDType(0) == max(genDType(zero), double(zero))
823        && genIType(0) == max(genIType(zero), genIType(zero))
824        && genIType(0) == max(genIType(zero), int(zero))
825        && genUType(0) == max(genUType(zero), genUType(zero))
826        && genUType(0) == max(genUType(zero), uint(zero))
827
828        // CHECK_GLSL-COUNT-8: clamp(
829        // CHECK_GLSL-NOT: clamp(
830        // CHECK_SPIR-COUNT-4: FClamp{{ }}
831        // CHECK_SPIR-NOT: FClamp{{ }}
832        // CHECK_SPIR-COUNT-2: SClamp{{ }}
833        // CHECK_SPIR-NOT: SClamp{{ }}
834        // CHECK_SPIR-COUNT-2: UClamp{{ }}
835        // CHECK_SPIR-NOT: UClamp{{ }}
836        && genFType(0) == clamp(genFType(zero), genFType(zero), genFType(zero))
837        && genFType(0) == clamp(genFType(zero), float(zero), float(zero))
838        && genDType(0) == clamp(genDType(zero), genDType(zero), genDType(zero))
839        && genDType(0) == clamp(genDType(zero), double(zero), double(zero))
840        && genIType(0) == clamp(genIType(zero), genIType(zero), genIType(zero))
841        && genIType(0) == clamp(genIType(zero), int(zero), int(zero))
842        && genUType(0) == clamp(genUType(zero), genUType(zero), genUType(zero))
843        && genUType(0) == clamp(genUType(zero), uint(zero), uint(zero))
844
845        // CHECK_GLSL-COUNT-4: mix(
846        // CHECK_GLSL-NOT: mix(
847        // CHECK_SPIR-COUNT-4: FMix{{ }}
848        // CHECK_SPIR-NOT: FMix{{ }}
849        && genFType(0) == mix(genFType(zero), genFType(zero), genFType(zero))
850        && genFType(0) == mix(genFType(zero), genFType(zero), float(one))
851        && genDType(0) == mix(genDType(zero), genDType(zero), genDType(zero))
852        && genDType(0) == mix(genDType(zero), genDType(zero), double(one))
853
854#if !defined(TARGET_CUDA)
855        // CHECK_GLSL-COUNT-5: mix(
856        // CHECK_GLSL-NOT: mix(
857        // C-HECK_SPIR-COUNT-5: OpSelect{{ }}
858        && genFType(0) == mix(genFType(zero), genFType(zero), genBType(zero))
859        && genDType(0) == mix(genDType(zero), genDType(zero), genBType(zero))
860        && genIType(0) == mix(genIType(zero), genIType(zero), genBType(zero))
861        && genUType(0) == mix(genUType(zero), genUType(zero), genBType(zero))
862        && genBType(0) == mix(genBType(zero), genBType(zero), genBType(zero))
863#endif // #if !defined(TARGET_CUDA)
864
865        // CHECK_GLSL-COUNT-4: step(
866        // CHECK_GLSL-NOT: step(
867        // CHECK_SPIR-COUNT-4: Step{{ }}
868        // CHECK_SPIR-NOT: Step{{ }}
869        && genFType(0) == step(genFType(one), genFType(zero))
870        && genFType(0) == step(float(one), genFType(zero))
871        && genDType(0) == step(genDType(one), genDType(zero))
872        && genDType(0) == step(double(one), genDType(zero))
873
874        // CHECK_GLSL-COUNT-4: smoothstep(
875        // CHECK_GLSL-NOT: smoothstep(
876        // CHECK_SPIR-COUNT-4: SmoothStep{{ }}
877        // CHECK_SPIR-NOT: SmoothStep{{ }}
878        && genFType(0) == smoothstep(genFType(zero), genFType(one), genFType(zero))
879        && genFType(0) == smoothstep(float(zero), float(one), genFType(zero))
880        && genDType(0) == smoothstep(genDType(zero), genDType(one), genDType(zero))
881        && genDType(0) == smoothstep(double(zero), double(one), genDType(zero))
882
883#if !defined(TARGET_CUDA)
884        // CHECK_GLSL-COUNT-2: isnan(
885        // CHECK_GLSL-NOT: isnan(
886        // CHECK_SPIR-COUNT-2: OpIsNan{{ }}
887        // CHECK_SPIR-NOT: OpIsNan{{ }}
888        && genBType(0) == isnan(genFType(zero))
889        && genBType(0) == isnan(genDType(zero))
890
891        // CHECK_GLSL-COUNT-2: isinf(
892        // CHECK_GLSL-NOT: isinf(
893        // CHECK_SPIR-COUNT-2: OpIsInf{{ }}
894        // CHECK_SPIR-NOT: OpIsInf{{ }}
895        && genBType(0) == isinf(genFType(zero))
896        && genBType(0) == isinf(genDType(zero))
897#endif // #if !defined(TARGET_CUDA)
898
899        // CHECK_GLSL: floatBitsToInt(
900        // CHECK_GLSL-NOT: floatBitsToInt(
901        // CHECK_SPIR: OpBitcast{{ }}
902        // CHECK_SPIR-NOT: OpBitcast{{ }}
903        && genIType(0) == floatBitsToInt(genFType(zero))
904
905        // CHECK_GLSL: floatBitsToUint(
906        // CHECK_GLSL-NOT: floatBitsToUint(
907        // CHECK_SPIR: OpBitcast{{ }}
908        // CHECK_SPIR-NOT: OpBitcast{{ }}
909        && genUType(0) == floatBitsToUint(genFType(zero))
910
911        // CHECK_GLSL: intBitsToFloat(
912        // CHECK_GLSL-NOT: intBitsToFloat(
913        // CHECK_SPIR: OpBitcast{{ }}
914        // CHECK_SPIR-NOT: OpBitcast{{ }}
915        && genFType(0) == intBitsToFloat(genIType(zero))
916
917        // CHECK_GLSL: uintBitsToFloat(
918        // CHECK_GLSL-NOT: uintBitsToFloat(
919        // CHECK_SPIR: OpBitcast{{ }}
920        // CHECK_SPIR-NOT: OpBitcast{{ }}
921        && genFType(0) == uintBitsToFloat(genUType(zero))
922
923        // CHECK_GLSL-COUNT-2: fma(
924        // CHECK_GLSL-NOT: fma(
925        // CHECK_SPIR-COUNT-2: Fma{{ }}
926        // CHECK_SPIR-NOT: Fma{{ }}
927        && genFType(0) == fma(genFType(zero), genFType(zero), genFType(zero))
928        && genDType(0) == fma(genDType(zero), genDType(zero), genDType(zero))
929
930        // CHECK_GLSL-COUNT-2: frexp(
931        // CHECK_GLSL-NOT: frexp(
932        // CHECK_SPIR-COUNT-2: Frexp{{ }}
933        // CHECK_SPIR-NOT: Frexp{{ }}
934        && genFType(0) == frexp(genFType(zero), outGenIType) && genIType(0) == outGenIType
935        && genDType(0) == frexp(genDType(zero), outGenIType) && genIType(0) == outGenIType
936
937        // CHECK_GLSL-COUNT-2: ldexp(
938        // CHECK_GLSL-NOT: ldexp(
939        // CHECK_SPIR-COUNT-2: Ldexp{{ }}
940        // CHECK_SPIR-NOT: Ldexp{{ }}
941        && genFType(0) == ldexp(genFType(zero), genIType(zero))
942        && genDType(0) == ldexp(genDType(zero), genIType(zero))
943
944        // 8.5. Geometric Functions
945
946        // CHECK_GLSL-COUNT-2: length(
947        // CHECK_GLSL-NOT: length(
948        // CHECK_SPIR-COUNT-2: Length{{ }}
949        // CHECK_SPIR-NOT: Length{{ }}
950        && float(0) == length(genFType(zero))
951        && double(0) == length(genDType(zero))
952
953        // CHECK_GLSL-COUNT-2: distance(
954        // CHECK_GLSL-NOT: distance(
955        // CHECK_SPIR-COUNT-2: Distance{{ }}
956        // CHECK_SPIR-NOT: Distance{{ }}
957        && float(0) == distance(genFType(zero), genFType(zero))
958        && double(0) == distance(genDType(zero), genDType(zero))
959
960        // CHECK_GLSL-COUNT-2: dot(
961        // CHECK_GLSL-NOT: dot(
962        && float(0) == dot(genFType(zero), genFType(zero))
963        && double(0) == dot(genDType(zero), genDType(zero))
964
965        // CHECK_GLSL-COUNT-2: normalize(
966        // CHECK_GLSL-NOT: normalize(
967        // CHECK_SPIR-COUNT-2: Normalize{{ }}
968        // CHECK_SPIR-NOT: Normalize{{ }}
969        && (abs(float(1) - length(normalize(genFType(one)))) < epsilon)
970        && (abs(double(1) - length(normalize(genDType(one)))) < double(epsilon))
971
972        // CHECK_GLSL-COUNT-2: faceforward(
973        // CHECK_GLSL-NOT: faceforward(
974        // CHECK_SPIR-COUNT-2: FaceForward{{ }}
975        // CHECK_SPIR-NOT: FaceForward{{ }}
976        && genFType(1) == faceforward(genFType(one), genFType(one), genFType(negaOne))
977        && genDType(1) == faceforward(genDType(one), genDType(one), genDType(negaOne))
978
979        // CHECK_GLSL-COUNT-2: reflect(
980        // CHECK_GLSL-NOT: reflect(
981        // CHECK_SPIR-COUNT-2: Reflect{{ }}
982        // CHECK_SPIR-NOT: Reflect{{ }}
983        && genFType(0) == reflect(genFType(zero), genFType(zero))
984        && genDType(0) == reflect(genDType(zero), genDType(zero))
985
986        // CHECK_GLSL-COUNT-2: refract(
987        // CHECK_GLSL-NOT: refract(
988        // CHECK_SPIR-COUNT-2: Refract{{ }}
989        // CHECK_SPIR-NOT: Refract{{ }}
990        && genFType(0) == refract(genFType(zero), genFType(zero), float(zero))
991        && genDType(0) == refract(genDType(zero), genDType(zero), double(zero))
992
993        // 8.7. Vector Relational Functions
994
995#if !defined(TARGET_CUDA)
996        // CHECK_GLSL-COUNT-3: lessThan(
997        // CHECK_GLSL-NOT: lessThan(
998        && bvec(1) == lessThan(vec(zero), vec(one))
999        && bvec(1) == lessThan(ivec(zero), ivec(one))
1000        && bvec(1) == lessThan(uvec(zero), uvec(one))
1001
1002        // CHECK_GLSL-COUNT-3: lessThanEqual(
1003        // CHECK_GLSL-NOT: lessThanEqual(
1004        && bvec(1) == lessThanEqual(vec(zero), vec(one))
1005        && bvec(1) == lessThanEqual(ivec(zero), ivec(one))
1006        && bvec(1) == lessThanEqual(uvec(zero), uvec(one))
1007
1008        // CHECK_GLSL-COUNT-3: greaterThan(
1009        // CHECK_GLSL-NOT: greaterThan(
1010        && bvec(0) == greaterThan(vec(zero), vec(one))
1011        && bvec(0) == greaterThan(ivec(zero), ivec(one))
1012        && bvec(0) == greaterThan(uvec(zero), uvec(one))
1013
1014        // CHECK_GLSL-COUNT-3: greaterThanEqual(
1015        // CHECK_GLSL-NOT: greaterThanEqual(
1016        && bvec(0) == greaterThanEqual(vec(zero), vec(one))
1017        && bvec(0) == greaterThanEqual(ivec(zero), ivec(one))
1018        && bvec(0) == greaterThanEqual(uvec(zero), uvec(one))
1019
1020        // CHECK_GLSL-COUNT-4: equal(
1021        && bvec(1) == equal(vec(zero), vec(zero))
1022        && bvec(1) == equal(ivec(zero), ivec(zero))
1023        && bvec(1) == equal(uvec(zero), uvec(zero))
1024        && bvec(1) == equal(bvec(zero), bvec(zero))
1025
1026        // CHECK_GLSL-COUNT-4: notEqual(
1027        // CHECK_GLSL-NOT: notEqual(
1028        && bvec(0) == notEqual(vec(zero), vec(zero))
1029        && bvec(0) == notEqual(ivec(zero), ivec(zero))
1030        && bvec(0) == notEqual(uvec(zero), uvec(zero))
1031        && bvec(0) == notEqual(bvec(zero), bvec(zero))
1032
1033        // CHECK_GLSL: any(
1034        // CHECK_GLSL-NOT: any(
1035        && bool(0) == any(bvec(zero))
1036
1037        // CHECK_GLSL: all(
1038        && bool(0) == all(bvec(zero))
1039
1040        // CHECK_GLSL: not(
1041        // CHECK_GLSL-NOT: not(
1042        && bvec(1) == not(bvec(zero))
1043#endif // #if !defined(TARGET_CUDA)
1044
1045        // 8.8. Integer Functions
1046
1047        // CHECK_GLSL: uaddCarry(
1048        // CHECK_GLSL-NOT: uaddCarry(
1049        // CHECK_SPIR: OpIAddCarry{{ }}
1050        // CHECK_SPIR-NOT: OpIAddCarry{{ }}
1051        && genUType(0) == uaddCarry(genUType(zero), genUType(zero), outGenUType) && genUType(0) == outGenUType
1052
1053        // CHECK_GLSL: usubBorrow(
1054        // CHECK_GLSL-NOT: usubBorrow(
1055        // CHECK_SPIR: OpISubBorrow{{ }}
1056        // CHECK_SPIR-NOT: OpISubBorrow{{ }}
1057        && genUType(0) == usubBorrow(genUType(zero), genUType(zero), outGenUType) && genUType(0) == outGenUType
1058
1059        // CHECK_GLSL-COUNT-2: bitfieldExtract(
1060        // CHECK_GLSL-NOT: bitfieldExtract(
1061        // CHECK_SPIR: OpBitFieldSExtract{{ }}
1062        // CHECK_SPIR-NOT: OpBitFieldSExtract{{ }}
1063        // CHECK_SPIR: OpBitFieldUExtract{{ }}
1064        // CHECK_SPIR-NOT: OpBitFieldUExtract{{ }}
1065        && genIType(0) == bitfieldExtract(genIType(zero), uint(zero), uint(zero))
1066        && genUType(0) == bitfieldExtract(genUType(zero), uint(zero), uint(zero))
1067
1068        // CHECK_GLSL-COUNT-2: bitfieldInsert(
1069        // CHECK_GLSL-NOT: bitfieldInsert(
1070        // CHECK_SPIR-COUNT-2: OpBitFieldInsert{{ }}
1071        // CHECK_SPIR-NOT: OpBitFieldInsert{{ }}
1072        && genIType(0) == bitfieldInsert(genIType(zero), genIType(zero), uint(zero), uint(zero))
1073        && genUType(0) == bitfieldInsert(genUType(zero), genUType(zero), uint(zero), uint(zero))
1074
1075        // CHECK_GLSL-COUNT-2: bitfieldReverse(
1076        // CHECK_GLSL-NOT: bitfieldReverse(
1077        // CHECK_SPIR-COUNT-2: OpBitReverse{{ }}
1078        // CHECK_SPIR-NOT: OpBitReverse{{ }}
1079        && genIType(0) == bitfieldReverse(genIType(zero))
1080        && genUType(0) == bitfieldReverse(genUType(zero))
1081
1082        // CHECK_GLSL-COUNT-2: bitCount(
1083        // CHECK_GLSL-NOT: bitCount(
1084        // CHECK_SPIR-COUNT-2: OpBitCount{{ }}
1085        // CHECK_SPIR-NOT: OpBitCount{{ }}
1086        && genIType(0) == bitCount(genIType(zero))
1087        && genIType(0) == bitCount(genUType(zero))
1088
1089#if !defined(TARGET_CUDA)
1090        // CHECK_GLSL-COUNT-2: findLSB(
1091        // CHECK_GLSL-NOT: findLSB(
1092        // CHECK_SPIR-COUNT-2: FindILsb{{ }}
1093        // CHECK_SPIR-NOT: FindILsb{{ }}
1094        && genIType(-1) == findLSB(genIType(zero))
1095        && genIType(-1) == findLSB(genUType(zero))
1096
1097        // CHECK_GLSL-COUNT-2: findMSB(
1098        // CHECK_GLSL-NOT: findMSB(
1099        // CHECK_SPIR: FindSMsb{{ }}
1100        // CHECK_SPIR-NOT: FindSMsb{{ }}
1101        // CHECK_SPIR: FindUMsb{{ }}
1102        // CHECK_SPIR-NOT: FindUMsb{{ }}
1103        && genIType(-1) == findMSB(genIType(zero))
1104        && genIType(-1) == findMSB(genUType(zero))
1105#endif // #if !defined(TARGET_CUDA)
1106        ;
1107
1108    // CHECK_GLSL-LABEL: bool Test_VectorType_1
1109    // CHECK_SPIR-LABEL: Op{{.*}}AccessChain {{.*}} %inputBuffer
1110}
1111
1112[numthreads(4, 1, 1)]
1113void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
1114{
1115    // CHECK_GLSL: void main(
1116    // CHECK_GLSL_SPIRV: OpEntryPoint
1117    // CHECK_HLSL: void computeMain(
1118    // CHECK_CUDA: void computeMain(
1119    // CHECK_CPP: void _computeMain(
1120    // BUF: 1
1121
1122    bool r = true
1123        && Test_ScalarType()
1124        && Test_VectorType<2>()
1125        && Test_VectorType<3>()
1126        && Test_VectorType<4>()
1127        ;
1128
1129    outputBuffer.result = int(r);
1130}