// 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/fuzzer_pass_donate_modules.h" #include #include "gtest/gtest.h" #include "source/fuzz/pseudo_random_generator.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { TEST(FuzzerPassDonateModulesTest, BasicDonation) { std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %10 "m" OpName %16 "v" OpDecorate %16 RelaxedPrecision OpDecorate %20 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 3 %8 = OpTypeMatrix %7 2 %9 = OpTypePointer Private %8 %10 = OpVariable %9 Private %11 = OpTypeInt 32 1 %12 = OpConstant %11 0 %13 = OpTypeInt 32 0 %14 = OpTypeVector %13 4 %15 = OpTypePointer Private %14 %16 = OpVariable %15 Private %17 = OpConstant %13 2 %18 = OpTypePointer Private %13 %22 = OpConstant %13 0 %23 = OpTypePointer Private %6 %4 = OpFunction %2 None %3 %5 = OpLabel %19 = OpAccessChain %18 %16 %17 %20 = OpLoad %13 %19 %21 = OpConvertUToF %6 %20 %24 = OpAccessChain %23 %10 %12 %22 OpStore %24 %21 OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %12 "bar(mf24;" OpName %11 "m" OpName %20 "foo(vu4;" OpName %19 "v" OpName %23 "x" OpName %26 "param" OpName %29 "result" OpName %31 "i" OpName %81 "param" %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypeMatrix %7 2 %9 = OpTypePointer Function %8 %10 = OpTypeFunction %6 %9 %14 = OpTypeInt 32 0 %15 = OpTypeVector %14 4 %16 = OpTypePointer Function %15 %17 = OpTypeInt 32 1 %18 = OpTypeFunction %17 %16 %22 = OpTypePointer Function %17 %24 = OpConstant %14 2 %25 = OpConstantComposite %15 %24 %24 %24 %24 %28 = OpTypePointer Function %6 %30 = OpConstant %6 0 %32 = OpConstant %17 0 %39 = OpConstant %17 10 %40 = OpTypeBool %43 = OpConstant %17 3 %50 = OpConstant %17 1 %55 = OpConstant %14 0 %56 = OpTypePointer Function %14 %59 = OpConstant %14 1 %65 = OpConstant %17 2 %68 = OpConstant %6 1 %69 = OpConstant %6 2 %70 = OpConstant %6 3 %71 = OpConstant %6 4 %72 = OpConstant %14 3 %76 = OpConstant %6 6 %77 = OpConstant %6 7 %4 = OpFunction %2 None %3 %5 = OpLabel %23 = OpVariable %22 Function %26 = OpVariable %16 Function OpStore %26 %25 %27 = OpFunctionCall %17 %20 %26 OpStore %23 %27 OpReturn OpFunctionEnd %12 = OpFunction %6 None %10 %11 = OpFunctionParameter %9 %13 = OpLabel %29 = OpVariable %28 Function %31 = OpVariable %22 Function OpStore %29 %30 OpStore %31 %32 OpBranch %33 %33 = OpLabel OpLoopMerge %35 %36 None OpBranch %37 %37 = OpLabel %38 = OpLoad %17 %31 %41 = OpSLessThan %40 %38 %39 OpBranchConditional %41 %34 %35 %34 = OpLabel %42 = OpLoad %17 %31 %44 = OpExtInst %17 %1 SClamp %42 %32 %43 %45 = OpAccessChain %28 %11 %32 %44 %46 = OpLoad %6 %45 %47 = OpLoad %6 %29 %48 = OpFAdd %6 %47 %46 OpStore %29 %48 OpBranch %36 %36 = OpLabel %49 = OpLoad %17 %31 %51 = OpIAdd %17 %49 %50 OpStore %31 %51 OpBranch %33 %35 = OpLabel %52 = OpLoad %6 %29 OpReturnValue %52 OpFunctionEnd %20 = OpFunction %17 None %18 %19 = OpFunctionParameter %16 %21 = OpLabel %81 = OpVariable %9 Function %57 = OpAccessChain %56 %19 %55 %58 = OpLoad %14 %57 %60 = OpAccessChain %56 %19 %59 %61 = OpLoad %14 %60 %62 = OpUGreaterThan %40 %58 %61 OpSelectionMerge %64 None OpBranchConditional %62 %63 %67 %63 = OpLabel OpReturnValue %65 %67 = OpLabel %73 = OpAccessChain %56 %19 %72 %74 = OpLoad %14 %73 %75 = OpConvertUToF %6 %74 %78 = OpCompositeConstruct %7 %30 %68 %69 %70 %79 = OpCompositeConstruct %7 %71 %75 %76 %77 %80 = OpCompositeConstruct %8 %78 %79 OpStore %81 %80 %82 = OpFunctionCall %6 %12 %81 %83 = OpConvertFToS %17 %82 OpReturnValue %83 %64 = OpLabel %85 = OpUndef %17 OpReturnValue %85 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonationWithUniforms) { // This test checks that when donating a shader that contains uniforms, // uniform variables and associated pointer types are demoted from having // Uniform storage class to Private storage class. std::string recipient_and_donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 0 OpMemberDecorate %19 0 Offset 0 OpDecorate %19 Block OpDecorate %21 DescriptorSet 0 OpDecorate %21 Binding 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpTypeStruct %6 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpTypeInt 32 1 %13 = OpConstant %12 0 %14 = OpTypePointer Uniform %6 %17 = OpTypePointer Function %12 %19 = OpTypeStruct %12 %20 = OpTypePointer Uniform %19 %21 = OpVariable %20 Uniform %22 = OpTypePointer Uniform %12 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %18 = OpVariable %17 Function %15 = OpAccessChain %14 %11 %13 %16 = OpLoad %6 %15 OpStore %8 %16 %23 = OpAccessChain %22 %21 %13 %24 = OpLoad %12 %23 OpStore %18 %24 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule( env, consumer, recipient_and_donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule( env, consumer, recipient_and_donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 Block OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 0 OpMemberDecorate %19 0 Offset 0 OpDecorate %19 Block OpDecorate %21 DescriptorSet 0 OpDecorate %21 Binding 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %9 = OpTypeStruct %6 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpTypeInt 32 1 %13 = OpConstant %12 0 %14 = OpTypePointer Uniform %6 %17 = OpTypePointer Function %12 %19 = OpTypeStruct %12 %20 = OpTypePointer Uniform %19 %21 = OpVariable %20 Uniform %22 = OpTypePointer Uniform %12 %100 = OpTypePointer Function %6 %101 = OpTypeStruct %6 %102 = OpTypePointer Private %101 %104 = OpConstant %6 0 %105 = OpConstantComposite %101 %104 %103 = OpVariable %102 Private %105 %106 = OpConstant %12 0 %107 = OpTypePointer Private %6 %108 = OpTypePointer Function %12 %109 = OpTypeStruct %12 %110 = OpTypePointer Private %109 %112 = OpConstantComposite %109 %13 %111 = OpVariable %110 Private %112 %113 = OpTypePointer Private %12 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %18 = OpVariable %17 Function %15 = OpAccessChain %14 %11 %13 %16 = OpLoad %6 %15 OpStore %8 %16 %23 = OpAccessChain %22 %21 %13 %24 = OpLoad %12 %23 OpStore %18 %24 OpReturn OpFunctionEnd %114 = OpFunction %2 None %3 %115 = OpLabel %116 = OpVariable %100 Function %104 %117 = OpVariable %108 Function %13 %118 = OpAccessChain %107 %103 %106 %119 = OpLoad %6 %118 OpStore %116 %119 %120 = OpAccessChain %113 %111 %106 %121 = OpLoad %12 %120 OpStore %117 %121 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, recipient_context.get())); } TEST(FuzzerPassDonateModulesTest, DonationWithInputAndOutputVariables) { // This test checks that when donating a shader that contains input and output // variables, such variables and associated pointer types are demoted to have // the Private storage class. std::string recipient_and_donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %9 Location 0 OpDecorate %11 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %7 %11 = OpVariable %10 Input %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %7 %11 OpStore %9 %12 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule( env, consumer, recipient_and_donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule( env, consumer, recipient_and_donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %9 %11 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpDecorate %9 Location 0 OpDecorate %11 Location 1 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeVector %6 4 %8 = OpTypePointer Output %7 %9 = OpVariable %8 Output %10 = OpTypePointer Input %7 %11 = OpVariable %10 Input %100 = OpTypePointer Private %7 %102 = OpConstant %6 0 %103 = OpConstantComposite %7 %102 %102 %102 %102 %101 = OpVariable %100 Private %103 %104 = OpTypePointer Private %7 %105 = OpVariable %104 Private %103 %4 = OpFunction %2 None %3 %5 = OpLabel %12 = OpLoad %7 %11 OpStore %9 %12 OpReturn OpFunctionEnd %106 = OpFunction %2 None %3 %107 = OpLabel %108 = OpLoad %7 %105 OpStore %101 %108 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, recipient_context.get())); } TEST(FuzzerPassDonateModulesTest, DonateFunctionTypeWithDifferentPointers) { std::string recipient_and_donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %8 = OpTypeFunction %2 %7 %4 = OpFunction %2 None %3 %5 = OpLabel %9 = OpVariable %7 Function %10 = OpFunctionCall %2 %11 %9 OpReturn OpFunctionEnd %11 = OpFunction %2 None %8 %12 = OpFunctionParameter %7 %13 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule( env, consumer, recipient_and_donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule( env, consumer, recipient_and_donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateOpConstantNull) { std::string recipient_shader = R"( OpCapability Shader OpCapability ImageQuery OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader OpCapability ImageQuery OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Private %6 %8 = OpConstantNull %7 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateCodeThatUsesImages) { std::string recipient_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" OpName %4 "main" OpName %10 "mySampler" OpName %21 "myTexture" OpName %33 "v" OpDecorate %10 RelaxedPrecision OpDecorate %10 DescriptorSet 0 OpDecorate %10 Binding 0 OpDecorate %11 RelaxedPrecision OpDecorate %21 RelaxedPrecision OpDecorate %21 DescriptorSet 0 OpDecorate %21 Binding 1 OpDecorate %22 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeImage %6 2D 0 0 0 1 Unknown %8 = OpTypeSampledImage %7 %9 = OpTypePointer UniformConstant %8 %10 = OpVariable %9 UniformConstant %12 = OpTypeInt 32 1 %13 = OpConstant %12 2 %15 = OpTypeVector %12 2 %17 = OpTypeInt 32 0 %18 = OpConstant %17 0 %20 = OpTypePointer UniformConstant %7 %21 = OpVariable %20 UniformConstant %23 = OpConstant %12 1 %25 = OpConstant %17 1 %27 = OpTypeBool %31 = OpTypeVector %6 4 %32 = OpTypePointer Function %31 %35 = OpConstantComposite %15 %23 %23 %36 = OpConstant %12 3 %37 = OpConstant %12 4 %38 = OpConstantComposite %15 %36 %37 %4 = OpFunction %2 None %3 %5 = OpLabel %33 = OpVariable %32 Function %11 = OpLoad %8 %10 %14 = OpImage %7 %11 %16 = OpImageQuerySizeLod %15 %14 %13 %19 = OpCompositeExtract %12 %16 0 %22 = OpLoad %7 %21 %24 = OpImageQuerySizeLod %15 %22 %23 %26 = OpCompositeExtract %12 %24 1 %28 = OpSGreaterThan %27 %19 %26 OpSelectionMerge %30 None OpBranchConditional %28 %29 %41 %29 = OpLabel %34 = OpLoad %8 %10 %39 = OpImage %7 %34 %40 = OpImageFetch %31 %39 %35 Lod|ConstOffset %13 %38 OpStore %33 %40 OpBranch %30 %41 = OpLabel %42 = OpLoad %7 %21 %43 = OpImageFetch %31 %42 %35 Lod|ConstOffset %13 %38 OpStore %33 %43 OpBranch %30 %30 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateCodeThatUsesSampler) { std::string recipient_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpDecorate %16 DescriptorSet 0 OpDecorate %16 Binding 0 OpDecorate %12 DescriptorSet 0 OpDecorate %12 Binding 64 %2 = OpTypeVoid %3 = OpTypeFunction %2 %23 = OpTypeFloat 32 %6 = OpTypeImage %23 2D 2 0 0 1 Unknown %47 = OpTypePointer UniformConstant %6 %12 = OpVariable %47 UniformConstant %15 = OpTypeSampler %55 = OpTypePointer UniformConstant %15 %17 = OpTypeSampledImage %6 %16 = OpVariable %55 UniformConstant %37 = OpTypeVector %23 4 %109 = OpConstant %23 0 %66 = OpConstantComposite %37 %109 %109 %109 %109 %56 = OpTypeBool %54 = OpConstantTrue %56 %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %50 %50 = OpLabel %51 = OpPhi %37 %66 %5 %111 %53 OpLoopMerge %52 %53 None OpBranchConditional %54 %53 %52 %53 = OpLabel %106 = OpLoad %6 %12 %107 = OpLoad %15 %16 %110 = OpSampledImage %17 %106 %107 %111 = OpImageSampleImplicitLod %37 %110 %66 Bias %109 OpBranch %50 %52 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateCodeThatUsesImageStructField) { std::string recipient_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" OpName %4 "main" OpName %10 "mySampler" OpName %21 "myTexture" OpName %33 "v" OpDecorate %10 RelaxedPrecision OpDecorate %10 DescriptorSet 0 OpDecorate %10 Binding 0 OpDecorate %11 RelaxedPrecision OpDecorate %21 RelaxedPrecision OpDecorate %21 DescriptorSet 0 OpDecorate %21 Binding 1 OpDecorate %22 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeImage %6 2D 0 0 0 1 Unknown %8 = OpTypeSampledImage %7 %9 = OpTypePointer UniformConstant %8 %10 = OpVariable %9 UniformConstant %12 = OpTypeInt 32 1 %13 = OpConstant %12 2 %15 = OpTypeVector %12 2 %17 = OpTypeInt 32 0 %18 = OpConstant %17 0 %20 = OpTypePointer UniformConstant %7 %21 = OpVariable %20 UniformConstant %23 = OpConstant %12 1 %25 = OpConstant %17 1 %27 = OpTypeBool %31 = OpTypeVector %6 4 %32 = OpTypePointer Function %31 %35 = OpConstantComposite %15 %23 %23 %36 = OpConstant %12 3 %37 = OpConstant %12 4 %38 = OpConstantComposite %15 %36 %37 %201 = OpTypeStruct %7 %7 %4 = OpFunction %2 None %3 %5 = OpLabel %33 = OpVariable %32 Function %11 = OpLoad %8 %10 %14 = OpImage %7 %11 %22 = OpLoad %7 %21 %200 = OpCompositeConstruct %201 %14 %22 %202 = OpCompositeExtract %7 %200 0 %203 = OpCompositeExtract %7 %200 1 %24 = OpImageQuerySizeLod %15 %203 %23 %16 = OpImageQuerySizeLod %15 %202 %13 %26 = OpCompositeExtract %12 %24 1 %19 = OpCompositeExtract %12 %16 0 %28 = OpSGreaterThan %27 %19 %26 OpSelectionMerge %30 None OpBranchConditional %28 %29 %41 %29 = OpLabel %34 = OpLoad %8 %10 %39 = OpImage %7 %34 %40 = OpImageFetch %31 %39 %35 Lod|ConstOffset %13 %38 OpStore %33 %40 OpBranch %30 %41 = OpLabel %42 = OpLoad %7 %21 %43 = OpImageFetch %31 %42 %35 Lod|ConstOffset %13 %38 OpStore %33 %43 OpBranch %30 %30 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateCodeThatUsesImageFunctionParameter) { std::string recipient_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" OpName %4 "main" OpName %10 "mySampler" OpName %21 "myTexture" OpName %33 "v" OpDecorate %10 RelaxedPrecision OpDecorate %10 DescriptorSet 0 OpDecorate %10 Binding 0 OpDecorate %11 RelaxedPrecision OpDecorate %21 RelaxedPrecision OpDecorate %21 DescriptorSet 0 OpDecorate %21 Binding 1 OpDecorate %22 RelaxedPrecision OpDecorate %34 RelaxedPrecision OpDecorate %40 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %43 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypeImage %6 2D 0 0 0 1 Unknown %8 = OpTypeSampledImage %7 %9 = OpTypePointer UniformConstant %8 %10 = OpVariable %9 UniformConstant %12 = OpTypeInt 32 1 %13 = OpConstant %12 2 %15 = OpTypeVector %12 2 %17 = OpTypeInt 32 0 %18 = OpConstant %17 0 %20 = OpTypePointer UniformConstant %7 %21 = OpVariable %20 UniformConstant %23 = OpConstant %12 1 %25 = OpConstant %17 1 %27 = OpTypeBool %31 = OpTypeVector %6 4 %32 = OpTypePointer Function %31 %35 = OpConstantComposite %15 %23 %23 %36 = OpConstant %12 3 %37 = OpConstant %12 4 %38 = OpConstantComposite %15 %36 %37 %201 = OpTypeFunction %15 %7 %12 %4 = OpFunction %2 None %3 %5 = OpLabel %33 = OpVariable %32 Function %11 = OpLoad %8 %10 %14 = OpImage %7 %11 %16 = OpFunctionCall %15 %200 %14 %13 %19 = OpCompositeExtract %12 %16 0 %22 = OpLoad %7 %21 %24 = OpImageQuerySizeLod %15 %22 %23 %26 = OpCompositeExtract %12 %24 1 %28 = OpSGreaterThan %27 %19 %26 OpSelectionMerge %30 None OpBranchConditional %28 %29 %41 %29 = OpLabel %34 = OpLoad %8 %10 %39 = OpImage %7 %34 %40 = OpImageFetch %31 %39 %35 Lod|ConstOffset %13 %38 OpStore %33 %40 OpBranch %30 %41 = OpLabel %42 = OpLoad %7 %21 %43 = OpImageFetch %31 %42 %35 Lod|ConstOffset %13 %38 OpStore %33 %43 OpBranch %30 %30 = OpLabel OpReturn OpFunctionEnd %200 = OpFunction %15 None %201 %202 = OpFunctionParameter %7 %203 = OpFunctionParameter %12 %204 = OpLabel %205 = OpImageQuerySizeLod %15 %202 %203 OpReturnValue %205 OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateShaderWithImageStorageClass) { std::string recipient_shader = R"( OpCapability Shader OpCapability ImageQuery %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 320 OpSourceExtension "GL_EXT_samplerless_texture_functions" %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader OpCapability SampledBuffer OpCapability ImageBuffer %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %2 "MainPSPacked" OpExecutionMode %2 OriginUpperLeft OpDecorate %18 DescriptorSet 0 OpDecorate %18 Binding 128 %49 = OpTypeInt 32 0 %50 = OpTypeFloat 32 %58 = OpConstant %50 1 %66 = OpConstant %49 0 %87 = OpTypeVector %50 2 %88 = OpConstantComposite %87 %58 %58 %17 = OpTypeImage %49 2D 2 0 0 2 R32ui %118 = OpTypePointer UniformConstant %17 %123 = OpTypeVector %49 2 %132 = OpTypeVoid %133 = OpTypeFunction %132 %142 = OpTypePointer Image %49 %18 = OpVariable %118 UniformConstant %2 = OpFunction %132 None %133 %153 = OpLabel %495 = OpConvertFToU %123 %88 %501 = OpImageTexelPointer %142 %18 %495 %66 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), true); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateComputeShaderWithRuntimeArray) { std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpDecorate %9 ArrayStride 4 OpMemberDecorate %10 0 Offset 0 OpDecorate %10 BufferBlock OpDecorate %12 DescriptorSet 0 OpDecorate %12 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpTypeRuntimeArray %6 %10 = OpTypeStruct %9 %11 = OpTypePointer Uniform %10 %12 = OpVariable %11 Uniform %13 = OpTypeInt 32 0 %16 = OpConstant %6 0 %18 = OpConstant %6 1 %20 = OpTypePointer Uniform %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %14 = OpArrayLength %13 %12 0 %15 = OpBitcast %6 %14 OpStore %8 %15 %17 = OpLoad %6 %8 %19 = OpISub %6 %17 %18 %21 = OpAccessChain %20 %12 %16 %19 OpStore %21 %16 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateComputeShaderWithRuntimeArrayLivesafe) { std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpDecorate %16 ArrayStride 4 OpMemberDecorate %17 0 Offset 0 OpDecorate %17 BufferBlock OpDecorate %19 DescriptorSet 0 OpDecorate %19 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Function %6 %9 = OpConstant %6 0 %16 = OpTypeRuntimeArray %6 %17 = OpTypeStruct %16 %18 = OpTypePointer Uniform %17 %19 = OpVariable %18 Uniform %20 = OpTypeInt 32 0 %23 = OpTypeBool %26 = OpConstant %6 32 %27 = OpTypePointer Uniform %6 %30 = OpConstant %6 1 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpStore %8 %9 OpBranch %10 %10 = OpLabel OpLoopMerge %12 %13 None OpBranch %14 %14 = OpLabel %15 = OpLoad %6 %8 %21 = OpArrayLength %20 %19 0 %22 = OpBitcast %6 %21 %24 = OpSLessThan %23 %15 %22 OpBranchConditional %24 %11 %12 %11 = OpLabel %25 = OpLoad %6 %8 %28 = OpAccessChain %27 %19 %9 %25 OpStore %28 %26 OpBranch %13 %13 = OpLabel %29 = OpLoad %6 %8 %31 = OpIAdd %6 %29 %30 OpStore %8 %31 OpBranch %10 %12 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), true); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateComputeShaderWithWorkgroupVariables) { std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 1 %7 = OpTypePointer Workgroup %6 %8 = OpVariable %7 Workgroup %9 = OpConstant %6 2 %10 = OpVariable %7 Workgroup %4 = OpFunction %2 None %3 %5 = OpLabel OpStore %8 %9 %11 = OpLoad %6 %8 OpStore %10 %11 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), true); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, DonateComputeShaderWithAtomics) { std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %4 "main" OpExecutionMode %4 LocalSize 1 1 1 OpSource ESSL 310 OpMemberDecorate %9 0 Offset 0 OpDecorate %9 BufferBlock OpDecorate %11 DescriptorSet 0 OpDecorate %11 Binding 0 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeInt 32 0 %7 = OpTypePointer Function %6 %9 = OpTypeStruct %6 %10 = OpTypePointer Uniform %9 %11 = OpVariable %10 Uniform %12 = OpTypeInt 32 1 %13 = OpConstant %12 0 %14 = OpTypePointer Uniform %6 %16 = OpConstant %6 1 %17 = OpConstant %6 0 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function %15 = OpAccessChain %14 %11 %13 %18 = OpAtomicIAdd %6 %15 %16 %17 %16 OpStore %8 %18 %19 = OpAccessChain %14 %11 %13 %20 = OpLoad %6 %8 %21 = OpAtomicUMin %6 %19 %16 %17 %20 OpStore %8 %21 %22 = OpAccessChain %14 %11 %13 %23 = OpLoad %6 %8 %24 = OpAtomicUMax %6 %22 %16 %17 %23 OpStore %8 %24 %25 = OpAccessChain %14 %11 %13 %26 = OpLoad %6 %8 %27 = OpAtomicAnd %6 %25 %16 %17 %26 OpStore %8 %27 %28 = OpAccessChain %14 %11 %13 %29 = OpLoad %6 %8 %30 = OpAtomicOr %6 %28 %16 %17 %29 OpStore %8 %30 %31 = OpAccessChain %14 %11 %13 %32 = OpLoad %6 %8 %33 = OpAtomicXor %6 %31 %16 %17 %32 OpStore %8 %33 %34 = OpAccessChain %14 %11 %13 %35 = OpLoad %6 %8 %36 = OpAtomicExchange %6 %34 %16 %17 %35 OpStore %8 %36 %37 = OpAccessChain %14 %11 %13 %38 = OpLoad %6 %8 %39 = OpAtomicCompareExchange %6 %37 %16 %17 %17 %16 %38 OpStore %8 %39 OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), true); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, Miscellaneous1) { std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %6 "foo(" OpName %10 "x" OpName %12 "i" OpName %33 "i" OpName %42 "j" OpDecorate %10 RelaxedPrecision OpDecorate %12 RelaxedPrecision OpDecorate %19 RelaxedPrecision OpDecorate %23 RelaxedPrecision OpDecorate %24 RelaxedPrecision OpDecorate %25 RelaxedPrecision OpDecorate %26 RelaxedPrecision OpDecorate %27 RelaxedPrecision OpDecorate %28 RelaxedPrecision OpDecorate %30 RelaxedPrecision OpDecorate %33 RelaxedPrecision OpDecorate %39 RelaxedPrecision OpDecorate %42 RelaxedPrecision OpDecorate %49 RelaxedPrecision OpDecorate %52 RelaxedPrecision OpDecorate %53 RelaxedPrecision OpDecorate %58 RelaxedPrecision OpDecorate %59 RelaxedPrecision OpDecorate %60 RelaxedPrecision OpDecorate %63 RelaxedPrecision OpDecorate %64 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %8 = OpTypeInt 32 1 %9 = OpTypePointer Function %8 %11 = OpConstant %8 2 %13 = OpConstant %8 0 %20 = OpConstant %8 100 %21 = OpTypeBool %29 = OpConstant %8 1 %40 = OpConstant %8 10 %43 = OpConstant %8 20 %61 = OpConstant %8 4 %4 = OpFunction %2 None %3 %5 = OpLabel %33 = OpVariable %9 Function %42 = OpVariable %9 Function %32 = OpFunctionCall %2 %6 OpStore %33 %13 OpBranch %34 %34 = OpLabel OpLoopMerge %36 %37 None OpBranch %38 %38 = OpLabel %39 = OpLoad %8 %33 %41 = OpSLessThan %21 %39 %40 OpBranchConditional %41 %35 %36 %35 = OpLabel OpStore %42 %43 OpBranch %44 %44 = OpLabel OpLoopMerge %46 %47 None OpBranch %48 %48 = OpLabel %49 = OpLoad %8 %42 %50 = OpSGreaterThan %21 %49 %13 OpBranchConditional %50 %45 %46 %45 = OpLabel %51 = OpFunctionCall %2 %6 %52 = OpLoad %8 %42 %53 = OpISub %8 %52 %29 OpStore %42 %53 OpBranch %47 %47 = OpLabel OpBranch %44 %46 = OpLabel OpBranch %54 %54 = OpLabel OpLoopMerge %56 %57 None OpBranch %55 %55 = OpLabel %58 = OpLoad %8 %33 %59 = OpIAdd %8 %58 %29 OpStore %33 %59 OpBranch %57 %57 = OpLabel %60 = OpLoad %8 %33 %62 = OpSLessThan %21 %60 %61 OpBranchConditional %62 %54 %56 %56 = OpLabel OpBranch %37 %37 = OpLabel %63 = OpLoad %8 %33 %64 = OpIAdd %8 %63 %29 OpStore %33 %64 OpBranch %34 %36 = OpLabel OpReturn OpFunctionEnd %6 = OpFunction %2 None %3 %7 = OpLabel %10 = OpVariable %9 Function %12 = OpVariable %9 Function OpStore %10 %11 OpStore %12 %13 OpBranch %14 %14 = OpLabel OpLoopMerge %16 %17 None OpBranch %18 %18 = OpLabel %19 = OpLoad %8 %12 %22 = OpSLessThan %21 %19 %20 OpBranchConditional %22 %15 %16 %15 = OpLabel %23 = OpLoad %8 %12 %24 = OpLoad %8 %10 %25 = OpIAdd %8 %24 %23 OpStore %10 %25 %26 = OpLoad %8 %10 %27 = OpIMul %8 %26 %11 OpStore %10 %27 OpBranch %17 %17 = OpLabel %28 = OpLoad %8 %12 %30 = OpIAdd %8 %28 %29 OpStore %12 %30 OpBranch %14 %16 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_5; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, OpSpecConstantInstructions) { std::string donor_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeBool %7 = OpTypeInt 32 1 %8 = OpTypeStruct %6 %6 %7 %9 = OpSpecConstantTrue %6 %10 = OpSpecConstantFalse %6 %11 = OpSpecConstant %7 2 %12 = OpSpecConstantComposite %8 %9 %10 %11 %13 = OpSpecConstantOp %6 LogicalEqual %9 %10 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // Check that the module is valid first. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); std::string expected_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %100 = OpTypeBool %101 = OpTypeInt 32 1 %102 = OpTypeStruct %100 %100 %101 %103 = OpConstantTrue %100 %104 = OpConstantFalse %100 %105 = OpConstant %101 2 %106 = OpConstantComposite %102 %103 %104 %105 %107 = OpSpecConstantOp %100 LogicalEqual %103 %104 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %108 = OpFunction %2 None %3 %109 = OpLabel OpReturn OpFunctionEnd )"; // Now check that the transformation has produced the expected result. ASSERT_TRUE(IsEqual(env, expected_shader, recipient_context.get())); } TEST(FuzzerPassDonateModulesTest, DonationSupportsOpTypeRuntimeArray) { std::string donor_shader = R"( OpCapability Shader OpExtension "SPV_KHR_storage_buffer_storage_class" OpMemoryModel Logical GLSL450 OpEntryPoint GLCompute %29 "kernel_1" OpEntryPoint GLCompute %37 "kernel_2" OpSource OpenCL_C 120 OpDecorate %2 ArrayStride 4 OpMemberDecorate %3 0 Offset 0 OpDecorate %3 Block OpMemberDecorate %5 0 Offset 0 OpMemberDecorate %6 0 Offset 0 OpDecorate %6 Block OpDecorate %21 BuiltIn WorkgroupSize OpDecorate %23 DescriptorSet 0 OpDecorate %23 Binding 0 OpDecorate %25 SpecId 3 OpDecorate %18 SpecId 0 OpDecorate %19 SpecId 1 OpDecorate %20 SpecId 2 %1 = OpTypeInt 32 0 %2 = OpTypeRuntimeArray %1 %3 = OpTypeStruct %2 %4 = OpTypePointer StorageBuffer %3 %5 = OpTypeStruct %1 %6 = OpTypeStruct %5 %7 = OpTypePointer PushConstant %6 %8 = OpTypeFloat 32 %9 = OpTypeVoid %10 = OpTypeFunction %9 %11 = OpTypePointer Workgroup %1 %12 = OpTypePointer PushConstant %5 %13 = OpTypePointer StorageBuffer %1 %14 = OpTypeFunction %1 %1 %15 = OpTypeVector %1 3 %16 = OpTypePointer Private %15 %17 = OpConstant %1 0 %18 = OpSpecConstant %1 1 %19 = OpSpecConstant %1 1 %20 = OpSpecConstant %1 1 %21 = OpSpecConstantComposite %15 %18 %19 %20 %25 = OpSpecConstant %1 1 %26 = OpTypeArray %1 %25 %27 = OpTypePointer Workgroup %26 %22 = OpVariable %16 Private %21 %23 = OpVariable %4 StorageBuffer %24 = OpVariable %7 PushConstant %28 = OpVariable %27 Workgroup %29 = OpFunction %9 None %10 %30 = OpLabel %31 = OpAccessChain %11 %28 %17 %32 = OpAccessChain %12 %24 %17 %33 = OpLoad %5 %32 %34 = OpCompositeExtract %1 %33 0 %35 = OpFunctionCall %1 %45 %34 %36 = OpAccessChain %13 %23 %17 %34 OpStore %36 %35 OpReturn OpFunctionEnd %37 = OpFunction %9 None %10 %38 = OpLabel %39 = OpAccessChain %11 %28 %17 %40 = OpAccessChain %12 %24 %17 %41 = OpLoad %5 %40 %42 = OpCompositeExtract %1 %41 0 %43 = OpFunctionCall %1 %45 %42 %44 = OpAccessChain %13 %23 %17 %42 OpStore %44 %43 OpReturn OpFunctionEnd %45 = OpFunction %1 Pure %14 %46 = OpFunctionParameter %1 %47 = OpLabel %48 = OpAccessChain %11 %28 %46 %49 = OpLoad %1 %48 OpReturnValue %49 OpFunctionEnd )"; std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_0; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), false); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } TEST(FuzzerPassDonateModulesTest, HandlesCapabilities) { std::string donor_shader = R"( OpCapability VariablePointersStorageBuffer %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %11 = OpConstant %6 23 %7 = OpTypePointer Function %6 %4 = OpFunction %2 None %3 %5 = OpLabel %8 = OpVariable %7 Function OpBranch %9 %9 = OpLabel %10 = OpPhi %7 %8 %5 OpStore %10 %11 OpReturn OpFunctionEnd )"; std::string recipient_shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); ASSERT_TRUE(donor_context->get_feature_mgr()->HasCapability( spv::Capability::VariablePointersStorageBuffer)); ASSERT_FALSE(recipient_context->get_feature_mgr()->HasCapability( spv::Capability::VariablePointersStorageBuffer)); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // Check that recipient module hasn't changed. ASSERT_TRUE(IsEqual(env, recipient_shader, recipient_context.get())); // Add the missing capability. // // We are adding VariablePointers to test the case when donor and recipient // have different OpCapability instructions but the same capabilities. In our // example, VariablePointers implicitly declares // VariablePointersStorageBuffer. Thus, two modules must be compatible. recipient_context->AddCapability(spv::Capability::VariablePointers); ASSERT_TRUE(donor_context->get_feature_mgr()->HasCapability( spv::Capability::VariablePointersStorageBuffer)); ASSERT_TRUE(recipient_context->get_feature_mgr()->HasCapability( spv::Capability::VariablePointersStorageBuffer)); fuzzer_pass.DonateSingleModule(donor_context.get(), false); // Check that donation was successful. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); std::string after_transformation = R"( OpCapability Shader OpCapability VariablePointers %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %100 = OpTypeFloat 32 %101 = OpConstant %100 23 %102 = OpTypePointer Function %100 %105 = OpConstant %100 0 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd %103 = OpFunction %2 None %3 %104 = OpLabel %106 = OpVariable %102 Function %105 OpBranch %107 %107 = OpLabel %108 = OpPhi %102 %106 %104 OpStore %108 %101 OpReturn OpFunctionEnd )"; ASSERT_TRUE(IsEqual(env, after_transformation, recipient_context.get())); } TEST(FuzzerPassDonateModulesTest, HandlesOpPhisInMergeBlock) { std::string donor_shader = R"( ; OpPhis don't support pointers without this capability ; and we need pointers to test some of the functionality OpCapability VariablePointers OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %14 = OpTypeBool %15 = OpConstantTrue %14 %42 = OpTypePointer Function %14 ; back-edge block is unreachable in the CFG %4 = OpFunction %2 None %3 %5 = OpLabel OpBranch %6 %6 = OpLabel OpLoopMerge %8 %7 None OpBranch %8 %7 = OpLabel OpBranch %6 %8 = OpLabel OpReturn OpFunctionEnd ; back-edge block already has an edge to the merge block %9 = OpFunction %2 None %3 %10 = OpLabel OpBranch %11 %11 = OpLabel OpLoopMerge %13 %12 None OpBranch %12 %12 = OpLabel OpBranchConditional %15 %11 %13 %13 = OpLabel OpReturn OpFunctionEnd ; merge block has no OpPhis %16 = OpFunction %2 None %3 %17 = OpLabel OpBranch %18 %18 = OpLabel OpLoopMerge %20 %19 None OpBranchConditional %15 %19 %20 %19 = OpLabel OpBranch %18 %20 = OpLabel OpReturn OpFunctionEnd ; merge block has OpPhis and some of their operands are available at ; the back-edge block %21 = OpFunction %2 None %3 %22 = OpLabel OpBranch %23 %23 = OpLabel %24 = OpCopyObject %14 %15 OpLoopMerge %28 %27 None OpBranchConditional %15 %25 %28 %25 = OpLabel %26 = OpCopyObject %14 %15 OpBranchConditional %15 %28 %27 %27 = OpLabel OpBranch %23 %28 = OpLabel %29 = OpPhi %14 %24 %23 %26 %25 OpReturn OpFunctionEnd ; none of the OpPhis' operands dominate the back-edge block but some of ; them have basic type %30 = OpFunction %2 None %3 %31 = OpLabel OpBranch %32 %32 = OpLabel OpLoopMerge %40 %39 None OpBranch %33 %33 = OpLabel OpSelectionMerge %38 None OpBranchConditional %15 %34 %36 %34 = OpLabel %35 = OpCopyObject %14 %15 OpBranchConditional %35 %38 %40 %36 = OpLabel %37 = OpCopyObject %14 %15 OpBranchConditional %37 %38 %40 %38 = OpLabel OpBranch %39 %39 = OpLabel OpBranch %32 %40 = OpLabel %41 = OpPhi %14 %35 %34 %37 %36 OpReturn OpFunctionEnd ; none of the OpPhis' operands dominate the back-edge block and none of ; them have basic type %43 = OpFunction %2 None %3 %44 = OpLabel %45 = OpVariable %42 Function OpBranch %46 %46 = OpLabel OpLoopMerge %54 %53 None OpBranch %47 %47 = OpLabel OpSelectionMerge %52 None OpBranchConditional %15 %48 %50 %48 = OpLabel %49 = OpCopyObject %42 %45 OpBranchConditional %15 %52 %54 %50 = OpLabel %51 = OpCopyObject %42 %45 OpBranchConditional %15 %52 %54 %52 = OpLabel OpBranch %53 %53 = OpLabel OpBranch %46 %54 = OpLabel %55 = OpPhi %42 %49 %48 %51 %50 OpReturn OpFunctionEnd )"; std::string recipient_shader = R"( ; OpPhis don't support pointers without this capability ; and we need pointers to test some of the functionality OpCapability VariablePointers OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 %2 = OpTypeVoid %3 = OpTypeFunction %2 %4 = OpFunction %2 None %3 %5 = OpLabel OpReturn OpFunctionEnd )"; const auto env = SPV_ENV_UNIVERSAL_1_3; const auto consumer = nullptr; spvtools::ValidatorOptions validator_options; const auto recipient_context = BuildModule(env, consumer, recipient_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); const auto donor_context = BuildModule(env, consumer, donor_shader, kFuzzAssembleOption); ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( donor_context.get(), validator_options, kConsoleMessageConsumer)); TransformationContext transformation_context( MakeUnique(recipient_context.get()), validator_options); FuzzerContext fuzzer_context(MakeUnique(0), 100, false); protobufs::TransformationSequence transformation_sequence; FuzzerPassDonateModules fuzzer_pass(recipient_context.get(), &transformation_context, &fuzzer_context, &transformation_sequence, false, {}); fuzzer_pass.DonateSingleModule(donor_context.get(), true); // We just check that the result is valid. Checking to what it should be // exactly equal to would be very fragile. ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed( recipient_context.get(), validator_options, kConsoleMessageConsumer)); } } // namespace } // namespace fuzz } // namespace spvtools