1/*------------------------------------------------------------------------- 2 * drawElements Quality Program OpenGL ES 3.1 Module 3 * ------------------------------------------------- 4 * 5 * Copyright 2014 The Android Open Source Project 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 Integer built-in function tests. 22 *//*--------------------------------------------------------------------*/ 23 24#include "es31fShaderIntegerFunctionTests.hpp" 25#include "glsShaderExecUtil.hpp" 26#include "tcuTestLog.hpp" 27#include "tcuFormatUtil.hpp" 28#include "tcuFloat.hpp" 29#include "deRandom.hpp" 30#include "deMath.h" 31#include "deString.h" 32#include "deInt32.h" 33 34namespace deqp 35{ 36namespace gles31 37{ 38namespace Functional 39{ 40 41using std::vector; 42using std::string; 43using tcu::TestLog; 44using namespace gls::ShaderExecUtil; 45 46using tcu::IVec2; 47using tcu::IVec3; 48using tcu::IVec4; 49using tcu::UVec2; 50using tcu::UVec3; 51using tcu::UVec4; 52 53// Utilities 54 55namespace 56{ 57 58struct HexFloat 59{ 60 const float value; 61 HexFloat (const float value_) : value(value_) {} 62}; 63 64std::ostream& operator<< (std::ostream& str, const HexFloat& v) 65{ 66 return str << v.value << " / " << tcu::toHex(tcu::Float32(v.value).bits()); 67} 68 69struct VarValue 70{ 71 const glu::VarType& type; 72 const void* value; 73 74 VarValue (const glu::VarType& type_, const void* value_) : type(type_), value(value_) {} 75}; 76 77std::ostream& operator<< (std::ostream& str, const VarValue& varValue) 78{ 79 DE_ASSERT(varValue.type.isBasicType()); 80 81 const glu::DataType basicType = varValue.type.getBasicType(); 82 const glu::DataType scalarType = glu::getDataTypeScalarType(basicType); 83 const int numComponents = glu::getDataTypeScalarSize(basicType); 84 85 if (numComponents > 1) 86 str << glu::getDataTypeName(basicType) << "("; 87 88 for (int compNdx = 0; compNdx < numComponents; compNdx++) 89 { 90 if (compNdx != 0) 91 str << ", "; 92 93 switch (scalarType) 94 { 95 case glu::TYPE_FLOAT: str << HexFloat(((const float*)varValue.value)[compNdx]); break; 96 case glu::TYPE_INT: str << ((const deInt32*)varValue.value)[compNdx]; break; 97 case glu::TYPE_UINT: str << tcu::toHex(((const deUint32*)varValue.value)[compNdx]); break; 98 case glu::TYPE_BOOL: str << (((const deUint32*)varValue.value)[compNdx] != 0 ? "true" : "false"); break; 99 100 default: 101 DE_ASSERT(false); 102 } 103 } 104 105 if (numComponents > 1) 106 str << ")"; 107 108 return str; 109} 110 111inline int getShaderUintBitCount (glu::ShaderType shaderType, glu::Precision precision) 112{ 113 // \todo [2013-10-31 pyry] Query from GL for vertex and fragment shaders. 114 DE_UNREF(shaderType); 115 const int bitCounts[] = { 9, 16, 32 }; 116 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(bitCounts) == glu::PRECISION_LAST); 117 return bitCounts[precision]; 118} 119 120static inline deUint32 extendSignTo32 (deUint32 integer, deUint32 integerLength) 121{ 122 DE_ASSERT(integerLength > 0 && integerLength <= 32); 123 124 return deUint32(0 - deInt32((integer & (1 << (integerLength - 1))) << 1)) | integer; 125} 126 127static inline deUint32 getLowBitMask (int integerLength) 128{ 129 DE_ASSERT(integerLength >= 0 && integerLength <= 32); 130 131 // \note: shifting more or equal to 32 => undefined behavior. Avoid it by shifting in two parts (1 << (num-1) << 1) 132 if (integerLength == 0u) 133 return 0u; 134 return ((1u << ((deUint32)integerLength - 1u)) << 1u) - 1u; 135} 136 137static void generateRandomInputData (de::Random& rnd, glu::ShaderType shaderType, glu::DataType dataType, glu::Precision precision, deUint32* dst, int numValues) 138{ 139 const int scalarSize = glu::getDataTypeScalarSize(dataType); 140 const deUint32 integerLength = (deUint32)getShaderUintBitCount(shaderType, precision); 141 const deUint32 integerMask = getLowBitMask(integerLength); 142 const bool isUnsigned = glu::isDataTypeUintOrUVec(dataType); 143 144 if (isUnsigned) 145 { 146 for (int valueNdx = 0; valueNdx < numValues; ++valueNdx) 147 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 148 dst[valueNdx*scalarSize + compNdx] = rnd.getUint32() & integerMask; 149 } 150 else 151 { 152 for (int valueNdx = 0; valueNdx < numValues; ++valueNdx) 153 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 154 dst[valueNdx*scalarSize + compNdx] = extendSignTo32(rnd.getUint32() & integerMask, integerLength); 155 } 156} 157 158} // anonymous 159 160// IntegerFunctionCase 161 162class IntegerFunctionCase : public TestCase 163{ 164public: 165 IntegerFunctionCase (Context& context, const char* name, const char* description, glu::ShaderType shaderType); 166 ~IntegerFunctionCase (void); 167 168 void init (void); 169 void deinit (void); 170 IterateResult iterate (void); 171 172protected: 173 IntegerFunctionCase (const IntegerFunctionCase& other); 174 IntegerFunctionCase& operator= (const IntegerFunctionCase& other); 175 176 virtual void getInputValues (int numValues, void* const* values) const = 0; 177 virtual bool compare (const void* const* inputs, const void* const* outputs) = 0; 178 179 glu::ShaderType m_shaderType; 180 ShaderSpec m_spec; 181 int m_numValues; 182 183 std::ostringstream m_failMsg; //!< Comparison failure help message. 184 185private: 186 ShaderExecutor* m_executor; 187}; 188 189IntegerFunctionCase::IntegerFunctionCase (Context& context, const char* name, const char* description, glu::ShaderType shaderType) 190 : TestCase (context, name, description) 191 , m_shaderType (shaderType) 192 , m_numValues (100) 193 , m_executor (DE_NULL) 194{ 195 m_spec.version = glu::getContextTypeGLSLVersion(context.getRenderContext().getType()); 196} 197 198IntegerFunctionCase::~IntegerFunctionCase (void) 199{ 200 IntegerFunctionCase::deinit(); 201} 202 203void IntegerFunctionCase::init (void) 204{ 205 DE_ASSERT(!m_executor); 206 207 m_executor = createExecutor(m_context.getRenderContext(), m_shaderType, m_spec); 208 m_testCtx.getLog() << m_executor; 209 210 if (!m_executor->isOk()) 211 throw tcu::TestError("Compile failed"); 212} 213 214void IntegerFunctionCase::deinit (void) 215{ 216 delete m_executor; 217 m_executor = DE_NULL; 218} 219 220static vector<int> getScalarSizes (const vector<Symbol>& symbols) 221{ 222 vector<int> sizes(symbols.size()); 223 for (int ndx = 0; ndx < (int)symbols.size(); ++ndx) 224 sizes[ndx] = symbols[ndx].varType.getScalarSize(); 225 return sizes; 226} 227 228static int computeTotalScalarSize (const vector<Symbol>& symbols) 229{ 230 int totalSize = 0; 231 for (vector<Symbol>::const_iterator sym = symbols.begin(); sym != symbols.end(); ++sym) 232 totalSize += sym->varType.getScalarSize(); 233 return totalSize; 234} 235 236static vector<void*> getInputOutputPointers (const vector<Symbol>& symbols, vector<deUint32>& data, const int numValues) 237{ 238 vector<void*> pointers (symbols.size()); 239 int curScalarOffset = 0; 240 241 for (int varNdx = 0; varNdx < (int)symbols.size(); ++varNdx) 242 { 243 const Symbol& var = symbols[varNdx]; 244 const int scalarSize = var.varType.getScalarSize(); 245 246 // Uses planar layout as input/output specs do not support strides. 247 pointers[varNdx] = &data[curScalarOffset]; 248 curScalarOffset += scalarSize*numValues; 249 } 250 251 DE_ASSERT(curScalarOffset == (int)data.size()); 252 253 return pointers; 254} 255 256IntegerFunctionCase::IterateResult IntegerFunctionCase::iterate (void) 257{ 258 const int numInputScalars = computeTotalScalarSize(m_spec.inputs); 259 const int numOutputScalars = computeTotalScalarSize(m_spec.outputs); 260 vector<deUint32> inputData (numInputScalars * m_numValues); 261 vector<deUint32> outputData (numOutputScalars * m_numValues); 262 const vector<void*> inputPointers = getInputOutputPointers(m_spec.inputs, inputData, m_numValues); 263 const vector<void*> outputPointers = getInputOutputPointers(m_spec.outputs, outputData, m_numValues); 264 265 // Initialize input data. 266 getInputValues(m_numValues, &inputPointers[0]); 267 268 // Execute shader. 269 m_executor->useProgram(); 270 m_executor->execute(m_numValues, &inputPointers[0], &outputPointers[0]); 271 272 // Compare results. 273 { 274 const vector<int> inScalarSizes = getScalarSizes(m_spec.inputs); 275 const vector<int> outScalarSizes = getScalarSizes(m_spec.outputs); 276 vector<void*> curInputPtr (inputPointers.size()); 277 vector<void*> curOutputPtr (outputPointers.size()); 278 int numFailed = 0; 279 280 for (int valNdx = 0; valNdx < m_numValues; valNdx++) 281 { 282 // Set up pointers for comparison. 283 for (int inNdx = 0; inNdx < (int)curInputPtr.size(); ++inNdx) 284 curInputPtr[inNdx] = (deUint32*)inputPointers[inNdx] + inScalarSizes[inNdx]*valNdx; 285 286 for (int outNdx = 0; outNdx < (int)curOutputPtr.size(); ++outNdx) 287 curOutputPtr[outNdx] = (deUint32*)outputPointers[outNdx] + outScalarSizes[outNdx]*valNdx; 288 289 if (!compare(&curInputPtr[0], &curOutputPtr[0])) 290 { 291 // \todo [2013-08-08 pyry] We probably want to log reference value as well? 292 293 m_testCtx.getLog() << TestLog::Message << "ERROR: comparison failed for value " << valNdx << ":\n " << m_failMsg.str() << TestLog::EndMessage; 294 295 m_testCtx.getLog() << TestLog::Message << " inputs:" << TestLog::EndMessage; 296 for (int inNdx = 0; inNdx < (int)curInputPtr.size(); inNdx++) 297 m_testCtx.getLog() << TestLog::Message << " " << m_spec.inputs[inNdx].name << " = " 298 << VarValue(m_spec.inputs[inNdx].varType, curInputPtr[inNdx]) 299 << TestLog::EndMessage; 300 301 m_testCtx.getLog() << TestLog::Message << " outputs:" << TestLog::EndMessage; 302 for (int outNdx = 0; outNdx < (int)curOutputPtr.size(); outNdx++) 303 m_testCtx.getLog() << TestLog::Message << " " << m_spec.outputs[outNdx].name << " = " 304 << VarValue(m_spec.outputs[outNdx].varType, curOutputPtr[outNdx]) 305 << TestLog::EndMessage; 306 307 m_failMsg.str(""); 308 m_failMsg.clear(); 309 numFailed += 1; 310 } 311 } 312 313 m_testCtx.getLog() << TestLog::Message << (m_numValues - numFailed) << " / " << m_numValues << " values passed" << TestLog::EndMessage; 314 315 m_testCtx.setTestResult(numFailed == 0 ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, 316 numFailed == 0 ? "Pass" : "Result comparison failed"); 317 } 318 319 return STOP; 320} 321 322static const char* getPrecisionPostfix (glu::Precision precision) 323{ 324 static const char* s_postfix[] = 325 { 326 "_lowp", 327 "_mediump", 328 "_highp" 329 }; 330 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_postfix) == glu::PRECISION_LAST); 331 DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(s_postfix))); 332 return s_postfix[precision]; 333} 334 335static const char* getShaderTypePostfix (glu::ShaderType shaderType) 336{ 337 static const char* s_postfix[] = 338 { 339 "_vertex", 340 "_fragment", 341 "_geometry", 342 "_tess_control", 343 "_tess_eval", 344 "_compute" 345 }; 346 DE_ASSERT(de::inBounds<int>(shaderType, 0, DE_LENGTH_OF_ARRAY(s_postfix))); 347 return s_postfix[shaderType]; 348} 349 350static std::string getIntegerFuncCaseName (glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType) 351{ 352 return string(glu::getDataTypeName(baseType)) + getPrecisionPostfix(precision) + getShaderTypePostfix(shaderType); 353} 354 355class UaddCarryCase : public IntegerFunctionCase 356{ 357public: 358 UaddCarryCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType) 359 : IntegerFunctionCase(context, getIntegerFuncCaseName(baseType, precision, shaderType).c_str(), "uaddCarry", shaderType) 360 { 361 m_spec.inputs.push_back(Symbol("x", glu::VarType(baseType, precision))); 362 m_spec.inputs.push_back(Symbol("y", glu::VarType(baseType, precision))); 363 m_spec.outputs.push_back(Symbol("sum", glu::VarType(baseType, precision))); 364 m_spec.outputs.push_back(Symbol("carry", glu::VarType(baseType, glu::PRECISION_LOWP))); 365 m_spec.source = "sum = uaddCarry(x, y, carry);"; 366 } 367 368 void getInputValues (int numValues, void* const* values) const 369 { 370 de::Random rnd (deStringHash(getName()) ^ 0x235facu); 371 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 372 const glu::Precision precision = m_spec.inputs[0].varType.getPrecision(); 373 const int scalarSize = glu::getDataTypeScalarSize(type); 374 const int integerLength = getShaderUintBitCount(m_shaderType, precision); 375 const deUint32 integerMask = getLowBitMask(integerLength); 376 const bool isSigned = glu::isDataTypeIntOrIVec(type); 377 deUint32* in0 = (deUint32*)values[0]; 378 deUint32* in1 = (deUint32*)values[1]; 379 380 const struct 381 { 382 deUint32 x; 383 deUint32 y; 384 } easyCases[] = 385 { 386 { 0x00000000u, 0x00000000u }, 387 { 0xfffffffeu, 0x00000001u }, 388 { 0x00000001u, 0xfffffffeu }, 389 { 0xffffffffu, 0x00000001u }, 390 { 0x00000001u, 0xffffffffu }, 391 { 0xfffffffeu, 0x00000002u }, 392 { 0x00000002u, 0xfffffffeu }, 393 { 0xffffffffu, 0xffffffffu } 394 }; 395 396 // generate integers with proper bit count 397 for (int easyCaseNdx = 0; easyCaseNdx < DE_LENGTH_OF_ARRAY(easyCases); easyCaseNdx++) 398 { 399 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 400 { 401 in0[easyCaseNdx*scalarSize + compNdx] = easyCases[easyCaseNdx].x & integerMask; 402 in1[easyCaseNdx*scalarSize + compNdx] = easyCases[easyCaseNdx].y & integerMask; 403 } 404 } 405 406 // convert to signed 407 if (isSigned) 408 { 409 for (int easyCaseNdx = 0; easyCaseNdx < DE_LENGTH_OF_ARRAY(easyCases); easyCaseNdx++) 410 { 411 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 412 { 413 in0[easyCaseNdx*scalarSize + compNdx] = extendSignTo32(in0[easyCaseNdx*scalarSize + compNdx], integerLength); 414 in1[easyCaseNdx*scalarSize + compNdx] = extendSignTo32(in1[easyCaseNdx*scalarSize + compNdx], integerLength); 415 } 416 } 417 } 418 419 generateRandomInputData(rnd, m_shaderType, type, precision, in0, numValues - DE_LENGTH_OF_ARRAY(easyCases)); 420 generateRandomInputData(rnd, m_shaderType, type, precision, in1, numValues - DE_LENGTH_OF_ARRAY(easyCases)); 421 } 422 423 bool compare (const void* const* inputs, const void* const* outputs) 424 { 425 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 426 const glu::Precision precision = m_spec.inputs[0].varType.getPrecision(); 427 const int scalarSize = glu::getDataTypeScalarSize(type); 428 const int integerLength = getShaderUintBitCount(m_shaderType, precision); 429 const deUint32 mask0 = getLowBitMask(integerLength); 430 431 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 432 { 433 const deUint32 in0 = ((const deUint32*)inputs[0])[compNdx]; 434 const deUint32 in1 = ((const deUint32*)inputs[1])[compNdx]; 435 const deUint32 out0 = ((const deUint32*)outputs[0])[compNdx]; 436 const deUint32 out1 = ((const deUint32*)outputs[1])[compNdx]; 437 const deUint32 ref0 = in0+in1; 438 const deUint32 ref1 = (deUint64(in0)+deUint64(in1)) > 0xffffffffu ? 1u : 0u; 439 440 if (((out0&mask0) != (ref0&mask0)) || out1 != ref1) 441 { 442 m_failMsg << "Expected [" << compNdx << "] = " << tcu::toHex(ref0) << ", " << tcu::toHex(ref1); 443 return false; 444 } 445 } 446 447 return true; 448 } 449}; 450 451class UsubBorrowCase : public IntegerFunctionCase 452{ 453public: 454 UsubBorrowCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType) 455 : IntegerFunctionCase(context, getIntegerFuncCaseName(baseType, precision, shaderType).c_str(), "usubBorrow", shaderType) 456 { 457 m_spec.inputs.push_back(Symbol("x", glu::VarType(baseType, precision))); 458 m_spec.inputs.push_back(Symbol("y", glu::VarType(baseType, precision))); 459 m_spec.outputs.push_back(Symbol("diff", glu::VarType(baseType, precision))); 460 m_spec.outputs.push_back(Symbol("carry", glu::VarType(baseType, glu::PRECISION_LOWP))); 461 m_spec.source = "diff = usubBorrow(x, y, carry);"; 462 } 463 464 void getInputValues (int numValues, void* const* values) const 465 { 466 de::Random rnd (deStringHash(getName()) ^ 0x235facu); 467 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 468 const glu::Precision precision = m_spec.inputs[0].varType.getPrecision(); 469 const int scalarSize = glu::getDataTypeScalarSize(type); 470 const int integerLength = getShaderUintBitCount(m_shaderType, precision); 471 const deUint32 integerMask = getLowBitMask(integerLength); 472 const bool isSigned = glu::isDataTypeIntOrIVec(type); 473 deUint32* in0 = (deUint32*)values[0]; 474 deUint32* in1 = (deUint32*)values[1]; 475 476 const struct 477 { 478 deUint32 x; 479 deUint32 y; 480 } easyCases[] = 481 { 482 { 0x00000000u, 0x00000000u }, 483 { 0x00000001u, 0x00000001u }, 484 { 0x00000001u, 0x00000002u }, 485 { 0x00000001u, 0xffffffffu }, 486 { 0xfffffffeu, 0xffffffffu }, 487 { 0xffffffffu, 0xffffffffu }, 488 }; 489 490 // generate integers with proper bit count 491 for (int easyCaseNdx = 0; easyCaseNdx < DE_LENGTH_OF_ARRAY(easyCases); easyCaseNdx++) 492 { 493 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 494 { 495 in0[easyCaseNdx*scalarSize + compNdx] = easyCases[easyCaseNdx].x & integerMask; 496 in1[easyCaseNdx*scalarSize + compNdx] = easyCases[easyCaseNdx].y & integerMask; 497 } 498 } 499 500 // convert to signed 501 if (isSigned) 502 { 503 for (int easyCaseNdx = 0; easyCaseNdx < DE_LENGTH_OF_ARRAY(easyCases); easyCaseNdx++) 504 { 505 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 506 { 507 in0[easyCaseNdx*scalarSize + compNdx] = extendSignTo32(in0[easyCaseNdx*scalarSize + compNdx], integerLength); 508 in1[easyCaseNdx*scalarSize + compNdx] = extendSignTo32(in1[easyCaseNdx*scalarSize + compNdx], integerLength); 509 } 510 } 511 } 512 513 generateRandomInputData(rnd, m_shaderType, type, precision, in0, numValues - DE_LENGTH_OF_ARRAY(easyCases)); 514 generateRandomInputData(rnd, m_shaderType, type, precision, in1, numValues - DE_LENGTH_OF_ARRAY(easyCases)); 515 } 516 517 bool compare (const void* const* inputs, const void* const* outputs) 518 { 519 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 520 const glu::Precision precision = m_spec.inputs[0].varType.getPrecision(); 521 const int scalarSize = glu::getDataTypeScalarSize(type); 522 const int integerLength = getShaderUintBitCount(m_shaderType, precision); 523 const deUint32 mask0 = getLowBitMask(integerLength); 524 525 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 526 { 527 const deUint32 in0 = ((const deUint32*)inputs[0])[compNdx]; 528 const deUint32 in1 = ((const deUint32*)inputs[1])[compNdx]; 529 const deUint32 out0 = ((const deUint32*)outputs[0])[compNdx]; 530 const deUint32 out1 = ((const deUint32*)outputs[1])[compNdx]; 531 const deUint32 ref0 = in0-in1; 532 const deUint32 ref1 = in0 >= in1 ? 0u : 1u; 533 534 if (((out0&mask0) != (ref0&mask0)) || out1 != ref1) 535 { 536 m_failMsg << "Expected [" << compNdx << "] = " << tcu::toHex(ref0) << ", " << tcu::toHex(ref1); 537 return false; 538 } 539 } 540 541 return true; 542 } 543}; 544 545class UmulExtendedCase : public IntegerFunctionCase 546{ 547public: 548 UmulExtendedCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType) 549 : IntegerFunctionCase(context, getIntegerFuncCaseName(baseType, precision, shaderType).c_str(), "umulExtended", shaderType) 550 { 551 m_spec.inputs.push_back(Symbol("x", glu::VarType(baseType, precision))); 552 m_spec.inputs.push_back(Symbol("y", glu::VarType(baseType, precision))); 553 m_spec.outputs.push_back(Symbol("msb", glu::VarType(baseType, precision))); 554 m_spec.outputs.push_back(Symbol("lsb", glu::VarType(baseType, precision))); 555 m_spec.source = "umulExtended(x, y, msb, lsb);"; 556 } 557 558 void getInputValues (int numValues, void* const* values) const 559 { 560 de::Random rnd (deStringHash(getName()) ^ 0x235facu); 561 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 562// const glu::Precision precision = m_spec.inputs[0].varType.getPrecision(); 563 const int scalarSize = glu::getDataTypeScalarSize(type); 564 deUint32* in0 = (deUint32*)values[0]; 565 deUint32* in1 = (deUint32*)values[1]; 566 int valueNdx = 0; 567 568 const struct 569 { 570 deUint32 x; 571 deUint32 y; 572 } easyCases[] = 573 { 574 { 0x00000000u, 0x00000000u }, 575 { 0xffffffffu, 0x00000001u }, 576 { 0xffffffffu, 0x00000002u }, 577 { 0x00000001u, 0xffffffffu }, 578 { 0x00000002u, 0xffffffffu }, 579 { 0xffffffffu, 0xffffffffu }, 580 }; 581 582 for (int easyCaseNdx = 0; easyCaseNdx < DE_LENGTH_OF_ARRAY(easyCases); easyCaseNdx++) 583 { 584 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 585 { 586 in0[valueNdx*scalarSize + compNdx] = easyCases[easyCaseNdx].x; 587 in1[valueNdx*scalarSize + compNdx] = easyCases[easyCaseNdx].y; 588 } 589 590 valueNdx += 1; 591 } 592 593 while (valueNdx < numValues) 594 { 595 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 596 { 597 const deUint32 base0 = rnd.getUint32(); 598 const deUint32 base1 = rnd.getUint32(); 599 const int adj0 = rnd.getInt(0, 20); 600 const int adj1 = rnd.getInt(0, 20); 601 in0[valueNdx*scalarSize + compNdx] = base0 >> adj0; 602 in1[valueNdx*scalarSize + compNdx] = base1 >> adj1; 603 } 604 605 valueNdx += 1; 606 } 607 } 608 609 bool compare (const void* const* inputs, const void* const* outputs) 610 { 611 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 612 const int scalarSize = glu::getDataTypeScalarSize(type); 613 614 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 615 { 616 const deUint32 in0 = ((const deUint32*)inputs[0])[compNdx]; 617 const deUint32 in1 = ((const deUint32*)inputs[1])[compNdx]; 618 const deUint32 out0 = ((const deUint32*)outputs[0])[compNdx]; 619 const deUint32 out1 = ((const deUint32*)outputs[1])[compNdx]; 620 const deUint64 mul64 = deUint64(in0)*deUint64(in1); 621 const deUint32 ref0 = deUint32(mul64 >> 32); 622 const deUint32 ref1 = deUint32(mul64 & 0xffffffffu); 623 624 if (out0 != ref0 || out1 != ref1) 625 { 626 m_failMsg << "Expected [" << compNdx << "] = " << tcu::toHex(ref0) << ", " << tcu::toHex(ref1); 627 return false; 628 } 629 } 630 631 return true; 632 } 633}; 634 635class ImulExtendedCase : public IntegerFunctionCase 636{ 637public: 638 ImulExtendedCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType) 639 : IntegerFunctionCase(context, getIntegerFuncCaseName(baseType, precision, shaderType).c_str(), "imulExtended", shaderType) 640 { 641 m_spec.inputs.push_back(Symbol("x", glu::VarType(baseType, precision))); 642 m_spec.inputs.push_back(Symbol("y", glu::VarType(baseType, precision))); 643 m_spec.outputs.push_back(Symbol("msb", glu::VarType(baseType, precision))); 644 m_spec.outputs.push_back(Symbol("lsb", glu::VarType(baseType, precision))); 645 m_spec.source = "imulExtended(x, y, msb, lsb);"; 646 } 647 648 void getInputValues (int numValues, void* const* values) const 649 { 650 de::Random rnd (deStringHash(getName()) ^ 0x224fa1u); 651 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 652// const glu::Precision precision = m_spec.inputs[0].varType.getPrecision(); 653 const int scalarSize = glu::getDataTypeScalarSize(type); 654 deUint32* in0 = (deUint32*)values[0]; 655 deUint32* in1 = (deUint32*)values[1]; 656 int valueNdx = 0; 657 658 const struct 659 { 660 deUint32 x; 661 deUint32 y; 662 } easyCases[] = 663 { 664 { 0x00000000u, 0x00000000u }, 665 { 0xffffffffu, 0x00000002u }, 666 { 0x7fffffffu, 0x00000001u }, 667 { 0x7fffffffu, 0x00000002u }, 668 { 0x7fffffffu, 0x7fffffffu }, 669 { 0xffffffffu, 0xffffffffu }, 670 { 0x7fffffffu, 0xfffffffeu }, 671 }; 672 673 for (int easyCaseNdx = 0; easyCaseNdx < DE_LENGTH_OF_ARRAY(easyCases); easyCaseNdx++) 674 { 675 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 676 { 677 in0[valueNdx*scalarSize + compNdx] = (deInt32)easyCases[easyCaseNdx].x; 678 in1[valueNdx*scalarSize + compNdx] = (deInt32)easyCases[easyCaseNdx].y; 679 } 680 681 valueNdx += 1; 682 } 683 684 while (valueNdx < numValues) 685 { 686 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 687 { 688 const deInt32 base0 = (deInt32)rnd.getUint32(); 689 const deInt32 base1 = (deInt32)rnd.getUint32(); 690 const int adj0 = rnd.getInt(0, 20); 691 const int adj1 = rnd.getInt(0, 20); 692 in0[valueNdx*scalarSize + compNdx] = base0 >> adj0; 693 in1[valueNdx*scalarSize + compNdx] = base1 >> adj1; 694 } 695 696 valueNdx += 1; 697 } 698 } 699 700 bool compare (const void* const* inputs, const void* const* outputs) 701 { 702 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 703 const int scalarSize = glu::getDataTypeScalarSize(type); 704 705 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 706 { 707 const deInt32 in0 = ((const deInt32*)inputs[0])[compNdx]; 708 const deInt32 in1 = ((const deInt32*)inputs[1])[compNdx]; 709 const deInt32 out0 = ((const deInt32*)outputs[0])[compNdx]; 710 const deInt32 out1 = ((const deInt32*)outputs[1])[compNdx]; 711 const deInt64 mul64 = deInt64(in0)*deInt64(in1); 712 const deInt32 ref0 = deInt32(mul64 >> 32); 713 const deInt32 ref1 = deInt32(mul64 & 0xffffffffu); 714 715 if (out0 != ref0 || out1 != ref1) 716 { 717 m_failMsg << "Expected [" << compNdx << "] = " << tcu::toHex(ref0) << ", " << tcu::toHex(ref1); 718 return false; 719 } 720 } 721 722 return true; 723 } 724}; 725 726class BitfieldExtractCase : public IntegerFunctionCase 727{ 728public: 729 BitfieldExtractCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType) 730 : IntegerFunctionCase(context, getIntegerFuncCaseName(baseType, precision, shaderType).c_str(), "bitfieldExtract", shaderType) 731 { 732 m_spec.inputs.push_back(Symbol("value", glu::VarType(baseType, precision))); 733 m_spec.inputs.push_back(Symbol("offset", glu::VarType(glu::TYPE_INT, precision))); 734 m_spec.inputs.push_back(Symbol("bits", glu::VarType(glu::TYPE_INT, precision))); 735 m_spec.outputs.push_back(Symbol("extracted", glu::VarType(baseType, precision))); 736 m_spec.source = "extracted = bitfieldExtract(value, offset, bits);"; 737 } 738 739 void getInputValues (int numValues, void* const* values) const 740 { 741 de::Random rnd (deStringHash(getName()) ^ 0xa113fca2u); 742 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 743 const glu::Precision precision = m_spec.inputs[0].varType.getPrecision(); 744 const bool ignoreSign = precision != glu::PRECISION_HIGHP && glu::isDataTypeIntOrIVec(type); 745 const int numBits = getShaderUintBitCount(m_shaderType, precision) - (ignoreSign ? 1 : 0); 746 deUint32* inValue = (deUint32*)values[0]; 747 int* inOffset = (int*)values[1]; 748 int* inBits = (int*)values[2]; 749 750 for (int valueNdx = 0; valueNdx < numValues; ++valueNdx) 751 { 752 const int bits = rnd.getInt(0, numBits); 753 const int offset = rnd.getInt(0, numBits-bits); 754 755 inOffset[valueNdx] = offset; 756 inBits[valueNdx] = bits; 757 } 758 759 generateRandomInputData(rnd, m_shaderType, type, precision, inValue, numValues); 760 } 761 762 bool compare (const void* const* inputs, const void* const* outputs) 763 { 764 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 765 const bool isSigned = glu::isDataTypeIntOrIVec(type); 766 const int scalarSize = glu::getDataTypeScalarSize(type); 767 const int offset = *((const int*)inputs[1]); 768 const int bits = *((const int*)inputs[2]); 769 770 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 771 { 772 const deUint32 value = ((const deUint32*)inputs[0])[compNdx]; 773 const deUint32 out = ((const deUint32*)outputs[0])[compNdx]; 774 const deUint32 valMask = (bits == 32 ? ~0u : ((1u<<bits)-1u)); 775 const deUint32 baseVal = (offset == 32) ? (0) : ((value >> offset) & valMask); 776 const deUint32 ref = baseVal | ((isSigned && (baseVal & (1<<(bits-1)))) ? ~valMask : 0u); 777 778 if (out != ref) 779 { 780 m_failMsg << "Expected [" << compNdx << "] = " << tcu::toHex(ref); 781 return false; 782 } 783 } 784 785 return true; 786 } 787}; 788 789class BitfieldInsertCase : public IntegerFunctionCase 790{ 791public: 792 BitfieldInsertCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType) 793 : IntegerFunctionCase(context, getIntegerFuncCaseName(baseType, precision, shaderType).c_str(), "bitfieldInsert", shaderType) 794 { 795 m_spec.inputs.push_back(Symbol("base", glu::VarType(baseType, precision))); 796 m_spec.inputs.push_back(Symbol("insert", glu::VarType(baseType, precision))); 797 m_spec.inputs.push_back(Symbol("offset", glu::VarType(glu::TYPE_INT, precision))); 798 m_spec.inputs.push_back(Symbol("bits", glu::VarType(glu::TYPE_INT, precision))); 799 m_spec.outputs.push_back(Symbol("result", glu::VarType(baseType, precision))); 800 m_spec.source = "result = bitfieldInsert(base, insert, offset, bits);"; 801 } 802 803 void getInputValues (int numValues, void* const* values) const 804 { 805 de::Random rnd (deStringHash(getName()) ^ 0x12c2acff); 806 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 807 const glu::Precision precision = m_spec.inputs[0].varType.getPrecision(); 808 const int numBits = getShaderUintBitCount(m_shaderType, precision); 809 deUint32* inBase = (deUint32*)values[0]; 810 deUint32* inInsert = (deUint32*)values[1]; 811 int* inOffset = (int*)values[2]; 812 int* inBits = (int*)values[3]; 813 814 for (int valueNdx = 0; valueNdx < numValues; ++valueNdx) 815 { 816 const int bits = rnd.getInt(0, numBits); 817 const int offset = rnd.getInt(0, numBits-bits); 818 819 inOffset[valueNdx] = offset; 820 inBits[valueNdx] = bits; 821 } 822 823 generateRandomInputData(rnd, m_shaderType, type, precision, inBase, numValues); 824 generateRandomInputData(rnd, m_shaderType, type, precision, inInsert, numValues); 825 } 826 827 bool compare (const void* const* inputs, const void* const* outputs) 828 { 829 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 830 const glu::Precision precision = m_spec.inputs[0].varType.getPrecision(); 831 const int scalarSize = glu::getDataTypeScalarSize(type); 832 const int integerLength = getShaderUintBitCount(m_shaderType, precision); 833 const deUint32 cmpMask = getLowBitMask(integerLength); 834 const int offset = *((const int*)inputs[2]); 835 const int bits = *((const int*)inputs[3]); 836 837 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 838 { 839 const deUint32 base = ((const deUint32*)inputs[0])[compNdx]; 840 const deUint32 insert = ((const deUint32*)inputs[1])[compNdx]; 841 const deInt32 out = ((const deUint32*)outputs[0])[compNdx]; 842 843 const deUint32 mask = bits == 32 ? ~0u : (1u<<bits)-1; 844 const deUint32 ref = (base & ~(mask<<offset)) | ((insert & mask)<<offset); 845 846 if ((out&cmpMask) != (ref&cmpMask)) 847 { 848 m_failMsg << "Expected [" << compNdx << "] = " << tcu::toHex(ref); 849 return false; 850 } 851 } 852 853 return true; 854 } 855}; 856 857static inline deUint32 reverseBits (deUint32 v) 858{ 859 v = (((v & 0xaaaaaaaa) >> 1) | ((v & 0x55555555) << 1)); 860 v = (((v & 0xcccccccc) >> 2) | ((v & 0x33333333) << 2)); 861 v = (((v & 0xf0f0f0f0) >> 4) | ((v & 0x0f0f0f0f) << 4)); 862 v = (((v & 0xff00ff00) >> 8) | ((v & 0x00ff00ff) << 8)); 863 return((v >> 16) | (v << 16)); 864} 865 866class BitfieldReverseCase : public IntegerFunctionCase 867{ 868public: 869 BitfieldReverseCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType) 870 : IntegerFunctionCase(context, getIntegerFuncCaseName(baseType, precision, shaderType).c_str(), "bitfieldReverse", shaderType) 871 { 872 m_spec.inputs.push_back(Symbol("value", glu::VarType(baseType, precision))); 873 m_spec.outputs.push_back(Symbol("result", glu::VarType(baseType, glu::PRECISION_HIGHP))); 874 m_spec.source = "result = bitfieldReverse(value);"; 875 } 876 877 void getInputValues (int numValues, void* const* values) const 878 { 879 de::Random rnd (deStringHash(getName()) ^ 0xff23a4); 880 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 881 const glu::Precision precision = m_spec.inputs[0].varType.getPrecision(); 882 deUint32* inValue = (deUint32*)values[0]; 883 884 generateRandomInputData(rnd, m_shaderType, type, precision, inValue, numValues); 885 } 886 887 bool compare (const void* const* inputs, const void* const* outputs) 888 { 889 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 890 const glu::Precision precision = m_spec.inputs[0].varType.getPrecision(); 891 const int integerLength = getShaderUintBitCount(m_shaderType, precision); 892 const int scalarSize = glu::getDataTypeScalarSize(type); 893 const deUint32 cmpMask = reverseBits(getLowBitMask(integerLength)); 894 895 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 896 { 897 const deUint32 value = ((const deUint32*)inputs[0])[compNdx]; 898 const deInt32 out = ((const deUint32*)outputs[0])[compNdx]; 899 const deUint32 ref = reverseBits(value); 900 901 if ((out&cmpMask) != (ref&cmpMask)) 902 { 903 m_failMsg << "Expected [" << compNdx << "] = " << tcu::toHex(ref); 904 return false; 905 } 906 } 907 908 return true; 909 } 910}; 911 912class BitCountCase : public IntegerFunctionCase 913{ 914public: 915 BitCountCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType) 916 : IntegerFunctionCase(context, getIntegerFuncCaseName(baseType, precision, shaderType).c_str(), "bitCount", shaderType) 917 { 918 const int vecSize = glu::getDataTypeScalarSize(baseType); 919 const glu::DataType intType = vecSize == 1 ? glu::TYPE_INT : glu::getDataTypeIntVec(vecSize); 920 921 m_spec.inputs.push_back(Symbol("value", glu::VarType(baseType, precision))); 922 m_spec.outputs.push_back(Symbol("count", glu::VarType(intType, glu::PRECISION_LOWP))); 923 m_spec.source = "count = bitCount(value);"; 924 } 925 926 void getInputValues (int numValues, void* const* values) const 927 { 928 de::Random rnd (deStringHash(getName()) ^ 0xab2cca4); 929 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 930 const glu::Precision precision = m_spec.inputs[0].varType.getPrecision(); 931 deUint32* inValue = (deUint32*)values[0]; 932 933 generateRandomInputData(rnd, m_shaderType, type, precision, inValue, numValues); 934 } 935 936 bool compare (const void* const* inputs, const void* const* outputs) 937 { 938 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 939 const glu::Precision precision = m_spec.inputs[0].varType.getPrecision(); 940 const int integerLength = getShaderUintBitCount(m_shaderType, precision); 941 const int scalarSize = glu::getDataTypeScalarSize(type); 942 const deUint32 countMask = getLowBitMask(integerLength); 943 944 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 945 { 946 const deUint32 value = ((const deUint32*)inputs[0])[compNdx]; 947 const int out = ((const int*)outputs[0])[compNdx]; 948 const int minRef = dePop32(value&countMask); 949 const int maxRef = dePop32(value); 950 951 if (!de::inRange(out, minRef, maxRef)) 952 { 953 m_failMsg << "Expected [" << compNdx << "] in range [" << minRef << ", " << maxRef << "]"; 954 return false; 955 } 956 } 957 958 return true; 959 } 960}; 961 962static int findLSB (deUint32 value) 963{ 964 for (int i = 0; i < 32; i++) 965 { 966 if (value & (1u<<i)) 967 return i; 968 } 969 return -1; 970} 971 972class FindLSBCase : public IntegerFunctionCase 973{ 974public: 975 FindLSBCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType) 976 : IntegerFunctionCase(context, getIntegerFuncCaseName(baseType, precision, shaderType).c_str(), "findLSB", shaderType) 977 { 978 const int vecSize = glu::getDataTypeScalarSize(baseType); 979 const glu::DataType intType = vecSize == 1 ? glu::TYPE_INT : glu::getDataTypeIntVec(vecSize); 980 981 m_spec.inputs.push_back(Symbol("value", glu::VarType(baseType, precision))); 982 m_spec.outputs.push_back(Symbol("lsb", glu::VarType(intType, glu::PRECISION_LOWP))); 983 m_spec.source = "lsb = findLSB(value);"; 984 } 985 986 void getInputValues (int numValues, void* const* values) const 987 { 988 de::Random rnd (deStringHash(getName()) ^ 0x9923c2af); 989 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 990 const glu::Precision precision = m_spec.inputs[0].varType.getPrecision(); 991 deUint32* inValue = (deUint32*)values[0]; 992 993 generateRandomInputData(rnd, m_shaderType, type, precision, inValue, numValues); 994 } 995 996 bool compare (const void* const* inputs, const void* const* outputs) 997 { 998 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 999 const glu::Precision precision = m_spec.inputs[0].varType.getPrecision(); 1000 const int scalarSize = glu::getDataTypeScalarSize(type); 1001 const int integerLength = getShaderUintBitCount(m_shaderType, precision); 1002 const deUint32 mask = getLowBitMask(integerLength); 1003 1004 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 1005 { 1006 const deUint32 value = ((const deUint32*)inputs[0])[compNdx]; 1007 const int out = ((const int*)outputs[0])[compNdx]; 1008 const int minRef = findLSB(value&mask); 1009 const int maxRef = findLSB(value); 1010 1011 if (!de::inRange(out, minRef, maxRef)) 1012 { 1013 m_failMsg << "Expected [" << compNdx << "] in range [" << minRef << ", " << maxRef << "]"; 1014 return false; 1015 } 1016 } 1017 1018 return true; 1019 } 1020}; 1021 1022static int findMSB (deInt32 value) 1023{ 1024 if (value > 0) 1025 return 31 - deClz32((deUint32)value); 1026 else if (value < 0) 1027 return 31 - deClz32(~(deUint32)value); 1028 else 1029 return -1; 1030} 1031 1032static int findMSB (deUint32 value) 1033{ 1034 if (value > 0) 1035 return 31 - deClz32(value); 1036 else 1037 return -1; 1038} 1039 1040static deUint32 toPrecision (deUint32 value, int numIntegerBits) 1041{ 1042 return value & getLowBitMask(numIntegerBits); 1043} 1044 1045static deInt32 toPrecision (deInt32 value, int numIntegerBits) 1046{ 1047 return (deInt32)extendSignTo32((deUint32)value & getLowBitMask(numIntegerBits), numIntegerBits); 1048} 1049 1050class FindMSBCase : public IntegerFunctionCase 1051{ 1052public: 1053 FindMSBCase (Context& context, glu::DataType baseType, glu::Precision precision, glu::ShaderType shaderType) 1054 : IntegerFunctionCase(context, getIntegerFuncCaseName(baseType, precision, shaderType).c_str(), "findMSB", shaderType) 1055 { 1056 const int vecSize = glu::getDataTypeScalarSize(baseType); 1057 const glu::DataType intType = vecSize == 1 ? glu::TYPE_INT : glu::getDataTypeIntVec(vecSize); 1058 1059 m_spec.inputs.push_back(Symbol("value", glu::VarType(baseType, precision))); 1060 m_spec.outputs.push_back(Symbol("msb", glu::VarType(intType, glu::PRECISION_LOWP))); 1061 m_spec.source = "msb = findMSB(value);"; 1062 } 1063 1064 void getInputValues (int numValues, void* const* values) const 1065 { 1066 de::Random rnd (deStringHash(getName()) ^ 0x742ac4e); 1067 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 1068 const glu::Precision precision = m_spec.inputs[0].varType.getPrecision(); 1069 deUint32* inValue = (deUint32*)values[0]; 1070 1071 generateRandomInputData(rnd, m_shaderType, type, precision, inValue, numValues); 1072 } 1073 1074 bool compare (const void* const* inputs, const void* const* outputs) 1075 { 1076 const glu::DataType type = m_spec.inputs[0].varType.getBasicType(); 1077 const glu::Precision precision = m_spec.inputs[0].varType.getPrecision(); 1078 const bool isSigned = glu::isDataTypeIntOrIVec(type); 1079 const int scalarSize = glu::getDataTypeScalarSize(type); 1080 const int integerLength = getShaderUintBitCount(m_shaderType, precision); 1081 1082 for (int compNdx = 0; compNdx < scalarSize; compNdx++) 1083 { 1084 const deUint32 value = ((const deUint32*)inputs[0])[compNdx]; 1085 const int out = ((const deInt32*)outputs[0])[compNdx]; 1086 const int minRef = isSigned ? findMSB(toPrecision(deInt32(value), integerLength)) : findMSB(toPrecision(value, integerLength)); 1087 const int maxRef = isSigned ? findMSB(deInt32(value)) : findMSB(value); 1088 1089 if (!de::inRange(out, minRef, maxRef)) 1090 { 1091 m_failMsg << "Expected [" << compNdx << "] in range [" << minRef << ", " << maxRef << "]"; 1092 return false; 1093 } 1094 } 1095 1096 return true; 1097 } 1098}; 1099 1100ShaderIntegerFunctionTests::ShaderIntegerFunctionTests (Context& context) 1101 : TestCaseGroup(context, "integer", "Integer function tests") 1102{ 1103} 1104 1105ShaderIntegerFunctionTests::~ShaderIntegerFunctionTests (void) 1106{ 1107} 1108 1109template<class TestClass> 1110static void addFunctionCases (TestCaseGroup* parent, const char* functionName, bool intTypes, bool uintTypes, bool allPrec, deUint32 shaderBits) 1111{ 1112 tcu::TestCaseGroup* group = new tcu::TestCaseGroup(parent->getTestContext(), functionName, functionName); 1113 parent->addChild(group); 1114 1115 const glu::DataType scalarTypes[] = 1116 { 1117 glu::TYPE_INT, 1118 glu::TYPE_UINT 1119 }; 1120 1121 for (int scalarTypeNdx = 0; scalarTypeNdx < DE_LENGTH_OF_ARRAY(scalarTypes); scalarTypeNdx++) 1122 { 1123 const glu::DataType scalarType = scalarTypes[scalarTypeNdx]; 1124 1125 if ((!intTypes && scalarType == glu::TYPE_INT) || (!uintTypes && scalarType == glu::TYPE_UINT)) 1126 continue; 1127 1128 for (int vecSize = 1; vecSize <= 4; vecSize++) 1129 { 1130 for (int prec = glu::PRECISION_LOWP; prec <= glu::PRECISION_HIGHP; prec++) 1131 { 1132 if (prec != glu::PRECISION_HIGHP && !allPrec) 1133 continue; 1134 1135 for (int shaderTypeNdx = 0; shaderTypeNdx < glu::SHADERTYPE_LAST; shaderTypeNdx++) 1136 { 1137 if (shaderBits & (1<<shaderTypeNdx)) 1138 group->addChild(new TestClass(parent->getContext(), glu::DataType(scalarType + vecSize - 1), glu::Precision(prec), glu::ShaderType(shaderTypeNdx))); 1139 } 1140 } 1141 } 1142 } 1143} 1144 1145void ShaderIntegerFunctionTests::init (void) 1146{ 1147 enum 1148 { 1149 VS = (1<<glu::SHADERTYPE_VERTEX), 1150 FS = (1<<glu::SHADERTYPE_FRAGMENT), 1151 CS = (1<<glu::SHADERTYPE_COMPUTE), 1152 GS = (1<<glu::SHADERTYPE_GEOMETRY), 1153 TC = (1<<glu::SHADERTYPE_TESSELLATION_CONTROL), 1154 TE = (1<<glu::SHADERTYPE_TESSELLATION_EVALUATION), 1155 1156 ALL_SHADERS = VS|TC|TE|GS|FS|CS 1157 }; 1158 1159 // Int? Uint? AllPrec? Shaders 1160 addFunctionCases<UaddCarryCase> (this, "uaddcarry", false, true, true, ALL_SHADERS); 1161 addFunctionCases<UsubBorrowCase> (this, "usubborrow", false, true, true, ALL_SHADERS); 1162 addFunctionCases<UmulExtendedCase> (this, "umulextended", false, true, false, ALL_SHADERS); 1163 addFunctionCases<ImulExtendedCase> (this, "imulextended", true, false, false, ALL_SHADERS); 1164 addFunctionCases<BitfieldExtractCase> (this, "bitfieldextract", true, true, true, ALL_SHADERS); 1165 addFunctionCases<BitfieldInsertCase> (this, "bitfieldinsert", true, true, true, ALL_SHADERS); 1166 addFunctionCases<BitfieldReverseCase> (this, "bitfieldreverse", true, true, true, ALL_SHADERS); 1167 addFunctionCases<BitCountCase> (this, "bitcount", true, true, true, ALL_SHADERS); 1168 addFunctionCases<FindLSBCase> (this, "findlsb", true, true, true, ALL_SHADERS); 1169 addFunctionCases<FindMSBCase> (this, "findmsb", true, true, true, ALL_SHADERS); 1170} 1171 1172} // Functional 1173} // gles31 1174} // deqp 1175