xref: /aosp_15_r20/external/deqp/external/openglcts/modules/gles31/es31cShaderBitfieldOperationTests.cpp (revision 35238bce31c2a825756842865a792f8cf7f89930) 
1 /*-------------------------------------------------------------------------
2  * OpenGL Conformance Test Suite
3  * -----------------------------
4  *
5  * Copyright (c) 2014-2016 The Khronos Group Inc.
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  */ /*!
20  * \file
21  * \brief
22  */ /*-------------------------------------------------------------------*/
23 
24 #include "es31cShaderBitfieldOperationTests.hpp"
25 #include "deMath.h"
26 #include "deRandom.hpp"
27 #include "deString.h"
28 #include "deStringUtil.hpp"
29 #include "deFloat16.h"
30 #include "gluContextInfo.hpp"
31 #include "gluDrawUtil.hpp"
32 #include "gluPixelTransfer.hpp"
33 #include "gluShaderProgram.hpp"
34 #include "glw.h"
35 #include "glwFunctions.hpp"
36 #include "tcuCommandLine.hpp"
37 #include "tcuStringTemplate.hpp"
38 #include "tcuSurface.hpp"
39 #include "tcuTestLog.hpp"
40 
41 namespace glcts
42 {
43 
44 using glcts::Context;
45 using std::string;
46 using std::vector;
47 using tcu::TestLog;
48 
specializeVersion(const std::string & source,glu::GLSLVersion version,const char * testStatement)49 static std::string specializeVersion(const std::string &source, glu::GLSLVersion version, const char *testStatement)
50 {
51     DE_ASSERT(version == glu::GLSL_VERSION_310_ES || version >= glu::GLSL_VERSION_430);
52     std::map<std::string, std::string> args;
53     args["VERSION_DECL"]   = glu::getGLSLVersionDeclaration(version);
54     args["TEST_STATEMENT"] = testStatement;
55     return tcu::StringTemplate(source.c_str()).specialize(args);
56 }
57 
58 struct Data
59 {
Dataglcts::Data60     Data()
61     {
62         memset(this, 0, sizeof *this);
63     }
Dataglcts::Data64     Data(Data const &init)
65     {
66         memcpy(this, &init, sizeof *this);
67     }
68 
69     GLuint inUvec4[4];
70     GLint inIvec4[4];
71     GLfloat inVec4[4];
72 
73     GLuint in2Uvec4[4];
74     GLint in2Ivec4[4];
75     GLfloat in2Vec4[4];
76 
77     GLint offset;
78     GLint bits;
79     GLint padding[2];
80 
81     GLuint outUvec4[4];
82     GLint outIvec4[4];
83     GLfloat outVec4[4];
84 
85     GLuint out2Uvec4[4];
86     GLint out2Ivec4[4];
87     GLfloat out2Vec4[4];
88 };
89 
90 struct Uvec4 : public Data
91 {
Uvec4glcts::Uvec492     Uvec4(GLuint x = 0, GLuint y = 0, GLuint z = 0, GLuint w = 0)
93     {
94         inUvec4[0] = x;
95         inUvec4[1] = y;
96         inUvec4[2] = z;
97         inUvec4[3] = w;
98     }
99 };
100 
101 struct Ivec4 : public Data
102 {
Ivec4glcts::Ivec4103     Ivec4(GLint x = 0, GLint y = 0, GLint z = 0, GLint w = 0)
104     {
105         inIvec4[0] = x;
106         inIvec4[1] = y;
107         inIvec4[2] = z;
108         inIvec4[3] = w;
109     }
110 };
111 
112 struct Vec4 : public Data
113 {
Vec4glcts::Vec4114     Vec4(GLfloat x = 0.0f, GLfloat y = 0.0f, GLfloat z = 0.0f, GLfloat w = 0.0f)
115     {
116         inVec4[0] = x;
117         inVec4[1] = y;
118         inVec4[2] = z;
119         inVec4[3] = w;
120     }
121 };
122 
123 class ShaderBitfieldOperationCase : public TestCase
124 {
125 public:
126     ShaderBitfieldOperationCase(Context &context, const char *name, const char *description,
127                                 glu::GLSLVersion glslVersion, Data const &data, char const *testStatement);
128     ~ShaderBitfieldOperationCase();
129 
130     IterateResult iterate();
131 
132 protected:
133     glu::GLSLVersion m_glslVersion;
134     Data m_data;
135     std::string m_testStatement;
136 
137     virtual bool test(Data const *data) = 0;
138 };
139 
ShaderBitfieldOperationCase(Context & context,const char * name,const char * description,glu::GLSLVersion glslVersion,Data const & data,char const * testStatement)140 ShaderBitfieldOperationCase::ShaderBitfieldOperationCase(Context &context, const char *name, const char *description,
141                                                          glu::GLSLVersion glslVersion, Data const &data,
142                                                          char const *testStatement)
143     : TestCase(context, name, description)
144     , m_glslVersion(glslVersion)
145     , m_data(data)
146     , m_testStatement(testStatement)
147 {
148     DE_ASSERT(glslVersion == glu::GLSL_VERSION_310_ES || glslVersion >= glu::GLSL_VERSION_430);
149 }
150 
~ShaderBitfieldOperationCase()151 ShaderBitfieldOperationCase::~ShaderBitfieldOperationCase()
152 {
153 }
154 
iterate()155 ShaderBitfieldOperationCase::IterateResult ShaderBitfieldOperationCase::iterate()
156 {
157     const glw::Functions &gl = m_context.getRenderContext().getFunctions();
158     bool isOk                = true;
159 
160     GLuint data;
161     gl.genBuffers(1, &data);
162     gl.bindBuffer(GL_SHADER_STORAGE_BUFFER, data);
163     gl.bufferData(GL_SHADER_STORAGE_BUFFER, sizeof(Data), &m_data, GL_STATIC_DRAW);
164     gl.bindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, data);
165 
166     char const *css = "${VERSION_DECL}\n"
167                       "\n"
168                       "layout(local_size_x = 1) in;\n"
169                       "\n"
170                       "layout(binding = 0, std430) buffer Data {\n"
171                       "    uvec4 inUvec4;\n"
172                       "    ivec4 inIvec4;\n"
173                       "    vec4 inVec4;\n"
174                       "\n"
175                       "    uvec4 in2Uvec4;\n"
176                       "    ivec4 in2Ivec4;\n"
177                       "    vec4 in2Vec4;\n"
178                       "\n"
179                       "    int offset;\n"
180                       "    int bits;\n"
181                       "\n"
182                       "    uvec4 outUvec4;\n"
183                       "    ivec4 outIvec4;\n"
184                       "    vec4 outVec4;\n"
185                       "\n"
186                       "    uvec4 out2Uvec4;\n"
187                       "    ivec4 out2Ivec4;\n"
188                       "    vec4 out2Vec4;\n"
189                       "};\n"
190                       "\n"
191                       "void main()\n"
192                       "{\n"
193                       "    ${TEST_STATEMENT};\n"
194                       "}\n";
195 
196     GLuint cs              = gl.createShader(GL_COMPUTE_SHADER);
197     std::string csString   = specializeVersion(css, m_glslVersion, m_testStatement.c_str());
198     char const *strings[1] = {csString.c_str()};
199     gl.shaderSource(cs, 1, strings, 0);
200     gl.compileShader(cs);
201     GLint compileSuccess = 0;
202     gl.getShaderiv(cs, GL_COMPILE_STATUS, &compileSuccess);
203     if (!compileSuccess)
204     {
205         TCU_FAIL("Compile failed");
206     }
207 
208     GLuint pgm = gl.createProgram();
209     gl.attachShader(pgm, cs);
210     gl.linkProgram(pgm);
211     GLint linkSuccess = 0;
212     gl.getProgramiv(pgm, GL_LINK_STATUS, &linkSuccess);
213     if (!linkSuccess)
214     {
215         gl.deleteShader(cs);
216         TCU_FAIL("Link failed");
217     }
218 
219     gl.useProgram(pgm);
220 
221     gl.dispatchCompute(1, 1, 1);
222 
223     Data const *results = (Data const *)gl.mapBufferRange(GL_SHADER_STORAGE_BUFFER, 0, sizeof(Data), GL_MAP_READ_BIT);
224     isOk                = test(results);
225     gl.unmapBuffer(GL_SHADER_STORAGE_BUFFER);
226 
227     gl.useProgram(0);
228     gl.deleteProgram(pgm);
229     gl.deleteShader(cs);
230 
231     gl.deleteBuffers(1, &data);
232 
233     m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, isOk ? "Pass" : "Fail");
234     return STOP;
235 }
236 
237 class ShaderBitfieldOperationCaseFrexp : public ShaderBitfieldOperationCase
238 {
239 public:
ShaderBitfieldOperationCaseFrexp(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,int components,char const * testStatement)240     ShaderBitfieldOperationCaseFrexp(Context &context, const char *name, glu::GLSLVersion glslVersion, Data const &data,
241                                      int components, char const *testStatement)
242         : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, testStatement)
243         , m_components(components)
244     {
245     }
246 
247 private:
248     int m_components;
249 
test(Data const * data)250     virtual bool test(Data const *data)
251     {
252         for (int i = 0; i < m_components; ++i)
253         {
254             if (data->inVec4[i] == 0.0)
255             {
256                 if (data->outVec4[i] != 0.0 || data->outIvec4[i] != 0)
257                 {
258                     return false;
259                 }
260             }
261             else if (deFloatAbs(data->outVec4[i]) < 0.5 || deFloatAbs(data->outVec4[i]) >= 1.0)
262             {
263                 return false;
264             }
265 
266             float result = data->outVec4[i] * deFloatPow(2.0, (float)data->outIvec4[i]);
267             if (deFloatAbs(result - data->inVec4[i]) > 0.0001f)
268             {
269                 return false;
270             }
271         }
272         return true;
273     }
274 };
275 
276 class ShaderBitfieldOperationCaseFrexpFloat : public ShaderBitfieldOperationCaseFrexp
277 {
278 public:
ShaderBitfieldOperationCaseFrexpFloat(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data)279     ShaderBitfieldOperationCaseFrexpFloat(Context &context, const char *name, glu::GLSLVersion glslVersion,
280                                           Data const &data)
281         : ShaderBitfieldOperationCaseFrexp(context, name, glslVersion, data, 1,
282                                            "outVec4.x = frexp(inVec4.x, outIvec4.x)")
283     {
284     }
285 };
286 
287 class ShaderBitfieldOperationCaseFrexpVec2 : public ShaderBitfieldOperationCaseFrexp
288 {
289 public:
ShaderBitfieldOperationCaseFrexpVec2(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data)290     ShaderBitfieldOperationCaseFrexpVec2(Context &context, const char *name, glu::GLSLVersion glslVersion,
291                                          Data const &data)
292         : ShaderBitfieldOperationCaseFrexp(context, name, glslVersion, data, 2,
293                                            "outVec4.xy = frexp(inVec4.xy, outIvec4.xy)")
294     {
295     }
296 };
297 
298 class ShaderBitfieldOperationCaseFrexpVec3 : public ShaderBitfieldOperationCaseFrexp
299 {
300 public:
ShaderBitfieldOperationCaseFrexpVec3(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data)301     ShaderBitfieldOperationCaseFrexpVec3(Context &context, const char *name, glu::GLSLVersion glslVersion,
302                                          Data const &data)
303         : ShaderBitfieldOperationCaseFrexp(context, name, glslVersion, data, 3,
304                                            "outVec4.xyz = frexp(inVec4.xyz, outIvec4.xyz)")
305     {
306     }
307 };
308 
309 class ShaderBitfieldOperationCaseFrexpVec4 : public ShaderBitfieldOperationCaseFrexp
310 {
311 public:
ShaderBitfieldOperationCaseFrexpVec4(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data)312     ShaderBitfieldOperationCaseFrexpVec4(Context &context, const char *name, glu::GLSLVersion glslVersion,
313                                          Data const &data)
314         : ShaderBitfieldOperationCaseFrexp(context, name, glslVersion, data, 4, "outVec4 = frexp(inVec4, outIvec4)")
315     {
316     }
317 };
318 
319 class ShaderBitfieldOperationCaseLdexp : public ShaderBitfieldOperationCase
320 {
321 public:
ShaderBitfieldOperationCaseLdexp(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,int components,char const * testStatement)322     ShaderBitfieldOperationCaseLdexp(Context &context, const char *name, glu::GLSLVersion glslVersion, Data const &data,
323                                      int components, char const *testStatement)
324         : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, testStatement)
325         , m_components(components)
326     {
327     }
328 
329 private:
330     int m_components;
331 
test(Data const * data)332     virtual bool test(Data const *data)
333     {
334         for (int i = 0; i < m_components; ++i)
335         {
336             float expected = deFloatLdExp(data->inVec4[i], data->inIvec4[i]);
337             if (deFloatAbs(expected - data->outVec4[i]) > 0.0001f)
338             {
339                 return false;
340             }
341         }
342         return true;
343     }
344 };
345 
346 class ShaderBitfieldOperationCaseLdexpFloat : public ShaderBitfieldOperationCaseLdexp
347 {
348 public:
ShaderBitfieldOperationCaseLdexpFloat(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,Data const & exp)349     ShaderBitfieldOperationCaseLdexpFloat(Context &context, const char *name, glu::GLSLVersion glslVersion,
350                                           Data const &data, Data const &exp)
351         : ShaderBitfieldOperationCaseLdexp(context, name, glslVersion, data, 1,
352                                            "outVec4.x = ldexp(inVec4.x, inIvec4.x)")
353     {
354         m_data.inIvec4[0] = exp.inIvec4[0];
355     }
356 };
357 
358 class ShaderBitfieldOperationCaseLdexpVec2 : public ShaderBitfieldOperationCaseLdexp
359 {
360 public:
ShaderBitfieldOperationCaseLdexpVec2(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,Data const & exp)361     ShaderBitfieldOperationCaseLdexpVec2(Context &context, const char *name, glu::GLSLVersion glslVersion,
362                                          Data const &data, Data const &exp)
363         : ShaderBitfieldOperationCaseLdexp(context, name, glslVersion, data, 2,
364                                            "outVec4.xy = ldexp(inVec4.xy, inIvec4.xy)")
365     {
366         m_data.inIvec4[0] = exp.inIvec4[0];
367         m_data.inIvec4[1] = exp.inIvec4[1];
368     }
369 };
370 
371 class ShaderBitfieldOperationCaseLdexpVec3 : public ShaderBitfieldOperationCaseLdexp
372 {
373 public:
ShaderBitfieldOperationCaseLdexpVec3(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,Data const & exp)374     ShaderBitfieldOperationCaseLdexpVec3(Context &context, const char *name, glu::GLSLVersion glslVersion,
375                                          Data const &data, Data const &exp)
376         : ShaderBitfieldOperationCaseLdexp(context, name, glslVersion, data, 3,
377                                            "outVec4.xyz = ldexp(inVec4.xyz, inIvec4.xyz)")
378     {
379         m_data.inIvec4[0] = exp.inIvec4[0];
380         m_data.inIvec4[1] = exp.inIvec4[1];
381         m_data.inIvec4[2] = exp.inIvec4[2];
382     }
383 };
384 
385 class ShaderBitfieldOperationCaseLdexpVec4 : public ShaderBitfieldOperationCaseLdexp
386 {
387 public:
ShaderBitfieldOperationCaseLdexpVec4(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,Data const & exp)388     ShaderBitfieldOperationCaseLdexpVec4(Context &context, const char *name, glu::GLSLVersion glslVersion,
389                                          Data const &data, Data const &exp)
390         : ShaderBitfieldOperationCaseLdexp(context, name, glslVersion, data, 4, "outVec4 = ldexp(inVec4, inIvec4)")
391     {
392         m_data.inIvec4[0] = exp.inIvec4[0];
393         m_data.inIvec4[1] = exp.inIvec4[1];
394         m_data.inIvec4[2] = exp.inIvec4[2];
395         m_data.inIvec4[3] = exp.inIvec4[3];
396     }
397 };
398 
reduce32PrecisionTo16(float f)399 static float reduce32PrecisionTo16(float f)
400 {
401     return deFloat16To32(deFloat32To16(f));
402 }
403 
pack(float x,float y,float z,float w,float range)404 static GLuint pack(float x, float y, float z, float w, float range)
405 {
406     return ((int(deFloatFloor(x * range + 0.5f)) & 0xFF) << 0) | ((int(deFloatFloor(y * range + 0.5f)) & 0xFF) << 8) |
407            ((int(deFloatFloor(z * range + 0.5f)) & 0xFF) << 16) | ((int(deFloatFloor(w * range + 0.5f)) & 0xFF) << 24);
408 }
409 
checkOutData(GLuint result,const GLfloat input[4],float range)410 static bool checkOutData(GLuint result, const GLfloat input[4], float range)
411 {
412     GLuint expected = pack(input[0], input[1], input[2], input[3], range);
413 
414     GLuint expected_mp = pack(reduce32PrecisionTo16(input[0]), reduce32PrecisionTo16(input[1]),
415                               reduce32PrecisionTo16(input[2]), reduce32PrecisionTo16(input[3]), range);
416 
417     return (expected == result || expected_mp == result);
418 }
419 
420 class ShaderBitfieldOperationCasePackUnorm : public ShaderBitfieldOperationCase
421 {
422 public:
ShaderBitfieldOperationCasePackUnorm(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data)423     ShaderBitfieldOperationCasePackUnorm(Context &context, const char *name, glu::GLSLVersion glslVersion,
424                                          Data const &data)
425         : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, "outUvec4.x = packUnorm4x8(inVec4)")
426     {
427     }
428 
429 private:
test(Data const * data)430     virtual bool test(Data const *data)
431     {
432         return checkOutData(data->outUvec4[0], data->inVec4, 255.0f);
433     }
434 };
435 
436 class ShaderBitfieldOperationCasePackSnorm : public ShaderBitfieldOperationCase
437 {
438 public:
ShaderBitfieldOperationCasePackSnorm(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data)439     ShaderBitfieldOperationCasePackSnorm(Context &context, const char *name, glu::GLSLVersion glslVersion,
440                                          Data const &data)
441         : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, "outUvec4.x = packSnorm4x8(inVec4)")
442     {
443     }
444 
445 private:
test(Data const * data)446     virtual bool test(Data const *data)
447     {
448         return checkOutData(data->outUvec4[0], data->inVec4, 127.0f);
449     }
450 };
451 
452 class ShaderBitfieldOperationCaseUnpackUnorm : public ShaderBitfieldOperationCase
453 {
454 public:
ShaderBitfieldOperationCaseUnpackUnorm(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data)455     ShaderBitfieldOperationCaseUnpackUnorm(Context &context, const char *name, glu::GLSLVersion glslVersion,
456                                            Data const &data)
457         : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, "outVec4 = unpackUnorm4x8(inUvec4.x)")
458     {
459     }
460 
461 private:
test(Data const * data)462     virtual bool test(Data const *data)
463     {
464         GLfloat x = float((data->inUvec4[0] >> 0) & 0xFF) / 255.0f;
465         if (deFloatAbs(data->outVec4[0] - x) > 0.0001f)
466         {
467             return false;
468         }
469         GLfloat y = float((data->inUvec4[0] >> 8) & 0xFF) / 255.0f;
470         if (deFloatAbs(data->outVec4[1] - y) > 0.0001f)
471         {
472             return false;
473         }
474         GLfloat z = float((data->inUvec4[0] >> 16) & 0xFF) / 255.0f;
475         if (deFloatAbs(data->outVec4[2] - z) > 0.0001f)
476         {
477             return false;
478         }
479         GLfloat w = float((data->inUvec4[0] >> 24) & 0xFF) / 255.0f;
480         if (deFloatAbs(data->outVec4[3] - w) > 0.0001f)
481         {
482             return false;
483         }
484 
485         return true;
486     }
487 };
488 
489 class ShaderBitfieldOperationCaseUnpackSnorm : public ShaderBitfieldOperationCase
490 {
491 public:
ShaderBitfieldOperationCaseUnpackSnorm(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data)492     ShaderBitfieldOperationCaseUnpackSnorm(Context &context, const char *name, glu::GLSLVersion glslVersion,
493                                            Data const &data)
494         : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, "outVec4 = unpackSnorm4x8(inUvec4.x)")
495     {
496     }
497 
498 private:
test(Data const * data)499     virtual bool test(Data const *data)
500     {
501         GLfloat x = float((signed char)((data->inUvec4[0] >> 0) & 0xFF)) / 127.0f;
502         x         = de::clamp<GLfloat>(x, -1.0f, 1.0f);
503         if (deFloatAbs(data->outVec4[0] - x) > 0.0001f)
504         {
505             return false;
506         }
507         GLfloat y = float((signed char)((data->inUvec4[0] >> 8) & 0xFF)) / 127.0f;
508         y         = de::clamp<GLfloat>(y, -1.0f, 1.0f);
509         if (deFloatAbs(data->outVec4[1] - y) > 0.0001f)
510         {
511             return false;
512         }
513         GLfloat z = float((signed char)((data->inUvec4[0] >> 16) & 0xFF)) / 127.0f;
514         z         = de::clamp<GLfloat>(z, -1.0f, 1.0f);
515         if (deFloatAbs(data->outVec4[2] - z) > 0.0001f)
516         {
517             return false;
518         }
519         GLfloat w = float((signed char)((data->inUvec4[0] >> 24) & 0xFF)) / 127.0f;
520         w         = de::clamp<GLfloat>(w, -1.0f, 1.0f);
521         if (deFloatAbs(data->outVec4[3] - w) > 0.0001f)
522         {
523             return false;
524         }
525 
526         return true;
527     }
528 };
529 
530 class ShaderBitfieldOperationCaseBitfieldExtractUint : public ShaderBitfieldOperationCase
531 {
532 public:
ShaderBitfieldOperationCaseBitfieldExtractUint(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,int offset,int bits,int components,char const * testStatement)533     ShaderBitfieldOperationCaseBitfieldExtractUint(Context &context, const char *name, glu::GLSLVersion glslVersion,
534                                                    Data const &data, int offset, int bits, int components,
535                                                    char const *testStatement)
536         : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, testStatement)
537         , m_components(components)
538     {
539         if (offset + bits > 32)
540         {
541             offset -= (offset + bits) - 32;
542         }
543         m_data.offset = offset;
544         m_data.bits   = bits;
545     }
546 
547 private:
548     int m_components;
549 
test(Data const * data)550     virtual bool test(Data const *data)
551     {
552         for (int i = 0; i < m_components; ++i)
553         {
554             GLuint expected =
555                 (data->inUvec4[i] >> data->offset) & (data->bits == 32 ? 0xFFFFFFFF : ((1u << data->bits) - 1));
556             if (data->outUvec4[i] != expected)
557             {
558                 return false;
559             }
560         }
561         return true;
562     }
563 };
564 
565 class ShaderBitfieldOperationCaseBitfieldExtractUint1 : public ShaderBitfieldOperationCaseBitfieldExtractUint
566 {
567 public:
ShaderBitfieldOperationCaseBitfieldExtractUint1(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,int offset,int bits)568     ShaderBitfieldOperationCaseBitfieldExtractUint1(Context &context, const char *name, glu::GLSLVersion glslVersion,
569                                                     Data const &data, int offset, int bits)
570         : ShaderBitfieldOperationCaseBitfieldExtractUint(context, name, glslVersion, data, offset, bits, 1,
571                                                          "outUvec4.x = bitfieldExtract(inUvec4.x, offset, bits)")
572     {
573     }
574 };
575 
576 class ShaderBitfieldOperationCaseBitfieldExtractUint2 : public ShaderBitfieldOperationCaseBitfieldExtractUint
577 {
578 public:
ShaderBitfieldOperationCaseBitfieldExtractUint2(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,int offset,int bits)579     ShaderBitfieldOperationCaseBitfieldExtractUint2(Context &context, const char *name, glu::GLSLVersion glslVersion,
580                                                     Data const &data, int offset, int bits)
581         : ShaderBitfieldOperationCaseBitfieldExtractUint(context, name, glslVersion, data, offset, bits, 2,
582                                                          "outUvec4.xy = bitfieldExtract(inUvec4.xy, offset, bits)")
583     {
584     }
585 };
586 
587 class ShaderBitfieldOperationCaseBitfieldExtractUint3 : public ShaderBitfieldOperationCaseBitfieldExtractUint
588 {
589 public:
ShaderBitfieldOperationCaseBitfieldExtractUint3(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,int offset,int bits)590     ShaderBitfieldOperationCaseBitfieldExtractUint3(Context &context, const char *name, glu::GLSLVersion glslVersion,
591                                                     Data const &data, int offset, int bits)
592         : ShaderBitfieldOperationCaseBitfieldExtractUint(context, name, glslVersion, data, offset, bits, 3,
593                                                          "outUvec4.xyz = bitfieldExtract(inUvec4.xyz, offset, bits)")
594     {
595     }
596 };
597 
598 class ShaderBitfieldOperationCaseBitfieldExtractUint4 : public ShaderBitfieldOperationCaseBitfieldExtractUint
599 {
600 public:
ShaderBitfieldOperationCaseBitfieldExtractUint4(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,int offset,int bits)601     ShaderBitfieldOperationCaseBitfieldExtractUint4(Context &context, const char *name, glu::GLSLVersion glslVersion,
602                                                     Data const &data, int offset, int bits)
603         : ShaderBitfieldOperationCaseBitfieldExtractUint(context, name, glslVersion, data, offset, bits, 4,
604                                                          "outUvec4 = bitfieldExtract(inUvec4, offset, bits)")
605     {
606     }
607 };
608 
609 class ShaderBitfieldOperationCaseBitfieldExtractInt : public ShaderBitfieldOperationCase
610 {
611 public:
ShaderBitfieldOperationCaseBitfieldExtractInt(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,int offset,int bits,int components,char const * testStatement)612     ShaderBitfieldOperationCaseBitfieldExtractInt(Context &context, const char *name, glu::GLSLVersion glslVersion,
613                                                   Data const &data, int offset, int bits, int components,
614                                                   char const *testStatement)
615         : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, testStatement)
616         , m_components(components)
617     {
618         if (offset + bits > 32)
619         {
620             offset -= (offset + bits) - 32;
621         }
622         m_data.offset = offset;
623         m_data.bits   = bits;
624     }
625 
626 private:
627     int m_components;
628 
test(Data const * data)629     virtual bool test(Data const *data)
630     {
631         for (int i = 0; i < m_components; ++i)
632         {
633             GLint expected = data->inIvec4[i] << (32 - (data->offset + data->bits));
634             expected >>= 32 - data->bits;
635             if (data->outIvec4[i] != expected)
636             {
637                 return false;
638             }
639         }
640         return true;
641     }
642 };
643 
644 class ShaderBitfieldOperationCaseBitfieldExtractInt1 : public ShaderBitfieldOperationCaseBitfieldExtractInt
645 {
646 public:
ShaderBitfieldOperationCaseBitfieldExtractInt1(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,int offset,int bits)647     ShaderBitfieldOperationCaseBitfieldExtractInt1(Context &context, const char *name, glu::GLSLVersion glslVersion,
648                                                    Data const &data, int offset, int bits)
649         : ShaderBitfieldOperationCaseBitfieldExtractInt(context, name, glslVersion, data, offset, bits, 1,
650                                                         "outIvec4.x = bitfieldExtract(inIvec4.x, offset, bits)")
651     {
652     }
653 };
654 
655 class ShaderBitfieldOperationCaseBitfieldExtractInt2 : public ShaderBitfieldOperationCaseBitfieldExtractInt
656 {
657 public:
ShaderBitfieldOperationCaseBitfieldExtractInt2(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,int offset,int bits)658     ShaderBitfieldOperationCaseBitfieldExtractInt2(Context &context, const char *name, glu::GLSLVersion glslVersion,
659                                                    Data const &data, int offset, int bits)
660         : ShaderBitfieldOperationCaseBitfieldExtractInt(context, name, glslVersion, data, offset, bits, 2,
661                                                         "outIvec4.xy = bitfieldExtract(inIvec4.xy, offset, bits)")
662     {
663     }
664 };
665 
666 class ShaderBitfieldOperationCaseBitfieldExtractInt3 : public ShaderBitfieldOperationCaseBitfieldExtractInt
667 {
668 public:
ShaderBitfieldOperationCaseBitfieldExtractInt3(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,int offset,int bits)669     ShaderBitfieldOperationCaseBitfieldExtractInt3(Context &context, const char *name, glu::GLSLVersion glslVersion,
670                                                    Data const &data, int offset, int bits)
671         : ShaderBitfieldOperationCaseBitfieldExtractInt(context, name, glslVersion, data, offset, bits, 3,
672                                                         "outIvec4.xyz = bitfieldExtract(inIvec4.xyz, offset, bits)")
673     {
674     }
675 };
676 
677 class ShaderBitfieldOperationCaseBitfieldExtractInt4 : public ShaderBitfieldOperationCaseBitfieldExtractInt
678 {
679 public:
ShaderBitfieldOperationCaseBitfieldExtractInt4(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,int offset,int bits)680     ShaderBitfieldOperationCaseBitfieldExtractInt4(Context &context, const char *name, glu::GLSLVersion glslVersion,
681                                                    Data const &data, int offset, int bits)
682         : ShaderBitfieldOperationCaseBitfieldExtractInt(context, name, glslVersion, data, offset, bits, 4,
683                                                         "outIvec4 = bitfieldExtract(inIvec4, offset, bits)")
684     {
685     }
686 };
687 
688 class ShaderBitfieldOperationCaseBitfieldInsertUint : public ShaderBitfieldOperationCase
689 {
690 public:
ShaderBitfieldOperationCaseBitfieldInsertUint(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,Data const & insert,int offset,int bits,int components,char const * testStatement)691     ShaderBitfieldOperationCaseBitfieldInsertUint(Context &context, const char *name, glu::GLSLVersion glslVersion,
692                                                   Data const &data, Data const &insert, int offset, int bits,
693                                                   int components, char const *testStatement)
694         : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, testStatement)
695         , m_components(components)
696     {
697         for (int i = 0; i < components; ++i)
698         {
699             m_data.in2Uvec4[i] = insert.inUvec4[i];
700         }
701         if (offset + bits > 32)
702         {
703             offset -= (offset + bits) - 32;
704         }
705         m_data.offset = offset;
706         m_data.bits   = bits;
707     }
708 
709 private:
710     int m_components;
711 
test(Data const * data)712     virtual bool test(Data const *data)
713     {
714         for (int i = 0; i < m_components; ++i)
715         {
716             GLuint mask = (data->bits == 32) ? ~0u : (1 << data->bits) - 1;
717             GLuint expected =
718                 (data->inUvec4[i] & ~(mask << data->offset)) | ((data->in2Uvec4[i] & mask) << data->offset);
719             if (data->outUvec4[i] != expected)
720             {
721                 return false;
722             }
723         }
724         return true;
725     }
726 };
727 
728 class ShaderBitfieldOperationCaseBitfieldInsertUint1 : public ShaderBitfieldOperationCaseBitfieldInsertUint
729 {
730 public:
ShaderBitfieldOperationCaseBitfieldInsertUint1(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,Data const & insert,int offset,int bits)731     ShaderBitfieldOperationCaseBitfieldInsertUint1(Context &context, const char *name, glu::GLSLVersion glslVersion,
732                                                    Data const &data, Data const &insert, int offset, int bits)
733         : ShaderBitfieldOperationCaseBitfieldInsertUint(
734               context, name, glslVersion, data, insert, offset, bits, 1,
735               "outUvec4.x = bitfieldInsert(inUvec4.x, in2Uvec4.x, offset, bits)")
736     {
737     }
738 };
739 
740 class ShaderBitfieldOperationCaseBitfieldInsertUint2 : public ShaderBitfieldOperationCaseBitfieldInsertUint
741 {
742 public:
ShaderBitfieldOperationCaseBitfieldInsertUint2(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,Data const & insert,int offset,int bits)743     ShaderBitfieldOperationCaseBitfieldInsertUint2(Context &context, const char *name, glu::GLSLVersion glslVersion,
744                                                    Data const &data, Data const &insert, int offset, int bits)
745         : ShaderBitfieldOperationCaseBitfieldInsertUint(
746               context, name, glslVersion, data, insert, offset, bits, 2,
747               "outUvec4.xy = bitfieldInsert(inUvec4.xy, in2Uvec4.xy, offset, bits)")
748     {
749     }
750 };
751 
752 class ShaderBitfieldOperationCaseBitfieldInsertUint3 : public ShaderBitfieldOperationCaseBitfieldInsertUint
753 {
754 public:
ShaderBitfieldOperationCaseBitfieldInsertUint3(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,Data const & insert,int offset,int bits)755     ShaderBitfieldOperationCaseBitfieldInsertUint3(Context &context, const char *name, glu::GLSLVersion glslVersion,
756                                                    Data const &data, Data const &insert, int offset, int bits)
757         : ShaderBitfieldOperationCaseBitfieldInsertUint(
758               context, name, glslVersion, data, insert, offset, bits, 3,
759               "outUvec4.xyz = bitfieldInsert(inUvec4.xyz, in2Uvec4.xyz, offset, bits)")
760     {
761     }
762 };
763 
764 class ShaderBitfieldOperationCaseBitfieldInsertUint4 : public ShaderBitfieldOperationCaseBitfieldInsertUint
765 {
766 public:
ShaderBitfieldOperationCaseBitfieldInsertUint4(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,Data const & insert,int offset,int bits)767     ShaderBitfieldOperationCaseBitfieldInsertUint4(Context &context, const char *name, glu::GLSLVersion glslVersion,
768                                                    Data const &data, Data const &insert, int offset, int bits)
769         : ShaderBitfieldOperationCaseBitfieldInsertUint(context, name, glslVersion, data, insert, offset, bits, 4,
770                                                         "outUvec4 = bitfieldInsert(inUvec4, in2Uvec4, offset, bits)")
771     {
772     }
773 };
774 
775 class ShaderBitfieldOperationCaseBitfieldInsertInt : public ShaderBitfieldOperationCase
776 {
777 public:
ShaderBitfieldOperationCaseBitfieldInsertInt(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,Data const & insert,int offset,int bits,int components,char const * testStatement)778     ShaderBitfieldOperationCaseBitfieldInsertInt(Context &context, const char *name, glu::GLSLVersion glslVersion,
779                                                  Data const &data, Data const &insert, int offset, int bits,
780                                                  int components, char const *testStatement)
781         : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, testStatement)
782         , m_components(components)
783     {
784         for (int i = 0; i < components; ++i)
785         {
786             m_data.in2Ivec4[i] = insert.inIvec4[i];
787         }
788         if (offset + bits > 32)
789         {
790             offset -= (offset + bits) - 32;
791         }
792         m_data.offset = offset;
793         m_data.bits   = bits;
794     }
795 
796 private:
797     int m_components;
798 
test(Data const * data)799     virtual bool test(Data const *data)
800     {
801         for (int i = 0; i < m_components; ++i)
802         {
803             GLuint mask = (data->bits == 32) ? ~0u : (1 << data->bits) - 1;
804             GLint expected =
805                 (data->inIvec4[i] & ~(mask << data->offset)) | ((data->in2Ivec4[i] & mask) << data->offset);
806             if (data->outIvec4[i] != expected)
807             {
808                 return false;
809             }
810         }
811         return true;
812     }
813 };
814 
815 class ShaderBitfieldOperationCaseBitfieldInsertInt1 : public ShaderBitfieldOperationCaseBitfieldInsertInt
816 {
817 public:
ShaderBitfieldOperationCaseBitfieldInsertInt1(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,Data const & insert,int offset,int bits)818     ShaderBitfieldOperationCaseBitfieldInsertInt1(Context &context, const char *name, glu::GLSLVersion glslVersion,
819                                                   Data const &data, Data const &insert, int offset, int bits)
820         : ShaderBitfieldOperationCaseBitfieldInsertInt(
821               context, name, glslVersion, data, insert, offset, bits, 1,
822               "outIvec4.x = bitfieldInsert(inIvec4.x, in2Ivec4.x, offset, bits)")
823     {
824     }
825 };
826 
827 class ShaderBitfieldOperationCaseBitfieldInsertInt2 : public ShaderBitfieldOperationCaseBitfieldInsertInt
828 {
829 public:
ShaderBitfieldOperationCaseBitfieldInsertInt2(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,Data const & insert,int offset,int bits)830     ShaderBitfieldOperationCaseBitfieldInsertInt2(Context &context, const char *name, glu::GLSLVersion glslVersion,
831                                                   Data const &data, Data const &insert, int offset, int bits)
832         : ShaderBitfieldOperationCaseBitfieldInsertInt(
833               context, name, glslVersion, data, insert, offset, bits, 2,
834               "outIvec4.xy = bitfieldInsert(inIvec4.xy, in2Ivec4.xy, offset, bits)")
835     {
836     }
837 };
838 
839 class ShaderBitfieldOperationCaseBitfieldInsertInt3 : public ShaderBitfieldOperationCaseBitfieldInsertInt
840 {
841 public:
ShaderBitfieldOperationCaseBitfieldInsertInt3(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,Data const & insert,int offset,int bits)842     ShaderBitfieldOperationCaseBitfieldInsertInt3(Context &context, const char *name, glu::GLSLVersion glslVersion,
843                                                   Data const &data, Data const &insert, int offset, int bits)
844         : ShaderBitfieldOperationCaseBitfieldInsertInt(
845               context, name, glslVersion, data, insert, offset, bits, 3,
846               "outIvec4.xyz = bitfieldInsert(inIvec4.xyz, in2Ivec4.xyz, offset, bits)")
847     {
848     }
849 };
850 
851 class ShaderBitfieldOperationCaseBitfieldInsertInt4 : public ShaderBitfieldOperationCaseBitfieldInsertInt
852 {
853 public:
ShaderBitfieldOperationCaseBitfieldInsertInt4(Context & context,const char * name,glu::GLSLVersion glslVersion,Data const & data,Data const & insert,int offset,int bits)854     ShaderBitfieldOperationCaseBitfieldInsertInt4(Context &context, const char *name, glu::GLSLVersion glslVersion,
855                                                   Data const &data, Data const &insert, int offset, int bits)
856         : ShaderBitfieldOperationCaseBitfieldInsertInt(context, name, glslVersion, data, insert, offset, bits, 4,
857                                                        "outIvec4 = bitfieldInsert(inIvec4, in2Ivec4, offset, bits)")
858     {
859     }
860 };
861 
862 typedef GLuint (*UnaryUFunc)(GLuint input);
863 typedef GLint (*UnaryIFunc)(GLint input);
864 
bitfieldReverse(GLuint input)865 static GLuint bitfieldReverse(GLuint input)
866 {
867     GLuint result = 0;
868     for (int i = 0; i < 32; ++i)
869     {
870         result >>= 1;
871         result |= (input & 0x80000000);
872         input <<= 1;
873     }
874     return result;
875 }
876 
bitCount(GLuint input)877 static GLuint bitCount(GLuint input)
878 {
879     GLuint result = 0;
880     while (input)
881     {
882         if (input & 1)
883         {
884             result += 1;
885         }
886         input >>= 1;
887     }
888     return result;
889 }
890 
findLSB(GLuint input)891 static GLuint findLSB(GLuint input)
892 {
893     if (!input)
894     {
895         return -1;
896     }
897     for (GLuint result = 0;; ++result)
898     {
899         if (input & 1)
900         {
901             return result;
902         }
903         input >>= 1;
904     }
905 }
906 
findMSBU(GLuint input)907 static GLuint findMSBU(GLuint input)
908 {
909     if (!input)
910     {
911         return -1;
912     }
913     for (GLuint result = 31;; --result)
914     {
915         if (input & 0x80000000)
916         {
917             return result;
918         }
919         input <<= 1;
920     }
921 }
922 
findMSBI(GLint input)923 static GLint findMSBI(GLint input)
924 {
925     if (input == 0 || input == -1)
926     {
927         return -1;
928     }
929     else if (input > 0)
930     {
931         for (GLuint result = 31;; --result)
932         {
933             if (input & 0x80000000)
934             {
935                 return result;
936             }
937             input <<= 1;
938         }
939     }
940     else
941     {
942         for (GLuint result = 31;; --result)
943         {
944             if (!(input & 0x80000000))
945             {
946                 return result;
947             }
948             input <<= 1;
949         }
950     }
951 }
952 
953 class ShaderBitfieldOperationCaseUnaryUint : public ShaderBitfieldOperationCase
954 {
955 public:
ShaderBitfieldOperationCaseUnaryUint(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * funcName,UnaryUFunc func,Data const & data,int components,char const * testStatement)956     ShaderBitfieldOperationCaseUnaryUint(Context &context, const char *name, glu::GLSLVersion glslVersion,
957                                          char const *funcName, UnaryUFunc func, Data const &data, int components,
958                                          char const *testStatement)
959         : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, testStatement)
960         , m_components(components)
961         , m_func(func)
962     {
963         size_t pos = m_testStatement.find("func");
964         m_testStatement.replace(pos, 4, funcName);
965     }
966 
967 private:
968     int m_components;
969     UnaryUFunc m_func;
970 
test(Data const * data)971     virtual bool test(Data const *data)
972     {
973         for (int i = 0; i < m_components; ++i)
974         {
975             GLuint expected = m_func(data->inUvec4[i]);
976             GLuint output   = data->outUvec4[i];
977             if (m_func == (UnaryUFunc)glcts::bitCount || m_func == (UnaryUFunc)glcts::findLSB ||
978                 m_func == (UnaryUFunc)glcts::findMSBU || m_func == (UnaryUFunc)glcts::findMSBI)
979             {
980                 /* The built-in bitCount, findLSB and findMSB functions
981                  * return a lowp int, which can be encoded with as little
982                  * as 9 bits. Since findLSB and findMSB can return negative
983                  * values (namely, -1), we cannot compare the value directly
984                  * against a (32-bit) GLuint.
985                  */
986                 GLuint output_9bits = output & 0x1ff;
987                 GLuint sign_extend  = output_9bits & 0x100 ? 0xfffffe00 : 0;
988                 output              = output_9bits | sign_extend;
989             }
990 
991             if (output != expected)
992             {
993                 return false;
994             }
995         }
996         return true;
997     }
998 };
999 
1000 class ShaderBitfieldOperationCaseUnaryUint1 : public ShaderBitfieldOperationCaseUnaryUint
1001 {
1002 public:
ShaderBitfieldOperationCaseUnaryUint1(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * funcName,UnaryUFunc func,Data const & data)1003     ShaderBitfieldOperationCaseUnaryUint1(Context &context, const char *name, glu::GLSLVersion glslVersion,
1004                                           char const *funcName, UnaryUFunc func, Data const &data)
1005         : ShaderBitfieldOperationCaseUnaryUint(context, name, glslVersion, funcName, func, data, 1,
1006                                                "outUvec4.x = uint(func(inUvec4.x))")
1007     {
1008     }
1009 };
1010 
1011 class ShaderBitfieldOperationCaseUnaryUint2 : public ShaderBitfieldOperationCaseUnaryUint
1012 {
1013 public:
ShaderBitfieldOperationCaseUnaryUint2(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * funcName,UnaryUFunc func,Data const & data)1014     ShaderBitfieldOperationCaseUnaryUint2(Context &context, const char *name, glu::GLSLVersion glslVersion,
1015                                           char const *funcName, UnaryUFunc func, Data const &data)
1016         : ShaderBitfieldOperationCaseUnaryUint(context, name, glslVersion, funcName, func, data, 2,
1017                                                "outUvec4.xy = uvec2(func(inUvec4.xy))")
1018     {
1019     }
1020 };
1021 
1022 class ShaderBitfieldOperationCaseUnaryUint3 : public ShaderBitfieldOperationCaseUnaryUint
1023 {
1024 public:
ShaderBitfieldOperationCaseUnaryUint3(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * funcName,UnaryUFunc func,Data const & data)1025     ShaderBitfieldOperationCaseUnaryUint3(Context &context, const char *name, glu::GLSLVersion glslVersion,
1026                                           char const *funcName, UnaryUFunc func, Data const &data)
1027         : ShaderBitfieldOperationCaseUnaryUint(context, name, glslVersion, funcName, func, data, 3,
1028                                                "outUvec4.xyz = uvec3(func(inUvec4.xyz))")
1029     {
1030     }
1031 };
1032 
1033 class ShaderBitfieldOperationCaseUnaryUint4 : public ShaderBitfieldOperationCaseUnaryUint
1034 {
1035 public:
ShaderBitfieldOperationCaseUnaryUint4(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * funcName,UnaryUFunc func,Data const & data)1036     ShaderBitfieldOperationCaseUnaryUint4(Context &context, const char *name, glu::GLSLVersion glslVersion,
1037                                           char const *funcName, UnaryUFunc func, Data const &data)
1038         : ShaderBitfieldOperationCaseUnaryUint(context, name, glslVersion, funcName, func, data, 4,
1039                                                "outUvec4 = uvec4(func(inUvec4))")
1040     {
1041     }
1042 };
1043 
1044 class ShaderBitfieldOperationCaseUnaryInt : public ShaderBitfieldOperationCase
1045 {
1046 public:
ShaderBitfieldOperationCaseUnaryInt(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * funcName,UnaryIFunc func,Data const & data,int components,char const * testStatement)1047     ShaderBitfieldOperationCaseUnaryInt(Context &context, const char *name, glu::GLSLVersion glslVersion,
1048                                         char const *funcName, UnaryIFunc func, Data const &data, int components,
1049                                         char const *testStatement)
1050         : ShaderBitfieldOperationCase(context, name, "", glslVersion, data, testStatement)
1051         , m_components(components)
1052         , m_func(func)
1053     {
1054         size_t pos = m_testStatement.find("func");
1055         m_testStatement.replace(pos, 4, funcName);
1056     }
1057 
1058 private:
1059     int m_components;
1060     UnaryIFunc m_func;
1061 
test(Data const * data)1062     virtual bool test(Data const *data)
1063     {
1064         for (int i = 0; i < m_components; ++i)
1065         {
1066             GLint expected = m_func(data->inIvec4[i]);
1067             if (data->outIvec4[i] != expected)
1068             {
1069                 return false;
1070             }
1071         }
1072         return true;
1073     }
1074 };
1075 
1076 class ShaderBitfieldOperationCaseUnaryInt1 : public ShaderBitfieldOperationCaseUnaryInt
1077 {
1078 public:
ShaderBitfieldOperationCaseUnaryInt1(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * funcName,UnaryIFunc func,Data const & data)1079     ShaderBitfieldOperationCaseUnaryInt1(Context &context, const char *name, glu::GLSLVersion glslVersion,
1080                                          char const *funcName, UnaryIFunc func, Data const &data)
1081         : ShaderBitfieldOperationCaseUnaryInt(context, name, glslVersion, funcName, func, data, 1,
1082                                               "outIvec4.x = func(inIvec4.x)")
1083     {
1084     }
1085 };
1086 
1087 class ShaderBitfieldOperationCaseUnaryInt2 : public ShaderBitfieldOperationCaseUnaryInt
1088 {
1089 public:
ShaderBitfieldOperationCaseUnaryInt2(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * funcName,UnaryIFunc func,Data const & data)1090     ShaderBitfieldOperationCaseUnaryInt2(Context &context, const char *name, glu::GLSLVersion glslVersion,
1091                                          char const *funcName, UnaryIFunc func, Data const &data)
1092         : ShaderBitfieldOperationCaseUnaryInt(context, name, glslVersion, funcName, func, data, 2,
1093                                               "outIvec4.xy = func(inIvec4.xy)")
1094     {
1095     }
1096 };
1097 
1098 class ShaderBitfieldOperationCaseUnaryInt3 : public ShaderBitfieldOperationCaseUnaryInt
1099 {
1100 public:
ShaderBitfieldOperationCaseUnaryInt3(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * funcName,UnaryIFunc func,Data const & data)1101     ShaderBitfieldOperationCaseUnaryInt3(Context &context, const char *name, glu::GLSLVersion glslVersion,
1102                                          char const *funcName, UnaryIFunc func, Data const &data)
1103         : ShaderBitfieldOperationCaseUnaryInt(context, name, glslVersion, funcName, func, data, 3,
1104                                               "outIvec4.xyz = func(inIvec4.xyz)")
1105     {
1106     }
1107 };
1108 
1109 class ShaderBitfieldOperationCaseUnaryInt4 : public ShaderBitfieldOperationCaseUnaryInt
1110 {
1111 public:
ShaderBitfieldOperationCaseUnaryInt4(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * funcName,UnaryIFunc func,Data const & data)1112     ShaderBitfieldOperationCaseUnaryInt4(Context &context, const char *name, glu::GLSLVersion glslVersion,
1113                                          char const *funcName, UnaryIFunc func, Data const &data)
1114         : ShaderBitfieldOperationCaseUnaryInt(context, name, glslVersion, funcName, func, data, 4,
1115                                               "outIvec4 = func(inIvec4)")
1116     {
1117     }
1118 };
1119 
1120 typedef GLuint (*BinaryUFunc)(GLuint input, GLuint input2, GLuint &output2);
1121 typedef GLint (*BinaryIFunc)(GLint input, GLint input2, GLint &output2);
1122 
uaddCarry(GLuint input,GLuint input2,GLuint & output2)1123 static GLuint uaddCarry(GLuint input, GLuint input2, GLuint &output2)
1124 {
1125     GLuint result = input + input2;
1126     output2       = (input > result) ? 1 : 0;
1127     return result;
1128 }
1129 
usubBorrow(GLuint input,GLuint input2,GLuint & output2)1130 static GLuint usubBorrow(GLuint input, GLuint input2, GLuint &output2)
1131 {
1132     output2 = (input2 > input) ? 1 : 0;
1133     return input - input2;
1134 }
1135 
umulExtended(GLuint input,GLuint input2,GLuint & output2)1136 static GLuint umulExtended(GLuint input, GLuint input2, GLuint &output2)
1137 {
1138     GLuint64 result = static_cast<GLuint64>(input) * static_cast<GLuint64>(input2);
1139     output2         = GLuint(result & 0xFFFFFFFF);
1140     return GLuint(result >> 32);
1141 }
1142 
imulExtended(GLint input,GLint input2,GLint & output2)1143 static GLint imulExtended(GLint input, GLint input2, GLint &output2)
1144 {
1145     GLint64 result = static_cast<GLint64>(input) * static_cast<GLint64>(input2);
1146     output2        = GLint(result & 0xFFFFFFFF);
1147     return GLint(result >> 32);
1148 }
1149 
1150 class ShaderBitfieldOperationCaseBinaryUint : public ShaderBitfieldOperationCase
1151 {
1152 public:
ShaderBitfieldOperationCaseBinaryUint(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * testStatement,BinaryUFunc func,Data const & input,Data const & input2,int components)1153     ShaderBitfieldOperationCaseBinaryUint(Context &context, const char *name, glu::GLSLVersion glslVersion,
1154                                           char const *testStatement, BinaryUFunc func, Data const &input,
1155                                           Data const &input2, int components)
1156         : ShaderBitfieldOperationCase(context, name, "", glslVersion, input, testStatement)
1157         , m_components(components)
1158         , m_func(func)
1159     {
1160         for (int i = 0; i < components; ++i)
1161         {
1162             m_data.in2Uvec4[i] = input2.inUvec4[i];
1163         }
1164     }
1165 
1166 private:
1167     int m_components;
1168     BinaryUFunc m_func;
1169 
test(Data const * data)1170     virtual bool test(Data const *data)
1171     {
1172         for (int i = 0; i < m_components; ++i)
1173         {
1174             GLuint expected2 = 0;
1175             GLuint expected  = m_func(data->inUvec4[i], data->in2Uvec4[i], expected2);
1176             if (data->outUvec4[i] != expected || data->out2Uvec4[i] != expected2)
1177             {
1178                 return false;
1179             }
1180         }
1181         return true;
1182     }
1183 };
1184 
1185 class ShaderBitfieldOperationCaseBinaryUint1 : public ShaderBitfieldOperationCaseBinaryUint
1186 {
1187 public:
ShaderBitfieldOperationCaseBinaryUint1(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * testStatement,BinaryUFunc func,Data const & input,Data const & input2)1188     ShaderBitfieldOperationCaseBinaryUint1(Context &context, const char *name, glu::GLSLVersion glslVersion,
1189                                            char const *testStatement, BinaryUFunc func, Data const &input,
1190                                            Data const &input2)
1191         : ShaderBitfieldOperationCaseBinaryUint(context, name, glslVersion, testStatement, func, input, input2, 1)
1192     {
1193     }
1194 };
1195 
1196 class ShaderBitfieldOperationCaseBinaryUint2 : public ShaderBitfieldOperationCaseBinaryUint
1197 {
1198 public:
ShaderBitfieldOperationCaseBinaryUint2(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * testStatement,BinaryUFunc func,Data const & input,Data const & input2)1199     ShaderBitfieldOperationCaseBinaryUint2(Context &context, const char *name, glu::GLSLVersion glslVersion,
1200                                            char const *testStatement, BinaryUFunc func, Data const &input,
1201                                            Data const &input2)
1202         : ShaderBitfieldOperationCaseBinaryUint(context, name, glslVersion, testStatement, func, input, input2, 2)
1203     {
1204     }
1205 };
1206 
1207 class ShaderBitfieldOperationCaseBinaryUint3 : public ShaderBitfieldOperationCaseBinaryUint
1208 {
1209 public:
ShaderBitfieldOperationCaseBinaryUint3(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * testStatement,BinaryUFunc func,Data const & input,Data const & input2)1210     ShaderBitfieldOperationCaseBinaryUint3(Context &context, const char *name, glu::GLSLVersion glslVersion,
1211                                            char const *testStatement, BinaryUFunc func, Data const &input,
1212                                            Data const &input2)
1213         : ShaderBitfieldOperationCaseBinaryUint(context, name, glslVersion, testStatement, func, input, input2, 3)
1214     {
1215     }
1216 };
1217 
1218 class ShaderBitfieldOperationCaseBinaryUint4 : public ShaderBitfieldOperationCaseBinaryUint
1219 {
1220 public:
ShaderBitfieldOperationCaseBinaryUint4(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * testStatement,BinaryUFunc func,Data const & input,Data const & input2)1221     ShaderBitfieldOperationCaseBinaryUint4(Context &context, const char *name, glu::GLSLVersion glslVersion,
1222                                            char const *testStatement, BinaryUFunc func, Data const &input,
1223                                            Data const &input2)
1224         : ShaderBitfieldOperationCaseBinaryUint(context, name, glslVersion, testStatement, func, input, input2, 4)
1225     {
1226     }
1227 };
1228 
1229 class ShaderBitfieldOperationCaseBinaryInt : public ShaderBitfieldOperationCase
1230 {
1231 public:
ShaderBitfieldOperationCaseBinaryInt(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * testStatement,BinaryIFunc func,Data const & input,Data const & input2,int components)1232     ShaderBitfieldOperationCaseBinaryInt(Context &context, const char *name, glu::GLSLVersion glslVersion,
1233                                          char const *testStatement, BinaryIFunc func, Data const &input,
1234                                          Data const &input2, int components)
1235         : ShaderBitfieldOperationCase(context, name, "", glslVersion, input, testStatement)
1236         , m_components(components)
1237         , m_func(func)
1238     {
1239         for (int i = 0; i < components; ++i)
1240         {
1241             m_data.in2Ivec4[i] = input2.inIvec4[i];
1242         }
1243     }
1244 
1245 private:
1246     int m_components;
1247     BinaryIFunc m_func;
1248 
test(Data const * data)1249     virtual bool test(Data const *data)
1250     {
1251         for (int i = 0; i < m_components; ++i)
1252         {
1253             GLint expected2 = 0;
1254             GLint expected  = m_func(data->inIvec4[i], data->in2Ivec4[i], expected2);
1255             if (data->outIvec4[i] != expected || data->out2Ivec4[i] != expected2)
1256             {
1257                 return false;
1258             }
1259         }
1260         return true;
1261     }
1262 };
1263 
1264 class ShaderBitfieldOperationCaseBinaryInt1 : public ShaderBitfieldOperationCaseBinaryInt
1265 {
1266 public:
ShaderBitfieldOperationCaseBinaryInt1(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * testStatement,BinaryIFunc func,Data const & input,Data const & input2)1267     ShaderBitfieldOperationCaseBinaryInt1(Context &context, const char *name, glu::GLSLVersion glslVersion,
1268                                           char const *testStatement, BinaryIFunc func, Data const &input,
1269                                           Data const &input2)
1270         : ShaderBitfieldOperationCaseBinaryInt(context, name, glslVersion, testStatement, func, input, input2, 1)
1271     {
1272     }
1273 };
1274 
1275 class ShaderBitfieldOperationCaseBinaryInt2 : public ShaderBitfieldOperationCaseBinaryInt
1276 {
1277 public:
ShaderBitfieldOperationCaseBinaryInt2(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * testStatement,BinaryIFunc func,Data const & input,Data const & input2)1278     ShaderBitfieldOperationCaseBinaryInt2(Context &context, const char *name, glu::GLSLVersion glslVersion,
1279                                           char const *testStatement, BinaryIFunc func, Data const &input,
1280                                           Data const &input2)
1281         : ShaderBitfieldOperationCaseBinaryInt(context, name, glslVersion, testStatement, func, input, input2, 2)
1282     {
1283     }
1284 };
1285 
1286 class ShaderBitfieldOperationCaseBinaryInt3 : public ShaderBitfieldOperationCaseBinaryInt
1287 {
1288 public:
ShaderBitfieldOperationCaseBinaryInt3(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * testStatement,BinaryIFunc func,Data const & input,Data const & input2)1289     ShaderBitfieldOperationCaseBinaryInt3(Context &context, const char *name, glu::GLSLVersion glslVersion,
1290                                           char const *testStatement, BinaryIFunc func, Data const &input,
1291                                           Data const &input2)
1292         : ShaderBitfieldOperationCaseBinaryInt(context, name, glslVersion, testStatement, func, input, input2, 3)
1293     {
1294     }
1295 };
1296 
1297 class ShaderBitfieldOperationCaseBinaryInt4 : public ShaderBitfieldOperationCaseBinaryInt
1298 {
1299 public:
ShaderBitfieldOperationCaseBinaryInt4(Context & context,const char * name,glu::GLSLVersion glslVersion,char const * testStatement,BinaryIFunc func,Data const & input,Data const & input2)1300     ShaderBitfieldOperationCaseBinaryInt4(Context &context, const char *name, glu::GLSLVersion glslVersion,
1301                                           char const *testStatement, BinaryIFunc func, Data const &input,
1302                                           Data const &input2)
1303         : ShaderBitfieldOperationCaseBinaryInt(context, name, glslVersion, testStatement, func, input, input2, 4)
1304     {
1305     }
1306 };
1307 
ShaderBitfieldOperationTests(Context & context,glu::GLSLVersion glslVersion)1308 ShaderBitfieldOperationTests::ShaderBitfieldOperationTests(Context &context, glu::GLSLVersion glslVersion)
1309     : TestCaseGroup(context, "shader_bitfield_operation", "Shader Bitfield Operation tests")
1310     , m_glslVersion(glslVersion)
1311 {
1312 }
1313 
~ShaderBitfieldOperationTests(void)1314 ShaderBitfieldOperationTests::~ShaderBitfieldOperationTests(void)
1315 {
1316 }
1317 
init(void)1318 void ShaderBitfieldOperationTests::init(void)
1319 {
1320     de::Random rnd(m_context.getTestContext().getCommandLine().getBaseSeed());
1321 
1322     // shader_bitfield_operation.frexp
1323     tcu::TestCaseGroup *frexpGroup = new tcu::TestCaseGroup(m_testCtx, "frexp", "");
1324     addChild(frexpGroup);
1325     frexpGroup->addChild(new ShaderBitfieldOperationCaseFrexpFloat(m_context, "float_zero", m_glslVersion, Vec4(0.0)));
1326     for (int i = 0; i < ITERATIONS; ++i)
1327     {
1328         std::stringstream ss;
1329         ss << "float_" << i;
1330         frexpGroup->addChild(new ShaderBitfieldOperationCaseFrexpFloat(m_context, ss.str().c_str(), m_glslVersion,
1331                                                                        Vec4(rnd.getFloat())));
1332     }
1333     frexpGroup->addChild(
1334         new ShaderBitfieldOperationCaseFrexpVec2(m_context, "vec2_zero", m_glslVersion, Vec4(0.0, 0.0)));
1335     for (int i = 0; i < ITERATIONS; ++i)
1336     {
1337         std::stringstream ss;
1338         ss << "vec2_" << i;
1339         frexpGroup->addChild(new ShaderBitfieldOperationCaseFrexpVec2(m_context, ss.str().c_str(), m_glslVersion,
1340                                                                       Vec4(rnd.getFloat(), -rnd.getFloat())));
1341     }
1342     frexpGroup->addChild(
1343         new ShaderBitfieldOperationCaseFrexpVec3(m_context, "vec3_zero", m_glslVersion, Vec4(0.0, 0.0, 0.0)));
1344     for (int i = 0; i < ITERATIONS; ++i)
1345     {
1346         std::stringstream ss;
1347         ss << "vec3_" << i;
1348         frexpGroup->addChild(new ShaderBitfieldOperationCaseFrexpVec3(
1349             m_context, ss.str().c_str(), m_glslVersion, Vec4(rnd.getFloat(), -rnd.getFloat(), rnd.getFloat())));
1350     }
1351     frexpGroup->addChild(
1352         new ShaderBitfieldOperationCaseFrexpVec4(m_context, "vec4_zero", m_glslVersion, Vec4(0.0, 0.0, 0.0, 0.0)));
1353     for (int i = 0; i < ITERATIONS; ++i)
1354     {
1355         std::stringstream ss;
1356         ss << "vec4_" << i;
1357         frexpGroup->addChild(new ShaderBitfieldOperationCaseFrexpVec4(
1358             m_context, ss.str().c_str(), m_glslVersion,
1359             Vec4(rnd.getFloat(), -rnd.getFloat(), rnd.getFloat(), -rnd.getFloat())));
1360     }
1361 
1362     // shader_bitfield_operation.ldexp
1363     tcu::TestCaseGroup *ldexpGroup = new tcu::TestCaseGroup(m_testCtx, "ldexp", "");
1364     addChild(ldexpGroup);
1365     ldexpGroup->addChild(
1366         new ShaderBitfieldOperationCaseLdexpFloat(m_context, "float_zero", m_glslVersion, Vec4(0.0), Ivec4(0)));
1367     for (int i = 0; i < ITERATIONS; ++i)
1368     {
1369         std::stringstream ss;
1370         ss << "float_" << i;
1371         ldexpGroup->addChild(new ShaderBitfieldOperationCaseLdexpFloat(m_context, ss.str().c_str(), m_glslVersion,
1372                                                                        Vec4(rnd.getFloat()), Ivec4(rnd.getInt(-8, 8))));
1373     }
1374     ldexpGroup->addChild(
1375         new ShaderBitfieldOperationCaseLdexpVec2(m_context, "vec2_zero", m_glslVersion, Vec4(0.0, 0.0), Ivec4(0, 0)));
1376     for (int i = 0; i < ITERATIONS; ++i)
1377     {
1378         std::stringstream ss;
1379         ss << "vec2_" << i;
1380         ldexpGroup->addChild(new ShaderBitfieldOperationCaseLdexpVec2(m_context, ss.str().c_str(), m_glslVersion,
1381                                                                       Vec4(rnd.getFloat(), -rnd.getFloat()),
1382                                                                       Ivec4(rnd.getInt(-8, 8), rnd.getInt(-8, 8))));
1383     }
1384     ldexpGroup->addChild(new ShaderBitfieldOperationCaseLdexpVec3(m_context, "vec3_zero", m_glslVersion,
1385                                                                   Vec4(0.0, 0.0, 0.0), Ivec4(0, 0, 0)));
1386     for (int i = 0; i < ITERATIONS; ++i)
1387     {
1388         std::stringstream ss;
1389         ss << "vec3_" << i;
1390         ldexpGroup->addChild(new ShaderBitfieldOperationCaseLdexpVec3(
1391             m_context, ss.str().c_str(), m_glslVersion, Vec4(rnd.getFloat(), -rnd.getFloat(), rnd.getFloat()),
1392             Ivec4(rnd.getInt(-8, 8), rnd.getInt(-8, 8), rnd.getInt(-8, 8))));
1393     }
1394     ldexpGroup->addChild(new ShaderBitfieldOperationCaseLdexpVec4(m_context, "vec4_zero", m_glslVersion,
1395                                                                   Vec4(0.0, 0.0, 0.0, 0.0), Ivec4(0, 0, 0, 0)));
1396     for (int i = 0; i < ITERATIONS; ++i)
1397     {
1398         std::stringstream ss;
1399         ss << "vec4_" << i;
1400         ldexpGroup->addChild(new ShaderBitfieldOperationCaseLdexpVec4(
1401             m_context, ss.str().c_str(), m_glslVersion,
1402             Vec4(rnd.getFloat(), -rnd.getFloat(), rnd.getFloat(), -rnd.getFloat()),
1403             Ivec4(rnd.getInt(-8, 8), rnd.getInt(-8, 8), rnd.getInt(-8, 8), rnd.getInt(-8, 8))));
1404     }
1405 
1406     // shader_bitfield_operation.packUnorm4x8
1407     tcu::TestCaseGroup *packUnormGroup = new tcu::TestCaseGroup(m_testCtx, "packUnorm4x8", "");
1408     addChild(packUnormGroup);
1409     for (int i = 0; i < ITERATIONS; ++i)
1410     {
1411         std::stringstream ss;
1412         ss << i;
1413         packUnormGroup->addChild(new ShaderBitfieldOperationCasePackUnorm(
1414             m_context, ss.str().c_str(), m_glslVersion,
1415             Vec4(rnd.getFloat(), rnd.getFloat(), rnd.getFloat(), rnd.getFloat())));
1416     }
1417 
1418     // shader_bitfield_operation.packSnorm4x8
1419     tcu::TestCaseGroup *packSnormGroup = new tcu::TestCaseGroup(m_testCtx, "packSnorm4x8", "");
1420     addChild(packSnormGroup);
1421     for (int i = 0; i < ITERATIONS; ++i)
1422     {
1423         std::stringstream ss;
1424         ss << i;
1425         packSnormGroup->addChild(new ShaderBitfieldOperationCasePackSnorm(
1426             m_context, ss.str().c_str(), m_glslVersion,
1427             Vec4(rnd.getFloat(), -rnd.getFloat(), rnd.getFloat(), -rnd.getFloat())));
1428     }
1429 
1430     // shader_bitfield_operation.unpackUnorm4x8
1431     tcu::TestCaseGroup *unpackUnormGroup = new tcu::TestCaseGroup(m_testCtx, "unpackUnorm4x8", "");
1432     addChild(unpackUnormGroup);
1433     for (int i = 0; i < ITERATIONS; ++i)
1434     {
1435         std::stringstream ss;
1436         ss << i;
1437         unpackUnormGroup->addChild(new ShaderBitfieldOperationCaseUnpackUnorm(m_context, ss.str().c_str(),
1438                                                                               m_glslVersion, Uvec4(rnd.getUint32())));
1439     }
1440 
1441     // shader_bitfield_operation.unpackSnorm4x8
1442     tcu::TestCaseGroup *unpackSnormGroup = new tcu::TestCaseGroup(m_testCtx, "unpackSnorm4x8", "");
1443     addChild(unpackSnormGroup);
1444     for (int i = 0; i < ITERATIONS; ++i)
1445     {
1446         std::stringstream ss;
1447         ss << i;
1448         unpackSnormGroup->addChild(new ShaderBitfieldOperationCaseUnpackSnorm(m_context, ss.str().c_str(),
1449                                                                               m_glslVersion, Uvec4(rnd.getUint32())));
1450     }
1451 
1452     // shader_bitfield_operation.bitfieldExtract
1453     tcu::TestCaseGroup *bitfieldExtractGroup = new tcu::TestCaseGroup(m_testCtx, "bitfieldExtract", "");
1454     addChild(bitfieldExtractGroup);
1455     for (int i = 0; i < ITERATIONS; ++i)
1456     {
1457         std::stringstream ss;
1458         ss << "uint_" << i;
1459         bitfieldExtractGroup->addChild(new ShaderBitfieldOperationCaseBitfieldExtractUint1(
1460             m_context, ss.str().c_str(), m_glslVersion, Uvec4(rnd.getUint32()), rnd.getInt(0, 31), rnd.getInt(1, 32)));
1461     }
1462     for (int i = 0; i < ITERATIONS; ++i)
1463     {
1464         std::stringstream ss;
1465         ss << "uvec2_" << i;
1466         bitfieldExtractGroup->addChild(new ShaderBitfieldOperationCaseBitfieldExtractUint2(
1467             m_context, ss.str().c_str(), m_glslVersion, Uvec4(rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31),
1468             rnd.getInt(1, 32)));
1469     }
1470     for (int i = 0; i < ITERATIONS; ++i)
1471     {
1472         std::stringstream ss;
1473         ss << "uvec3_" << i;
1474         bitfieldExtractGroup->addChild(new ShaderBitfieldOperationCaseBitfieldExtractUint3(
1475             m_context, ss.str().c_str(), m_glslVersion, Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()),
1476             rnd.getInt(0, 31), rnd.getInt(1, 32)));
1477     }
1478     for (int i = 0; i < ITERATIONS; ++i)
1479     {
1480         std::stringstream ss;
1481         ss << "uvec4_" << i;
1482         bitfieldExtractGroup->addChild(new ShaderBitfieldOperationCaseBitfieldExtractUint4(
1483             m_context, ss.str().c_str(), m_glslVersion,
1484             Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31),
1485             rnd.getInt(1, 32)));
1486     }
1487 
1488     for (int i = 0; i < ITERATIONS; ++i)
1489     {
1490         std::stringstream ss;
1491         ss << "int_" << i;
1492         bitfieldExtractGroup->addChild(new ShaderBitfieldOperationCaseBitfieldExtractInt1(
1493             m_context, ss.str().c_str(), m_glslVersion, Ivec4(rnd.getUint32()), rnd.getInt(0, 31), rnd.getInt(1, 32)));
1494     }
1495     for (int i = 0; i < ITERATIONS; ++i)
1496     {
1497         std::stringstream ss;
1498         ss << "ivec2_" << i;
1499         bitfieldExtractGroup->addChild(new ShaderBitfieldOperationCaseBitfieldExtractInt2(
1500             m_context, ss.str().c_str(), m_glslVersion, Ivec4(rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31),
1501             rnd.getInt(1, 32)));
1502     }
1503     for (int i = 0; i < ITERATIONS; ++i)
1504     {
1505         std::stringstream ss;
1506         ss << "ivec3_" << i;
1507         bitfieldExtractGroup->addChild(new ShaderBitfieldOperationCaseBitfieldExtractInt3(
1508             m_context, ss.str().c_str(), m_glslVersion, Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()),
1509             rnd.getInt(0, 31), rnd.getInt(1, 32)));
1510     }
1511     for (int i = 0; i < ITERATIONS; ++i)
1512     {
1513         std::stringstream ss;
1514         ss << "ivec4_" << i;
1515         bitfieldExtractGroup->addChild(new ShaderBitfieldOperationCaseBitfieldExtractInt4(
1516             m_context, ss.str().c_str(), m_glslVersion,
1517             Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31),
1518             rnd.getInt(1, 32)));
1519     }
1520 
1521     // shader_bitfield_operation.bitfieldInsert
1522     tcu::TestCaseGroup *bitfieldInsertGroup = new tcu::TestCaseGroup(m_testCtx, "bitfieldInsert", "");
1523     addChild(bitfieldInsertGroup);
1524     for (int i = 0; i < ITERATIONS; ++i)
1525     {
1526         std::stringstream ss;
1527         ss << "uint_" << i;
1528         bitfieldInsertGroup->addChild(new ShaderBitfieldOperationCaseBitfieldInsertUint1(
1529             m_context, ss.str().c_str(), m_glslVersion, Uvec4(rnd.getUint32()), Uvec4(rnd.getUint32()),
1530             rnd.getInt(0, 31), rnd.getInt(1, 32)));
1531     }
1532     for (int i = 0; i < ITERATIONS; ++i)
1533     {
1534         std::stringstream ss;
1535         ss << "uvec2_" << i;
1536         bitfieldInsertGroup->addChild(new ShaderBitfieldOperationCaseBitfieldInsertUint2(
1537             m_context, ss.str().c_str(), m_glslVersion, Uvec4(rnd.getUint32(), rnd.getUint32()),
1538             Uvec4(rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31), rnd.getInt(1, 32)));
1539     }
1540     for (int i = 0; i < ITERATIONS; ++i)
1541     {
1542         std::stringstream ss;
1543         ss << "uvec3_" << i;
1544         bitfieldInsertGroup->addChild(new ShaderBitfieldOperationCaseBitfieldInsertUint3(
1545             m_context, ss.str().c_str(), m_glslVersion, Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()),
1546             Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31), rnd.getInt(1, 32)));
1547     }
1548     for (int i = 0; i < ITERATIONS; ++i)
1549     {
1550         std::stringstream ss;
1551         ss << "uvec4_" << i;
1552         bitfieldInsertGroup->addChild(new ShaderBitfieldOperationCaseBitfieldInsertUint4(
1553             m_context, ss.str().c_str(), m_glslVersion,
1554             Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()),
1555             Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31),
1556             rnd.getInt(1, 32)));
1557     }
1558 
1559     for (int i = 0; i < ITERATIONS; ++i)
1560     {
1561         std::stringstream ss;
1562         ss << "int_" << i;
1563         bitfieldInsertGroup->addChild(new ShaderBitfieldOperationCaseBitfieldInsertInt1(
1564             m_context, ss.str().c_str(), m_glslVersion, Ivec4(rnd.getUint32()), Ivec4(rnd.getUint32()),
1565             rnd.getInt(0, 31), rnd.getInt(1, 32)));
1566     }
1567     for (int i = 0; i < ITERATIONS; ++i)
1568     {
1569         std::stringstream ss;
1570         ss << "ivec2_" << i;
1571         bitfieldInsertGroup->addChild(new ShaderBitfieldOperationCaseBitfieldInsertInt2(
1572             m_context, ss.str().c_str(), m_glslVersion, Ivec4(rnd.getUint32(), rnd.getUint32()),
1573             Ivec4(rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31), rnd.getInt(1, 32)));
1574     }
1575     for (int i = 0; i < ITERATIONS; ++i)
1576     {
1577         std::stringstream ss;
1578         ss << "ivec3_" << i;
1579         bitfieldInsertGroup->addChild(new ShaderBitfieldOperationCaseBitfieldInsertInt3(
1580             m_context, ss.str().c_str(), m_glslVersion, Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()),
1581             Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31), rnd.getInt(1, 32)));
1582     }
1583     for (int i = 0; i < ITERATIONS; ++i)
1584     {
1585         std::stringstream ss;
1586         ss << "ivec4_" << i;
1587         bitfieldInsertGroup->addChild(new ShaderBitfieldOperationCaseBitfieldInsertInt4(
1588             m_context, ss.str().c_str(), m_glslVersion,
1589             Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()),
1590             Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()), rnd.getInt(0, 31),
1591             rnd.getInt(1, 32)));
1592     }
1593 
1594     struct UnaryTest
1595     {
1596         char const *funcName;
1597         UnaryUFunc funcU;
1598         UnaryIFunc funcI;
1599     } commonTests[] = {
1600         {"bitfieldReverse", bitfieldReverse,
1601          reinterpret_cast<UnaryIFunc>(bitfieldReverse)},                // shader_bitfield_operation.bitfieldReverse
1602         {"bitCount", bitCount, reinterpret_cast<UnaryIFunc>(bitCount)}, // shader_bitfield_operation.bitCount
1603         {"findLSB", findLSB, reinterpret_cast<UnaryIFunc>(findLSB)},    // shader_bitfield_operation.findLSB
1604         {"findMSB", findMSBU, findMSBI},                                // shader_bitfield_operation.findMSB
1605     };
1606     for (int test = 0; test < DE_LENGTH_OF_ARRAY(commonTests); ++test)
1607     {
1608         tcu::TestCaseGroup *commonGroup = new tcu::TestCaseGroup(m_testCtx, commonTests[test].funcName, "");
1609         addChild(commonGroup);
1610         commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryUint1(
1611             m_context, "uint_zero", m_glslVersion, commonTests[test].funcName, commonTests[test].funcU, Uvec4(0)));
1612         for (int i = 0; i < ITERATIONS; ++i)
1613         {
1614             std::stringstream ss;
1615             ss << "uint_" << i;
1616             commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryUint1(
1617                 m_context, ss.str().c_str(), m_glslVersion, commonTests[test].funcName, commonTests[test].funcU,
1618                 Uvec4(rnd.getUint32())));
1619         }
1620         for (int i = 0; i < ITERATIONS; ++i)
1621         {
1622             std::stringstream ss;
1623             ss << "uvec2_" << i;
1624             commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryUint2(
1625                 m_context, ss.str().c_str(), m_glslVersion, commonTests[test].funcName, commonTests[test].funcU,
1626                 Uvec4(rnd.getUint32(), rnd.getUint32())));
1627         }
1628         for (int i = 0; i < ITERATIONS; ++i)
1629         {
1630             std::stringstream ss;
1631             ss << "uvec3_" << i;
1632             commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryUint3(
1633                 m_context, ss.str().c_str(), m_glslVersion, commonTests[test].funcName, commonTests[test].funcU,
1634                 Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32())));
1635         }
1636         for (int i = 0; i < ITERATIONS; ++i)
1637         {
1638             std::stringstream ss;
1639             ss << "uvec4_" << i;
1640             commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryUint4(
1641                 m_context, ss.str().c_str(), m_glslVersion, commonTests[test].funcName, commonTests[test].funcU,
1642                 Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32())));
1643         }
1644 
1645         commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryInt1(
1646             m_context, "int_zero", m_glslVersion, commonTests[test].funcName, commonTests[test].funcI, Ivec4(0)));
1647         commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryInt1(
1648             m_context, "int_minus_one", m_glslVersion, commonTests[test].funcName, commonTests[test].funcI, Ivec4(-1)));
1649         for (int i = 0; i < ITERATIONS; ++i)
1650         {
1651             std::stringstream ss;
1652             ss << "int_" << i;
1653             commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryInt1(
1654                 m_context, ss.str().c_str(), m_glslVersion, commonTests[test].funcName, commonTests[test].funcI,
1655                 Ivec4(rnd.getUint32())));
1656         }
1657         for (int i = 0; i < ITERATIONS; ++i)
1658         {
1659             std::stringstream ss;
1660             ss << "ivec2_" << i;
1661             commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryInt2(
1662                 m_context, ss.str().c_str(), m_glslVersion, commonTests[test].funcName, commonTests[test].funcI,
1663                 Ivec4(rnd.getUint32(), rnd.getUint32())));
1664         }
1665         for (int i = 0; i < ITERATIONS; ++i)
1666         {
1667             std::stringstream ss;
1668             ss << "ivec3_" << i;
1669             commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryInt3(
1670                 m_context, ss.str().c_str(), m_glslVersion, commonTests[test].funcName, commonTests[test].funcI,
1671                 Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32())));
1672         }
1673         for (int i = 0; i < ITERATIONS; ++i)
1674         {
1675             std::stringstream ss;
1676             ss << "ivec4_" << i;
1677             commonGroup->addChild(new ShaderBitfieldOperationCaseUnaryInt4(
1678                 m_context, ss.str().c_str(), m_glslVersion, commonTests[test].funcName, commonTests[test].funcI,
1679                 Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32())));
1680         }
1681     }
1682 
1683     // shader_bitfield_operation.uaddCarry
1684     tcu::TestCaseGroup *uaddCarryGroup = new tcu::TestCaseGroup(m_testCtx, "uaddCarry", "");
1685     addChild(uaddCarryGroup);
1686     for (int i = 0; i < ITERATIONS; ++i)
1687     {
1688         std::stringstream ss;
1689         ss << "uint_" << i;
1690         uaddCarryGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint1(
1691             m_context, ss.str().c_str(), m_glslVersion, "outUvec4.x = uaddCarry(inUvec4.x, in2Uvec4.x, out2Uvec4.x);",
1692             uaddCarry, Uvec4(rnd.getUint32()), Uvec4(rnd.getUint32())));
1693     }
1694     for (int i = 0; i < ITERATIONS; ++i)
1695     {
1696         std::stringstream ss;
1697         ss << "uvec2_" << i;
1698         uaddCarryGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint2(
1699             m_context, ss.str().c_str(), m_glslVersion,
1700             "outUvec4.xy = uaddCarry(inUvec4.xy, in2Uvec4.xy, out2Uvec4.xy);", uaddCarry,
1701             Uvec4(rnd.getUint32(), rnd.getUint32()), Uvec4(rnd.getUint32(), rnd.getUint32())));
1702     }
1703     for (int i = 0; i < ITERATIONS; ++i)
1704     {
1705         std::stringstream ss;
1706         ss << "uvec3_" << i;
1707         uaddCarryGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint3(
1708             m_context, ss.str().c_str(), m_glslVersion,
1709             "outUvec4.xyz = uaddCarry(inUvec4.xyz, in2Uvec4.xyz, out2Uvec4.xyz);", uaddCarry,
1710             Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()),
1711             Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32())));
1712     }
1713     for (int i = 0; i < ITERATIONS; ++i)
1714     {
1715         std::stringstream ss;
1716         ss << "uvec4_" << i;
1717         uaddCarryGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint4(
1718             m_context, ss.str().c_str(), m_glslVersion, "outUvec4 = uaddCarry(inUvec4, in2Uvec4, out2Uvec4);",
1719             uaddCarry, Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()),
1720             Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32())));
1721     }
1722 
1723     // shader_bitfield_operation.usubBorrow
1724     tcu::TestCaseGroup *usubBorrowGroup = new tcu::TestCaseGroup(m_testCtx, "usubBorrow", "");
1725     addChild(usubBorrowGroup);
1726     for (int i = 0; i < ITERATIONS; ++i)
1727     {
1728         std::stringstream ss;
1729         ss << "uint_" << i;
1730         usubBorrowGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint1(
1731             m_context, ss.str().c_str(), m_glslVersion, "outUvec4.x = usubBorrow(inUvec4.x, in2Uvec4.x, out2Uvec4.x);",
1732             usubBorrow, Uvec4(rnd.getUint32()), Uvec4(rnd.getUint32())));
1733     }
1734     for (int i = 0; i < ITERATIONS; ++i)
1735     {
1736         std::stringstream ss;
1737         ss << "uvec2_" << i;
1738         usubBorrowGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint2(
1739             m_context, ss.str().c_str(), m_glslVersion,
1740             "outUvec4.xy = usubBorrow(inUvec4.xy, in2Uvec4.xy, out2Uvec4.xy);", usubBorrow,
1741             Uvec4(rnd.getUint32(), rnd.getUint32()), Uvec4(rnd.getUint32(), rnd.getUint32())));
1742     }
1743     for (int i = 0; i < ITERATIONS; ++i)
1744     {
1745         std::stringstream ss;
1746         ss << "uvec3_" << i;
1747         usubBorrowGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint3(
1748             m_context, ss.str().c_str(), m_glslVersion,
1749             "outUvec4.xyz = usubBorrow(inUvec4.xyz, in2Uvec4.xyz, out2Uvec4.xyz);", usubBorrow,
1750             Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()),
1751             Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32())));
1752     }
1753     for (int i = 0; i < ITERATIONS; ++i)
1754     {
1755         std::stringstream ss;
1756         ss << "uvec4_" << i;
1757         usubBorrowGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint4(
1758             m_context, ss.str().c_str(), m_glslVersion, "outUvec4 = usubBorrow(inUvec4, in2Uvec4, out2Uvec4);",
1759             usubBorrow, Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()),
1760             Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32())));
1761     }
1762 
1763     // shader_bitfield_operation.umulExtended
1764     tcu::TestCaseGroup *umulExtendedGroup = new tcu::TestCaseGroup(m_testCtx, "umulExtended", "");
1765     addChild(umulExtendedGroup);
1766     for (int i = 0; i < ITERATIONS; ++i)
1767     {
1768         std::stringstream ss;
1769         ss << "uint_" << i;
1770         umulExtendedGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint1(
1771             m_context, ss.str().c_str(), m_glslVersion, "umulExtended(inUvec4.x, in2Uvec4.x, outUvec4.x, out2Uvec4.x);",
1772             umulExtended, Uvec4(rnd.getUint32()), Uvec4(rnd.getUint32())));
1773     }
1774     for (int i = 0; i < ITERATIONS; ++i)
1775     {
1776         std::stringstream ss;
1777         ss << "uvec2_" << i;
1778         umulExtendedGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint2(
1779             m_context, ss.str().c_str(), m_glslVersion,
1780             "umulExtended(inUvec4.xy, in2Uvec4.xy, outUvec4.xy, out2Uvec4.xy);", umulExtended,
1781             Uvec4(rnd.getUint32(), rnd.getUint32()), Uvec4(rnd.getUint32(), rnd.getUint32())));
1782     }
1783     for (int i = 0; i < ITERATIONS; ++i)
1784     {
1785         std::stringstream ss;
1786         ss << "uvec3_" << i;
1787         umulExtendedGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint3(
1788             m_context, ss.str().c_str(), m_glslVersion,
1789             "umulExtended(inUvec4.xyz, in2Uvec4.xyz, outUvec4.xyz, out2Uvec4.xyz);", umulExtended,
1790             Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()),
1791             Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32())));
1792     }
1793     for (int i = 0; i < ITERATIONS; ++i)
1794     {
1795         std::stringstream ss;
1796         ss << "uvec4_" << i;
1797         umulExtendedGroup->addChild(new ShaderBitfieldOperationCaseBinaryUint4(
1798             m_context, ss.str().c_str(), m_glslVersion, "umulExtended(inUvec4, in2Uvec4, outUvec4, out2Uvec4);",
1799             umulExtended, Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()),
1800             Uvec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32())));
1801     }
1802 
1803     // shader_bitfield_operation.imulExtended
1804     tcu::TestCaseGroup *imulExtendedGroup = new tcu::TestCaseGroup(m_testCtx, "imulExtended", "");
1805     addChild(imulExtendedGroup);
1806     for (int i = 0; i < ITERATIONS; ++i)
1807     {
1808         std::stringstream ss;
1809         ss << "int_" << i;
1810         imulExtendedGroup->addChild(new ShaderBitfieldOperationCaseBinaryInt1(
1811             m_context, ss.str().c_str(), m_glslVersion, "imulExtended(inIvec4.x, in2Ivec4.x, outIvec4.x, out2Ivec4.x);",
1812             imulExtended, Ivec4(rnd.getUint32()), Ivec4(rnd.getUint32())));
1813     }
1814     for (int i = 0; i < ITERATIONS; ++i)
1815     {
1816         std::stringstream ss;
1817         ss << "ivec2_" << i;
1818         imulExtendedGroup->addChild(new ShaderBitfieldOperationCaseBinaryInt2(
1819             m_context, ss.str().c_str(), m_glslVersion,
1820             "imulExtended(inIvec4.xy, in2Ivec4.xy, outIvec4.xy, out2Ivec4.xy);", imulExtended,
1821             Ivec4(rnd.getUint32(), rnd.getUint32()), Ivec4(rnd.getUint32(), rnd.getUint32())));
1822     }
1823     for (int i = 0; i < ITERATIONS; ++i)
1824     {
1825         std::stringstream ss;
1826         ss << "ivec3_" << i;
1827         imulExtendedGroup->addChild(new ShaderBitfieldOperationCaseBinaryInt3(
1828             m_context, ss.str().c_str(), m_glslVersion,
1829             "imulExtended(inIvec4.xyz, in2Ivec4.xyz, outIvec4.xyz, out2Ivec4.xyz);", imulExtended,
1830             Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32()),
1831             Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32())));
1832     }
1833     for (int i = 0; i < ITERATIONS; ++i)
1834     {
1835         std::stringstream ss;
1836         ss << "ivec4_" << i;
1837         imulExtendedGroup->addChild(new ShaderBitfieldOperationCaseBinaryInt4(
1838             m_context, ss.str().c_str(), m_glslVersion, "imulExtended(inIvec4, in2Ivec4, outIvec4, out2Ivec4);",
1839             imulExtended, Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32()),
1840             Ivec4(rnd.getUint32(), rnd.getUint32(), rnd.getUint32(), rnd.getUint32())));
1841     }
1842 }
1843 
1844 } // namespace glcts
1845