// 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.h" #include "test/fuzz/fuzz_test_util.h" namespace spvtools { namespace fuzz { namespace { // Assembles the given |shader| text, and then runs the fuzzer |num_runs| // times, using successive seeds starting from |initial_seed|. Checks that // the binary produced after each fuzzer run is valid. void RunFuzzer(const std::string& shader, uint32_t initial_seed, uint32_t num_runs) { const auto env = SPV_ENV_UNIVERSAL_1_3; std::vector binary_in; SpirvTools t(env); ASSERT_TRUE(t.Assemble(shader, &binary_in, kFuzzAssembleOption)); ASSERT_TRUE(t.Validate(binary_in)); for (uint32_t seed = initial_seed; seed < initial_seed + num_runs; seed++) { protobufs::FactSequence initial_facts; std::vector binary_out; protobufs::TransformationSequence transformation_sequence_out; spvtools::FuzzerOptions fuzzer_options; spvFuzzerOptionsSetRandomSeed(fuzzer_options, seed); Fuzzer fuzzer(env); fuzzer.Run(binary_in, initial_facts, &binary_out, &transformation_sequence_out, fuzzer_options); ASSERT_TRUE(t.Validate(binary_out)); } } TEST(FuzzerTest, Miscellaneous1) { // The SPIR-V came from this GLSL: // // #version 310 es // // void foo() { // int x; // x = 2; // for (int i = 0; i < 100; i++) { // x += i; // x = x * 2; // } // return; // } // // void main() { // foo(); // for (int i = 0; i < 10; i++) { // int j = 20; // while(j > 0) { // foo(); // j--; // } // do { // i++; // } while(i < 4); // } // } std::string 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 )"; // Do 10 fuzzer runs, starting from an initial seed of 0 (seed value chosen // arbitrarily). RunFuzzer(shader, 0, 10); } TEST(FuzzerTest, Miscellaneous2) { // The SPIR-V came from this GLSL, which was then optimized using spirv-opt // with the -O argument: // // #version 310 es // // precision highp float; // // layout(location = 0) out vec4 _GLF_color; // // layout(set = 0, binding = 0) uniform buf0 { // vec2 injectionSwitch; // }; // layout(set = 0, binding = 1) uniform buf1 { // vec2 resolution; // }; // bool checkSwap(float a, float b) // { // return gl_FragCoord.y < resolution.y / 2.0 ? a > b : a < b; // } // void main() // { // float data[10]; // for(int i = 0; i < 10; i++) // { // data[i] = float(10 - i) * injectionSwitch.y; // } // for(int i = 0; i < 9; i++) // { // for(int j = 0; j < 10; j++) // { // if(j < i + 1) // { // continue; // } // bool doSwap = checkSwap(data[i], data[j]); // if(doSwap) // { // float temp = data[i]; // data[i] = data[j]; // data[j] = temp; // } // } // } // if(gl_FragCoord.x < resolution.x / 2.0) // { // _GLF_color = vec4(data[0] / 10.0, data[5] / 10.0, data[9] / 10.0, 1.0); // } // else // { // _GLF_color = vec4(data[5] / 10.0, data[9] / 10.0, data[0] / 10.0, 1.0); // } // } std::string shader = R"( OpCapability Shader %1 = OpExtInstImport "GLSL.std.450" OpMemoryModel Logical GLSL450 OpEntryPoint Fragment %4 "main" %16 %139 OpExecutionMode %4 OriginUpperLeft OpSource ESSL 310 OpName %4 "main" OpName %16 "gl_FragCoord" OpName %23 "buf1" OpMemberName %23 0 "resolution" OpName %25 "" OpName %61 "data" OpName %66 "buf0" OpMemberName %66 0 "injectionSwitch" OpName %68 "" OpName %139 "_GLF_color" OpDecorate %16 BuiltIn FragCoord OpMemberDecorate %23 0 Offset 0 OpDecorate %23 Block OpDecorate %25 DescriptorSet 0 OpDecorate %25 Binding 1 OpDecorate %64 RelaxedPrecision OpMemberDecorate %66 0 Offset 0 OpDecorate %66 Block OpDecorate %68 DescriptorSet 0 OpDecorate %68 Binding 0 OpDecorate %75 RelaxedPrecision OpDecorate %95 RelaxedPrecision OpDecorate %126 RelaxedPrecision OpDecorate %128 RelaxedPrecision OpDecorate %139 Location 0 OpDecorate %182 RelaxedPrecision OpDecorate %183 RelaxedPrecision OpDecorate %184 RelaxedPrecision %2 = OpTypeVoid %3 = OpTypeFunction %2 %6 = OpTypeFloat 32 %7 = OpTypePointer Function %6 %8 = OpTypeBool %14 = OpTypeVector %6 4 %15 = OpTypePointer Input %14 %16 = OpVariable %15 Input %17 = OpTypeInt 32 0 %18 = OpConstant %17 1 %19 = OpTypePointer Input %6 %22 = OpTypeVector %6 2 %23 = OpTypeStruct %22 %24 = OpTypePointer Uniform %23 %25 = OpVariable %24 Uniform %26 = OpTypeInt 32 1 %27 = OpConstant %26 0 %28 = OpTypePointer Uniform %6 %56 = OpConstant %26 10 %58 = OpConstant %17 10 %59 = OpTypeArray %6 %58 %60 = OpTypePointer Function %59 %66 = OpTypeStruct %22 %67 = OpTypePointer Uniform %66 %68 = OpVariable %67 Uniform %74 = OpConstant %26 1 %83 = OpConstant %26 9 %129 = OpConstant %17 0 %138 = OpTypePointer Output %14 %139 = OpVariable %138 Output %144 = OpConstant %26 5 %151 = OpConstant %6 1 %194 = OpConstant %6 0.5 %195 = OpConstant %6 0.100000001 %4 = OpFunction %2 None %3 %5 = OpLabel %61 = OpVariable %60 Function OpBranch %50 %50 = OpLabel %182 = OpPhi %26 %27 %5 %75 %51 %57 = OpSLessThan %8 %182 %56 OpLoopMerge %52 %51 None OpBranchConditional %57 %51 %52 %51 = OpLabel %64 = OpISub %26 %56 %182 %65 = OpConvertSToF %6 %64 %69 = OpAccessChain %28 %68 %27 %18 %70 = OpLoad %6 %69 %71 = OpFMul %6 %65 %70 %72 = OpAccessChain %7 %61 %182 OpStore %72 %71 %75 = OpIAdd %26 %182 %74 OpBranch %50 %52 = OpLabel OpBranch %77 %77 = OpLabel %183 = OpPhi %26 %27 %52 %128 %88 %84 = OpSLessThan %8 %183 %83 OpLoopMerge %79 %88 None OpBranchConditional %84 %78 %79 %78 = OpLabel OpBranch %86 %86 = OpLabel %184 = OpPhi %26 %27 %78 %126 %89 %92 = OpSLessThan %8 %184 %56 OpLoopMerge %88 %89 None OpBranchConditional %92 %87 %88 %87 = OpLabel %95 = OpIAdd %26 %183 %74 %96 = OpSLessThan %8 %184 %95 OpSelectionMerge %98 None OpBranchConditional %96 %97 %98 %97 = OpLabel OpBranch %89 %98 = OpLabel %104 = OpAccessChain %7 %61 %183 %105 = OpLoad %6 %104 %107 = OpAccessChain %7 %61 %184 %108 = OpLoad %6 %107 %166 = OpAccessChain %19 %16 %18 %167 = OpLoad %6 %166 %168 = OpAccessChain %28 %25 %27 %18 %169 = OpLoad %6 %168 %170 = OpFMul %6 %169 %194 %171 = OpFOrdLessThan %8 %167 %170 OpSelectionMerge %172 None OpBranchConditional %171 %173 %174 %173 = OpLabel %177 = OpFOrdGreaterThan %8 %105 %108 OpBranch %172 %174 = OpLabel %180 = OpFOrdLessThan %8 %105 %108 OpBranch %172 %172 = OpLabel %186 = OpPhi %8 %177 %173 %180 %174 OpSelectionMerge %112 None OpBranchConditional %186 %111 %112 %111 = OpLabel %116 = OpLoad %6 %104 %120 = OpLoad %6 %107 OpStore %104 %120 OpStore %107 %116 OpBranch %112 %112 = OpLabel OpBranch %89 %89 = OpLabel %126 = OpIAdd %26 %184 %74 OpBranch %86 %88 = OpLabel %128 = OpIAdd %26 %183 %74 OpBranch %77 %79 = OpLabel %130 = OpAccessChain %19 %16 %129 %131 = OpLoad %6 %130 %132 = OpAccessChain %28 %25 %27 %129 %133 = OpLoad %6 %132 %134 = OpFMul %6 %133 %194 %135 = OpFOrdLessThan %8 %131 %134 OpSelectionMerge %137 None OpBranchConditional %135 %136 %153 %136 = OpLabel %140 = OpAccessChain %7 %61 %27 %141 = OpLoad %6 %140 %143 = OpFMul %6 %141 %195 %145 = OpAccessChain %7 %61 %144 %146 = OpLoad %6 %145 %147 = OpFMul %6 %146 %195 %148 = OpAccessChain %7 %61 %83 %149 = OpLoad %6 %148 %150 = OpFMul %6 %149 %195 %152 = OpCompositeConstruct %14 %143 %147 %150 %151 OpStore %139 %152 OpBranch %137 %153 = OpLabel %154 = OpAccessChain %7 %61 %144 %155 = OpLoad %6 %154 %156 = OpFMul %6 %155 %195 %157 = OpAccessChain %7 %61 %83 %158 = OpLoad %6 %157 %159 = OpFMul %6 %158 %195 %160 = OpAccessChain %7 %61 %27 %161 = OpLoad %6 %160 %162 = OpFMul %6 %161 %195 %163 = OpCompositeConstruct %14 %156 %159 %162 %151 OpStore %139 %163 OpBranch %137 %137 = OpLabel OpReturn OpFunctionEnd )"; // Do 10 fuzzer runs, starting from an initial seed of 10 (seed value chosen // arbitrarily). RunFuzzer(shader, 10, 10); } } // namespace } // namespace fuzz } // namespace spvtools