// Copyright (c) 2019 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "source/fuzz/fact_manager/fact_manager.h" #include "gtest/gtest.h" #include "source/fuzz/fuzzer_util.h" #include "source/fuzz/transformation_merge_blocks.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { void CheckConsistencyOfSynonymFacts( opt::IRContext* ir_context, const TransformationContext& transformation_context) { for (uint32_t id : transformation_context.GetFactManager() ->GetIdsForWhichSynonymsAreKnown()) { // Every id reported by the fact manager should exist in the module. ASSERT_NE(ir_context->get_def_use_mgr()->GetDef(id), nullptr); auto synonyms = transformation_context.GetFactManager()->GetSynonymsForId(id); for (auto& dd : synonyms) { // Every reported synonym should have a base object that exists in the // module. ASSERT_NE(ir_context->get_def_use_mgr()->GetDef(dd->object()), nullptr); } } } TEST(DataSynonymAndIdEquationFactsTest, RecursiveAdditionOfFacts) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypeMatrix %7 4 %9 = OpConstant %6 0 %10 = OpConstantComposite %7 %9 %9 %9 %9 %11 = OpConstantComposite %8 %10 %10 %10 %10 %12 = OpFunction %2 None %3 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); fact_manager.AddFactDataSynonym(MakeDataDescriptor(10, {}), MakeDataDescriptor(11, {2})); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(10, {}), MakeDataDescriptor(11, {2}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(10, {0}), MakeDataDescriptor(11, {2, 0}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(10, {1}), MakeDataDescriptor(11, {2, 1}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(10, {2}), MakeDataDescriptor(11, {2, 2}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(10, {3}), MakeDataDescriptor(11, {2, 3}))); } TEST(DataSynonymAndIdEquationFactsTest, CorollaryConversionFacts) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypeInt 32 0 %8 = OpTypeVector %6 2 %9 = OpTypeVector %7 2 %10 = OpTypeFloat 32 %11 = OpTypeVector %10 2 %15 = OpConstant %6 24 ; synonym of %16 %16 = OpConstant %6 24 %17 = OpConstant %7 24 ; synonym of %18 %18 = OpConstant %7 24 %19 = OpConstantComposite %8 %15 %15 ; synonym of %20 %20 = OpConstantComposite %8 %16 %16 %21 = OpConstantComposite %9 %17 %17 ; synonym of %22 %22 = OpConstantComposite %9 %18 %18 %23 = OpConstantComposite %8 %15 %15 ; not a synonym of %19 %12 = OpFunction %2 None %3 %13 = OpLabel %24 = OpConvertSToF %10 %15 ; synonym of %25 %25 = OpConvertSToF %10 %16 %26 = OpConvertUToF %10 %17 ; not a synonym of %27 (different opcode) %27 = OpConvertSToF %10 %18 %28 = OpConvertUToF %11 %19 ; synonym of %29 %29 = OpConvertUToF %11 %20 %30 = OpConvertSToF %11 %21 ; not a synonym of %31 (different opcode) %31 = OpConvertUToF %11 %22 %32 = OpConvertUToF %11 %23 ; not a synonym of %28 (operand is not synonymous) OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); // Add equation facts fact_manager.AddFactIdEquation(24, spv::Op::OpConvertSToF, {15}); fact_manager.AddFactIdEquation(25, spv::Op::OpConvertSToF, {16}); fact_manager.AddFactIdEquation(26, spv::Op::OpConvertUToF, {17}); fact_manager.AddFactIdEquation(27, spv::Op::OpConvertSToF, {18}); fact_manager.AddFactIdEquation(28, spv::Op::OpConvertUToF, {19}); fact_manager.AddFactIdEquation(29, spv::Op::OpConvertUToF, {20}); fact_manager.AddFactIdEquation(30, spv::Op::OpConvertSToF, {21}); fact_manager.AddFactIdEquation(31, spv::Op::OpConvertUToF, {22}); fact_manager.AddFactIdEquation(32, spv::Op::OpConvertUToF, {23}); fact_manager.AddFactDataSynonym(MakeDataDescriptor(15, {}), MakeDataDescriptor(16, {})); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(24, {}), MakeDataDescriptor(25, {}))); fact_manager.AddFactDataSynonym(MakeDataDescriptor(17, {}), MakeDataDescriptor(18, {})); ASSERT_FALSE(fact_manager.IsSynonymous(MakeDataDescriptor(26, {}), MakeDataDescriptor(27, {}))); fact_manager.AddFactDataSynonym(MakeDataDescriptor(19, {}), MakeDataDescriptor(20, {})); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(28, {}), MakeDataDescriptor(29, {}))); fact_manager.AddFactDataSynonym(MakeDataDescriptor(21, {}), MakeDataDescriptor(22, {})); ASSERT_FALSE(fact_manager.IsSynonymous(MakeDataDescriptor(30, {}), MakeDataDescriptor(31, {}))); ASSERT_FALSE(fact_manager.IsSynonymous(MakeDataDescriptor(32, {}), MakeDataDescriptor(28, {}))); fact_manager.AddFactDataSynonym(MakeDataDescriptor(23, {}), MakeDataDescriptor(19, {})); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(32, {}), MakeDataDescriptor(28, {}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(32, {}), MakeDataDescriptor(29, {}))); } TEST(DataSynonymAndIdEquationFactsTest, HandlesCorollariesWithInvalidIds) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %8 = OpTypeInt 32 1 %9 = OpConstant %8 3 %12 = OpFunction %2 None %3 %13 = OpLabel %14 = OpConvertSToF %6 %9 OpBranch %16 %16 = OpLabel %17 = OpPhi %6 %14 %13 %15 = OpConvertSToF %6 %9 %18 = OpConvertSToF %6 %9 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(context.get()), validator_options); // Add required facts. transformation_context.GetFactManager()->AddFactIdEquation( 14, spv::Op::OpConvertSToF, {9}); transformation_context.GetFactManager()->AddFactDataSynonym( MakeDataDescriptor(14, {}), MakeDataDescriptor(17, {})); CheckConsistencyOfSynonymFacts(context.get(), transformation_context); // Apply TransformationMergeBlocks which will remove %17 from the module. TransformationMergeBlocks transformation(16); ASSERT_TRUE( transformation.IsApplicable(context.get(), transformation_context)); transformation.Apply(context.get(), &transformation_context); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); CheckConsistencyOfSynonymFacts(context.get(), transformation_context); ASSERT_EQ(context->get_def_use_mgr()->GetDef(17), nullptr); // Add another equation. transformation_context.GetFactManager()->AddFactIdEquation( 15, spv::Op::OpConvertSToF, {9}); // Check that two ids are synonymous even though one of them doesn't exist in // the module (%17). ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(15, {}), MakeDataDescriptor(17, {}))); ASSERT_TRUE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(15, {}), MakeDataDescriptor(14, {}))); CheckConsistencyOfSynonymFacts(context.get(), transformation_context); // Remove some instructions from the module. At this point, the equivalence // class of %14 has no valid members. ASSERT_TRUE(context->KillDef(14)); ASSERT_TRUE(context->KillDef(15)); transformation_context.GetFactManager()->AddFactIdEquation( 18, spv::Op::OpConvertSToF, {9}); CheckConsistencyOfSynonymFacts(context.get(), transformation_context); // We don't create synonyms if at least one of the equivalence classes has no // valid members. ASSERT_FALSE(transformation_context.GetFactManager()->IsSynonymous( MakeDataDescriptor(14, {}), MakeDataDescriptor(18, {}))); } TEST(DataSynonymAndIdEquationFactsTest, LogicalNotEquationFacts) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpConstantTrue %6 %12 = OpFunction %2 None %3 %13 = OpLabel %14 = OpLogicalNot %6 %7 %15 = OpCopyObject %6 %7 %16 = OpCopyObject %6 %14 %17 = OpLogicalNot %6 %16 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); fact_manager.AddFactDataSynonym(MakeDataDescriptor(15, {}), MakeDataDescriptor(7, {})); fact_manager.AddFactDataSynonym(MakeDataDescriptor(16, {}), MakeDataDescriptor(14, {})); fact_manager.AddFactIdEquation(14, spv::Op::OpLogicalNot, {7}); fact_manager.AddFactIdEquation(17, spv::Op::OpLogicalNot, {16}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(15, {}), MakeDataDescriptor(7, {}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(17, {}), MakeDataDescriptor(7, {}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(15, {}), MakeDataDescriptor(17, {}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(16, {}), MakeDataDescriptor(14, {}))); } TEST(DataSynonymAndIdEquationFactsTest, SignedNegateEquationFacts) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpConstant %6 24 %12 = OpFunction %2 None %3 %13 = OpLabel %14 = OpSNegate %6 %7 %15 = OpSNegate %6 %14 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); fact_manager.AddFactIdEquation(14, spv::Op::OpSNegate, {7}); fact_manager.AddFactIdEquation(15, spv::Op::OpSNegate, {14}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(7, {}), MakeDataDescriptor(15, {}))); } TEST(DataSynonymAndIdEquationFactsTest, AddSubNegateFacts1) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %15 = OpConstant %6 24 %16 = OpConstant %6 37 %12 = OpFunction %2 None %3 %13 = OpLabel %14 = OpIAdd %6 %15 %16 %17 = OpCopyObject %6 %15 %18 = OpCopyObject %6 %16 %19 = OpISub %6 %14 %18 ; ==> synonymous(%19, %15) %20 = OpISub %6 %14 %17 ; ==> synonymous(%20, %16) %21 = OpCopyObject %6 %14 %22 = OpISub %6 %16 %21 %23 = OpCopyObject %6 %22 %24 = OpSNegate %6 %23 ; ==> synonymous(%24, %15) OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); fact_manager.AddFactIdEquation(14, spv::Op::OpIAdd, {15, 16}); fact_manager.AddFactDataSynonym(MakeDataDescriptor(17, {}), MakeDataDescriptor(15, {})); fact_manager.AddFactDataSynonym(MakeDataDescriptor(18, {}), MakeDataDescriptor(16, {})); fact_manager.AddFactIdEquation(19, spv::Op::OpISub, {14, 18}); fact_manager.AddFactIdEquation(20, spv::Op::OpISub, {14, 17}); fact_manager.AddFactDataSynonym(MakeDataDescriptor(21, {}), MakeDataDescriptor(14, {})); fact_manager.AddFactIdEquation(22, spv::Op::OpISub, {16, 21}); fact_manager.AddFactDataSynonym(MakeDataDescriptor(23, {}), MakeDataDescriptor(22, {})); fact_manager.AddFactIdEquation(24, spv::Op::OpSNegate, {23}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(19, {}), MakeDataDescriptor(15, {}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(20, {}), MakeDataDescriptor(16, {}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(24, {}), MakeDataDescriptor(15, {}))); } TEST(DataSynonymAndIdEquationFactsTest, AddSubNegateFacts2) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %15 = OpConstant %6 24 %16 = OpConstant %6 37 %12 = OpFunction %2 None %3 %13 = OpLabel %14 = OpISub %6 %15 %16 %17 = OpIAdd %6 %14 %16 ; ==> synonymous(%17, %15) %18 = OpIAdd %6 %16 %14 ; ==> synonymous(%17, %18, %15) %19 = OpISub %6 %14 %15 %20 = OpSNegate %6 %19 ; ==> synonymous(%20, %16) %21 = OpISub %6 %14 %19 ; ==> synonymous(%21, %15) %22 = OpISub %6 %14 %18 %23 = OpSNegate %6 %22 ; ==> synonymous(%23, %16) OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); fact_manager.AddFactIdEquation(14, spv::Op::OpISub, {15, 16}); fact_manager.AddFactIdEquation(17, spv::Op::OpIAdd, {14, 16}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(17, {}), MakeDataDescriptor(15, {}))); fact_manager.AddFactIdEquation(18, spv::Op::OpIAdd, {16, 14}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(18, {}), MakeDataDescriptor(15, {}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(17, {}), MakeDataDescriptor(18, {}))); fact_manager.AddFactIdEquation(19, spv::Op::OpISub, {14, 15}); fact_manager.AddFactIdEquation(20, spv::Op::OpSNegate, {19}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(20, {}), MakeDataDescriptor(16, {}))); fact_manager.AddFactIdEquation(21, spv::Op::OpISub, {14, 19}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(21, {}), MakeDataDescriptor(15, {}))); fact_manager.AddFactIdEquation(22, spv::Op::OpISub, {14, 18}); fact_manager.AddFactIdEquation(23, spv::Op::OpSNegate, {22}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(23, {}), MakeDataDescriptor(16, {}))); } TEST(DataSynonymAndIdEquationFactsTest, ConversionEquations) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 1 %5 = OpTypeInt 32 0 %6 = OpTypeFloat 32 %14 = OpTypeVector %4 2 %15 = OpTypeVector %5 2 %24 = OpTypeVector %6 2 %16 = OpConstant %4 32 ; synonym of %17 %17 = OpConstant %4 32 %18 = OpConstant %5 32 ; synonym of %19 %19 = OpConstant %5 32 %20 = OpConstantComposite %14 %16 %16 ; synonym of %21 %21 = OpConstantComposite %14 %17 %17 %22 = OpConstantComposite %15 %18 %18 ; synonym of %23 %23 = OpConstantComposite %15 %19 %19 %12 = OpFunction %2 None %3 %13 = OpLabel %25 = OpConvertUToF %6 %16 ; synonym of %26 %26 = OpConvertUToF %6 %17 %27 = OpConvertSToF %24 %20 ; not a synonym of %28 (wrong opcode) %28 = OpConvertUToF %24 %21 %29 = OpConvertSToF %6 %18 ; not a synonym of %30 (wrong opcode) %30 = OpConvertUToF %6 %19 %31 = OpConvertSToF %24 %22 ; synonym of %32 %32 = OpConvertSToF %24 %23 %33 = OpConvertUToF %6 %17 ; synonym of %26 %34 = OpConvertSToF %24 %23 ; synonym of %32 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); fact_manager.AddFactDataSynonym(MakeDataDescriptor(16, {}), MakeDataDescriptor(17, {})); fact_manager.AddFactDataSynonym(MakeDataDescriptor(18, {}), MakeDataDescriptor(19, {})); fact_manager.AddFactDataSynonym(MakeDataDescriptor(20, {}), MakeDataDescriptor(21, {})); fact_manager.AddFactDataSynonym(MakeDataDescriptor(22, {}), MakeDataDescriptor(23, {})); fact_manager.AddFactIdEquation(25, spv::Op::OpConvertUToF, {16}); fact_manager.AddFactIdEquation(26, spv::Op::OpConvertUToF, {17}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(25, {}), MakeDataDescriptor(26, {}))); fact_manager.AddFactIdEquation(27, spv::Op::OpConvertSToF, {20}); fact_manager.AddFactIdEquation(28, spv::Op::OpConvertUToF, {21}); ASSERT_FALSE(fact_manager.IsSynonymous(MakeDataDescriptor(27, {}), MakeDataDescriptor(28, {}))); fact_manager.AddFactIdEquation(29, spv::Op::OpConvertSToF, {18}); fact_manager.AddFactIdEquation(30, spv::Op::OpConvertUToF, {19}); ASSERT_FALSE(fact_manager.IsSynonymous(MakeDataDescriptor(29, {}), MakeDataDescriptor(30, {}))); fact_manager.AddFactIdEquation(31, spv::Op::OpConvertSToF, {22}); fact_manager.AddFactIdEquation(32, spv::Op::OpConvertSToF, {23}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(31, {}), MakeDataDescriptor(32, {}))); fact_manager.AddFactIdEquation(33, spv::Op::OpConvertUToF, {17}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(33, {}), MakeDataDescriptor(26, {}))); fact_manager.AddFactIdEquation(34, spv::Op::OpConvertSToF, {23}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(32, {}), MakeDataDescriptor(34, {}))); } TEST(DataSynonymAndIdEquationFactsTest, BitcastEquationFacts) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpTypeInt 32 1 %5 = OpTypeInt 32 0 %8 = OpTypeFloat 32 %9 = OpTypeVector %4 2 %10 = OpTypeVector %5 2 %11 = OpTypeVector %8 2 %6 = OpConstant %4 23 %7 = OpConstant %5 23 %19 = OpConstant %8 23 %20 = OpConstantComposite %9 %6 %6 %21 = OpConstantComposite %10 %7 %7 %22 = OpConstantComposite %11 %19 %19 %12 = OpFunction %2 None %3 %13 = OpLabel %30 = OpBitcast %8 %6 %31 = OpBitcast %5 %6 %32 = OpBitcast %8 %7 %33 = OpBitcast %4 %7 %34 = OpBitcast %4 %19 %35 = OpBitcast %5 %19 %36 = OpBitcast %10 %20 %37 = OpBitcast %11 %20 %38 = OpBitcast %9 %21 %39 = OpBitcast %11 %21 %40 = OpBitcast %9 %22 %41 = OpBitcast %10 %22 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); uint32_t lhs_id = 30; for (uint32_t rhs_id : {6, 6, 7, 7, 19, 19, 20, 20, 21, 21, 22, 22}) { fact_manager.AddFactIdEquation(lhs_id, spv::Op::OpBitcast, {rhs_id}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(lhs_id, {}), MakeDataDescriptor(rhs_id, {}))); ++lhs_id; } } TEST(DataSynonymAndIdEquationFactsTest, EquationAndEquivalenceFacts) { std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %12 "main" OpExecutionMode %12 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %15 = OpConstant %6 24 %16 = OpConstant %6 37 %12 = OpFunction %2 None %3 %13 = OpLabel %14 = OpISub %6 %15 %16 %114 = OpCopyObject %6 %14 %17 = OpIAdd %6 %114 %16 ; ==> synonymous(%17, %15) %18 = OpIAdd %6 %16 %114 ; ==> synonymous(%17, %18, %15) %19 = OpISub %6 %114 %15 %119 = OpCopyObject %6 %19 %20 = OpSNegate %6 %119 ; ==> synonymous(%20, %16) %21 = OpISub %6 %14 %19 ; ==> synonymous(%21, %15) %22 = OpISub %6 %14 %18 %220 = OpCopyObject %6 %22 %23 = OpSNegate %6 %220 ; ==> synonymous(%23, %16) OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption); spvtools::ValidatorOptions validator_options; ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options, kConsoleMessageConsumer)); FactManager fact_manager(context.get()); fact_manager.AddFactIdEquation(14, spv::Op::OpISub, {15, 16}); fact_manager.AddFactDataSynonym(MakeDataDescriptor(114, {}), MakeDataDescriptor(14, {})); fact_manager.AddFactIdEquation(17, spv::Op::OpIAdd, {114, 16}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(17, {}), MakeDataDescriptor(15, {}))); fact_manager.AddFactIdEquation(18, spv::Op::OpIAdd, {16, 114}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(18, {}), MakeDataDescriptor(15, {}))); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(17, {}), MakeDataDescriptor(18, {}))); fact_manager.AddFactIdEquation(19, spv::Op::OpISub, {14, 15}); fact_manager.AddFactDataSynonym(MakeDataDescriptor(119, {}), MakeDataDescriptor(19, {})); fact_manager.AddFactIdEquation(20, spv::Op::OpSNegate, {119}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(20, {}), MakeDataDescriptor(16, {}))); fact_manager.AddFactIdEquation(21, spv::Op::OpISub, {14, 19}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(21, {}), MakeDataDescriptor(15, {}))); fact_manager.AddFactIdEquation(22, spv::Op::OpISub, {14, 18}); fact_manager.AddFactDataSynonym(MakeDataDescriptor(22, {}), MakeDataDescriptor(220, {})); fact_manager.AddFactIdEquation(23, spv::Op::OpSNegate, {220}); ASSERT_TRUE(fact_manager.IsSynonymous(MakeDataDescriptor(23, {}), MakeDataDescriptor(16, {}))); } } // namespace } // namespace fuzz } // namespace spvtools