mirror of
https://github.com/KhronosGroup/SPIRV-Tools
synced 2024-11-28 06:01:04 +00:00
502e982956
This fixes a problem where TransformationInlineFunction could lead to distinct instructions having identical unique ids. It adds a validity check to detect this problem in general. Fixes #3911.
1617 lines
56 KiB
C++
1617 lines
56 KiB
C++
// 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/transformation_add_dead_continue.h"
|
|
|
|
#include "gtest/gtest.h"
|
|
#include "source/fuzz/fuzzer_util.h"
|
|
#include "test/fuzz/fuzz_test_util.h"
|
|
|
|
namespace spvtools {
|
|
namespace fuzz {
|
|
namespace {
|
|
|
|
TEST(TransformationAddDeadContinueTest, SimpleExample) {
|
|
// For a simple loop, checks that some dead continue scenarios are possible,
|
|
// checks that some invalid scenarios are indeed not allowed, and then applies
|
|
// a transformation.
|
|
|
|
// The SPIR-V for this test is adapted from the following GLSL, by separating
|
|
// some assignments into their own basic blocks, and adding constants for true
|
|
// and false:
|
|
//
|
|
// void main() {
|
|
// int x = 0;
|
|
// for (int i = 0; i < 10; i++) {
|
|
// x = x + i;
|
|
// x = x + i;
|
|
// }
|
|
// }
|
|
|
|
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 %8 "x"
|
|
OpName %10 "i"
|
|
%2 = OpTypeVoid
|
|
%3 = OpTypeFunction %2
|
|
%6 = OpTypeInt 32 1
|
|
%7 = OpTypePointer Function %6
|
|
%9 = OpConstant %6 0
|
|
%17 = OpConstant %6 10
|
|
%18 = OpTypeBool
|
|
%41 = OpConstantTrue %18
|
|
%42 = OpConstantFalse %18
|
|
%27 = OpConstant %6 1
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
%8 = OpVariable %7 Function
|
|
%10 = OpVariable %7 Function
|
|
OpStore %8 %9
|
|
OpStore %10 %9
|
|
OpBranch %11
|
|
%11 = OpLabel
|
|
OpLoopMerge %13 %14 None
|
|
OpBranch %15
|
|
%15 = OpLabel
|
|
%16 = OpLoad %6 %10
|
|
%19 = OpSLessThan %18 %16 %17
|
|
OpBranchConditional %19 %12 %13
|
|
%12 = OpLabel
|
|
%20 = OpLoad %6 %8
|
|
%21 = OpLoad %6 %10
|
|
%22 = OpIAdd %6 %20 %21
|
|
OpStore %8 %22
|
|
OpBranch %40
|
|
%40 = OpLabel
|
|
%23 = OpLoad %6 %8
|
|
%24 = OpLoad %6 %10
|
|
%25 = OpIAdd %6 %23 %24
|
|
OpStore %8 %25
|
|
OpBranch %14
|
|
%14 = OpLabel
|
|
%26 = OpLoad %6 %10
|
|
%28 = OpIAdd %6 %26 %27
|
|
OpStore %10 %28
|
|
OpBranch %11
|
|
%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));
|
|
TransformationContext transformation_context(
|
|
MakeUnique<FactManager>(context.get()), validator_options);
|
|
// These are all possibilities.
|
|
ASSERT_TRUE(TransformationAddDeadContinue(11, true, {})
|
|
.IsApplicable(context.get(), transformation_context));
|
|
ASSERT_TRUE(TransformationAddDeadContinue(11, false, {})
|
|
.IsApplicable(context.get(), transformation_context));
|
|
ASSERT_TRUE(TransformationAddDeadContinue(12, true, {})
|
|
.IsApplicable(context.get(), transformation_context));
|
|
ASSERT_TRUE(TransformationAddDeadContinue(12, false, {})
|
|
.IsApplicable(context.get(), transformation_context));
|
|
ASSERT_TRUE(TransformationAddDeadContinue(40, true, {})
|
|
.IsApplicable(context.get(), transformation_context));
|
|
ASSERT_TRUE(TransformationAddDeadContinue(40, false, {})
|
|
.IsApplicable(context.get(), transformation_context));
|
|
|
|
// Inapplicable: 100 is not a block id.
|
|
ASSERT_FALSE(TransformationAddDeadContinue(100, true, {})
|
|
.IsApplicable(context.get(), transformation_context));
|
|
|
|
// Inapplicable: 10 is not in a loop.
|
|
ASSERT_FALSE(TransformationAddDeadContinue(10, true, {})
|
|
.IsApplicable(context.get(), transformation_context));
|
|
|
|
// Inapplicable: 15 does not branch unconditionally to a single successor.
|
|
ASSERT_FALSE(TransformationAddDeadContinue(15, true, {})
|
|
.IsApplicable(context.get(), transformation_context));
|
|
|
|
// Inapplicable: 13 is not in a loop and has no successor.
|
|
ASSERT_FALSE(TransformationAddDeadContinue(13, true, {})
|
|
.IsApplicable(context.get(), transformation_context));
|
|
|
|
// Inapplicable: 14 is the loop continue target, so it's not OK to jump to
|
|
// the loop continue from there.
|
|
ASSERT_FALSE(TransformationAddDeadContinue(14, false, {})
|
|
.IsApplicable(context.get(), transformation_context));
|
|
|
|
// These are the transformations we will apply.
|
|
auto transformation1 = TransformationAddDeadContinue(11, true, {});
|
|
auto transformation2 = TransformationAddDeadContinue(12, false, {});
|
|
auto transformation3 = TransformationAddDeadContinue(40, true, {});
|
|
|
|
ASSERT_TRUE(
|
|
transformation1.IsApplicable(context.get(), transformation_context));
|
|
ApplyAndCheckFreshIds(transformation1, context.get(),
|
|
&transformation_context);
|
|
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
|
|
kConsoleMessageConsumer));
|
|
|
|
ASSERT_TRUE(
|
|
transformation2.IsApplicable(context.get(), transformation_context));
|
|
ApplyAndCheckFreshIds(transformation2, context.get(),
|
|
&transformation_context);
|
|
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
|
|
kConsoleMessageConsumer));
|
|
|
|
ASSERT_TRUE(
|
|
transformation3.IsApplicable(context.get(), transformation_context));
|
|
ApplyAndCheckFreshIds(transformation3, context.get(),
|
|
&transformation_context);
|
|
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(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
|
|
OpName %4 "main"
|
|
OpName %8 "x"
|
|
OpName %10 "i"
|
|
%2 = OpTypeVoid
|
|
%3 = OpTypeFunction %2
|
|
%6 = OpTypeInt 32 1
|
|
%7 = OpTypePointer Function %6
|
|
%9 = OpConstant %6 0
|
|
%17 = OpConstant %6 10
|
|
%18 = OpTypeBool
|
|
%41 = OpConstantTrue %18
|
|
%42 = OpConstantFalse %18
|
|
%27 = OpConstant %6 1
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
%8 = OpVariable %7 Function
|
|
%10 = OpVariable %7 Function
|
|
OpStore %8 %9
|
|
OpStore %10 %9
|
|
OpBranch %11
|
|
%11 = OpLabel
|
|
OpLoopMerge %13 %14 None
|
|
OpBranchConditional %41 %15 %14
|
|
%15 = OpLabel
|
|
%16 = OpLoad %6 %10
|
|
%19 = OpSLessThan %18 %16 %17
|
|
OpBranchConditional %19 %12 %13
|
|
%12 = OpLabel
|
|
%20 = OpLoad %6 %8
|
|
%21 = OpLoad %6 %10
|
|
%22 = OpIAdd %6 %20 %21
|
|
OpStore %8 %22
|
|
OpBranchConditional %42 %14 %40
|
|
%40 = OpLabel
|
|
%23 = OpLoad %6 %8
|
|
%24 = OpLoad %6 %10
|
|
%25 = OpIAdd %6 %23 %24
|
|
OpStore %8 %25
|
|
OpBranchConditional %41 %14 %14
|
|
%14 = OpLabel
|
|
%26 = OpLoad %6 %10
|
|
%28 = OpIAdd %6 %26 %27
|
|
OpStore %10 %28
|
|
OpBranch %11
|
|
%13 = OpLabel
|
|
OpReturn
|
|
OpFunctionEnd
|
|
)";
|
|
|
|
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
|
|
}
|
|
|
|
TEST(TransformationAddDeadContinueTest, LoopNest) {
|
|
// Checks some allowed and disallowed scenarios for a nest of loops, including
|
|
// continuing a loop from an if or switch.
|
|
|
|
// The SPIR-V for this test is adapted from the following GLSL:
|
|
//
|
|
// void main() {
|
|
// int x, y;
|
|
// do {
|
|
// x++;
|
|
// for (int j = 0; j < 100; j++) {
|
|
// y++;
|
|
// if (x == y) {
|
|
// x++;
|
|
// if (x == 2) {
|
|
// y++;
|
|
// }
|
|
// switch (x) {
|
|
// case 0:
|
|
// x = 2;
|
|
// default:
|
|
// break;
|
|
// }
|
|
// }
|
|
// }
|
|
// } while (x > y);
|
|
//
|
|
// for (int i = 0; i < 100; i++) {
|
|
// x++;
|
|
// }
|
|
// }
|
|
|
|
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 %12 "x"
|
|
OpName %16 "j"
|
|
OpName %27 "y"
|
|
OpName %55 "i"
|
|
%2 = OpTypeVoid
|
|
%3 = OpTypeFunction %2
|
|
%10 = OpTypeInt 32 1
|
|
%11 = OpTypePointer Function %10
|
|
%14 = OpConstant %10 1
|
|
%17 = OpConstant %10 0
|
|
%24 = OpConstant %10 100
|
|
%25 = OpTypeBool
|
|
%38 = OpConstant %10 2
|
|
%67 = OpConstantTrue %25
|
|
%68 = OpConstantFalse %25
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
%12 = OpVariable %11 Function
|
|
%16 = OpVariable %11 Function
|
|
%27 = OpVariable %11 Function
|
|
%55 = OpVariable %11 Function
|
|
OpBranch %6
|
|
%6 = OpLabel
|
|
OpLoopMerge %8 %9 None
|
|
OpBranch %7
|
|
%7 = OpLabel
|
|
%13 = OpLoad %10 %12
|
|
%15 = OpIAdd %10 %13 %14
|
|
OpStore %12 %15
|
|
OpStore %16 %17
|
|
OpBranch %18
|
|
%18 = OpLabel
|
|
OpLoopMerge %20 %21 None
|
|
OpBranch %22
|
|
%22 = OpLabel
|
|
%23 = OpLoad %10 %16
|
|
%26 = OpSLessThan %25 %23 %24
|
|
OpBranchConditional %26 %19 %20
|
|
%19 = OpLabel
|
|
%28 = OpLoad %10 %27
|
|
%29 = OpIAdd %10 %28 %14
|
|
OpStore %27 %29
|
|
%30 = OpLoad %10 %12
|
|
%31 = OpLoad %10 %27
|
|
%32 = OpIEqual %25 %30 %31
|
|
OpSelectionMerge %34 None
|
|
OpBranchConditional %32 %33 %34
|
|
%33 = OpLabel
|
|
%35 = OpLoad %10 %12
|
|
%36 = OpIAdd %10 %35 %14
|
|
OpStore %12 %36
|
|
%37 = OpLoad %10 %12
|
|
%39 = OpIEqual %25 %37 %38
|
|
OpSelectionMerge %41 None
|
|
OpBranchConditional %39 %40 %41
|
|
%40 = OpLabel
|
|
%42 = OpLoad %10 %27
|
|
%43 = OpIAdd %10 %42 %14
|
|
OpStore %27 %43
|
|
OpBranch %41
|
|
%41 = OpLabel
|
|
%44 = OpLoad %10 %12
|
|
OpSelectionMerge %47 None
|
|
OpSwitch %44 %46 0 %45
|
|
%46 = OpLabel
|
|
OpBranch %47
|
|
%45 = OpLabel
|
|
OpStore %12 %38
|
|
OpBranch %46
|
|
%47 = OpLabel
|
|
OpBranch %34
|
|
%34 = OpLabel
|
|
OpBranch %21
|
|
%21 = OpLabel
|
|
%50 = OpLoad %10 %16
|
|
%51 = OpIAdd %10 %50 %14
|
|
OpStore %16 %51
|
|
OpBranch %18
|
|
%20 = OpLabel
|
|
OpBranch %9
|
|
%9 = OpLabel
|
|
%52 = OpLoad %10 %12
|
|
%53 = OpLoad %10 %27
|
|
%54 = OpSGreaterThan %25 %52 %53
|
|
OpBranchConditional %54 %6 %8
|
|
%8 = OpLabel
|
|
OpStore %55 %17
|
|
OpBranch %56
|
|
%56 = OpLabel
|
|
OpLoopMerge %58 %59 None
|
|
OpBranch %60
|
|
%60 = OpLabel
|
|
%61 = OpLoad %10 %55
|
|
%62 = OpSLessThan %25 %61 %24
|
|
OpBranchConditional %62 %57 %58
|
|
%57 = OpLabel
|
|
%63 = OpLoad %10 %12
|
|
%64 = OpIAdd %10 %63 %14
|
|
OpStore %12 %64
|
|
OpBranch %59
|
|
%59 = OpLabel
|
|
%65 = OpLoad %10 %55
|
|
%66 = OpIAdd %10 %65 %14
|
|
OpStore %55 %66
|
|
OpBranch %56
|
|
%58 = 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));
|
|
TransformationContext transformation_context(
|
|
MakeUnique<FactManager>(context.get()), validator_options);
|
|
std::vector<uint32_t> good = {6, 7, 18, 20, 34, 40, 45, 46, 47, 56, 57};
|
|
std::vector<uint32_t> bad = {5, 8, 9, 19, 21, 22, 33, 41, 58, 59, 60};
|
|
|
|
for (uint32_t from_block : bad) {
|
|
ASSERT_FALSE(TransformationAddDeadContinue(from_block, true, {})
|
|
.IsApplicable(context.get(), transformation_context));
|
|
}
|
|
for (uint32_t from_block : good) {
|
|
const TransformationAddDeadContinue transformation(from_block, true, {});
|
|
ASSERT_TRUE(
|
|
transformation.IsApplicable(context.get(), transformation_context));
|
|
ApplyAndCheckFreshIds(transformation, context.get(),
|
|
&transformation_context);
|
|
ASSERT_FALSE(
|
|
transformation.IsApplicable(context.get(), transformation_context));
|
|
}
|
|
|
|
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
|
|
OpName %4 "main"
|
|
OpName %12 "x"
|
|
OpName %16 "j"
|
|
OpName %27 "y"
|
|
OpName %55 "i"
|
|
%2 = OpTypeVoid
|
|
%3 = OpTypeFunction %2
|
|
%10 = OpTypeInt 32 1
|
|
%11 = OpTypePointer Function %10
|
|
%14 = OpConstant %10 1
|
|
%17 = OpConstant %10 0
|
|
%24 = OpConstant %10 100
|
|
%25 = OpTypeBool
|
|
%38 = OpConstant %10 2
|
|
%67 = OpConstantTrue %25
|
|
%68 = OpConstantFalse %25
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
%12 = OpVariable %11 Function
|
|
%16 = OpVariable %11 Function
|
|
%27 = OpVariable %11 Function
|
|
%55 = OpVariable %11 Function
|
|
OpBranch %6
|
|
%6 = OpLabel
|
|
OpLoopMerge %8 %9 None
|
|
OpBranchConditional %67 %7 %9
|
|
%7 = OpLabel
|
|
%13 = OpLoad %10 %12
|
|
%15 = OpIAdd %10 %13 %14
|
|
OpStore %12 %15
|
|
OpStore %16 %17
|
|
OpBranchConditional %67 %18 %9
|
|
%18 = OpLabel
|
|
OpLoopMerge %20 %21 None
|
|
OpBranchConditional %67 %22 %21
|
|
%22 = OpLabel
|
|
%23 = OpLoad %10 %16
|
|
%26 = OpSLessThan %25 %23 %24
|
|
OpBranchConditional %26 %19 %20
|
|
%19 = OpLabel
|
|
%28 = OpLoad %10 %27
|
|
%29 = OpIAdd %10 %28 %14
|
|
OpStore %27 %29
|
|
%30 = OpLoad %10 %12
|
|
%31 = OpLoad %10 %27
|
|
%32 = OpIEqual %25 %30 %31
|
|
OpSelectionMerge %34 None
|
|
OpBranchConditional %32 %33 %34
|
|
%33 = OpLabel
|
|
%35 = OpLoad %10 %12
|
|
%36 = OpIAdd %10 %35 %14
|
|
OpStore %12 %36
|
|
%37 = OpLoad %10 %12
|
|
%39 = OpIEqual %25 %37 %38
|
|
OpSelectionMerge %41 None
|
|
OpBranchConditional %39 %40 %41
|
|
%40 = OpLabel
|
|
%42 = OpLoad %10 %27
|
|
%43 = OpIAdd %10 %42 %14
|
|
OpStore %27 %43
|
|
OpBranchConditional %67 %41 %21
|
|
%41 = OpLabel
|
|
%44 = OpLoad %10 %12
|
|
OpSelectionMerge %47 None
|
|
OpSwitch %44 %46 0 %45
|
|
%46 = OpLabel
|
|
OpBranchConditional %67 %47 %21
|
|
%45 = OpLabel
|
|
OpStore %12 %38
|
|
OpBranchConditional %67 %46 %21
|
|
%47 = OpLabel
|
|
OpBranchConditional %67 %34 %21
|
|
%34 = OpLabel
|
|
OpBranchConditional %67 %21 %21
|
|
%21 = OpLabel
|
|
%50 = OpLoad %10 %16
|
|
%51 = OpIAdd %10 %50 %14
|
|
OpStore %16 %51
|
|
OpBranch %18
|
|
%20 = OpLabel
|
|
OpBranchConditional %67 %9 %9
|
|
%9 = OpLabel
|
|
%52 = OpLoad %10 %12
|
|
%53 = OpLoad %10 %27
|
|
%54 = OpSGreaterThan %25 %52 %53
|
|
OpBranchConditional %54 %6 %8
|
|
%8 = OpLabel
|
|
OpStore %55 %17
|
|
OpBranch %56
|
|
%56 = OpLabel
|
|
OpLoopMerge %58 %59 None
|
|
OpBranchConditional %67 %60 %59
|
|
%60 = OpLabel
|
|
%61 = OpLoad %10 %55
|
|
%62 = OpSLessThan %25 %61 %24
|
|
OpBranchConditional %62 %57 %58
|
|
%57 = OpLabel
|
|
%63 = OpLoad %10 %12
|
|
%64 = OpIAdd %10 %63 %14
|
|
OpStore %12 %64
|
|
OpBranchConditional %67 %59 %59
|
|
%59 = OpLabel
|
|
%65 = OpLoad %10 %55
|
|
%66 = OpIAdd %10 %65 %14
|
|
OpStore %55 %66
|
|
OpBranch %56
|
|
%58 = OpLabel
|
|
OpReturn
|
|
OpFunctionEnd
|
|
)";
|
|
|
|
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
|
|
}
|
|
|
|
TEST(TransformationAddDeadConditionalTest, LoopInContinueConstruct) {
|
|
// Considers some scenarios where there is a loop in a loop's continue
|
|
// construct.
|
|
|
|
// The SPIR-V for this test is adapted from the following GLSL, with inlining
|
|
// applied so that the loop from foo is in the main loop's continue construct:
|
|
//
|
|
// int foo() {
|
|
// int result = 0;
|
|
// for (int j = 0; j < 10; j++) {
|
|
// result++;
|
|
// }
|
|
// return result;
|
|
// }
|
|
//
|
|
// void main() {
|
|
// for (int i = 0; i < 100; i += foo()) {
|
|
// }
|
|
// }
|
|
|
|
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 %31 "i"
|
|
%2 = OpTypeVoid
|
|
%3 = OpTypeFunction %2
|
|
%6 = OpTypeInt 32 1
|
|
%7 = OpTypeFunction %6
|
|
%10 = OpTypePointer Function %6
|
|
%12 = OpConstant %6 0
|
|
%20 = OpConstant %6 10
|
|
%21 = OpTypeBool
|
|
%100 = OpConstantFalse %21
|
|
%24 = OpConstant %6 1
|
|
%38 = OpConstant %6 100
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
%43 = OpVariable %10 Function
|
|
%44 = OpVariable %10 Function
|
|
%45 = OpVariable %10 Function
|
|
%31 = OpVariable %10 Function
|
|
OpStore %31 %12
|
|
OpBranch %32
|
|
%32 = OpLabel
|
|
OpLoopMerge %34 %35 None
|
|
OpBranch %36
|
|
%36 = OpLabel
|
|
%37 = OpLoad %6 %31
|
|
%39 = OpSLessThan %21 %37 %38
|
|
OpBranchConditional %39 %33 %34
|
|
%33 = OpLabel
|
|
OpBranch %35
|
|
%35 = OpLabel
|
|
OpStore %43 %12
|
|
OpStore %44 %12
|
|
OpBranch %46
|
|
%46 = OpLabel
|
|
OpLoopMerge %47 %48 None
|
|
OpBranch %49
|
|
%49 = OpLabel
|
|
%50 = OpLoad %6 %44
|
|
%51 = OpSLessThan %21 %50 %20
|
|
OpBranchConditional %51 %52 %47
|
|
%52 = OpLabel
|
|
%53 = OpLoad %6 %43
|
|
OpBranch %101
|
|
%101 = OpLabel
|
|
%54 = OpIAdd %6 %53 %24
|
|
OpStore %43 %54
|
|
OpBranch %48
|
|
%48 = OpLabel
|
|
%55 = OpLoad %6 %44
|
|
%56 = OpIAdd %6 %55 %24
|
|
OpStore %44 %56
|
|
OpBranch %46
|
|
%47 = OpLabel
|
|
%57 = OpLoad %6 %43
|
|
OpStore %45 %57
|
|
%40 = OpLoad %6 %45
|
|
%41 = OpLoad %6 %31
|
|
%42 = OpIAdd %6 %41 %40
|
|
OpStore %31 %42
|
|
OpBranch %32
|
|
%34 = 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));
|
|
TransformationContext transformation_context(
|
|
MakeUnique<FactManager>(context.get()), validator_options);
|
|
std::vector<uint32_t> good = {32, 33, 46, 52, 101};
|
|
std::vector<uint32_t> bad = {5, 34, 36, 35, 47, 49, 48};
|
|
|
|
for (uint32_t from_block : bad) {
|
|
ASSERT_FALSE(TransformationAddDeadContinue(from_block, false, {})
|
|
.IsApplicable(context.get(), transformation_context));
|
|
}
|
|
for (uint32_t from_block : good) {
|
|
const TransformationAddDeadContinue transformation(from_block, false, {});
|
|
ASSERT_TRUE(
|
|
transformation.IsApplicable(context.get(), transformation_context));
|
|
ApplyAndCheckFreshIds(transformation, context.get(),
|
|
&transformation_context);
|
|
ASSERT_FALSE(
|
|
transformation.IsApplicable(context.get(), transformation_context));
|
|
}
|
|
|
|
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
|
|
OpName %4 "main"
|
|
OpName %31 "i"
|
|
%2 = OpTypeVoid
|
|
%3 = OpTypeFunction %2
|
|
%6 = OpTypeInt 32 1
|
|
%7 = OpTypeFunction %6
|
|
%10 = OpTypePointer Function %6
|
|
%12 = OpConstant %6 0
|
|
%20 = OpConstant %6 10
|
|
%21 = OpTypeBool
|
|
%100 = OpConstantFalse %21
|
|
%24 = OpConstant %6 1
|
|
%38 = OpConstant %6 100
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
%43 = OpVariable %10 Function
|
|
%44 = OpVariable %10 Function
|
|
%45 = OpVariable %10 Function
|
|
%31 = OpVariable %10 Function
|
|
OpStore %31 %12
|
|
OpBranch %32
|
|
%32 = OpLabel
|
|
OpLoopMerge %34 %35 None
|
|
OpBranchConditional %100 %35 %36
|
|
%36 = OpLabel
|
|
%37 = OpLoad %6 %31
|
|
%39 = OpSLessThan %21 %37 %38
|
|
OpBranchConditional %39 %33 %34
|
|
%33 = OpLabel
|
|
OpBranchConditional %100 %35 %35
|
|
%35 = OpLabel
|
|
OpStore %43 %12
|
|
OpStore %44 %12
|
|
OpBranch %46
|
|
%46 = OpLabel
|
|
OpLoopMerge %47 %48 None
|
|
OpBranchConditional %100 %48 %49
|
|
%49 = OpLabel
|
|
%50 = OpLoad %6 %44
|
|
%51 = OpSLessThan %21 %50 %20
|
|
OpBranchConditional %51 %52 %47
|
|
%52 = OpLabel
|
|
%53 = OpLoad %6 %43
|
|
OpBranchConditional %100 %48 %101
|
|
%101 = OpLabel
|
|
%54 = OpIAdd %6 %53 %24
|
|
OpStore %43 %54
|
|
OpBranchConditional %100 %48 %48
|
|
%48 = OpLabel
|
|
%55 = OpLoad %6 %44
|
|
%56 = OpIAdd %6 %55 %24
|
|
OpStore %44 %56
|
|
OpBranch %46
|
|
%47 = OpLabel
|
|
%57 = OpLoad %6 %43
|
|
OpStore %45 %57
|
|
%40 = OpLoad %6 %45
|
|
%41 = OpLoad %6 %31
|
|
%42 = OpIAdd %6 %41 %40
|
|
OpStore %31 %42
|
|
OpBranch %32
|
|
%34 = OpLabel
|
|
OpReturn
|
|
OpFunctionEnd
|
|
)";
|
|
|
|
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
|
|
}
|
|
|
|
TEST(TransformationAddDeadContinueTest, PhiInstructions) {
|
|
// Checks that the transformation works in the presence of phi instructions.
|
|
|
|
// The SPIR-V for this test is adapted from the following GLSL, with a bit of
|
|
// extra and artificial work to get some interesting uses of OpPhi:
|
|
//
|
|
// void main() {
|
|
// int x; int y;
|
|
// float f;
|
|
// x = 2;
|
|
// f = 3.0;
|
|
// if (x > y) {
|
|
// x = 3;
|
|
// f = 4.0;
|
|
// } else {
|
|
// x = x + 2;
|
|
// f = f + 10.0;
|
|
// }
|
|
// while (x < y) {
|
|
// x = x + 1;
|
|
// f = f + 1.0;
|
|
// }
|
|
// y = x;
|
|
// f = f + 3.0;
|
|
// }
|
|
|
|
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 %8 "x"
|
|
OpName %12 "f"
|
|
OpName %15 "y"
|
|
%2 = OpTypeVoid
|
|
%3 = OpTypeFunction %2
|
|
%6 = OpTypeInt 32 1
|
|
%7 = OpTypePointer Function %6
|
|
%9 = OpConstant %6 2
|
|
%10 = OpTypeFloat 32
|
|
%11 = OpTypePointer Function %10
|
|
%13 = OpConstant %10 3
|
|
%17 = OpTypeBool
|
|
%80 = OpConstantTrue %17
|
|
%21 = OpConstant %6 3
|
|
%22 = OpConstant %10 4
|
|
%27 = OpConstant %10 10
|
|
%38 = OpConstant %6 1
|
|
%41 = OpConstant %10 1
|
|
%46 = OpUndef %6
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
%8 = OpVariable %7 Function
|
|
%12 = OpVariable %11 Function
|
|
%15 = OpVariable %7 Function
|
|
OpStore %8 %9
|
|
OpStore %12 %13
|
|
%18 = OpSGreaterThan %17 %9 %46
|
|
OpSelectionMerge %20 None
|
|
OpBranchConditional %18 %19 %23
|
|
%19 = OpLabel
|
|
OpStore %8 %21
|
|
OpStore %12 %22
|
|
OpBranch %20
|
|
%23 = OpLabel
|
|
%25 = OpIAdd %6 %9 %9
|
|
OpStore %8 %25
|
|
OpBranch %70
|
|
%70 = OpLabel
|
|
%28 = OpFAdd %10 %13 %27
|
|
OpStore %12 %28
|
|
OpBranch %20
|
|
%20 = OpLabel
|
|
%52 = OpPhi %10 %22 %19 %28 %70
|
|
%48 = OpPhi %6 %21 %19 %25 %70
|
|
OpBranch %29
|
|
%29 = OpLabel
|
|
%51 = OpPhi %10 %52 %20 %100 %32
|
|
%47 = OpPhi %6 %48 %20 %101 %32
|
|
OpLoopMerge %31 %32 None
|
|
OpBranch %33
|
|
%33 = OpLabel
|
|
%36 = OpSLessThan %17 %47 %46
|
|
OpBranchConditional %36 %30 %31
|
|
%30 = OpLabel
|
|
%39 = OpIAdd %6 %47 %38
|
|
OpStore %8 %39
|
|
OpBranch %75
|
|
%75 = OpLabel
|
|
%42 = OpFAdd %10 %51 %41
|
|
OpStore %12 %42
|
|
OpBranch %32
|
|
%32 = OpLabel
|
|
%100 = OpPhi %10 %42 %75
|
|
%101 = OpPhi %6 %39 %75
|
|
OpBranch %29
|
|
%31 = OpLabel
|
|
%71 = OpPhi %6 %47 %33
|
|
%72 = OpPhi %10 %51 %33
|
|
OpStore %15 %71
|
|
%45 = OpFAdd %10 %72 %13
|
|
OpStore %12 %45
|
|
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<FactManager>(context.get()), validator_options);
|
|
std::vector<uint32_t> bad = {5, 19, 20, 23, 31, 32, 33, 70};
|
|
|
|
std::vector<uint32_t> good = {29, 30, 75};
|
|
|
|
for (uint32_t from_block : bad) {
|
|
ASSERT_FALSE(TransformationAddDeadContinue(from_block, true, {})
|
|
.IsApplicable(context.get(), transformation_context));
|
|
}
|
|
auto transformation1 = TransformationAddDeadContinue(29, true, {13, 21});
|
|
ASSERT_TRUE(
|
|
transformation1.IsApplicable(context.get(), transformation_context));
|
|
ApplyAndCheckFreshIds(transformation1, context.get(),
|
|
&transformation_context);
|
|
|
|
auto transformation2 = TransformationAddDeadContinue(30, true, {22, 46});
|
|
ASSERT_TRUE(
|
|
transformation2.IsApplicable(context.get(), transformation_context));
|
|
ApplyAndCheckFreshIds(transformation2, context.get(),
|
|
&transformation_context);
|
|
|
|
// 75 already has the continue block as a successor, so we should not provide
|
|
// phi ids.
|
|
auto transformationBad = TransformationAddDeadContinue(75, true, {27, 46});
|
|
ASSERT_FALSE(
|
|
transformationBad.IsApplicable(context.get(), transformation_context));
|
|
|
|
auto transformation3 = TransformationAddDeadContinue(75, true, {});
|
|
ASSERT_TRUE(
|
|
transformation3.IsApplicable(context.get(), transformation_context));
|
|
ApplyAndCheckFreshIds(transformation3, context.get(),
|
|
&transformation_context);
|
|
|
|
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
|
|
OpName %4 "main"
|
|
OpName %8 "x"
|
|
OpName %12 "f"
|
|
OpName %15 "y"
|
|
%2 = OpTypeVoid
|
|
%3 = OpTypeFunction %2
|
|
%6 = OpTypeInt 32 1
|
|
%7 = OpTypePointer Function %6
|
|
%9 = OpConstant %6 2
|
|
%10 = OpTypeFloat 32
|
|
%11 = OpTypePointer Function %10
|
|
%13 = OpConstant %10 3
|
|
%17 = OpTypeBool
|
|
%80 = OpConstantTrue %17
|
|
%21 = OpConstant %6 3
|
|
%22 = OpConstant %10 4
|
|
%27 = OpConstant %10 10
|
|
%38 = OpConstant %6 1
|
|
%41 = OpConstant %10 1
|
|
%46 = OpUndef %6
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
%8 = OpVariable %7 Function
|
|
%12 = OpVariable %11 Function
|
|
%15 = OpVariable %7 Function
|
|
OpStore %8 %9
|
|
OpStore %12 %13
|
|
%18 = OpSGreaterThan %17 %9 %46
|
|
OpSelectionMerge %20 None
|
|
OpBranchConditional %18 %19 %23
|
|
%19 = OpLabel
|
|
OpStore %8 %21
|
|
OpStore %12 %22
|
|
OpBranch %20
|
|
%23 = OpLabel
|
|
%25 = OpIAdd %6 %9 %9
|
|
OpStore %8 %25
|
|
OpBranch %70
|
|
%70 = OpLabel
|
|
%28 = OpFAdd %10 %13 %27
|
|
OpStore %12 %28
|
|
OpBranch %20
|
|
%20 = OpLabel
|
|
%52 = OpPhi %10 %22 %19 %28 %70
|
|
%48 = OpPhi %6 %21 %19 %25 %70
|
|
OpBranch %29
|
|
%29 = OpLabel
|
|
%51 = OpPhi %10 %52 %20 %100 %32
|
|
%47 = OpPhi %6 %48 %20 %101 %32
|
|
OpLoopMerge %31 %32 None
|
|
OpBranchConditional %80 %33 %32
|
|
%33 = OpLabel
|
|
%36 = OpSLessThan %17 %47 %46
|
|
OpBranchConditional %36 %30 %31
|
|
%30 = OpLabel
|
|
%39 = OpIAdd %6 %47 %38
|
|
OpStore %8 %39
|
|
OpBranchConditional %80 %75 %32
|
|
%75 = OpLabel
|
|
%42 = OpFAdd %10 %51 %41
|
|
OpStore %12 %42
|
|
OpBranchConditional %80 %32 %32
|
|
%32 = OpLabel
|
|
%100 = OpPhi %10 %42 %75 %13 %29 %22 %30
|
|
%101 = OpPhi %6 %39 %75 %21 %29 %46 %30
|
|
OpBranch %29
|
|
%31 = OpLabel
|
|
%71 = OpPhi %6 %47 %33
|
|
%72 = OpPhi %10 %51 %33
|
|
OpStore %15 %71
|
|
%45 = OpFAdd %10 %72 %13
|
|
OpStore %12 %45
|
|
OpReturn
|
|
OpFunctionEnd
|
|
)";
|
|
|
|
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
|
|
}
|
|
|
|
TEST(TransformationAddDeadContinueTest, RespectDominanceRules1) {
|
|
// Checks that a dead continue cannot be added if it would prevent a block
|
|
// later in the loop from dominating the loop's continue construct, in the
|
|
// case where said block defines and id that is used in the loop's continue
|
|
// construct.
|
|
|
|
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"
|
|
%2 = OpTypeVoid
|
|
%3 = OpTypeFunction %2
|
|
%10 = OpTypeBool
|
|
%11 = OpConstantFalse %10
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
OpBranch %6
|
|
%6 = OpLabel
|
|
OpLoopMerge %8 %9 None
|
|
OpBranch %7
|
|
%7 = OpLabel
|
|
%21 = OpCopyObject %10 %11
|
|
OpBranch %9
|
|
%9 = OpLabel
|
|
%20 = OpPhi %10 %21 %7
|
|
OpBranchConditional %11 %6 %8
|
|
%8 = OpLabel
|
|
OpBranch %12
|
|
%12 = OpLabel
|
|
OpLoopMerge %14 %15 None
|
|
OpBranch %13
|
|
%13 = OpLabel
|
|
OpBranch %22
|
|
%22 = OpLabel
|
|
%23 = OpCopyObject %10 %11
|
|
OpBranch %25
|
|
%25 = OpLabel
|
|
OpBranch %15
|
|
%15 = OpLabel
|
|
%26 = OpCopyObject %10 %23
|
|
OpBranchConditional %11 %12 %14
|
|
%14 = 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));
|
|
TransformationContext transformation_context(
|
|
MakeUnique<FactManager>(context.get()), validator_options);
|
|
// This transformation is not applicable because the dead continue from the
|
|
// loop body prevents the definition of %23 later in the loop body from
|
|
// dominating its use in the loop's continue target.
|
|
auto bad_transformation = TransformationAddDeadContinue(13, false, {});
|
|
ASSERT_FALSE(
|
|
bad_transformation.IsApplicable(context.get(), transformation_context));
|
|
|
|
auto good_transformation_1 = TransformationAddDeadContinue(7, false, {});
|
|
ASSERT_TRUE(good_transformation_1.IsApplicable(context.get(),
|
|
transformation_context));
|
|
ApplyAndCheckFreshIds(good_transformation_1, context.get(),
|
|
&transformation_context);
|
|
|
|
auto good_transformation_2 = TransformationAddDeadContinue(22, false, {});
|
|
ASSERT_TRUE(good_transformation_2.IsApplicable(context.get(),
|
|
transformation_context));
|
|
ApplyAndCheckFreshIds(good_transformation_2, context.get(),
|
|
&transformation_context);
|
|
|
|
// This transformation is OK, because the definition of %21 in the loop body
|
|
// is only used in an OpPhi in the loop's continue target.
|
|
auto good_transformation_3 = TransformationAddDeadContinue(6, false, {11});
|
|
ASSERT_TRUE(good_transformation_3.IsApplicable(context.get(),
|
|
transformation_context));
|
|
ApplyAndCheckFreshIds(good_transformation_3, context.get(),
|
|
&transformation_context);
|
|
|
|
std::string after_transformations = R"(
|
|
OpCapability Shader
|
|
%1 = OpExtInstImport "GLSL.std.450"
|
|
OpMemoryModel Logical GLSL450
|
|
OpEntryPoint Fragment %4 "main"
|
|
OpExecutionMode %4 OriginUpperLeft
|
|
OpSource ESSL 310
|
|
OpName %4 "main"
|
|
%2 = OpTypeVoid
|
|
%3 = OpTypeFunction %2
|
|
%10 = OpTypeBool
|
|
%11 = OpConstantFalse %10
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
OpBranch %6
|
|
%6 = OpLabel
|
|
OpLoopMerge %8 %9 None
|
|
OpBranchConditional %11 %9 %7
|
|
%7 = OpLabel
|
|
%21 = OpCopyObject %10 %11
|
|
OpBranchConditional %11 %9 %9
|
|
%9 = OpLabel
|
|
%20 = OpPhi %10 %21 %7 %11 %6
|
|
OpBranchConditional %11 %6 %8
|
|
%8 = OpLabel
|
|
OpBranch %12
|
|
%12 = OpLabel
|
|
OpLoopMerge %14 %15 None
|
|
OpBranch %13
|
|
%13 = OpLabel
|
|
OpBranch %22
|
|
%22 = OpLabel
|
|
%23 = OpCopyObject %10 %11
|
|
OpBranchConditional %11 %15 %25
|
|
%25 = OpLabel
|
|
OpBranch %15
|
|
%15 = OpLabel
|
|
%26 = OpCopyObject %10 %23
|
|
OpBranchConditional %11 %12 %14
|
|
%14 = OpLabel
|
|
OpReturn
|
|
OpFunctionEnd
|
|
)";
|
|
|
|
ASSERT_TRUE(IsEqual(env, after_transformations, context.get()));
|
|
}
|
|
|
|
TEST(TransformationAddDeadContinueTest, RespectDominanceRules2) {
|
|
// Checks that a dead continue cannot be added if it would lead to a use after
|
|
// the loop failing to be dominated by its definition.
|
|
|
|
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"
|
|
%2 = OpTypeVoid
|
|
%3 = OpTypeFunction %2
|
|
%10 = OpTypeBool
|
|
%11 = OpConstantFalse %10
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
OpBranch %100
|
|
%100 = OpLabel
|
|
OpLoopMerge %101 %102 None
|
|
OpBranch %103
|
|
%103 = OpLabel
|
|
%200 = OpCopyObject %10 %11
|
|
OpBranch %104
|
|
%104 = OpLabel
|
|
OpBranch %102
|
|
%102 = OpLabel
|
|
OpBranchConditional %11 %100 %101
|
|
%101 = OpLabel
|
|
%201 = OpCopyObject %10 %200
|
|
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<FactManager>(context.get()), validator_options);
|
|
// This transformation would shortcut the part of the loop body that defines
|
|
// an id used after the loop.
|
|
auto bad_transformation = TransformationAddDeadContinue(100, false, {});
|
|
ASSERT_FALSE(
|
|
bad_transformation.IsApplicable(context.get(), transformation_context));
|
|
}
|
|
|
|
TEST(TransformationAddDeadContinueTest, RespectDominanceRules3) {
|
|
// Checks that a dead continue cannot be added if it would lead to a dominance
|
|
// problem with an id used in an OpPhi after the loop.
|
|
|
|
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"
|
|
%2 = OpTypeVoid
|
|
%3 = OpTypeFunction %2
|
|
%10 = OpTypeBool
|
|
%11 = OpConstantFalse %10
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
OpBranch %100
|
|
%100 = OpLabel
|
|
OpLoopMerge %101 %102 None
|
|
OpBranch %103
|
|
%103 = OpLabel
|
|
%200 = OpCopyObject %10 %11
|
|
OpBranch %104
|
|
%104 = OpLabel
|
|
OpBranch %102
|
|
%102 = OpLabel
|
|
OpBranchConditional %11 %100 %101
|
|
%101 = OpLabel
|
|
%201 = OpPhi %10 %200 %102
|
|
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<FactManager>(context.get()), validator_options);
|
|
// This transformation would shortcut the part of the loop body that defines
|
|
// an id used after the loop.
|
|
auto bad_transformation = TransformationAddDeadContinue(100, false, {});
|
|
ASSERT_FALSE(
|
|
bad_transformation.IsApplicable(context.get(), transformation_context));
|
|
}
|
|
|
|
TEST(TransformationAddDeadContinueTest, Miscellaneous1) {
|
|
// A miscellaneous test that exposed a bug in spirv-fuzz.
|
|
|
|
std::string shader = R"(
|
|
OpCapability Shader
|
|
%1 = OpExtInstImport "GLSL.std.450"
|
|
OpMemoryModel Logical GLSL450
|
|
OpEntryPoint Fragment %4 "main" %586 %623
|
|
OpExecutionMode %4 OriginUpperLeft
|
|
OpSource ESSL 310
|
|
OpMemberDecorate %34 0 Offset 0
|
|
OpDecorate %34 Block
|
|
OpDecorate %36 DescriptorSet 0
|
|
OpDecorate %36 Binding 0
|
|
OpDecorate %586 BuiltIn FragCoord
|
|
OpMemberDecorate %591 0 Offset 0
|
|
OpDecorate %591 Block
|
|
OpDecorate %593 DescriptorSet 0
|
|
OpDecorate %593 Binding 1
|
|
OpDecorate %623 Location 0
|
|
%2 = OpTypeVoid
|
|
%3 = OpTypeFunction %2
|
|
%6 = OpTypeInt 32 1
|
|
%7 = OpTypePointer Function %6
|
|
%9 = OpConstant %6 0
|
|
%16 = OpConstant %6 2
|
|
%17 = OpTypeBool
|
|
%27 = OpTypeFloat 32
|
|
%28 = OpTypeVector %27 2
|
|
%29 = OpTypeMatrix %28 2
|
|
%30 = OpTypePointer Private %29
|
|
%31 = OpVariable %30 Private
|
|
%34 = OpTypeStruct %27
|
|
%35 = OpTypePointer Uniform %34
|
|
%36 = OpVariable %35 Uniform
|
|
%37 = OpTypePointer Uniform %27
|
|
%40 = OpTypePointer Private %27
|
|
%43 = OpConstant %6 1
|
|
%62 = OpConstant %6 3
|
|
%64 = OpTypeVector %27 3
|
|
%65 = OpTypeMatrix %64 2
|
|
%66 = OpTypePointer Private %65
|
|
%67 = OpVariable %66 Private
|
|
%92 = OpConstant %6 4
|
|
%94 = OpTypeVector %27 4
|
|
%95 = OpTypeMatrix %94 2
|
|
%96 = OpTypePointer Private %95
|
|
%97 = OpVariable %96 Private
|
|
%123 = OpTypeMatrix %28 3
|
|
%124 = OpTypePointer Private %123
|
|
%125 = OpVariable %124 Private
|
|
%151 = OpTypeMatrix %64 3
|
|
%152 = OpTypePointer Private %151
|
|
%153 = OpVariable %152 Private
|
|
%179 = OpTypeMatrix %94 3
|
|
%180 = OpTypePointer Private %179
|
|
%181 = OpVariable %180 Private
|
|
%207 = OpTypeMatrix %28 4
|
|
%208 = OpTypePointer Private %207
|
|
%209 = OpVariable %208 Private
|
|
%235 = OpTypeMatrix %64 4
|
|
%236 = OpTypePointer Private %235
|
|
%237 = OpVariable %236 Private
|
|
%263 = OpTypeMatrix %94 4
|
|
%264 = OpTypePointer Private %263
|
|
%265 = OpVariable %264 Private
|
|
%275 = OpTypeInt 32 0
|
|
%276 = OpConstant %275 9
|
|
%277 = OpTypeArray %27 %276
|
|
%278 = OpTypePointer Function %277
|
|
%280 = OpConstant %27 0
|
|
%281 = OpTypePointer Function %27
|
|
%311 = OpConstant %27 16
|
|
%448 = OpConstant %6 5
|
|
%482 = OpConstant %6 6
|
|
%516 = OpConstant %6 7
|
|
%550 = OpConstant %6 8
|
|
%585 = OpTypePointer Input %94
|
|
%586 = OpVariable %585 Input
|
|
%587 = OpConstant %275 0
|
|
%588 = OpTypePointer Input %27
|
|
%591 = OpTypeStruct %28
|
|
%592 = OpTypePointer Uniform %591
|
|
%593 = OpVariable %592 Uniform
|
|
%596 = OpConstant %27 3
|
|
%601 = OpConstant %275 1
|
|
%617 = OpConstant %6 9
|
|
%622 = OpTypePointer Output %94
|
|
%623 = OpVariable %622 Output
|
|
%628 = OpConstant %27 1
|
|
%634 = OpConstantComposite %94 %280 %280 %280 %628
|
|
%635 = OpUndef %6
|
|
%636 = OpUndef %17
|
|
%637 = OpUndef %27
|
|
%638 = OpUndef %64
|
|
%639 = OpUndef %94
|
|
%640 = OpConstantTrue %17
|
|
%736 = OpConstantFalse %17
|
|
%642 = OpVariable %37 Uniform
|
|
%643 = OpVariable %40 Private
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
OpBranch %164
|
|
%164 = OpLabel
|
|
OpLoopMerge %166 %167 None
|
|
OpBranch %165
|
|
%165 = OpLabel
|
|
OpBranch %172
|
|
%172 = OpLabel
|
|
OpSelectionMerge %174 None
|
|
OpBranchConditional %640 %174 %174
|
|
%174 = OpLabel
|
|
%785 = OpCopyObject %6 %43
|
|
OpBranch %167
|
|
%167 = OpLabel
|
|
%190 = OpIAdd %6 %9 %785
|
|
OpBranchConditional %640 %164 %166
|
|
%166 = OpLabel
|
|
OpBranch %196
|
|
%196 = OpLabel
|
|
OpBranch %194
|
|
%194 = 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));
|
|
TransformationContext transformation_context(
|
|
MakeUnique<FactManager>(context.get()), validator_options);
|
|
// This transformation would shortcut the part of the loop body that defines
|
|
// an id used in the continue target.
|
|
auto bad_transformation = TransformationAddDeadContinue(165, false, {});
|
|
ASSERT_FALSE(
|
|
bad_transformation.IsApplicable(context.get(), transformation_context));
|
|
}
|
|
|
|
TEST(TransformationAddDeadContinueTest, Miscellaneous2) {
|
|
// A miscellaneous test that exposed a bug in spirv-fuzz.
|
|
|
|
std::string 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
|
|
%51 = OpTypeBool
|
|
%395 = OpConstantTrue %51
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
OpBranch %389
|
|
%389 = OpLabel
|
|
OpLoopMerge %388 %391 None
|
|
OpBranch %339
|
|
%339 = OpLabel
|
|
OpSelectionMerge %396 None
|
|
OpBranchConditional %395 %388 %396
|
|
%396 = OpLabel
|
|
OpBranch %1552
|
|
%1552 = OpLabel
|
|
OpLoopMerge %1553 %1554 None
|
|
OpBranch %1556
|
|
%1556 = OpLabel
|
|
OpLoopMerge %1557 %1570 None
|
|
OpBranchConditional %395 %1562 %1557
|
|
%1562 = OpLabel
|
|
OpBranchConditional %395 %1571 %1570
|
|
%1571 = OpLabel
|
|
OpBranch %1557
|
|
%1570 = OpLabel
|
|
OpBranch %1556
|
|
%1557 = OpLabel
|
|
OpSelectionMerge %1586 None
|
|
OpBranchConditional %395 %1553 %1586
|
|
%1586 = OpLabel
|
|
OpBranch %1553
|
|
%1554 = OpLabel
|
|
OpBranch %1552
|
|
%1553 = OpLabel
|
|
OpBranch %388
|
|
%391 = OpLabel
|
|
OpBranch %389
|
|
%388 = 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));
|
|
TransformationContext transformation_context(
|
|
MakeUnique<FactManager>(context.get()), validator_options);
|
|
// This transformation would introduce a branch from a continue target to
|
|
// itself.
|
|
auto bad_transformation = TransformationAddDeadContinue(1554, true, {});
|
|
ASSERT_FALSE(
|
|
bad_transformation.IsApplicable(context.get(), transformation_context));
|
|
}
|
|
|
|
TEST(TransformationAddDeadContinueTest, Miscellaneous3) {
|
|
// A miscellaneous test that exposed a bug in spirv-fuzz.
|
|
|
|
std::string 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
|
|
%85 = OpTypeBool
|
|
%434 = OpConstantFalse %85
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
OpBranch %234
|
|
%234 = OpLabel
|
|
OpLoopMerge %235 %236 None
|
|
OpBranch %259
|
|
%259 = OpLabel
|
|
OpLoopMerge %260 %274 None
|
|
OpBranchConditional %434 %265 %260
|
|
%265 = OpLabel
|
|
OpBranch %275
|
|
%275 = OpLabel
|
|
OpBranch %260
|
|
%274 = OpLabel
|
|
OpBranch %259
|
|
%260 = OpLabel
|
|
OpSelectionMerge %298 None
|
|
OpBranchConditional %434 %299 %300
|
|
%300 = OpLabel
|
|
OpBranch %235
|
|
%298 = OpLabel
|
|
OpUnreachable
|
|
%236 = OpLabel
|
|
OpBranch %234
|
|
%299 = OpLabel
|
|
OpBranch %235
|
|
%235 = 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));
|
|
TransformationContext transformation_context(
|
|
MakeUnique<FactManager>(context.get()), validator_options);
|
|
auto bad_transformation = TransformationAddDeadContinue(299, false, {});
|
|
|
|
// The continue edge would connect %299 to the previously-unreachable %236,
|
|
// making %299 dominate %236, and breaking the rule that block ordering must
|
|
// respect dominance.
|
|
ASSERT_FALSE(
|
|
bad_transformation.IsApplicable(context.get(), transformation_context));
|
|
}
|
|
|
|
TEST(TransformationAddDeadContinueTest, Miscellaneous4) {
|
|
// A miscellaneous test that exposed a bug in spirv-fuzz.
|
|
|
|
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 %8 "i"
|
|
%2 = OpTypeVoid
|
|
%3 = OpTypeFunction %2
|
|
%6 = OpTypeInt 32 1
|
|
%7 = OpTypePointer Function %6
|
|
%9 = OpConstant %6 0
|
|
%16 = OpConstant %6 100
|
|
%17 = OpTypeBool
|
|
%100 = OpConstantFalse %17
|
|
%21 = OpConstant %6 1
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
%8 = OpVariable %7 Function
|
|
OpStore %8 %9
|
|
OpBranch %10
|
|
%13 = OpLabel
|
|
%20 = OpLoad %6 %8
|
|
%22 = OpIAdd %6 %20 %21
|
|
OpStore %8 %22
|
|
OpBranch %10
|
|
%10 = OpLabel
|
|
OpLoopMerge %12 %13 None
|
|
OpBranch %14
|
|
%14 = OpLabel
|
|
%15 = OpLoad %6 %8
|
|
%18 = OpSLessThan %17 %15 %16
|
|
OpBranchConditional %18 %11 %12
|
|
%11 = OpLabel
|
|
OpBranch %12
|
|
%12 = 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));
|
|
TransformationContext transformation_context(
|
|
MakeUnique<FactManager>(context.get()), validator_options);
|
|
auto bad_transformation = TransformationAddDeadContinue(10, false, {});
|
|
|
|
// The continue edge would connect %10 to the previously-unreachable %13,
|
|
// making %10 dominate %13, and breaking the rule that block ordering must
|
|
// respect dominance.
|
|
ASSERT_FALSE(
|
|
bad_transformation.IsApplicable(context.get(), transformation_context));
|
|
}
|
|
|
|
TEST(TransformationAddDeadContinueTest, Miscellaneous5) {
|
|
// A miscellaneous test that exposed a bug in spirv-fuzz.
|
|
|
|
std::string 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 = OpTypePointer Function %6
|
|
%9 = OpConstantTrue %6
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
OpBranch %98
|
|
%98 = OpLabel
|
|
OpLoopMerge %100 %101 None
|
|
OpBranch %99
|
|
%99 = OpLabel
|
|
OpSelectionMerge %111 None
|
|
OpBranchConditional %9 %110 %111
|
|
%110 = OpLabel
|
|
OpBranch %100
|
|
%111 = OpLabel
|
|
%200 = OpCopyObject %6 %9
|
|
OpBranch %101
|
|
%101 = OpLabel
|
|
%201 = OpCopyObject %6 %200
|
|
OpBranchConditional %9 %98 %100
|
|
%100 = 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));
|
|
TransformationContext transformation_context(
|
|
MakeUnique<FactManager>(context.get()), validator_options);
|
|
auto bad_transformation = TransformationAddDeadContinue(110, true, {});
|
|
|
|
// The continue edge would lead to the use of %200 in block %101 no longer
|
|
// being dominated by its definition in block %111.
|
|
ASSERT_FALSE(
|
|
bad_transformation.IsApplicable(context.get(), transformation_context));
|
|
}
|
|
|
|
TEST(TransformationAddDeadContinueTest, Miscellaneous6) {
|
|
// A miscellaneous test that exposed a bug in spirv-fuzz.
|
|
|
|
std::string 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
|
|
%9 = OpConstantTrue %6
|
|
%4 = OpFunction %2 None %3
|
|
%5 = OpLabel
|
|
OpBranch %10
|
|
%10 = OpLabel
|
|
OpLoopMerge %13 %12 None
|
|
OpBranch %11
|
|
%11 = OpLabel
|
|
%20 = OpCopyObject %6 %9
|
|
OpBranch %12
|
|
%12 = OpLabel
|
|
OpBranchConditional %9 %10 %13
|
|
%13 = OpLabel
|
|
%21 = OpCopyObject %6 %20
|
|
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<FactManager>(context.get()), validator_options);
|
|
auto bad_transformation = TransformationAddDeadContinue(10, true, {});
|
|
|
|
ASSERT_FALSE(
|
|
bad_transformation.IsApplicable(context.get(), transformation_context));
|
|
}
|
|
|
|
} // namespace
|
|
} // namespace fuzz
|
|
} // namespace spvtools
|