AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-11-25 21:10:04 +00:00
Code Issues Packages Projects Releases Wiki Activity
1f07f483ef
SPIRV-Tools/test/fuzz/transformation_outline_function_test.cpp
Alastair Donaldson 0861a8fa21
spirv-fuzz: Fix OutlineFunction in presence of unreachable blocks (#4308) 
This change prevents TransformationOutlineFunction from outlining a
region of blocks if some block in the region has an unreachable
predecessor. This avoids a bug whereby the region would be outlined,
and the unreachable predecessors would be left behind, referring to
blocks that are no longer in the function.
2021-06-01 11:44:21 +01:00

3252 lines
118 KiB
C++
Raw Blame History

// 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_outline_function.h"
#include "gtest/gtest.h"
#include "source/fuzz/counter_overflow_id_source.h"
#include "source/fuzz/fuzzer_util.h"
#include "test/fuzz/fuzz_test_util.h"
namespace spvtools {
namespace fuzz {
namespace {
TEST(TransformationOutlineFunctionTest, TrivialOutline) {
// This tests outlining of a single, empty basic block.
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
%4 = OpFunction %2 None %3
%5 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(5, 5, /* not relevant */ 200,
100, 101, 102, 103,
/* not relevant */ 201, {}, {});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, 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"
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%4 = OpFunction %2 None %3
%5 = OpLabel
%103 = OpFunctionCall %2 %101
OpReturn
OpFunctionEnd
%101 = OpFunction %2 None %3
%102 = OpLabel
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationOutlineFunctionTest,
DoNotOutlineIfRegionStartsWithOpVariable) {
// This checks that we do not outline the first block of a function if it
// contains OpVariable.
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
%7 = OpTypeBool
%8 = OpTypePointer Function %7
%4 = OpFunction %2 None %3
%5 = OpLabel
%6 = OpVariable %8 Function
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(5, 5, /* not relevant */ 200,
100, 101, 102, 103,
/* not relevant */ 201, {}, {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationOutlineFunctionTest, OutlineInterestingControlFlowNoState) {
// This tests outlining of some non-trivial control flow, but such that the
// basic blocks in the control flow do not actually do anything.
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
%20 = OpTypeBool
%21 = OpConstantTrue %20
%3 = OpTypeFunction %2
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %6
%6 = OpLabel
OpBranch %7
%7 = OpLabel
OpSelectionMerge %9 None
OpBranchConditional %21 %8 %9
%8 = OpLabel
OpBranch %9
%9 = OpLabel
OpLoopMerge %12 %11 None
OpBranch %10
%10 = OpLabel
OpBranchConditional %21 %11 %12
%11 = OpLabel
OpBranch %9
%12 = OpLabel
OpBranch %13
%13 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(6, 13, /* not relevant */
200, 100, 101, 102, 103,
/* not relevant */ 201, {}, {});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, 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"
%2 = OpTypeVoid
%20 = OpTypeBool
%21 = OpConstantTrue %20
%3 = OpTypeFunction %2
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %6
%6 = OpLabel
%103 = OpFunctionCall %2 %101
OpReturn
OpFunctionEnd
%101 = OpFunction %2 None %3
%102 = OpLabel
OpBranch %7
%7 = OpLabel
OpSelectionMerge %9 None
OpBranchConditional %21 %8 %9
%8 = OpLabel
OpBranch %9
%9 = OpLabel
OpLoopMerge %12 %11 None
OpBranch %10
%10 = OpLabel
OpBranchConditional %21 %11 %12
%11 = OpLabel
OpBranch %9
%12 = OpLabel
OpBranch %13
%13 = OpLabel
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationOutlineFunctionTest, OutlineCodeThatGeneratesUnusedIds) {
// This tests outlining of a single basic block that does some computation,
// but that does not use nor generate ids required outside of the outlined
// region.
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
%20 = OpTypeInt 32 1
%21 = OpConstant %20 5
%3 = OpTypeFunction %2
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %6
%6 = OpLabel
%7 = OpCopyObject %20 %21
%8 = OpCopyObject %20 %21
%9 = OpIAdd %20 %7 %8
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(6, 6, /* not relevant */ 200,
100, 101, 102, 103,
/* not relevant */ 201, {}, {});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, 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"
%2 = OpTypeVoid
%20 = OpTypeInt 32 1
%21 = OpConstant %20 5
%3 = OpTypeFunction %2
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %6
%6 = OpLabel
%103 = OpFunctionCall %2 %101
OpReturn
OpFunctionEnd
%101 = OpFunction %2 None %3
%102 = OpLabel
%7 = OpCopyObject %20 %21
%8 = OpCopyObject %20 %21
%9 = OpIAdd %20 %7 %8
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationOutlineFunctionTest, OutlineCodeThatGeneratesSingleUsedId) {
// This tests outlining of a block that generates an id that is used in a
// later block.
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
%20 = OpTypeInt 32 1
%21 = OpConstant %20 5
%3 = OpTypeFunction %2
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %6
%6 = OpLabel
%7 = OpCopyObject %20 %21
%8 = OpCopyObject %20 %21
%9 = OpIAdd %20 %7 %8
OpBranch %10
%10 = OpLabel
%11 = OpCopyObject %20 %9
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(6, 6, 99, 100, 101, 102, 103,
105, {}, {{9, 104}});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, 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"
%2 = OpTypeVoid
%20 = OpTypeInt 32 1
%21 = OpConstant %20 5
%3 = OpTypeFunction %2
%99 = OpTypeStruct %20
%100 = OpTypeFunction %99
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %6
%6 = OpLabel
%103 = OpFunctionCall %99 %101
%9 = OpCompositeExtract %20 %103 0
OpBranch %10
%10 = OpLabel
%11 = OpCopyObject %20 %9
OpReturn
OpFunctionEnd
%101 = OpFunction %99 None %100
%102 = OpLabel
%7 = OpCopyObject %20 %21
%8 = OpCopyObject %20 %21
%104 = OpIAdd %20 %7 %8
%105 = OpCompositeConstruct %99 %104
OpReturnValue %105
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationOutlineFunctionTest, OutlineDiamondThatGeneratesSeveralIds) {
// This tests outlining of several blocks that generate a number of ids that
// are used in later blocks.
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
%20 = OpTypeInt 32 1
%21 = OpConstant %20 5
%22 = OpTypeBool
%3 = OpTypeFunction %2
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %6
%6 = OpLabel
%7 = OpCopyObject %20 %21
%8 = OpCopyObject %20 %21
%9 = OpSLessThan %22 %7 %8
OpSelectionMerge %12 None
OpBranchConditional %9 %10 %11
%10 = OpLabel
%13 = OpIAdd %20 %7 %8
OpBranch %12
%11 = OpLabel
%14 = OpIAdd %20 %7 %7
OpBranch %12
%12 = OpLabel
%15 = OpPhi %20 %13 %10 %14 %11
OpBranch %80
%80 = OpLabel
OpBranch %16
%16 = OpLabel
%17 = OpCopyObject %20 %15
%18 = OpCopyObject %22 %9
%19 = OpIAdd %20 %7 %8
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(
6, 80, 100, 101, 102, 103, 104, 105, {},
{{15, 106}, {9, 107}, {7, 108}, {8, 109}});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, 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"
%2 = OpTypeVoid
%20 = OpTypeInt 32 1
%21 = OpConstant %20 5
%22 = OpTypeBool
%3 = OpTypeFunction %2
%100 = OpTypeStruct %20 %20 %22 %20
%101 = OpTypeFunction %100
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %6
%6 = OpLabel
%104 = OpFunctionCall %100 %102
%7 = OpCompositeExtract %20 %104 0
%8 = OpCompositeExtract %20 %104 1
%9 = OpCompositeExtract %22 %104 2
%15 = OpCompositeExtract %20 %104 3
OpBranch %16
%16 = OpLabel
%17 = OpCopyObject %20 %15
%18 = OpCopyObject %22 %9
%19 = OpIAdd %20 %7 %8
OpReturn
OpFunctionEnd
%102 = OpFunction %100 None %101
%103 = OpLabel
%108 = OpCopyObject %20 %21
%109 = OpCopyObject %20 %21
%107 = OpSLessThan %22 %108 %109
OpSelectionMerge %12 None
OpBranchConditional %107 %10 %11
%10 = OpLabel
%13 = OpIAdd %20 %108 %109
OpBranch %12
%11 = OpLabel
%14 = OpIAdd %20 %108 %108
OpBranch %12
%12 = OpLabel
%106 = OpPhi %20 %13 %10 %14 %11
OpBranch %80
%80 = OpLabel
%105 = OpCompositeConstruct %100 %108 %109 %107 %106
OpReturnValue %105
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationOutlineFunctionTest, OutlineCodeThatUsesASingleId) {
// This tests outlining of a block that uses an id defined earlier.
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
%20 = OpTypeInt 32 1
%21 = OpConstant %20 5
%3 = OpTypeFunction %2
%4 = OpFunction %2 None %3
%5 = OpLabel
%7 = OpCopyObject %20 %21
OpBranch %6
%6 = OpLabel
%8 = OpCopyObject %20 %7
OpBranch %10
%10 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(6, 6, 100, 101, 102, 103, 104,
105, {{7, 106}}, {});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, 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"
%2 = OpTypeVoid
%20 = OpTypeInt 32 1
%21 = OpConstant %20 5
%3 = OpTypeFunction %2
%101 = OpTypeFunction %2 %20
%4 = OpFunction %2 None %3
%5 = OpLabel
%7 = OpCopyObject %20 %21
OpBranch %6
%6 = OpLabel
%104 = OpFunctionCall %2 %102 %7
OpBranch %10
%10 = OpLabel
OpReturn
OpFunctionEnd
%102 = OpFunction %2 None %101
%106 = OpFunctionParameter %20
%103 = OpLabel
%8 = OpCopyObject %20 %106
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationOutlineFunctionTest, OutlineCodeThatUsesAVariable) {
// This tests outlining of a block that uses a variable.
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
%20 = OpTypeInt 32 1
%21 = OpConstant %20 5
%3 = OpTypeFunction %2
%12 = OpTypePointer Function %20
%4 = OpFunction %2 None %3
%5 = OpLabel
%13 = OpVariable %12 Function
OpBranch %6
%6 = OpLabel
%8 = OpLoad %20 %13
OpBranch %10
%10 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(6, 6, 100, 101, 102, 103, 104,
105, {{13, 106}}, {});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, 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"
%2 = OpTypeVoid
%20 = OpTypeInt 32 1
%21 = OpConstant %20 5
%3 = OpTypeFunction %2
%12 = OpTypePointer Function %20
%101 = OpTypeFunction %2 %12
%4 = OpFunction %2 None %3
%5 = OpLabel
%13 = OpVariable %12 Function
OpBranch %6
%6 = OpLabel
%104 = OpFunctionCall %2 %102 %13
OpBranch %10
%10 = OpLabel
OpReturn
OpFunctionEnd
%102 = OpFunction %2 None %101
%106 = OpFunctionParameter %12
%103 = OpLabel
%8 = OpLoad %20 %106
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationOutlineFunctionTest, OutlineCodeThatUsesAParameter) {
// This tests outlining of a block that uses a function parameter.
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 %10 "foo(i1;"
OpName %9 "x"
OpName %18 "param"
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeInt 32 1
%7 = OpTypePointer Function %6
%8 = OpTypeFunction %6 %7
%13 = OpConstant %6 1
%17 = OpConstant %6 3
%4 = OpFunction %2 None %3
%5 = OpLabel
%18 = OpVariable %7 Function
OpStore %18 %17
%19 = OpFunctionCall %6 %10 %18
OpReturn
OpFunctionEnd
%10 = OpFunction %6 None %8
%9 = OpFunctionParameter %7
%11 = OpLabel
%12 = OpLoad %6 %9
%14 = OpIAdd %6 %12 %13
OpReturnValue %14
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(11, 11, 100, 101, 102, 103, 104,
105, {{9, 106}}, {{14, 107}});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, 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 %10 "foo(i1;"
OpName %9 "x"
OpName %18 "param"
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeInt 32 1
%7 = OpTypePointer Function %6
%8 = OpTypeFunction %6 %7
%13 = OpConstant %6 1
%17 = OpConstant %6 3
%100 = OpTypeStruct %6
%101 = OpTypeFunction %100 %7
%4 = OpFunction %2 None %3
%5 = OpLabel
%18 = OpVariable %7 Function
OpStore %18 %17
%19 = OpFunctionCall %6 %10 %18
OpReturn
OpFunctionEnd
%10 = OpFunction %6 None %8
%9 = OpFunctionParameter %7
%11 = OpLabel
%104 = OpFunctionCall %100 %102 %9
%14 = OpCompositeExtract %6 %104 0
OpReturnValue %14
OpFunctionEnd
%102 = OpFunction %100 None %101
%106 = OpFunctionParameter %7
%103 = OpLabel
%12 = OpLoad %6 %106
%107 = OpIAdd %6 %12 %13
%105 = OpCompositeConstruct %100 %107
OpReturnValue %105
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationOutlineFunctionTest,
DoNotOutlineIfLoopMergeIsOutsideRegion) {
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
%9 = OpTypeBool
%10 = OpConstantTrue %9
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %6
%6 = OpLabel
OpLoopMerge %7 %8 None
OpBranch %8
%8 = OpLabel
OpBranchConditional %10 %6 %7
%7 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(6, 8, 100, 101, 102, 103, 104,
105, {}, {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationOutlineFunctionTest, DoNotOutlineIfRegionInvolvesReturn) {
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
%20 = OpTypeBool
%21 = OpConstantTrue %20
%3 = OpTypeFunction %2
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %6
%6 = OpLabel
OpBranch %7
%7 = OpLabel
OpSelectionMerge %10 None
OpBranchConditional %21 %8 %9
%8 = OpLabel
OpReturn
%9 = OpLabel
OpBranch %10
%10 = OpLabel
OpBranch %11
%11 = OpLabel
OpBranch %12
%12 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(6, 11, /* not relevant */ 200,
100, 101, 102, 103,
/* not relevant */ 201, {}, {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationOutlineFunctionTest, DoNotOutlineIfRegionInvolvesKill) {
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
%20 = OpTypeBool
%21 = OpConstantTrue %20
%3 = OpTypeFunction %2
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %6
%6 = OpLabel
OpBranch %7
%7 = OpLabel
OpSelectionMerge %10 None
OpBranchConditional %21 %8 %9
%8 = OpLabel
OpKill
%9 = OpLabel
OpBranch %10
%10 = OpLabel
OpBranch %11
%11 = OpLabel
OpBranch %12
%12 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(6, 11, /* not relevant */ 200,
100, 101, 102, 103,
/* not relevant */ 201, {}, {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationOutlineFunctionTest,
DoNotOutlineIfRegionInvolvesUnreachable) {
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
%20 = OpTypeBool
%21 = OpConstantTrue %20
%3 = OpTypeFunction %2
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %6
%6 = OpLabel
OpBranch %7
%7 = OpLabel
OpSelectionMerge %10 None
OpBranchConditional %21 %8 %9
%8 = OpLabel
OpBranch %10
%9 = OpLabel
OpUnreachable
%10 = OpLabel
OpBranch %11
%11 = OpLabel
OpBranch %12
%12 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(6, 11, /* not relevant */ 200,
100, 101, 102, 103,
/* not relevant */ 201, {}, {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationOutlineFunctionTest,
DoNotOutlineIfSelectionMergeIsOutsideRegion) {
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
%9 = OpTypeBool
%10 = OpConstantTrue %9
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %6
%6 = OpLabel
OpSelectionMerge %7 None
OpBranchConditional %10 %8 %7
%8 = OpLabel
OpBranch %7
%7 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(6, 8, 100, 101, 102, 103, 104,
105, {}, {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationOutlineFunctionTest, DoNotOutlineIfLoopHeadIsOutsideRegion) {
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
%9 = OpTypeBool
%10 = OpConstantTrue %9
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %6
%6 = OpLabel
OpLoopMerge %8 %11 None
OpBranch %7
%7 = OpLabel
OpBranchConditional %10 %11 %8
%11 = OpLabel
OpBranch %6
%8 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(7, 8, 100, 101, 102, 103, 104,
105, {}, {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationOutlineFunctionTest,
DoNotOutlineIfLoopContinueIsOutsideRegion) {
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
%9 = OpTypeBool
%10 = OpConstantTrue %9
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %6
%6 = OpLabel
OpLoopMerge %7 %8 None
OpBranch %7
%8 = OpLabel
OpBranch %6
%7 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(6, 7, 100, 101, 102, 103, 104,
105, {}, {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationOutlineFunctionTest,
DoNotOutlineWithLoopCarriedPhiDependence) {
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
%9 = OpTypeBool
%10 = OpConstantTrue %9
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %6
%6 = OpLabel
%12 = OpPhi %9 %10 %5 %13 %8
OpLoopMerge %7 %8 None
OpBranch %8
%8 = OpLabel
%13 = OpCopyObject %9 %10
OpBranchConditional %10 %6 %7
%7 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(6, 7, 100, 101, 102, 103, 104,
105, {}, {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationOutlineFunctionTest,
DoNotOutlineSelectionHeaderNotInRegion) {
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
%6 = OpTypeBool
%7 = OpConstantTrue %6
%4 = OpFunction %2 None %3
%5 = OpLabel
OpSelectionMerge %10 None
OpBranchConditional %7 %8 %8
%8 = OpLabel
OpBranch %9
%9 = OpLabel
OpBranch %10
%10 = OpLabel
OpBranch %11
%11 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(8, 11, 100, 101, 102, 103, 104,
105, {}, {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationOutlineFunctionTest, OutlineRegionEndingWithReturnVoid) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 310
%20 = OpTypeInt 32 0
%21 = OpConstant %20 1
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%4 = OpFunction %2 None %3
%5 = OpLabel
%22 = OpCopyObject %20 %21
OpBranch %54
%54 = OpLabel
OpBranch %57
%57 = OpLabel
%23 = OpCopyObject %20 %22
OpBranch %58
%58 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
TransformationOutlineFunction transformation(
/*entry_block*/ 54,
/*exit_block*/ 58,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 203,
/*new_caller_result_id*/ 204,
/*new_callee_result_id*/ 205,
/*input_id_to_fresh_id*/ {{22, 206}},
/*output_id_to_fresh_id*/ {});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, 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
%20 = OpTypeInt 32 0
%21 = OpConstant %20 1
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%201 = OpTypeFunction %2 %20
%4 = OpFunction %2 None %3
%5 = OpLabel
%22 = OpCopyObject %20 %21
OpBranch %54
%54 = OpLabel
%204 = OpFunctionCall %2 %202 %22
OpReturn
OpFunctionEnd
%202 = OpFunction %2 None %201
%206 = OpFunctionParameter %20
%203 = OpLabel
OpBranch %57
%57 = OpLabel
%23 = OpCopyObject %20 %206
OpBranch %58
%58 = OpLabel
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationOutlineFunctionTest, OutlineRegionEndingWithReturnValue) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 310
%20 = OpTypeInt 32 0
%21 = OpConstant %20 1
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%30 = OpTypeFunction %20
%4 = OpFunction %2 None %3
%5 = OpLabel
%6 = OpFunctionCall %20 %100
OpReturn
OpFunctionEnd
%100 = OpFunction %20 None %30
%8 = OpLabel
%31 = OpCopyObject %20 %21
OpBranch %9
%9 = OpLabel
%32 = OpCopyObject %20 %31
OpBranch %10
%10 = OpLabel
OpReturnValue %32
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
TransformationOutlineFunction transformation(
/*entry_block*/ 9,
/*exit_block*/ 10,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 203,
/*new_caller_result_id*/ 204,
/*new_callee_result_id*/ 205,
/*input_id_to_fresh_id*/ {{31, 206}},
/*output_id_to_fresh_id*/ {{32, 207}});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, 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
%20 = OpTypeInt 32 0
%21 = OpConstant %20 1
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%30 = OpTypeFunction %20
%200 = OpTypeStruct %20
%201 = OpTypeFunction %200 %20
%4 = OpFunction %2 None %3
%5 = OpLabel
%6 = OpFunctionCall %20 %100
OpReturn
OpFunctionEnd
%100 = OpFunction %20 None %30
%8 = OpLabel
%31 = OpCopyObject %20 %21
OpBranch %9
%9 = OpLabel
%204 = OpFunctionCall %200 %202 %31
%32 = OpCompositeExtract %20 %204 0
OpReturnValue %32
OpFunctionEnd
%202 = OpFunction %200 None %201
%206 = OpFunctionParameter %20
%203 = OpLabel
%207 = OpCopyObject %20 %206
OpBranch %10
%10 = OpLabel
%205 = OpCompositeConstruct %200 %207
OpReturnValue %205
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationOutlineFunctionTest,
OutlineRegionEndingWithConditionalBranch) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 310
%20 = OpTypeBool
%21 = OpConstantTrue %20
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %54
%54 = OpLabel
%6 = OpCopyObject %20 %21
OpSelectionMerge %8 None
OpBranchConditional %6 %7 %8
%7 = OpLabel
OpBranch %8
%8 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
TransformationOutlineFunction transformation(
/*entry_block*/ 54,
/*exit_block*/ 54,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 203,
/*new_caller_result_id*/ 204,
/*new_callee_result_id*/ 205,
/*input_id_to_fresh_id*/ {{}},
/*output_id_to_fresh_id*/ {{6, 206}});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, 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
%20 = OpTypeBool
%21 = OpConstantTrue %20
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%200 = OpTypeStruct %20
%201 = OpTypeFunction %200
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %54
%54 = OpLabel
%204 = OpFunctionCall %200 %202
%6 = OpCompositeExtract %20 %204 0
OpSelectionMerge %8 None
OpBranchConditional %6 %7 %8
%7 = OpLabel
OpBranch %8
%8 = OpLabel
OpReturn
OpFunctionEnd
%202 = OpFunction %200 None %201
%203 = OpLabel
%206 = OpCopyObject %20 %21
%205 = OpCompositeConstruct %200 %206
OpReturnValue %205
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationOutlineFunctionTest,
OutlineRegionEndingWithConditionalBranch2) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 310
%20 = OpTypeBool
%21 = OpConstantTrue %20
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%4 = OpFunction %2 None %3
%5 = OpLabel
%6 = OpCopyObject %20 %21
OpBranch %54
%54 = OpLabel
OpSelectionMerge %8 None
OpBranchConditional %6 %7 %8
%7 = OpLabel
OpBranch %8
%8 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
TransformationOutlineFunction transformation(
/*entry_block*/ 54,
/*exit_block*/ 54,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 203,
/*new_caller_result_id*/ 204,
/*new_callee_result_id*/ 205,
/*input_id_to_fresh_id*/ {},
/*output_id_to_fresh_id*/ {});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, 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
%20 = OpTypeBool
%21 = OpConstantTrue %20
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%4 = OpFunction %2 None %3
%5 = OpLabel
%6 = OpCopyObject %20 %21
OpBranch %54
%54 = OpLabel
%204 = OpFunctionCall %2 %202
OpSelectionMerge %8 None
OpBranchConditional %6 %7 %8
%7 = OpLabel
OpBranch %8
%8 = OpLabel
OpReturn
OpFunctionEnd
%202 = OpFunction %2 None %3
%203 = OpLabel
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationOutlineFunctionTest, DoNotOutlineRegionThatStartsWithOpPhi) {
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
%6 = OpTypeBool
%7 = OpConstantTrue %6
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %21
%21 = OpLabel
%22 = OpPhi %6 %7 %5
%23 = OpCopyObject %6 %22
OpBranch %24
%24 = OpLabel
%25 = OpCopyObject %6 %23
%26 = OpCopyObject %6 %22
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
TransformationOutlineFunction transformation(
/*entry_block*/ 21,
/*exit_block*/ 21,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 204,
/*new_caller_result_id*/ 205,
/*new_callee_result_id*/ 206,
/*input_id_to_fresh_id*/ {{22, 207}},
/*output_id_to_fresh_id*/ {{23, 208}});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationOutlineFunctionTest,
DoNotOutlineRegionThatStartsWithLoopHeader) {
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
%6 = OpTypeBool
%7 = OpConstantTrue %6
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %21
%21 = OpLabel
OpLoopMerge %22 %23 None
OpBranch %24
%24 = OpLabel
OpBranchConditional %7 %22 %23
%23 = OpLabel
OpBranch %21
%22 = OpLabel
OpBranch %25
%25 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
TransformationOutlineFunction transformation(
/*entry_block*/ 21,
/*exit_block*/ 24,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 204,
/*new_caller_result_id*/ 205,
/*new_callee_result_id*/ 206,
/*input_id_to_fresh_id*/ {},
/*output_id_to_fresh_id*/ {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationOutlineFunctionTest,
DoNotOutlineRegionThatEndsWithLoopMerge) {
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
%6 = OpTypeBool
%7 = OpConstantTrue %6
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %21
%21 = OpLabel
OpLoopMerge %22 %23 None
OpBranch %24
%24 = OpLabel
OpBranchConditional %7 %22 %23
%23 = OpLabel
OpBranch %21
%22 = OpLabel
OpBranch %25
%25 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
TransformationOutlineFunction transformation(
/*entry_block*/ 5,
/*exit_block*/ 22,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 204,
/*new_caller_result_id*/ 205,
/*new_callee_result_id*/ 206,
/*input_id_to_fresh_id*/ {},
/*output_id_to_fresh_id*/ {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationOutlineFunctionTest, DoNotOutlineRegionThatUsesAccessChain) {
// An access chain result is a pointer, but it cannot be passed as a function
// parameter, as it is not a memory object.
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
%6 = OpTypeFloat 32
%7 = OpTypeVector %6 4
%8 = OpTypePointer Function %7
%9 = OpTypePointer Function %6
%18 = OpTypeInt 32 0
%19 = OpConstant %18 0
%4 = OpFunction %2 None %3
%5 = OpLabel
%10 = OpVariable %8 Function
OpBranch %11
%11 = OpLabel
%12 = OpAccessChain %9 %10 %19
OpBranch %13
%13 = OpLabel
%14 = OpLoad %6 %12
OpBranch %15
%15 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
TransformationOutlineFunction transformation(
/*entry_block*/ 13,
/*exit_block*/ 15,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 204,
/*new_caller_result_id*/ 205,
/*new_callee_result_id*/ 206,
/*input_id_to_fresh_id*/ {{12, 207}},
/*output_id_to_fresh_id*/ {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationOutlineFunctionTest,
DoNotOutlineRegionThatUsesCopiedObject) {
// Copying a variable leads to a pointer, but one that cannot be passed as a
// function parameter, as it is not a memory object.
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
%6 = OpTypeFloat 32
%7 = OpTypeVector %6 4
%8 = OpTypePointer Function %7
%9 = OpTypePointer Function %6
%18 = OpTypeInt 32 0
%19 = OpConstant %18 0
%4 = OpFunction %2 None %3
%5 = OpLabel
%10 = OpVariable %8 Function
OpBranch %11
%11 = OpLabel
%20 = OpCopyObject %8 %10
OpBranch %13
%13 = OpLabel
%12 = OpAccessChain %9 %20 %19
%14 = OpLoad %6 %12
OpBranch %15
%15 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
TransformationOutlineFunction transformation(
/*entry_block*/ 13,
/*exit_block*/ 15,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 204,
/*new_caller_result_id*/ 205,
/*new_callee_result_id*/ 206,
/*input_id_to_fresh_id*/ {{20, 207}},
/*output_id_to_fresh_id*/ {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationOutlineFunctionTest,
DoOutlineRegionThatUsesPointerParameter) {
// The region being outlined reads from a function parameter of pointer type.
// This is OK: the function parameter can itself be passed on as a function
// parameter.
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 = OpTypeInt 32 1
%7 = OpTypePointer Function %6
%8 = OpTypeFunction %2 %7
%13 = OpConstant %6 2
%4 = OpFunction %2 None %3
%5 = OpLabel
%15 = OpVariable %7 Function
%16 = OpVariable %7 Function
%17 = OpLoad %6 %15
OpStore %16 %17
%18 = OpFunctionCall %2 %10 %16
%19 = OpLoad %6 %16
OpStore %15 %19
OpReturn
OpFunctionEnd
%10 = OpFunction %2 None %8
%9 = OpFunctionParameter %7
%11 = OpLabel
%12 = OpLoad %6 %9
%14 = OpIAdd %6 %12 %13
OpBranch %20
%20 = OpLabel
OpStore %9 %14
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
TransformationOutlineFunction transformation(
/*entry_block*/ 11,
/*exit_block*/ 11,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 204,
/*new_caller_result_id*/ 205,
/*new_callee_result_id*/ 206,
/*input_id_to_fresh_id*/ {{9, 207}},
/*output_id_to_fresh_id*/ {{14, 208}});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, 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
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeInt 32 1
%7 = OpTypePointer Function %6
%8 = OpTypeFunction %2 %7
%13 = OpConstant %6 2
%200 = OpTypeStruct %6
%201 = OpTypeFunction %200 %7
%4 = OpFunction %2 None %3
%5 = OpLabel
%15 = OpVariable %7 Function
%16 = OpVariable %7 Function
%17 = OpLoad %6 %15
OpStore %16 %17
%18 = OpFunctionCall %2 %10 %16
%19 = OpLoad %6 %16
OpStore %15 %19
OpReturn
OpFunctionEnd
%10 = OpFunction %2 None %8
%9 = OpFunctionParameter %7
%11 = OpLabel
%205 = OpFunctionCall %200 %202 %9
%14 = OpCompositeExtract %6 %205 0
OpBranch %20
%20 = OpLabel
OpStore %9 %14
OpReturn
OpFunctionEnd
%202 = OpFunction %200 None %201
%207 = OpFunctionParameter %7
%204 = OpLabel
%12 = OpLoad %6 %207
%208 = OpIAdd %6 %12 %13
%206 = OpCompositeConstruct %200 %208
OpReturnValue %206
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationOutlineFunctionTest, OutlineLivesafe) {
// In the following, %30 is a livesafe function, with irrelevant parameter
// %200 and irrelevant local variable %201. Variable %100 is a loop limiter,
// which is not irrelevant. The test checks that the outlined function is
// livesafe, and that the parameters corresponding to %200 and %201 have the
// irrelevant fact associated with them.
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 = OpTypeInt 32 0
%7 = OpTypePointer Function %6
%199 = OpTypeFunction %2 %7
%8 = OpConstant %6 0
%9 = OpConstant %6 1
%10 = OpConstant %6 5
%11 = OpTypeBool
%12 = OpConstantTrue %11
%4 = OpFunction %2 None %3
%5 = OpLabel
OpReturn
OpFunctionEnd
%30 = OpFunction %2 None %199
%200 = OpFunctionParameter %7
%31 = OpLabel
%100 = OpVariable %7 Function %8
%201 = OpVariable %7 Function %8
OpBranch %198
%198 = OpLabel
OpBranch %20
%20 = OpLabel
%101 = OpLoad %6 %100
%102 = OpIAdd %6 %101 %9
%202 = OpLoad %6 %200
OpStore %201 %202
OpStore %100 %102
%103 = OpUGreaterThanEqual %11 %101 %10
OpLoopMerge %21 %22 None
OpBranchConditional %103 %21 %104
%104 = OpLabel
OpBranchConditional %12 %23 %21
%23 = OpLabel
%105 = OpLoad %6 %100
%106 = OpIAdd %6 %105 %9
OpStore %100 %106
%107 = OpUGreaterThanEqual %11 %105 %10
OpLoopMerge %25 %26 None
OpBranchConditional %107 %25 %108
%108 = OpLabel
OpBranch %28
%28 = OpLabel
OpBranchConditional %12 %26 %25
%26 = OpLabel
OpBranch %23
%25 = OpLabel
%109 = OpLoad %6 %100
%110 = OpIAdd %6 %109 %9
OpStore %100 %110
%111 = OpUGreaterThanEqual %11 %109 %10
OpLoopMerge %24 %27 None
OpBranchConditional %111 %24 %112
%112 = OpLabel
OpBranchConditional %12 %24 %27
%27 = OpLabel
OpBranch %25
%24 = OpLabel
OpBranch %22
%22 = OpLabel
OpBranch %20
%21 = OpLabel
OpBranch %197
%197 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
transformation_context.GetFactManager()->AddFactFunctionIsLivesafe(30);
transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant(
200);
transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant(
201);
TransformationOutlineFunction transformation(
/*entry_block*/ 198,
/*exit_block*/ 197,
/*new_function_struct_return_type_id*/ 400,
/*new_function_type_id*/ 401,
/*new_function_id*/ 402,
/*new_function_region_entry_block*/ 404,
/*new_caller_result_id*/ 405,
/*new_callee_result_id*/ 406,
/*input_id_to_fresh_id*/ {{100, 407}, {200, 408}, {201, 409}},
/*output_id_to_fresh_id*/ {});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
// The original function should still be livesafe.
ASSERT_TRUE(transformation_context.GetFactManager()->FunctionIsLivesafe(30));
// The outlined function should be livesafe.
ASSERT_TRUE(transformation_context.GetFactManager()->FunctionIsLivesafe(402));
// The variable and parameter that were originally irrelevant should still be.
ASSERT_TRUE(
transformation_context.GetFactManager()->PointeeValueIsIrrelevant(200));
ASSERT_TRUE(
transformation_context.GetFactManager()->PointeeValueIsIrrelevant(201));
// The loop limiter should still be non-irrelevant.
ASSERT_FALSE(
transformation_context.GetFactManager()->PointeeValueIsIrrelevant(100));
// The parameters for the original irrelevant variables should be irrelevant.
ASSERT_TRUE(
transformation_context.GetFactManager()->PointeeValueIsIrrelevant(408));
ASSERT_TRUE(
transformation_context.GetFactManager()->PointeeValueIsIrrelevant(409));
// The parameter for the loop limiter should not be irrelevant.
ASSERT_FALSE(
transformation_context.GetFactManager()->PointeeValueIsIrrelevant(407));
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
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeInt 32 0
%7 = OpTypePointer Function %6
%199 = OpTypeFunction %2 %7
%8 = OpConstant %6 0
%9 = OpConstant %6 1
%10 = OpConstant %6 5
%11 = OpTypeBool
%12 = OpConstantTrue %11
%401 = OpTypeFunction %2 %7 %7 %7
%4 = OpFunction %2 None %3
%5 = OpLabel
OpReturn
OpFunctionEnd
%30 = OpFunction %2 None %199
%200 = OpFunctionParameter %7
%31 = OpLabel
%100 = OpVariable %7 Function %8
%201 = OpVariable %7 Function %8
OpBranch %198
%198 = OpLabel
%405 = OpFunctionCall %2 %402 %200 %100 %201
OpReturn
OpFunctionEnd
%402 = OpFunction %2 None %401
%408 = OpFunctionParameter %7
%407 = OpFunctionParameter %7
%409 = OpFunctionParameter %7
%404 = OpLabel
OpBranch %20
%20 = OpLabel
%101 = OpLoad %6 %407
%102 = OpIAdd %6 %101 %9
%202 = OpLoad %6 %408
OpStore %409 %202
OpStore %407 %102
%103 = OpUGreaterThanEqual %11 %101 %10
OpLoopMerge %21 %22 None
OpBranchConditional %103 %21 %104
%104 = OpLabel
OpBranchConditional %12 %23 %21
%23 = OpLabel
%105 = OpLoad %6 %407
%106 = OpIAdd %6 %105 %9
OpStore %407 %106
%107 = OpUGreaterThanEqual %11 %105 %10
OpLoopMerge %25 %26 None
OpBranchConditional %107 %25 %108
%108 = OpLabel
OpBranch %28
%28 = OpLabel
OpBranchConditional %12 %26 %25
%26 = OpLabel
OpBranch %23
%25 = OpLabel
%109 = OpLoad %6 %407
%110 = OpIAdd %6 %109 %9
OpStore %407 %110
%111 = OpUGreaterThanEqual %11 %109 %10
OpLoopMerge %24 %27 None
OpBranchConditional %111 %24 %112
%112 = OpLabel
OpBranchConditional %12 %24 %27
%27 = OpLabel
OpBranch %25
%24 = OpLabel
OpBranch %22
%22 = OpLabel
OpBranch %20
%21 = OpLabel
OpBranch %197
%197 = OpLabel
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationOutlineFunctionTest, OutlineWithDeadBlocks1) {
// This checks that if all blocks in the region being outlined were dead, all
// blocks in the outlined function will be dead.
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 %10 "foo(i1;"
OpName %9 "x"
OpName %12 "y"
OpName %21 "i"
OpName %46 "param"
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeInt 32 1
%7 = OpTypePointer Function %6
%8 = OpTypeFunction %2 %7
%13 = OpConstant %6 2
%14 = OpTypeBool
%15 = OpConstantFalse %14
%22 = OpConstant %6 0
%29 = OpConstant %6 10
%41 = OpConstant %6 1
%4 = OpFunction %2 None %3
%5 = OpLabel
%46 = OpVariable %7 Function
OpStore %46 %13
%47 = OpFunctionCall %2 %10 %46
OpReturn
OpFunctionEnd
%10 = OpFunction %2 None %8
%9 = OpFunctionParameter %7
%11 = OpLabel
%12 = OpVariable %7 Function
%21 = OpVariable %7 Function
OpStore %12 %13
OpSelectionMerge %17 None
OpBranchConditional %15 %16 %17
%16 = OpLabel
%18 = OpLoad %6 %9
OpStore %12 %18
%19 = OpLoad %6 %9
%20 = OpIAdd %6 %19 %13
OpStore %9 %20
OpStore %21 %22
OpBranch %23
%23 = OpLabel
OpLoopMerge %25 %26 None
OpBranch %27
%27 = OpLabel
%28 = OpLoad %6 %21
%30 = OpSLessThan %14 %28 %29
OpBranchConditional %30 %24 %25
%24 = OpLabel
%31 = OpLoad %6 %9
%32 = OpLoad %6 %21
%33 = OpSGreaterThan %14 %31 %32
OpSelectionMerge %35 None
OpBranchConditional %33 %34 %35
%34 = OpLabel
OpBranch %26
%35 = OpLabel
%37 = OpLoad %6 %9
%38 = OpLoad %6 %12
%39 = OpIAdd %6 %38 %37
OpStore %12 %39
OpBranch %26
%26 = OpLabel
%40 = OpLoad %6 %21
%42 = OpIAdd %6 %40 %41
OpStore %21 %42
OpBranch %23
%25 = OpLabel
OpBranch %50
%50 = OpLabel
OpBranch %17
%17 = OpLabel
%43 = OpLoad %6 %9
%44 = OpLoad %6 %12
%45 = OpIAdd %6 %44 %43
OpStore %12 %45
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
for (uint32_t block_id : {16u, 23u, 24u, 26u, 27u, 34u, 35u, 50u}) {
transformation_context.GetFactManager()->AddFactBlockIsDead(block_id);
}
TransformationOutlineFunction transformation(
/*entry_block*/ 16,
/*exit_block*/ 50,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 203,
/*new_caller_result_id*/ 204,
/*new_callee_result_id*/ 205,
/*input_id_to_fresh_id*/ {{9, 206}, {12, 207}, {21, 208}},
/*output_id_to_fresh_id*/ {});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
// All the original blocks, plus the new function entry block, should be dead.
for (uint32_t block_id : {16u, 23u, 24u, 26u, 27u, 34u, 35u, 50u, 203u}) {
ASSERT_TRUE(transformation_context.GetFactManager()->BlockIsDead(block_id));
}
}
TEST(TransformationOutlineFunctionTest, OutlineWithDeadBlocks2) {
// This checks that if some, but not all, blocks in the outlined region are
// dead, those (but not others) will be dead in the outlined function.
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main" %8
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 310
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%7 = OpTypePointer Private %6
%8 = OpVariable %7 Private
%9 = OpConstantFalse %6
%10 = OpTypePointer Function %6
%12 = OpConstantTrue %6
%4 = OpFunction %2 None %3
%5 = OpLabel
%11 = OpVariable %10 Function
OpBranch %30
%30 = OpLabel
OpStore %8 %9
OpBranch %31
%31 = OpLabel
OpStore %11 %12
OpSelectionMerge %36 None
OpBranchConditional %9 %32 %33
%32 = OpLabel
OpBranch %34
%33 = OpLabel
OpBranch %36
%34 = OpLabel
OpBranch %35
%35 = OpLabel
OpBranch %36
%36 = OpLabel
OpBranch %37
%37 = OpLabel
%13 = OpLoad %6 %8
OpStore %11 %13
%14 = OpLoad %6 %11
OpStore %8 %14
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
for (uint32_t block_id : {32u, 34u, 35u}) {
transformation_context.GetFactManager()->AddFactBlockIsDead(block_id);
}
TransformationOutlineFunction transformation(
/*entry_block*/ 30,
/*exit_block*/ 37,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 203,
/*new_caller_result_id*/ 204,
/*new_callee_result_id*/ 205,
/*input_id_to_fresh_id*/ {{11, 206}},
/*output_id_to_fresh_id*/ {});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
// The blocks that were originally dead, but not others, should be dead.
for (uint32_t block_id : {32u, 34u, 35u}) {
ASSERT_TRUE(transformation_context.GetFactManager()->BlockIsDead(block_id));
}
for (uint32_t block_id : {5u, 30u, 31u, 33u, 36u, 37u, 203u}) {
ASSERT_FALSE(
transformation_context.GetFactManager()->BlockIsDead(block_id));
}
}
TEST(TransformationOutlineFunctionTest,
OutlineWithIrrelevantVariablesAndParameters) {
// This checks that if the outlined region uses a mixture of irrelevant and
// non-irrelevant variables and parameters, these properties are preserved
// during outlining.
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 = OpTypeInt 32 1
%7 = OpTypePointer Function %6
%8 = OpTypeFunction %2 %7 %7
%13 = OpConstant %6 2
%15 = OpConstant %6 3
%4 = OpFunction %2 None %3
%5 = OpLabel
OpReturn
OpFunctionEnd
%11 = OpFunction %2 None %8
%9 = OpFunctionParameter %7
%10 = OpFunctionParameter %7
%12 = OpLabel
%14 = OpVariable %7 Function
%20 = OpVariable %7 Function
OpBranch %50
%50 = OpLabel
OpStore %9 %13
OpStore %14 %15
%16 = OpLoad %6 %14
OpStore %10 %16
%17 = OpLoad %6 %9
%18 = OpLoad %6 %10
%19 = OpIAdd %6 %17 %18
OpStore %14 %19
%21 = OpLoad %6 %9
OpStore %20 %21
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant(9);
transformation_context.GetFactManager()->AddFactValueOfPointeeIsIrrelevant(
14);
TransformationOutlineFunction transformation(
/*entry_block*/ 50,
/*exit_block*/ 50,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 203,
/*new_caller_result_id*/ 204,
/*new_callee_result_id*/ 205,
/*input_id_to_fresh_id*/ {{9, 206}, {10, 207}, {14, 208}, {20, 209}},
/*output_id_to_fresh_id*/ {});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
// The variables that were originally irrelevant, plus input parameters
// corresponding to them, should be irrelevant. The rest should not be.
for (uint32_t variable_id : {9u, 14u, 206u, 208u}) {
ASSERT_TRUE(
transformation_context.GetFactManager()->PointeeValueIsIrrelevant(
variable_id));
}
for (uint32_t variable_id : {10u, 20u, 207u, 209u}) {
ASSERT_FALSE(
transformation_context.GetFactManager()->BlockIsDead(variable_id));
}
}
TEST(TransformationOutlineFunctionTest,
DoNotOutlineCodeThatProducesUsedPointer) {
// This checks that we cannot outline a region of code if it produces a
// pointer result id that gets used outside the region. This avoids creating
// a struct with a pointer member.
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %6 "main"
OpExecutionMode %6 OriginUpperLeft
OpSource ESSL 310
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%21 = OpTypeBool
%100 = OpTypeInt 32 0
%99 = OpConstant %100 0
%101 = OpTypeVector %100 2
%102 = OpTypePointer Function %100
%103 = OpTypePointer Function %101
%6 = OpFunction %2 None %3
%7 = OpLabel
%104 = OpVariable %103 Function
OpBranch %80
%80 = OpLabel
%105 = OpAccessChain %102 %104 %99
OpBranch %106
%106 = OpLabel
OpStore %105 %99
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
TransformationOutlineFunction transformation(
/*entry_block*/ 80,
/*exit_block*/ 80,
/*new_function_struct_return_type_id*/ 300,
/*new_function_type_id*/ 301,
/*new_function_id*/ 302,
/*new_function_region_entry_block*/ 304,
/*new_caller_result_id*/ 305,
/*new_callee_result_id*/ 306,
/*input_id_to_fresh_id*/ {{104, 307}},
/*output_id_to_fresh_id*/ {{105, 308}});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationOutlineFunctionTest, ExitBlockHeadsLoop) {
// This checks that it is not possible outline a region that ends in a loop
// head.
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
%15 = OpTypeInt 32 1
%35 = OpTypeBool
%39 = OpConstant %15 1
%40 = OpConstantTrue %35
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %22
%22 = OpLabel
OpBranch %23
%23 = OpLabel
%24 = OpPhi %15 %39 %22 %39 %25
OpLoopMerge %26 %25 None
OpBranchConditional %40 %25 %26
%25 = OpLabel
OpBranch %23
%26 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
TransformationOutlineFunction transformation(
/*entry_block*/ 22,
/*exit_block*/ 23,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 203,
/*new_caller_result_id*/ 204,
/*new_callee_result_id*/ 205,
/*input_id_to_fresh_id*/ {},
/*output_id_to_fresh_id*/ {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
}
TEST(TransformationOutlineFunctionTest, Miscellaneous1) {
// This tests outlining of some non-trivial code, and also tests the way
// overflow ids are used by the transformation.
std::string reference_shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main" %85
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 310
OpName %4 "main"
OpName %28 "buf"
OpMemberName %28 0 "u1"
OpMemberName %28 1 "u2"
OpName %30 ""
OpName %85 "color"
OpMemberDecorate %28 0 Offset 0
OpMemberDecorate %28 1 Offset 4
OpDecorate %28 Block
OpDecorate %30 DescriptorSet 0
OpDecorate %30 Binding 0
OpDecorate %85 Location 0
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeFloat 32
%7 = OpTypeVector %6 4
%10 = OpConstant %6 1
%11 = OpConstant %6 2
%12 = OpConstant %6 3
%13 = OpConstant %6 4
%14 = OpConstantComposite %7 %10 %11 %12 %13
%15 = OpTypeInt 32 1
%18 = OpConstant %15 0
%28 = OpTypeStruct %6 %6
%29 = OpTypePointer Uniform %28
%30 = OpVariable %29 Uniform
%31 = OpTypePointer Uniform %6
%35 = OpTypeBool
%39 = OpConstant %15 1
%84 = OpTypePointer Output %7
%85 = OpVariable %84 Output
%114 = OpConstant %15 8
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %22
%22 = OpLabel
%103 = OpPhi %15 %18 %5 %106 %43
%102 = OpPhi %7 %14 %5 %107 %43
%101 = OpPhi %15 %18 %5 %40 %43
%32 = OpAccessChain %31 %30 %18
%33 = OpLoad %6 %32
%34 = OpConvertFToS %15 %33
%36 = OpSLessThan %35 %101 %34
OpLoopMerge %24 %43 None
OpBranchConditional %36 %23 %24
%23 = OpLabel
%40 = OpIAdd %15 %101 %39
OpBranch %150
%150 = OpLabel
OpBranch %41
%41 = OpLabel
%107 = OpPhi %7 %102 %150 %111 %65
%106 = OpPhi %15 %103 %150 %110 %65
%104 = OpPhi %15 %40 %150 %81 %65
%47 = OpAccessChain %31 %30 %39
%48 = OpLoad %6 %47
%49 = OpConvertFToS %15 %48
%50 = OpSLessThan %35 %104 %49
OpLoopMerge %1000 %65 None
OpBranchConditional %50 %42 %1000
%42 = OpLabel
%60 = OpIAdd %15 %106 %114
%63 = OpSGreaterThan %35 %104 %60
OpBranchConditional %63 %64 %65
%64 = OpLabel
%71 = OpCompositeExtract %6 %107 0
%72 = OpFAdd %6 %71 %11
%97 = OpCompositeInsert %7 %72 %107 0
%76 = OpCompositeExtract %6 %107 3
%77 = OpConvertFToS %15 %76
%79 = OpIAdd %15 %60 %77
OpBranch %65
%65 = OpLabel
%111 = OpPhi %7 %107 %42 %97 %64
%110 = OpPhi %15 %60 %42 %79 %64
%81 = OpIAdd %15 %104 %39
OpBranch %41
%1000 = OpLabel
OpBranch %1001
%1001 = OpLabel
OpBranch %43
%43 = OpLabel
OpBranch %22
%24 = OpLabel
%87 = OpCompositeExtract %6 %102 0
%91 = OpConvertSToF %6 %103
%92 = OpCompositeConstruct %7 %87 %11 %91 %10
OpStore %85 %92
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_3;
const auto consumer = nullptr;
spvtools::ValidatorOptions validator_options;
TransformationOutlineFunction transformation(
/*entry_block*/ 150,
/*exit_block*/ 1001,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 203,
/*new_caller_result_id*/ 204,
/*new_callee_result_id*/ 205,
/*input_id_to_fresh_id*/ {{102, 300}, {103, 301}, {40, 302}},
/*output_id_to_fresh_id*/ {{106, 400}, {107, 401}});
TransformationOutlineFunction transformation_with_missing_input_id(
/*entry_block*/ 150,
/*exit_block*/ 1001,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 203,
/*new_caller_result_id*/ 204,
/*new_callee_result_id*/ 205,
/*input_id_to_fresh_id*/ {{102, 300}, {40, 302}},
/*output_id_to_fresh_id*/ {{106, 400}, {107, 401}});
TransformationOutlineFunction transformation_with_missing_output_id(
/*entry_block*/ 150,
/*exit_block*/ 1001,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 203,
/*new_caller_result_id*/ 204,
/*new_callee_result_id*/ 205,
/*input_id_to_fresh_id*/ {{102, 300}, {103, 301}, {40, 302}},
/*output_id_to_fresh_id*/ {{106, 400}});
TransformationOutlineFunction
transformation_with_missing_input_and_output_ids(
/*entry_block*/ 150,
/*exit_block*/ 1001,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 203,
/*new_caller_result_id*/ 204,
/*new_callee_result_id*/ 205,
/*input_id_to_fresh_id*/ {{102, 300}, {40, 302}},
/*output_id_to_fresh_id*/ {{106, 400}});
{
const auto context =
BuildModule(env, consumer, reference_shader, kFuzzAssembleOption);
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(
context.get(), validator_options, kConsoleMessageConsumer));
TransformationContext transformation_context(
MakeUnique<FactManager>(context.get()), validator_options);
#ifndef NDEBUG
// We expect the following applicability checks to lead to assertion
// failures since the transformations are missing input or output ids, and
// the transformation context does not have a source of overflow ids.
ASSERT_DEATH(transformation_with_missing_input_id.IsApplicable(
context.get(), transformation_context),
"Bad attempt to query whether overflow ids are available.");
ASSERT_DEATH(transformation_with_missing_output_id.IsApplicable(
context.get(), transformation_context),
"Bad attempt to query whether overflow ids are available.");
ASSERT_DEATH(transformation_with_missing_input_and_output_ids.IsApplicable(
context.get(), transformation_context),
"Bad attempt to query whether overflow ids are available.");
#endif
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, context.get(),
&transformation_context);
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(
context.get(), validator_options, kConsoleMessageConsumer));
std::string variant_shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main" %85
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 310
OpName %4 "main"
OpName %28 "buf"
OpMemberName %28 0 "u1"
OpMemberName %28 1 "u2"
OpName %30 ""
OpName %85 "color"
OpMemberDecorate %28 0 Offset 0
OpMemberDecorate %28 1 Offset 4
OpDecorate %28 Block
OpDecorate %30 DescriptorSet 0
OpDecorate %30 Binding 0
OpDecorate %85 Location 0
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeFloat 32
%7 = OpTypeVector %6 4
%10 = OpConstant %6 1
%11 = OpConstant %6 2
%12 = OpConstant %6 3
%13 = OpConstant %6 4
%14 = OpConstantComposite %7 %10 %11 %12 %13
%15 = OpTypeInt 32 1
%18 = OpConstant %15 0
%28 = OpTypeStruct %6 %6
%29 = OpTypePointer Uniform %28
%30 = OpVariable %29 Uniform
%31 = OpTypePointer Uniform %6
%35 = OpTypeBool
%39 = OpConstant %15 1
%84 = OpTypePointer Output %7
%85 = OpVariable %84 Output
%114 = OpConstant %15 8
%200 = OpTypeStruct %7 %15
%201 = OpTypeFunction %200 %15 %7 %15
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %22
%22 = OpLabel
%103 = OpPhi %15 %18 %5 %106 %43
%102 = OpPhi %7 %14 %5 %107 %43
%101 = OpPhi %15 %18 %5 %40 %43
%32 = OpAccessChain %31 %30 %18
%33 = OpLoad %6 %32
%34 = OpConvertFToS %15 %33
%36 = OpSLessThan %35 %101 %34
OpLoopMerge %24 %43 None
OpBranchConditional %36 %23 %24
%23 = OpLabel
%40 = OpIAdd %15 %101 %39
OpBranch %150
%150 = OpLabel
%204 = OpFunctionCall %200 %202 %103 %102 %40
%107 = OpCompositeExtract %7 %204 0
%106 = OpCompositeExtract %15 %204 1
OpBranch %43
%43 = OpLabel
OpBranch %22
%24 = OpLabel
%87 = OpCompositeExtract %6 %102 0
%91 = OpConvertSToF %6 %103
%92 = OpCompositeConstruct %7 %87 %11 %91 %10
OpStore %85 %92
OpReturn
OpFunctionEnd
%202 = OpFunction %200 None %201
%301 = OpFunctionParameter %15
%300 = OpFunctionParameter %7
%302 = OpFunctionParameter %15
%203 = OpLabel
OpBranch %41
%41 = OpLabel
%401 = OpPhi %7 %300 %203 %111 %65
%400 = OpPhi %15 %301 %203 %110 %65
%104 = OpPhi %15 %302 %203 %81 %65
%47 = OpAccessChain %31 %30 %39
%48 = OpLoad %6 %47
%49 = OpConvertFToS %15 %48
%50 = OpSLessThan %35 %104 %49
OpLoopMerge %1000 %65 None
OpBranchConditional %50 %42 %1000
%42 = OpLabel
%60 = OpIAdd %15 %400 %114
%63 = OpSGreaterThan %35 %104 %60
OpBranchConditional %63 %64 %65
%64 = OpLabel
%71 = OpCompositeExtract %6 %401 0
%72 = OpFAdd %6 %71 %11
%97 = OpCompositeInsert %7 %72 %401 0
%76 = OpCompositeExtract %6 %401 3
%77 = OpConvertFToS %15 %76
%79 = OpIAdd %15 %60 %77
OpBranch %65
%65 = OpLabel
%111 = OpPhi %7 %401 %42 %97 %64
%110 = OpPhi %15 %60 %42 %79 %64
%81 = OpIAdd %15 %104 %39
OpBranch %41
%1000 = OpLabel
OpBranch %1001
%1001 = OpLabel
%205 = OpCompositeConstruct %200 %401 %400
OpReturnValue %205
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, variant_shader, context.get()));
}
{
const auto context =
BuildModule(env, consumer, reference_shader, kFuzzAssembleOption);
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(
context.get(), validator_options, kConsoleMessageConsumer));
auto overflow_ids_unique_ptr = MakeUnique<CounterOverflowIdSource>(2000);
auto overflow_ids_ptr = overflow_ids_unique_ptr.get();
TransformationContext new_transformation_context(
MakeUnique<FactManager>(context.get()), validator_options,
std::move(overflow_ids_unique_ptr));
ASSERT_TRUE(transformation_with_missing_input_id.IsApplicable(
context.get(), new_transformation_context));
ASSERT_TRUE(transformation_with_missing_output_id.IsApplicable(
context.get(), new_transformation_context));
ASSERT_TRUE(transformation_with_missing_input_and_output_ids.IsApplicable(
context.get(), new_transformation_context));
ApplyAndCheckFreshIds(transformation_with_missing_input_and_output_ids,
context.get(), &new_transformation_context,
overflow_ids_ptr->GetIssuedOverflowIds());
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(
context.get(), validator_options, kConsoleMessageConsumer));
std::string variant_shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main" %85
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 310
OpName %4 "main"
OpName %28 "buf"
OpMemberName %28 0 "u1"
OpMemberName %28 1 "u2"
OpName %30 ""
OpName %85 "color"
OpMemberDecorate %28 0 Offset 0
OpMemberDecorate %28 1 Offset 4
OpDecorate %28 Block
OpDecorate %30 DescriptorSet 0
OpDecorate %30 Binding 0
OpDecorate %85 Location 0
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeFloat 32
%7 = OpTypeVector %6 4
%10 = OpConstant %6 1
%11 = OpConstant %6 2
%12 = OpConstant %6 3
%13 = OpConstant %6 4
%14 = OpConstantComposite %7 %10 %11 %12 %13
%15 = OpTypeInt 32 1
%18 = OpConstant %15 0
%28 = OpTypeStruct %6 %6
%29 = OpTypePointer Uniform %28
%30 = OpVariable %29 Uniform
%31 = OpTypePointer Uniform %6
%35 = OpTypeBool
%39 = OpConstant %15 1
%84 = OpTypePointer Output %7
%85 = OpVariable %84 Output
%114 = OpConstant %15 8
%200 = OpTypeStruct %7 %15
%201 = OpTypeFunction %200 %15 %7 %15
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %22
%22 = OpLabel
%103 = OpPhi %15 %18 %5 %106 %43
%102 = OpPhi %7 %14 %5 %107 %43
%101 = OpPhi %15 %18 %5 %40 %43
%32 = OpAccessChain %31 %30 %18
%33 = OpLoad %6 %32
%34 = OpConvertFToS %15 %33
%36 = OpSLessThan %35 %101 %34
OpLoopMerge %24 %43 None
OpBranchConditional %36 %23 %24
%23 = OpLabel
%40 = OpIAdd %15 %101 %39
OpBranch %150
%150 = OpLabel
%204 = OpFunctionCall %200 %202 %103 %102 %40
%107 = OpCompositeExtract %7 %204 0
%106 = OpCompositeExtract %15 %204 1
OpBranch %43
%43 = OpLabel
OpBranch %22
%24 = OpLabel
%87 = OpCompositeExtract %6 %102 0
%91 = OpConvertSToF %6 %103
%92 = OpCompositeConstruct %7 %87 %11 %91 %10
OpStore %85 %92
OpReturn
OpFunctionEnd
%202 = OpFunction %200 None %201
%2000 = OpFunctionParameter %15
%300 = OpFunctionParameter %7
%302 = OpFunctionParameter %15
%203 = OpLabel
OpBranch %41
%41 = OpLabel
%2001 = OpPhi %7 %300 %203 %111 %65
%400 = OpPhi %15 %2000 %203 %110 %65
%104 = OpPhi %15 %302 %203 %81 %65
%47 = OpAccessChain %31 %30 %39
%48 = OpLoad %6 %47
%49 = OpConvertFToS %15 %48
%50 = OpSLessThan %35 %104 %49
OpLoopMerge %1000 %65 None
OpBranchConditional %50 %42 %1000
%42 = OpLabel
%60 = OpIAdd %15 %400 %114
%63 = OpSGreaterThan %35 %104 %60
OpBranchConditional %63 %64 %65
%64 = OpLabel
%71 = OpCompositeExtract %6 %2001 0
%72 = OpFAdd %6 %71 %11
%97 = OpCompositeInsert %7 %72 %2001 0
%76 = OpCompositeExtract %6 %2001 3
%77 = OpConvertFToS %15 %76
%79 = OpIAdd %15 %60 %77
OpBranch %65
%65 = OpLabel
%111 = OpPhi %7 %2001 %42 %97 %64
%110 = OpPhi %15 %60 %42 %79 %64
%81 = OpIAdd %15 %104 %39
OpBranch %41
%1000 = OpLabel
OpBranch %1001
%1001 = OpLabel
%205 = OpCompositeConstruct %200 %2001 %400
OpReturnValue %205
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, variant_shader, context.get()));
}
}
TEST(TransformationOutlineFunctionTest, Miscellaneous2) {
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
%21 = OpTypeBool
%167 = OpConstantTrue %21
%168 = OpConstantFalse %21
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %34
%34 = OpLabel
OpLoopMerge %36 %37 None
OpBranchConditional %168 %37 %38
%38 = OpLabel
OpBranchConditional %168 %37 %36
%37 = OpLabel
OpBranch %34
%36 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
TransformationOutlineFunction transformation(
/*entry_block*/ 38,
/*exit_block*/ 36,
/*new_function_struct_return_type_id*/ 200,
/*new_function_type_id*/ 201,
/*new_function_id*/ 202,
/*new_function_region_entry_block*/ 203,
/*new_caller_result_id*/ 204,
/*new_callee_result_id*/ 205,
/*input_id_to_fresh_id*/ {},
/*output_id_to_fresh_id*/ {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationOutlineFunctionTest, Miscellaneous3) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %6 "main"
OpExecutionMode %6 OriginUpperLeft
OpSource ESSL 310
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%21 = OpTypeBool
%167 = OpConstantTrue %21
%6 = OpFunction %2 None %3
%7 = OpLabel
OpBranch %80
%80 = OpLabel
OpBranch %14
%14 = OpLabel
OpLoopMerge %16 %17 None
OpBranch %18
%18 = OpLabel
OpBranchConditional %167 %15 %16
%15 = OpLabel
OpBranch %17
%16 = OpLabel
OpBranch %81
%81 = OpLabel
OpReturn
%17 = OpLabel
OpBranch %14
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
TransformationOutlineFunction transformation(
/*entry_block*/ 80,
/*exit_block*/ 81,
/*new_function_struct_return_type_id*/ 300,
/*new_function_type_id*/ 301,
/*new_function_id*/ 302,
/*new_function_region_entry_block*/ 304,
/*new_caller_result_id*/ 305,
/*new_callee_result_id*/ 306,
/*input_id_to_fresh_id*/ {},
/*output_id_to_fresh_id*/ {});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, 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 %6 "main"
OpExecutionMode %6 OriginUpperLeft
OpSource ESSL 310
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%21 = OpTypeBool
%167 = OpConstantTrue %21
%6 = OpFunction %2 None %3
%7 = OpLabel
OpBranch %80
%80 = OpLabel
%305 = OpFunctionCall %2 %302
OpReturn
OpFunctionEnd
%302 = OpFunction %2 None %3
%304 = OpLabel
OpBranch %14
%14 = OpLabel
OpLoopMerge %16 %17 None
OpBranch %18
%18 = OpLabel
OpBranchConditional %167 %15 %16
%15 = OpLabel
OpBranch %17
%16 = OpLabel
OpBranch %81
%81 = OpLabel
OpReturn
%17 = OpLabel
OpBranch %14
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationOutlineFunctionTest, Miscellaneous4) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %6 "main"
OpExecutionMode %6 OriginUpperLeft
OpSource ESSL 310
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%21 = OpTypeBool
%100 = OpTypeInt 32 0
%101 = OpTypePointer Function %100
%102 = OpTypePointer Function %100
%103 = OpTypeFunction %2 %101
%6 = OpFunction %2 None %3
%7 = OpLabel
%104 = OpVariable %102 Function
OpBranch %80
%80 = OpLabel
%105 = OpLoad %100 %104
OpBranch %106
%106 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_5;
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);
TransformationOutlineFunction transformation(
/*entry_block*/ 80,
/*exit_block*/ 106,
/*new_function_struct_return_type_id*/ 300,
/*new_function_type_id*/ 301,
/*new_function_id*/ 302,
/*new_function_region_entry_block*/ 304,
/*new_caller_result_id*/ 305,
/*new_callee_result_id*/ 306,
/*input_id_to_fresh_id*/ {{104, 307}},
/*output_id_to_fresh_id*/ {});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, 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 %6 "main"
OpExecutionMode %6 OriginUpperLeft
OpSource ESSL 310
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%21 = OpTypeBool
%100 = OpTypeInt 32 0
%101 = OpTypePointer Function %100
%102 = OpTypePointer Function %100
%103 = OpTypeFunction %2 %101
%301 = OpTypeFunction %2 %102
%6 = OpFunction %2 None %3
%7 = OpLabel
%104 = OpVariable %102 Function
OpBranch %80
%80 = OpLabel
%305 = OpFunctionCall %2 %302 %104
OpReturn
OpFunctionEnd
%302 = OpFunction %2 None %301
%307 = OpFunctionParameter %102
%304 = OpLabel
%105 = OpLoad %100 %307
OpBranch %106
%106 = OpLabel
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationOutlineFunctionTest, NoOutlineWithUnreachableBlocks) {
// This checks that outlining will not be performed if a node in the region
// has an unreachable predecessor.
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
%4 = OpFunction %2 None %3
%7 = OpLabel
OpBranch %5
%5 = OpLabel
OpReturn
%6 = OpLabel
OpBranch %5
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_4;
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);
TransformationOutlineFunction transformation(5, 5, /* not relevant */ 200,
100, 101, 102, 103,
/* not relevant */ 201, {}, {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
} // namespace
} // namespace fuzz
} // namespace spvtools
Reference in New Issue View Git Blame Copy Permalink