From 65bfc4d585173027152dc4b0b0eccd7aefd1973d Mon Sep 17 00:00:00 2001 From: Lei Zhang Date: Wed, 26 Aug 2015 17:23:35 -0400 Subject: [PATCH] Unify tests for GLSL std450 extended instructions. Previously we had two tests: one checks test to binary, the other checks round trip. This patch merges the check in the former to the latter. --- test/ExtInstGLSLstd450.cpp | 251 +++++++++++++-------------------------------- 1 file changed, 70 insertions(+), 181 deletions(-) diff --git a/test/ExtInstGLSLstd450.cpp b/test/ExtInstGLSLstd450.cpp index 3bdd65c..01bc7e6 100644 --- a/test/ExtInstGLSLstd450.cpp +++ b/test/ExtInstGLSLstd450.cpp @@ -40,136 +40,13 @@ struct ExtInstContext { const char* extInstRetType; const char* extInstOpName; const char* extInstOperandVars; - uint32_t extInstOpcode; + /// The following fields are used to check the SPIR-V binary representation + /// of this instruction. + uint32_t extInstOpcode; ///< Opcode value for this extended instruction. + uint32_t extInstLength; ///< Wordcount of this extended instruction. + std::vector extInstOperandIds; ///< Ids for operands. }; -/// Context for an extended instruction with corresponding binary code for some -/// fields. -/// -/// Information about a GLSL extended instruction (including its opname, return -/// type, etc.) and related instructions used to generate the return type and -/// constant as the operands. Also includes the corresponding binary code for -/// some fields. Used in generating extended instruction tests. -struct ExtInstBinContext { - const char* typeGenInst; - const char* constGenInst; - const char* extInstRetType; - const char* extInstOpName; - const char* extInstOperandVars; - uint32_t extInstOpcode; - uint32_t extInstLength; - std::vector extInstOperandIds; -}; - -using ExtInstGLSLstd450TextToBinTest = - TextToBinaryTestBase<::testing::TestWithParam>; - -TEST_P(ExtInstGLSLstd450TextToBinTest, ParamterizedExtInst) { - const std::string spirv = R"( - OpCapability Shader - %glsl450 = OpExtInstImport "GLSL.std.450" - OpMemoryModel Logical Simple - OpEntryPoint Vertex %main "main" - %void = OpTypeVoid -)" + std::string(GetParam().typeGenInst) + - "\n" + std::string(GetParam().constGenInst) + R"( - %fnMain = OpTypeFunction %void - %main = OpFunction %void None %fnMain - %lbMain = OpLabel - %result = OpExtInst )" + GetParam().extInstRetType + - " %glsl450 " + GetParam().extInstOpName + " " + - GetParam().extInstOperandVars + R"( - OpReturn - OpFunctionEnd -)"; - - this->text.str = spirv.c_str(); - this->text.length = spirv.size(); - EXPECT_EQ(SPV_SUCCESS, spvTextToBinary(&this->text, this->opcodeTable, - this->operandTable, this->extInstTable, - &this->binary, &this->diagnostic)) - << "Source was: " << std::endl - << spirv << std::endl - << "Test case for : " << GetParam().extInstOpName << std::endl; - std::vector expected_contains( - {12 /*OpExtInst*/ | GetParam().extInstLength << 16, 4 /*%flt*/, - 8 /*%result*/, 1 /*%glsl450*/, GetParam().extInstOpcode}); - for (uint32_t operand : GetParam().extInstOperandIds) { - expected_contains.push_back(operand); - } - EXPECT_TRUE(std::search(this->binary->code, - this->binary->code + this->binary->wordCount, - expected_contains.begin(), expected_contains.end()) != - this->binary->code + this->binary->wordCount) - << "Cannot find\n" << expected_contains << "in\n" << *this->binary; - if (this->binary) { - spvBinaryDestroy(this->binary); - } - if (this->diagnostic) { - spvDiagnosticPrint(this->diagnostic); - } -} - -static const char* kF32TypeSym = R"(%flt = OpTypeFloat 32)"; -static const char* kF32ConstSym = R"(%c1.5 = OpConstant %flt 1.5)"; -static const char* kU32TypeSym = R"(%int = OpTypeInt 32 0)"; -static const char* kS32TypeSym = R"(%int = OpTypeInt 32 1)"; -static const char* kI32ConstSym = R"(%c1 = OpConstant %int 1)"; - -INSTANTIATE_TEST_CASE_P( - ExtInstParameters, ExtInstGLSLstd450TextToBinTest, - ::testing::ValuesIn(std::vector({ - // clang-format off - {kF32TypeSym, kF32ConstSym, "%flt", "Round", "%c1.5", 1, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "RoundEven", "%c1.5", 2, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Trunc", "%c1.5", 3, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "FAbs", "%c1.5", 4, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "SAbs", "%c1.5", 5, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "FSign", "%c1.5", 6, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "SSign", "%c1.5", 7, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Floor", "%c1.5", 8, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Ceil", "%c1.5", 9, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Fract", "%c1.5", 10, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Radians", "%c1.5", 11, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Degrees", "%c1.5", 12, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Sin", "%c1.5", 13, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Cos", "%c1.5", 14, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Tan", "%c1.5", 15, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Asin", "%c1.5", 16, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Acos", "%c1.5", 17, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Atan", "%c1.5", 18, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Sinh", "%c1.5", 19, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Cosh", "%c1.5", 20, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Tanh", "%c1.5", 21, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Asinh", "%c1.5", 22, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Acosh", "%c1.5", 23, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Atanh", "%c1.5", 24, 6, {5}}, - /* {"Atan2", 25}, {"Pow", 26} */ - {kF32TypeSym, kF32ConstSym, "%flt", "Exp", "%c1.5", 27, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Log", "%c1.5", 28, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Exp2", "%c1.5", 29, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Log2", "%c1.5", 30, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Sqrt", "%c1.5", 31, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Inversesqrt", "%c1.5", 32, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Determinant", "%c1.5", 33, 6, {5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Inverse", "%c1.5", 34, 6, {5}}, - /* Modf */ - /* ModfStruct */ - {kF32TypeSym, kF32ConstSym, "%flt", "FMin", "%c1.5 %c1.5", 37, 7, {5, 5}}, - {kU32TypeSym, kI32ConstSym, "%int", "UMin", "%c1 %c1", 38, 7, {5, 5}}, - {kS32TypeSym, kI32ConstSym, "%int", "SMin", "%c1 %c1", 39, 7, {5, 5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "FMax", "%c1.5 %c1.5", 40, 7, {5, 5}}, - {kU32TypeSym, kI32ConstSym, "%int", "UMax", "%c1 %c1", 41, 7, {5, 5}}, - {kS32TypeSym, kI32ConstSym, "%int", "SMax", "%c1 %c1", 42, 7, {5, 5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "FClamp", "%c1.5 %c1.5 %c1.5", 43, 8, {5, 5, 5}}, - {kU32TypeSym, kI32ConstSym, "%int", "UClamp", "%c1 %c1 %c1", 44, 8, {5, 5, 5}}, - {kS32TypeSym, kI32ConstSym, "%int", "SClamp", "%c1 %c1 %c1", 45, 8, {5, 5, 5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Mix", "%c1.5 %c1.5 %c1.5", 46, 8, {5, 5, 5}}, - {kF32TypeSym, kF32ConstSym, "%flt", "Step", "%c1.5 %c1.5", 47, 7, {5, 5}}, - /* SmoothStep */ - // clang-format on - }))); - using ExtInstGLSLstd450RoundTripTest = ::testing::TestWithParam; TEST_P(ExtInstGLSLstd450RoundTripTest, ParamterizedExtInst) { @@ -179,6 +56,7 @@ TEST_P(ExtInstGLSLstd450RoundTripTest, ParamterizedExtInst) { ASSERT_EQ(SPV_SUCCESS, spvOperandTableGet(&operandTable)); spv_ext_inst_table extInstTable; ASSERT_EQ(SPV_SUCCESS, spvExtInstTableGet(&extInstTable)); + const std::string spirv = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" @@ -216,6 +94,20 @@ OpFunctionEnd << "Test case for : " << GetParam().extInstOpName << std::endl; } + // Check we do have the extended instruction's corresponding binary code in + // the generated SPIR-V binary. + std::vector expected_contains( + {12 /*OpExtInst*/ | GetParam().extInstLength << 16, 4 /*%flt*/, + 9 /*%result*/, 1 /*%glsl450*/, GetParam().extInstOpcode}); + for (uint32_t operand : GetParam().extInstOperandIds) { + expected_contains.push_back(operand); + } + EXPECT_NE(binary->code + binary->wordCount, + std::search(binary->code, binary->code + binary->wordCount, + expected_contains.begin(), expected_contains.end())) + << "Cannot find\n" << expected_contains << "in\n" << *binary; + + // Check round trip gives the same text. spv_text output_text; error = spvBinaryToText(binary, SPV_BINARY_TO_TEXT_OPTION_NONE, opcodeTable, @@ -230,64 +122,61 @@ OpFunctionEnd spvTextDestroy(output_text); } -static const char* kF32TypeNum = R"(%4 = OpTypeFloat 32)"; -static const char* kF32ConstNum = R"(%5 = OpConstant %4 1)"; -static const char* kU32TypeNum = R"(%4 = OpTypeInt 32 0)"; -static const char* kS32TypeNum = R"(%4 = OpTypeInt 32 1)"; -static const char* kI32ConstNum = R"(%5 = OpConstant %4 1)"; +static const char* kF32Type = R"(%4 = OpTypeFloat 32)"; +static const char* kF32Const = R"(%5 = OpConstant %4 1)"; +static const char* kU32Type = R"(%4 = OpTypeInt 32 0)"; +static const char* kS32Type = R"(%4 = OpTypeInt 32 1)"; +static const char* kI32Const = R"(%5 = OpConstant %4 1)"; INSTANTIATE_TEST_CASE_P( ExtInstParameters, ExtInstGLSLstd450RoundTripTest, ::testing::ValuesIn(std::vector({ - {kF32TypeNum, kF32ConstNum, "%4", "Round", "%5", 1}, - {kF32TypeNum, kF32ConstNum, "%4", "RoundEven", "%5", 2}, - {kF32TypeNum, kF32ConstNum, "%4", "Trunc", "%5", 3}, - {kF32TypeNum, kF32ConstNum, "%4", "FAbs", "%5", 4}, - {kF32TypeNum, kF32ConstNum, "%4", "SAbs", "%5", 5}, - {kF32TypeNum, kF32ConstNum, "%4", "FSign", "%5", 6}, - {kF32TypeNum, kF32ConstNum, "%4", "SSign", "%5", 7}, - {kF32TypeNum, kF32ConstNum, "%4", "Floor", "%5", 8}, - {kF32TypeNum, kF32ConstNum, "%4", "Ceil", "%5", 9}, - {kF32TypeNum, kF32ConstNum, "%4", "Fract", "%5", 10}, - {kF32TypeNum, kF32ConstNum, "%4", "Radians", "%5", 11}, - {kF32TypeNum, kF32ConstNum, "%4", "Degrees", "%5", 12}, - {kF32TypeNum, kF32ConstNum, "%4", "Sin", "%5", 13}, - {kF32TypeNum, kF32ConstNum, "%4", "Cos", "%5", 14}, - {kF32TypeNum, kF32ConstNum, "%4", "Tan", "%5", 15}, - {kF32TypeNum, kF32ConstNum, "%4", "Asin", "%5", 16}, - {kF32TypeNum, kF32ConstNum, "%4", "Acos", "%5", 17}, - {kF32TypeNum, kF32ConstNum, "%4", "Atan", "%5", 18}, - {kF32TypeNum, kF32ConstNum, "%4", "Sinh", "%5", 19}, - {kF32TypeNum, kF32ConstNum, "%4", "Cosh", "%5", 20}, - {kF32TypeNum, kF32ConstNum, "%4", "Tanh", "%5", 21}, - {kF32TypeNum, kF32ConstNum, "%4", "Asinh", "%5", 22}, - {kF32TypeNum, kF32ConstNum, "%4", "Acosh", "%5", 23}, - {kF32TypeNum, kF32ConstNum, "%4", "Atanh", "%5", 24}, - {kU32TypeNum, kI32ConstNum, "%4", "UMin", "%5 %5", 38}, - {kS32TypeNum, kI32ConstNum, "%4", "SMin", "%5 %5", 39}, - {kU32TypeNum, kI32ConstNum, "%4", "UMax", "%5 %5", 41}, - {kS32TypeNum, kI32ConstNum, "%4", "SMax", "%5 %5", 42}, - /* {"Atan2", 25}, {"Pow", 26} */ - {kF32TypeNum, kF32ConstNum, "%4", "Exp", "%5", 27}, - {kF32TypeNum, kF32ConstNum, "%4", "Log", "%5", 28}, - {kF32TypeNum, kF32ConstNum, "%4", "Exp2", "%5", 29}, - {kF32TypeNum, kF32ConstNum, "%4", "Log2", "%5", 30}, - {kF32TypeNum, kF32ConstNum, "%4", "Sqrt", "%5", 31}, - {kF32TypeNum, kF32ConstNum, "%4", "Inversesqrt", "%5", 32}, - {kF32TypeNum, kF32ConstNum, "%4", "Determinant", "%5", 33}, - {kF32TypeNum, kF32ConstNum, "%4", "Inverse", "%5", 34}, + {kF32Type, kF32Const, "%4", "Round", "%5", 1, 6, {5}}, + {kF32Type, kF32Const, "%4", "RoundEven", "%5", 2, 6, {5}}, + {kF32Type, kF32Const, "%4", "Trunc", "%5", 3, 6, {5}}, + {kF32Type, kF32Const, "%4", "FAbs", "%5", 4, 6, {5}}, + {kF32Type, kF32Const, "%4", "SAbs", "%5", 5, 6, {5}}, + {kF32Type, kF32Const, "%4", "FSign", "%5", 6, 6, {5}}, + {kF32Type, kF32Const, "%4", "SSign", "%5", 7, 6, {5}}, + {kF32Type, kF32Const, "%4", "Floor", "%5", 8, 6, {5}}, + {kF32Type, kF32Const, "%4", "Ceil", "%5", 9, 6, {5}}, + {kF32Type, kF32Const, "%4", "Fract", "%5", 10, 6, {5}}, + {kF32Type, kF32Const, "%4", "Radians", "%5", 11, 6, {5}}, + {kF32Type, kF32Const, "%4", "Degrees", "%5", 12, 6, {5}}, + {kF32Type, kF32Const, "%4", "Sin", "%5", 13, 6, {5}}, + {kF32Type, kF32Const, "%4", "Cos", "%5", 14, 6, {5}}, + {kF32Type, kF32Const, "%4", "Tan", "%5", 15, 6, {5}}, + {kF32Type, kF32Const, "%4", "Asin", "%5", 16, 6, {5}}, + {kF32Type, kF32Const, "%4", "Acos", "%5", 17, 6, {5}}, + {kF32Type, kF32Const, "%4", "Atan", "%5", 18, 6, {5}}, + {kF32Type, kF32Const, "%4", "Sinh", "%5", 19, 6, {5}}, + {kF32Type, kF32Const, "%4", "Cosh", "%5", 20, 6, {5}}, + {kF32Type, kF32Const, "%4", "Tanh", "%5", 21, 6, {5}}, + {kF32Type, kF32Const, "%4", "Asinh", "%5", 22, 6, {5}}, + {kF32Type, kF32Const, "%4", "Acosh", "%5", 23, 6, {5}}, + {kF32Type, kF32Const, "%4", "Atanh", "%5", 24, 6, {5}}, + /* Atan2 */ + /* Pow */ + {kF32Type, kF32Const, "%4", "Exp", "%5", 27, 6, {5}}, + {kF32Type, kF32Const, "%4", "Log", "%5", 28, 6, {5}}, + {kF32Type, kF32Const, "%4", "Exp2", "%5", 29, 6, {5}}, + {kF32Type, kF32Const, "%4", "Log2", "%5", 30, 6, {5}}, + {kF32Type, kF32Const, "%4", "Sqrt", "%5", 31, 6, {5}}, + {kF32Type, kF32Const, "%4", "Inversesqrt", "%5", 32, 6, {5}}, + {kF32Type, kF32Const, "%4", "Determinant", "%5", 33, 6, {5}}, + {kF32Type, kF32Const, "%4", "Inverse", "%5", 34, 6, {5}}, /* Modf */ /* ModfStruct */ - {kF32TypeNum, kF32ConstNum, "%4", "FMin", "%5 %5", 37}, - {kU32TypeNum, kI32ConstNum, "%4", "UMin", "%5 %5", 38}, - {kS32TypeNum, kI32ConstNum, "%4", "SMin", "%5 %5", 39}, - {kF32TypeNum, kF32ConstNum, "%4", "FMax", "%5 %5", 40}, - {kU32TypeNum, kI32ConstNum, "%4", "UMax", "%5 %5", 41}, - {kS32TypeNum, kI32ConstNum, "%4", "SMax", "%5 %5", 42}, - {kF32TypeNum, kF32ConstNum, "%4", "FClamp", "%5 %5 %5", 43}, - {kU32TypeNum, kI32ConstNum, "%4", "UClamp", "%5 %5 %5", 44}, - {kS32TypeNum, kI32ConstNum, "%4", "SClamp", "%5 %5 %5", 45}, - {kF32TypeNum, kF32ConstNum, "%4", "Mix", "%5 %5 %5", 46}, - {kF32TypeNum, kF32ConstNum, "%4", "Step", "%5 %5", 47}, + {kF32Type, kF32Const, "%4", "FMin", "%5 %5", 37, 7, {5, 5}}, + {kU32Type, kI32Const, "%4", "UMin", "%5 %5", 38, 7, {5, 5}}, + {kS32Type, kI32Const, "%4", "SMin", "%5 %5", 39, 7, {5, 5}}, + {kF32Type, kF32Const, "%4", "FMax", "%5 %5", 40, 7, {5, 5}}, + {kU32Type, kI32Const, "%4", "UMax", "%5 %5", 41, 7, {5, 5}}, + {kS32Type, kI32Const, "%4", "SMax", "%5 %5", 42, 7, {5, 5}}, + {kF32Type, kF32Const, "%4", "FClamp", "%5 %5 %5", 43, 8, {5, 5, 5}}, + {kU32Type, kI32Const, "%4", "UClamp", "%5 %5 %5", 44, 8, {5, 5, 5}}, + {kS32Type, kI32Const, "%4", "SClamp", "%5 %5 %5", 45, 8, {5, 5, 5}}, + {kF32Type, kF32Const, "%4", "Mix", "%5 %5 %5", 46, 8, {5, 5, 5}}, + {kF32Type, kF32Const, "%4", "Step", "%5 %5", 47, 7, {5, 5}}, /* SmoothStep */ }))); -- 2.7.4