AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-11-22 19:50:05 +00:00
Code Issues Packages Projects Releases Wiki Activity
9117e042b9
SPIRV-Tools/test/fuzz/transformation_flatten_conditional_branch_test.cpp

2208 lines
79 KiB
C++
Raw Normal View History

spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
// Copyright (c) 2020 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_flatten_conditional_branch.h"
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
#include "gtest/gtest.h"
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
#include "source/fuzz/counter_overflow_id_source.h"
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
#include "source/fuzz/fuzzer_util.h"
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
#include "source/fuzz/instruction_descriptor.h"
#include "test/fuzz/fuzz_test_util.h"
namespace spvtools {
namespace fuzz {
namespace {
protobufs::SideEffectWrapperInfo MakeSideEffectWrapperInfo(
const protobufs::InstructionDescriptor& instruction,
uint32_t merge_block_id, uint32_t execute_block_id,
spirv-fuzz: Do not allow creation of constants of block-decorated structs (#3903) Fixes #3902.
2020-10-13 17:35:41 +00:00
uint32_t actual_result_id, uint32_t alternative_block_id,
uint32_t placeholder_result_id, uint32_t value_to_copy_id) {
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
protobufs::SideEffectWrapperInfo result;
*result.mutable_instruction() = instruction;
result.set_merge_block_id(merge_block_id);
result.set_execute_block_id(execute_block_id);
result.set_actual_result_id(actual_result_id);
result.set_alternative_block_id(alternative_block_id);
result.set_placeholder_result_id(placeholder_result_id);
result.set_value_to_copy_id(value_to_copy_id);
return result;
}
spirv-fuzz: Do not allow creation of constants of block-decorated structs (#3903) Fixes #3902.
2020-10-13 17:35:41 +00:00
protobufs::SideEffectWrapperInfo MakeSideEffectWrapperInfo(
const protobufs::InstructionDescriptor& instruction,
uint32_t merge_block_id, uint32_t execute_block_id) {
return MakeSideEffectWrapperInfo(instruction, merge_block_id,
execute_block_id, 0, 0, 0, 0);
}
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
TEST(TransformationFlattenConditionalBranchTest, Inapplicable) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main" %3
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
OpName %2 "main"
%4 = OpTypeVoid
%5 = OpTypeFunction %4
%6 = OpTypeInt 32 1
%7 = OpTypeInt 32 0
%8 = OpConstant %7 0
%9 = OpTypeBool
%10 = OpConstantTrue %9
%11 = OpTypePointer Function %6
%12 = OpTypePointer Workgroup %6
%3 = OpVariable %12 Workgroup
%13 = OpConstant %6 2
%2 = OpFunction %4 None %5
%14 = OpLabel
OpBranch %15
%15 = OpLabel
OpSelectionMerge %16 None
OpSwitch %13 %17 2 %18
%17 = OpLabel
OpBranch %16
%18 = OpLabel
OpBranch %16
%16 = OpLabel
OpLoopMerge %19 %16 None
OpBranchConditional %10 %16 %19
%19 = OpLabel
OpSelectionMerge %20 None
OpBranchConditional %10 %21 %20
%21 = OpLabel
OpReturn
%20 = OpLabel
OpSelectionMerge %22 None
OpBranchConditional %10 %23 %22
%23 = OpLabel
OpSelectionMerge %24 None
OpBranchConditional %10 %25 %24
%25 = OpLabel
OpBranch %24
%24 = OpLabel
OpBranch %22
%22 = OpLabel
OpSelectionMerge %26 None
OpBranchConditional %10 %26 %27
%27 = OpLabel
OpBranch %28
%28 = OpLabel
OpLoopMerge %29 %28 None
OpBranchConditional %10 %28 %29
%29 = OpLabel
OpBranch %26
%26 = OpLabel
OpSelectionMerge %30 None
OpBranchConditional %10 %30 %31
%31 = OpLabel
OpBranch %32
%32 = OpLabel
%33 = OpAtomicLoad %6 %3 %8 %8
OpBranch %30
%30 = OpLabel
OpSelectionMerge %34 None
OpBranchConditional %10 %35 %34
%35 = OpLabel
OpMemoryBarrier %8 %8
OpBranch %34
%34 = OpLabel
OpLoopMerge %40 %39 None
OpBranchConditional %10 %36 %40
%36 = OpLabel
OpSelectionMerge %38 None
OpBranchConditional %10 %37 %38
%37 = OpLabel
OpBranch %40
%38 = OpLabel
OpBranch %39
%39 = OpLabel
OpBranch %34
%40 = 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;
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Use unique_ptr<FactManager> in TransformationContext (#3844) TransformationContext now holds a std::unique_ptr to a FactManager, rather than a plain pointer. This makes it easier for clients of TransformationContext to work with heap-allocated instances of TransformationContext, which is needed in some upcoming work.
2020-09-24 16:28:49 +00:00
TransformationContext transformation_context(
MakeUnique<FactManager>(context.get()), validator_options);
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
// Block %15 does not end with OpBranchConditional.
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
ASSERT_FALSE(TransformationFlattenConditionalBranch(15, true, 0, 0, 0, {})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context));
// Block %17 is not a selection header.
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
ASSERT_FALSE(TransformationFlattenConditionalBranch(17, true, 0, 0, 0, {})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context));
// Block %16 is a loop header, not a selection header.
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
ASSERT_FALSE(TransformationFlattenConditionalBranch(16, true, 0, 0, 0, {})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context));
// Block %19 and the corresponding merge block do not describe a single-entry,
// single-exit region, because there is a return instruction in %21.
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
ASSERT_FALSE(TransformationFlattenConditionalBranch(19, true, 0, 0, 0, {})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context));
// Block %20 is the header of a construct containing an inner selection
// construct.
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
ASSERT_FALSE(TransformationFlattenConditionalBranch(20, true, 0, 0, 0, {})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context));
// Block %22 is the header of a construct containing an inner loop.
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
ASSERT_FALSE(TransformationFlattenConditionalBranch(22, true, 0, 0, 0, {})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context));
// Block %30 is the header of a construct containing a barrier instruction.
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
ASSERT_FALSE(TransformationFlattenConditionalBranch(30, true, 0, 0, 0, {})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context));
// %33 is not a block.
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
ASSERT_FALSE(TransformationFlattenConditionalBranch(33, true, 0, 0, 0, {})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context));
// Block %36 and the corresponding merge block do not describe a single-entry,
// single-exit region, because block %37 breaks out of the outer loop.
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
ASSERT_FALSE(TransformationFlattenConditionalBranch(36, true, 0, 0, 0, {})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationFlattenConditionalBranchTest, Simple) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
OpName %2 "main"
%3 = OpTypeBool
%4 = OpConstantTrue %3
%5 = OpTypeVoid
%6 = OpTypeFunction %5
%2 = OpFunction %5 None %6
%7 = OpLabel
OpSelectionMerge %8 None
OpBranchConditional %4 %9 %10
%10 = OpLabel
%26 = OpPhi %3 %4 %7
OpBranch %8
%9 = OpLabel
%27 = OpPhi %3 %4 %7
%11 = OpCopyObject %3 %4
OpBranch %8
%8 = OpLabel
%12 = OpPhi %3 %11 %9 %4 %10
%23 = OpPhi %3 %4 %9 %4 %10
OpBranch %13
%13 = OpLabel
%14 = OpCopyObject %3 %4
OpSelectionMerge %15 None
OpBranchConditional %4 %16 %17
%16 = OpLabel
%28 = OpPhi %3 %4 %13
OpBranch %18
%18 = OpLabel
OpBranch %19
%17 = OpLabel
%29 = OpPhi %3 %4 %13
%20 = OpCopyObject %3 %4
OpBranch %19
%19 = OpLabel
%21 = OpPhi %3 %4 %18 %20 %17
OpBranch %15
%15 = OpLabel
OpSelectionMerge %22 None
OpBranchConditional %4 %22 %22
%22 = OpLabel
%30 = OpPhi %3 %4 %15
OpSelectionMerge %25 None
OpBranchConditional %4 %24 %24
%24 = 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;
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Use unique_ptr<FactManager> in TransformationContext (#3844) TransformationContext now holds a std::unique_ptr to a FactManager, rather than a plain pointer. This makes it easier for clients of TransformationContext to work with heap-allocated instances of TransformationContext, which is needed in some upcoming work.
2020-09-24 16:28:49 +00:00
TransformationContext transformation_context(
MakeUnique<FactManager>(context.get()), validator_options);
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
auto transformation1 =
TransformationFlattenConditionalBranch(7, true, 0, 0, 0, {});
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
ASSERT_TRUE(
transformation1.IsApplicable(context.get(), transformation_context));
spirv-fuzz: Report fresh ids in transformations (#3856) Adds a virtual method, GetFreshIds(), to Transformation. Every transformation uses this to indicate which ids in its protobuf message are fresh ids. This means that when replaying a sequence of transformations the replayer can obtain a smallest id that is not in use by the module already and that will not be used by any transformation by necessity. Ids greater than or equal to this id can be used as overflow ids. Fixes #3851.
2020-09-29 21:12:49 +00:00
ApplyAndCheckFreshIds(transformation1, context.get(),
&transformation_context);
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
auto transformation2 =
TransformationFlattenConditionalBranch(13, false, 0, 0, 0, {});
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
ASSERT_TRUE(
transformation2.IsApplicable(context.get(), transformation_context));
spirv-fuzz: Report fresh ids in transformations (#3856) Adds a virtual method, GetFreshIds(), to Transformation. Every transformation uses this to indicate which ids in its protobuf message are fresh ids. This means that when replaying a sequence of transformations the replayer can obtain a smallest id that is not in use by the module already and that will not be used by any transformation by necessity. Ids greater than or equal to this id can be used as overflow ids. Fixes #3851.
2020-09-29 21:12:49 +00:00
ApplyAndCheckFreshIds(transformation2, context.get(),
&transformation_context);
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
auto transformation3 =
TransformationFlattenConditionalBranch(15, true, 0, 0, 0, {});
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
ASSERT_TRUE(
transformation3.IsApplicable(context.get(), transformation_context));
spirv-fuzz: Report fresh ids in transformations (#3856) Adds a virtual method, GetFreshIds(), to Transformation. Every transformation uses this to indicate which ids in its protobuf message are fresh ids. This means that when replaying a sequence of transformations the replayer can obtain a smallest id that is not in use by the module already and that will not be used by any transformation by necessity. Ids greater than or equal to this id can be used as overflow ids. Fixes #3851.
2020-09-29 21:12:49 +00:00
ApplyAndCheckFreshIds(transformation3, context.get(),
&transformation_context);
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
auto transformation4 =
TransformationFlattenConditionalBranch(22, false, 0, 0, 0, {});
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
ASSERT_TRUE(
transformation4.IsApplicable(context.get(), transformation_context));
spirv-fuzz: Report fresh ids in transformations (#3856) Adds a virtual method, GetFreshIds(), to Transformation. Every transformation uses this to indicate which ids in its protobuf message are fresh ids. This means that when replaying a sequence of transformations the replayer can obtain a smallest id that is not in use by the module already and that will not be used by any transformation by necessity. Ids greater than or equal to this id can be used as overflow ids. Fixes #3851.
2020-09-29 21:12:49 +00:00
ApplyAndCheckFreshIds(transformation4, context.get(),
&transformation_context);
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
std::string after_transformations = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
OpName %2 "main"
%3 = OpTypeBool
%4 = OpConstantTrue %3
%5 = OpTypeVoid
%6 = OpTypeFunction %5
%2 = OpFunction %5 None %6
%7 = OpLabel
OpBranch %9
%9 = OpLabel
%27 = OpPhi %3 %4 %7
%11 = OpCopyObject %3 %4
OpBranch %10
%10 = OpLabel
%26 = OpPhi %3 %4 %9
OpBranch %8
%8 = OpLabel
%12 = OpSelect %3 %4 %11 %4
%23 = OpSelect %3 %4 %4 %4
OpBranch %13
%13 = OpLabel
%14 = OpCopyObject %3 %4
OpBranch %17
%17 = OpLabel
%29 = OpPhi %3 %4 %13
%20 = OpCopyObject %3 %4
OpBranch %16
%16 = OpLabel
%28 = OpPhi %3 %4 %17
OpBranch %18
%18 = OpLabel
OpBranch %19
%19 = OpLabel
%21 = OpSelect %3 %4 %4 %20
OpBranch %15
%15 = OpLabel
OpBranch %22
%22 = OpLabel
%30 = OpPhi %3 %4 %15
OpBranch %24
%24 = OpLabel
OpBranch %25
%25 = OpLabel
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformations, context.get()));
}
TEST(TransformationFlattenConditionalBranchTest, LoadStoreFunctionCall) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
%9 = OpTypeVoid
%10 = OpTypeFunction %9
%11 = OpTypeInt 32 1
%12 = OpTypeVector %11 4
%13 = OpTypeFunction %11
%70 = OpConstant %11 0
%14 = OpConstant %11 1
%15 = OpTypeFloat 32
%16 = OpTypeVector %15 2
%17 = OpConstant %15 1
%18 = OpConstantComposite %16 %17 %17
%19 = OpTypeBool
%20 = OpConstantTrue %19
%21 = OpTypePointer Function %11
%22 = OpTypeSampler
%23 = OpTypeImage %9 2D 2 0 0 1 Unknown
%24 = OpTypeSampledImage %23
%25 = OpTypePointer Function %23
%26 = OpTypePointer Function %22
%27 = OpTypeInt 32 0
%28 = OpConstant %27 2
%29 = OpTypeArray %11 %28
%30 = OpTypePointer Function %29
%2 = OpFunction %9 None %10
%31 = OpLabel
%4 = OpVariable %21 Function
%5 = OpVariable %30 Function
%32 = OpVariable %25 Function
%33 = OpVariable %26 Function
%34 = OpLoad %23 %32
%35 = OpLoad %22 %33
OpSelectionMerge %36 None
OpBranchConditional %20 %37 %36
%37 = OpLabel
%6 = OpLoad %11 %4
%7 = OpIAdd %11 %6 %14
OpStore %4 %7
OpBranch %36
%36 = OpLabel
%42 = OpPhi %11 %14 %37 %14 %31
OpSelectionMerge %43 None
OpBranchConditional %20 %44 %45
%44 = OpLabel
%8 = OpFunctionCall %11 %3
OpStore %4 %8
OpBranch %46
%45 = OpLabel
%47 = OpAccessChain %21 %5 %14
OpStore %47 %14
OpBranch %46
%46 = OpLabel
OpStore %4 %14
OpBranch %43
%43 = OpLabel
OpStore %4 %14
OpSelectionMerge %48 None
OpBranchConditional %20 %49 %48
%49 = OpLabel
OpBranch %48
%48 = OpLabel
OpSelectionMerge %50 None
OpBranchConditional %20 %51 %50
%51 = OpLabel
%52 = OpSampledImage %24 %34 %35
%53 = OpLoad %11 %4
%54 = OpImageSampleImplicitLod %12 %52 %18
OpBranch %50
%50 = OpLabel
OpReturn
OpFunctionEnd
%3 = OpFunction %11 None %13
%55 = OpLabel
OpReturnValue %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;
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Use unique_ptr<FactManager> in TransformationContext (#3844) TransformationContext now holds a std::unique_ptr to a FactManager, rather than a plain pointer. This makes it easier for clients of TransformationContext to work with heap-allocated instances of TransformationContext, which is needed in some upcoming work.
2020-09-24 16:28:49 +00:00
TransformationContext transformation_context(
MakeUnique<FactManager>(context.get()), validator_options);
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
#ifndef NDEBUG
// The following checks lead to assertion failures, since some entries
// requiring fresh ids are not present in the map, and the transformation
// context does not have a source overflow ids.
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
ASSERT_DEATH(TransformationFlattenConditionalBranch(31, true, 0, 0, 0, {})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context),
"Bad attempt to query whether overflow ids are available.");
ASSERT_DEATH(TransformationFlattenConditionalBranch(
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
31, true, 0, 0, 0,
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
{{MakeSideEffectWrapperInfo(
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
MakeInstructionDescriptor(6, spv::Op::OpLoad, 0), 100,
101, 102, 103, 104, 14)}})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context),
"Bad attempt to query whether overflow ids are available.");
#endif
// The map maps from an instruction to a list with not enough fresh ids.
spirv-fuzz: Do not allow creation of constants of block-decorated structs (#3903) Fixes #3902.
2020-10-13 17:35:41 +00:00
ASSERT_FALSE(TransformationFlattenConditionalBranch(
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
31, true, 0, 0, 0,
spirv-fuzz: Do not allow creation of constants of block-decorated structs (#3903) Fixes #3902.
2020-10-13 17:35:41 +00:00
{{MakeSideEffectWrapperInfo(
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
MakeInstructionDescriptor(6, spv::Op::OpLoad, 0), 100,
101, 102, 103, 0, 0)}})
spirv-fuzz: Do not allow creation of constants of block-decorated structs (#3903) Fixes #3902.
2020-10-13 17:35:41 +00:00
.IsApplicable(context.get(), transformation_context));
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
// Not all fresh ids given are distinct.
ASSERT_FALSE(TransformationFlattenConditionalBranch(
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
31, true, 0, 0, 0,
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
{{MakeSideEffectWrapperInfo(
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
MakeInstructionDescriptor(6, spv::Op::OpLoad, 0), 100,
100, 102, 103, 104, 0)}})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context));
// %48 heads a construct containing an OpSampledImage instruction.
ASSERT_FALSE(TransformationFlattenConditionalBranch(
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
48, true, 0, 0, 0,
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
{{MakeSideEffectWrapperInfo(
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
MakeInstructionDescriptor(53, spv::Op::OpLoad, 0), 100,
101, 102, 103, 104, 0)}})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context));
// %0 is not a valid id.
ASSERT_FALSE(
TransformationFlattenConditionalBranch(
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
31, true, 0, 0, 0,
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
{MakeSideEffectWrapperInfo(
MakeInstructionDescriptor(6, spv::Op::OpLoad, 0), 104, 100, 101,
102, 103, 0),
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
MakeSideEffectWrapperInfo(
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
MakeInstructionDescriptor(6, spv::Op::OpStore, 0), 106, 105)})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context));
// %17 is a float constant, while %6 has int type.
ASSERT_FALSE(
TransformationFlattenConditionalBranch(
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
31, true, 0, 0, 0,
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
{MakeSideEffectWrapperInfo(
MakeInstructionDescriptor(6, spv::Op::OpLoad, 0), 104, 100, 101,
102, 103, 17),
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
MakeSideEffectWrapperInfo(
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
MakeInstructionDescriptor(6, spv::Op::OpStore, 0), 106, 105)})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context));
auto transformation1 = TransformationFlattenConditionalBranch(
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
31, true, 0, 0, 0,
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
{MakeSideEffectWrapperInfo(
MakeInstructionDescriptor(6, spv::Op::OpLoad, 0), 104, 100, 101, 102,
103, 70),
MakeSideEffectWrapperInfo(
MakeInstructionDescriptor(6, spv::Op::OpStore, 0), 106, 105)});
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
ASSERT_TRUE(
transformation1.IsApplicable(context.get(), transformation_context));
spirv-fuzz: Report fresh ids in transformations (#3856) Adds a virtual method, GetFreshIds(), to Transformation. Every transformation uses this to indicate which ids in its protobuf message are fresh ids. This means that when replaying a sequence of transformations the replayer can obtain a smallest id that is not in use by the module already and that will not be used by any transformation by necessity. Ids greater than or equal to this id can be used as overflow ids. Fixes #3851.
2020-09-29 21:12:49 +00:00
ApplyAndCheckFreshIds(transformation1, context.get(),
&transformation_context);
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
// Check that the placeholder id was marked as irrelevant.
spirv-fuzz: Move IRContext parameter into constructor (#3837) This PR converts IRContext parameter in fact managers into a class field. Part of #3698.
2020-09-24 11:27:59 +00:00
ASSERT_TRUE(transformation_context.GetFactManager()->IdIsIrrelevant(103));
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
// Make a new transformation context with a source of overflow ids.
spirv-fuzz: Report fresh ids in transformations (#3856) Adds a virtual method, GetFreshIds(), to Transformation. Every transformation uses this to indicate which ids in its protobuf message are fresh ids. This means that when replaying a sequence of transformations the replayer can obtain a smallest id that is not in use by the module already and that will not be used by any transformation by necessity. Ids greater than or equal to this id can be used as overflow ids. Fixes #3851.
2020-09-29 21:12:49 +00:00
auto overflow_ids_unique_ptr = MakeUnique<CounterOverflowIdSource>(1000);
auto overflow_ids_ptr = overflow_ids_unique_ptr.get();
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
TransformationContext new_transformation_context(
spirv-fuzz: Use unique_ptr<FactManager> in TransformationContext (#3844) TransformationContext now holds a std::unique_ptr to a FactManager, rather than a plain pointer. This makes it easier for clients of TransformationContext to work with heap-allocated instances of TransformationContext, which is needed in some upcoming work.
2020-09-24 16:28:49 +00:00
MakeUnique<FactManager>(context.get()), validator_options,
spirv-fuzz: Report fresh ids in transformations (#3856) Adds a virtual method, GetFreshIds(), to Transformation. Every transformation uses this to indicate which ids in its protobuf message are fresh ids. This means that when replaying a sequence of transformations the replayer can obtain a smallest id that is not in use by the module already and that will not be used by any transformation by necessity. Ids greater than or equal to this id can be used as overflow ids. Fixes #3851.
2020-09-29 21:12:49 +00:00
std::move(overflow_ids_unique_ptr));
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
auto transformation2 = TransformationFlattenConditionalBranch(
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
36, false, 0, 0, 0,
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
{MakeSideEffectWrapperInfo(
MakeInstructionDescriptor(8, spv::Op::OpStore, 0), 114, 113)});
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
ASSERT_TRUE(
transformation2.IsApplicable(context.get(), new_transformation_context));
spirv-fuzz: Report fresh ids in transformations (#3856) Adds a virtual method, GetFreshIds(), to Transformation. Every transformation uses this to indicate which ids in its protobuf message are fresh ids. This means that when replaying a sequence of transformations the replayer can obtain a smallest id that is not in use by the module already and that will not be used by any transformation by necessity. Ids greater than or equal to this id can be used as overflow ids. Fixes #3851.
2020-09-29 21:12:49 +00:00
ApplyAndCheckFreshIds(transformation2, context.get(),
&new_transformation_context,
overflow_ids_ptr->GetIssuedOverflowIds());
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
std::string after_transformations = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
%9 = OpTypeVoid
%10 = OpTypeFunction %9
%11 = OpTypeInt 32 1
%12 = OpTypeVector %11 4
%13 = OpTypeFunction %11
%70 = OpConstant %11 0
%14 = OpConstant %11 1
%15 = OpTypeFloat 32
%16 = OpTypeVector %15 2
%17 = OpConstant %15 1
%18 = OpConstantComposite %16 %17 %17
%19 = OpTypeBool
%20 = OpConstantTrue %19
%21 = OpTypePointer Function %11
%22 = OpTypeSampler
%23 = OpTypeImage %9 2D 2 0 0 1 Unknown
%24 = OpTypeSampledImage %23
%25 = OpTypePointer Function %23
%26 = OpTypePointer Function %22
%27 = OpTypeInt 32 0
%28 = OpConstant %27 2
%29 = OpTypeArray %11 %28
%30 = OpTypePointer Function %29
%2 = OpFunction %9 None %10
%31 = OpLabel
%4 = OpVariable %21 Function
%5 = OpVariable %30 Function
%32 = OpVariable %25 Function
%33 = OpVariable %26 Function
%34 = OpLoad %23 %32
%35 = OpLoad %22 %33
OpBranch %37
%37 = OpLabel
OpSelectionMerge %104 None
OpBranchConditional %20 %100 %102
%100 = OpLabel
%101 = OpLoad %11 %4
OpBranch %104
%102 = OpLabel
%103 = OpCopyObject %11 %70
OpBranch %104
%104 = OpLabel
%6 = OpPhi %11 %101 %100 %103 %102
%7 = OpIAdd %11 %6 %14
OpSelectionMerge %106 None
OpBranchConditional %20 %105 %106
%105 = OpLabel
OpStore %4 %7
OpBranch %106
%106 = OpLabel
OpBranch %36
%36 = OpLabel
%42 = OpSelect %11 %20 %14 %14
OpBranch %45
%45 = OpLabel
%47 = OpAccessChain %21 %5 %14
OpSelectionMerge %1005 None
OpBranchConditional %20 %1005 %1006
%1006 = OpLabel
OpStore %47 %14
OpBranch %1005
%1005 = OpLabel
OpBranch %44
%44 = OpLabel
OpSelectionMerge %1000 None
OpBranchConditional %20 %1001 %1003
%1001 = OpLabel
%1002 = OpFunctionCall %11 %3
OpBranch %1000
%1003 = OpLabel
%1004 = OpCopyObject %11 %70
OpBranch %1000
%1000 = OpLabel
%8 = OpPhi %11 %1002 %1001 %1004 %1003
OpSelectionMerge %114 None
OpBranchConditional %20 %113 %114
%113 = OpLabel
OpStore %4 %8
OpBranch %114
%114 = OpLabel
OpBranch %46
%46 = OpLabel
OpStore %4 %14
OpBranch %43
%43 = OpLabel
OpStore %4 %14
OpSelectionMerge %48 None
OpBranchConditional %20 %49 %48
%49 = OpLabel
OpBranch %48
%48 = OpLabel
OpSelectionMerge %50 None
OpBranchConditional %20 %51 %50
%51 = OpLabel
%52 = OpSampledImage %24 %34 %35
%53 = OpLoad %11 %4
%54 = OpImageSampleImplicitLod %12 %52 %18
OpBranch %50
%50 = OpLabel
OpReturn
OpFunctionEnd
%3 = OpFunction %11 None %13
%55 = OpLabel
OpReturnValue %14
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformations, context.get()));
} // namespace
TEST(TransformationFlattenConditionalBranchTest, EdgeCases) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
%3 = OpTypeVoid
%4 = OpTypeBool
%5 = OpConstantTrue %4
%6 = OpTypeFunction %3
%2 = OpFunction %3 None %6
%7 = OpLabel
OpSelectionMerge %8 None
OpBranchConditional %5 %9 %8
%9 = OpLabel
%10 = OpFunctionCall %3 %11
OpBranch %8
%8 = OpLabel
OpSelectionMerge %12 None
OpBranchConditional %5 %13 %12
%13 = OpLabel
%14 = OpFunctionCall %3 %11
OpBranch %12
%12 = OpLabel
OpReturn
%16 = OpLabel
OpSelectionMerge %17 None
OpBranchConditional %5 %18 %17
%18 = OpLabel
OpBranch %17
%17 = OpLabel
OpReturn
OpFunctionEnd
%11 = OpFunction %3 None %6
%19 = OpLabel
OpBranch %20
%20 = OpLabel
OpSelectionMerge %25 None
OpBranchConditional %5 %21 %22
%21 = OpLabel
OpBranch %22
%22 = OpLabel
OpSelectionMerge %24 None
OpBranchConditional %5 %24 %23
%23 = OpLabel
OpBranch %24
%24 = 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;
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Use unique_ptr<FactManager> in TransformationContext (#3844) TransformationContext now holds a std::unique_ptr to a FactManager, rather than a plain pointer. This makes it easier for clients of TransformationContext to work with heap-allocated instances of TransformationContext, which is needed in some upcoming work.
2020-09-24 16:28:49 +00:00
TransformationContext transformation_context(
MakeUnique<FactManager>(context.get()), validator_options);
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
#ifndef NDEBUG
// The selection construct headed by %7 requires fresh ids because it contains
// a function call. This causes an assertion failure because transformation
// context does not have a source of overflow ids.
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
ASSERT_DEATH(TransformationFlattenConditionalBranch(7, true, 0, 0, 0, {})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context),
"Bad attempt to query whether overflow ids are available.");
#endif
auto transformation1 = TransformationFlattenConditionalBranch(
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
7, true, 0, 0, 0,
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
{{MakeSideEffectWrapperInfo(
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
MakeInstructionDescriptor(10, spv::Op::OpFunctionCall, 0), 100,
101)}});
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
ASSERT_TRUE(
transformation1.IsApplicable(context.get(), transformation_context));
spirv-fuzz: Report fresh ids in transformations (#3856) Adds a virtual method, GetFreshIds(), to Transformation. Every transformation uses this to indicate which ids in its protobuf message are fresh ids. This means that when replaying a sequence of transformations the replayer can obtain a smallest id that is not in use by the module already and that will not be used by any transformation by necessity. Ids greater than or equal to this id can be used as overflow ids. Fixes #3851.
2020-09-29 21:12:49 +00:00
ApplyAndCheckFreshIds(transformation1, context.get(),
&transformation_context);
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
// The selection construct headed by %8 cannot be flattened because it
// contains a function call returning void, whose result id is used.
ASSERT_FALSE(
TransformationFlattenConditionalBranch(
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
7, true, 0, 0, 0,
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
{{MakeSideEffectWrapperInfo(
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
MakeInstructionDescriptor(14, spv::Op::OpFunctionCall, 0), 102,
103)}})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context));
// Block %16 is unreachable.
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
ASSERT_FALSE(TransformationFlattenConditionalBranch(16, true, 0, 0, 0, {})
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
.IsApplicable(context.get(), transformation_context));
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
auto transformation2 =
TransformationFlattenConditionalBranch(20, false, 0, 0, 0, {});
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
ASSERT_TRUE(
transformation2.IsApplicable(context.get(), transformation_context));
spirv-fuzz: Report fresh ids in transformations (#3856) Adds a virtual method, GetFreshIds(), to Transformation. Every transformation uses this to indicate which ids in its protobuf message are fresh ids. This means that when replaying a sequence of transformations the replayer can obtain a smallest id that is not in use by the module already and that will not be used by any transformation by necessity. Ids greater than or equal to this id can be used as overflow ids. Fixes #3851.
2020-09-29 21:12:49 +00:00
ApplyAndCheckFreshIds(transformation2, context.get(),
&transformation_context);
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
std::string after_transformation = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
%3 = OpTypeVoid
%4 = OpTypeBool
%5 = OpConstantTrue %4
%6 = OpTypeFunction %3
%2 = OpFunction %3 None %6
%7 = OpLabel
OpBranch %9
%9 = OpLabel
OpSelectionMerge %100 None
OpBranchConditional %5 %101 %100
%101 = OpLabel
%10 = OpFunctionCall %3 %11
OpBranch %100
%100 = OpLabel
OpBranch %8
%8 = OpLabel
OpSelectionMerge %12 None
OpBranchConditional %5 %13 %12
%13 = OpLabel
%14 = OpFunctionCall %3 %11
OpBranch %12
%12 = OpLabel
OpReturn
%16 = OpLabel
OpSelectionMerge %17 None
OpBranchConditional %5 %18 %17
%18 = OpLabel
OpBranch %17
%17 = OpLabel
OpReturn
OpFunctionEnd
%11 = OpFunction %3 None %6
%19 = OpLabel
OpBranch %20
%20 = OpLabel
OpBranch %21
%21 = OpLabel
OpBranch %22
%22 = OpLabel
OpSelectionMerge %24 None
OpBranchConditional %5 %24 %23
%23 = OpLabel
OpBranch %24
%24 = OpLabel
OpBranch %25
%25 = OpLabel
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
spirv-fuzz: Fix flatten conditional branch transformation (#3859) Fixes #3850.
2020-09-30 10:43:40 +00:00
TEST(TransformationFlattenConditionalBranchTest, PhiToSelect1) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
%3 = OpTypeVoid
%4 = OpTypeBool
%5 = OpConstantTrue %4
%10 = OpConstantFalse %4
%6 = OpTypeFunction %3
%2 = OpFunction %3 None %6
%7 = OpLabel
OpSelectionMerge %8 None
OpBranchConditional %5 %9 %8
%9 = OpLabel
OpBranch %8
%8 = OpLabel
%11 = OpPhi %4 %5 %9 %10 %7
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;
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Fix flatten conditional branch transformation (#3859) Fixes #3850.
2020-09-30 10:43:40 +00:00
TransformationContext transformation_context(
MakeUnique<FactManager>(context.get()), validator_options);
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
auto transformation =
TransformationFlattenConditionalBranch(7, true, 0, 0, 0, {});
spirv-fuzz: Fix flatten conditional branch transformation (#3859) Fixes #3850.
2020-09-30 10:43:40 +00:00
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Fix flatten conditional branch transformation (#3859) Fixes #3850.
2020-09-30 10:43:40 +00:00
std::string after_transformation = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
%3 = OpTypeVoid
%4 = OpTypeBool
%5 = OpConstantTrue %4
%10 = OpConstantFalse %4
%6 = OpTypeFunction %3
%2 = OpFunction %3 None %6
%7 = OpLabel
OpBranch %9
%9 = OpLabel
OpBranch %8
%8 = OpLabel
%11 = OpSelect %4 %5 %5 %10
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationFlattenConditionalBranchTest, PhiToSelect2) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
%3 = OpTypeVoid
%4 = OpTypeBool
%5 = OpConstantTrue %4
%10 = OpConstantFalse %4
%6 = OpTypeFunction %3
%2 = OpFunction %3 None %6
%7 = OpLabel
OpSelectionMerge %8 None
OpBranchConditional %5 %9 %8
%9 = OpLabel
OpBranch %8
%8 = OpLabel
%11 = OpPhi %4 %10 %7 %5 %9
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;
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Fix flatten conditional branch transformation (#3859) Fixes #3850.
2020-09-30 10:43:40 +00:00
TransformationContext transformation_context(
MakeUnique<FactManager>(context.get()), validator_options);
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
auto transformation =
TransformationFlattenConditionalBranch(7, true, 0, 0, 0, {});
spirv-fuzz: Fix flatten conditional branch transformation (#3859) Fixes #3850.
2020-09-30 10:43:40 +00:00
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Fix flatten conditional branch transformation (#3859) Fixes #3850.
2020-09-30 10:43:40 +00:00
std::string after_transformation = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
%3 = OpTypeVoid
%4 = OpTypeBool
%5 = OpConstantTrue %4
%10 = OpConstantFalse %4
%6 = OpTypeFunction %3
%2 = OpFunction %3 None %6
%7 = OpLabel
OpBranch %9
%9 = OpLabel
OpBranch %8
%8 = OpLabel
%11 = OpSelect %4 %5 %5 %10
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationFlattenConditionalBranchTest, PhiToSelect3) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
%3 = OpTypeVoid
%4 = OpTypeBool
%5 = OpConstantTrue %4
%10 = OpConstantFalse %4
%6 = OpTypeFunction %3
%2 = OpFunction %3 None %6
%7 = OpLabel
OpSelectionMerge %8 None
OpBranchConditional %5 %9 %12
%9 = OpLabel
OpBranch %8
%12 = OpLabel
OpBranch %8
%8 = OpLabel
%11 = OpPhi %4 %10 %12 %5 %9
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;
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Fix flatten conditional branch transformation (#3859) Fixes #3850.
2020-09-30 10:43:40 +00:00
TransformationContext transformation_context(
MakeUnique<FactManager>(context.get()), validator_options);
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
auto transformation =
TransformationFlattenConditionalBranch(7, true, 0, 0, 0, {});
spirv-fuzz: Fix flatten conditional branch transformation (#3859) Fixes #3850.
2020-09-30 10:43:40 +00:00
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Fix flatten conditional branch transformation (#3859) Fixes #3850.
2020-09-30 10:43:40 +00:00
std::string after_transformation = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
%3 = OpTypeVoid
%4 = OpTypeBool
%5 = OpConstantTrue %4
%10 = OpConstantFalse %4
%6 = OpTypeFunction %3
%2 = OpFunction %3 None %6
%7 = OpLabel
OpBranch %9
%9 = OpLabel
OpBranch %12
%12 = OpLabel
OpBranch %8
%8 = OpLabel
%11 = OpSelect %4 %5 %5 %10
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationFlattenConditionalBranchTest, PhiToSelect4) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
%3 = OpTypeVoid
%4 = OpTypeBool
%5 = OpConstantTrue %4
%10 = OpConstantFalse %4
%6 = OpTypeFunction %3
%2 = OpFunction %3 None %6
%7 = OpLabel
OpSelectionMerge %8 None
OpBranchConditional %5 %9 %12
%9 = OpLabel
OpBranch %8
%12 = OpLabel
OpBranch %8
%8 = OpLabel
%11 = OpPhi %4 %5 %9 %10 %12
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;
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Fix flatten conditional branch transformation (#3859) Fixes #3850.
2020-09-30 10:43:40 +00:00
TransformationContext transformation_context(
MakeUnique<FactManager>(context.get()), validator_options);
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
auto transformation =
TransformationFlattenConditionalBranch(7, true, 0, 0, 0, {});
spirv-fuzz: Fix flatten conditional branch transformation (#3859) Fixes #3850.
2020-09-30 10:43:40 +00:00
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Fix flatten conditional branch transformation (#3859) Fixes #3850.
2020-09-30 10:43:40 +00:00
std::string after_transformation = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
%3 = OpTypeVoid
%4 = OpTypeBool
%5 = OpConstantTrue %4
%10 = OpConstantFalse %4
%6 = OpTypeFunction %3
%2 = OpFunction %3 None %6
%7 = OpLabel
OpBranch %9
%9 = OpLabel
OpBranch %12
%12 = OpLabel
OpBranch %8
%8 = OpLabel
%11 = OpSelect %4 %5 %5 %10
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
spirv-fuzz: Fix handling of OpPhi in FlattenConditionalBranch (#3916) Fixes #3915.
2020-10-15 13:41:23 +00:00
}
TEST(TransformationFlattenConditionalBranchTest, PhiToSelect5) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
%3 = OpTypeVoid
%4 = OpTypeBool
%5 = OpConstantTrue %4
%10 = OpConstantFalse %4
%6 = OpTypeFunction %3
%100 = OpTypePointer Function %4
%2 = OpFunction %3 None %6
%7 = OpLabel
%101 = OpVariable %100 Function
%102 = OpVariable %100 Function
OpSelectionMerge %470 None
OpBranchConditional %5 %454 %462
%454 = OpLabel
%522 = OpLoad %4 %101
OpBranch %470
%462 = OpLabel
%466 = OpLoad %4 %102
OpBranch %470
%470 = OpLabel
%534 = OpPhi %4 %522 %454 %466 %462
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;
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Fix handling of OpPhi in FlattenConditionalBranch (#3916) Fixes #3915.
2020-10-15 13:41:23 +00:00
TransformationContext transformation_context(
MakeUnique<FactManager>(context.get()), validator_options);
auto transformation = TransformationFlattenConditionalBranch(
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
7, true, 0, 0, 0,
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
{MakeSideEffectWrapperInfo(
MakeInstructionDescriptor(522, spv::Op::OpLoad, 0), 200, 201, 202,
203, 204, 5),
MakeSideEffectWrapperInfo(
MakeInstructionDescriptor(466, spv::Op::OpLoad, 0), 300, 301, 302,
303, 304, 5)});
spirv-fuzz: Fix handling of OpPhi in FlattenConditionalBranch (#3916) Fixes #3915.
2020-10-15 13:41:23 +00:00
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Fix handling of OpPhi in FlattenConditionalBranch (#3916) Fixes #3915.
2020-10-15 13:41:23 +00:00
std::string after_transformation = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %2 "main"
OpExecutionMode %2 OriginUpperLeft
OpSource ESSL 310
%3 = OpTypeVoid
%4 = OpTypeBool
%5 = OpConstantTrue %4
%10 = OpConstantFalse %4
%6 = OpTypeFunction %3
%100 = OpTypePointer Function %4
%2 = OpFunction %3 None %6
%7 = OpLabel
%101 = OpVariable %100 Function
%102 = OpVariable %100 Function
OpBranch %454
%454 = OpLabel
OpSelectionMerge %200 None
OpBranchConditional %5 %201 %203
%201 = OpLabel
%202 = OpLoad %4 %101
OpBranch %200
%203 = OpLabel
%204 = OpCopyObject %4 %5
OpBranch %200
%200 = OpLabel
%522 = OpPhi %4 %202 %201 %204 %203
OpBranch %462
%462 = OpLabel
OpSelectionMerge %300 None
OpBranchConditional %5 %303 %301
%301 = OpLabel
%302 = OpLoad %4 %102
OpBranch %300
%303 = OpLabel
%304 = OpCopyObject %4 %5
OpBranch %300
%300 = OpLabel
%466 = OpPhi %4 %302 %301 %304 %303
OpBranch %470
%470 = OpLabel
%534 = OpSelect %4 %5 %522 %466
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
spirv-fuzz: Fix flatten conditional branch transformation (#3859) Fixes #3850.
2020-09-30 10:43:40 +00:00
}
spirv-fuzz: Do not allow creation of constants of block-decorated structs (#3903) Fixes #3902.
2020-10-13 17:35:41 +00:00
TEST(TransformationFlattenConditionalBranchTest,
LoadFromBufferBlockDecoratedStruct) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
OpMemberDecorate %11 0 Offset 0
OpDecorate %11 BufferBlock
OpDecorate %13 DescriptorSet 0
OpDecorate %13 Binding 0
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%7 = OpConstantTrue %6
%10 = OpTypeInt 32 1
%11 = OpTypeStruct %10
%12 = OpTypePointer Uniform %11
%13 = OpVariable %12 Uniform
%21 = OpUndef %11
%4 = OpFunction %2 None %3
%5 = OpLabel
OpSelectionMerge %9 None
OpBranchConditional %7 %8 %9
%8 = OpLabel
%20 = OpLoad %11 %13
OpBranch %9
%9 = 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;
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Do not allow creation of constants of block-decorated structs (#3903) Fixes #3902.
2020-10-13 17:35:41 +00:00
TransformationContext transformation_context(
MakeUnique<FactManager>(context.get()), validator_options);
auto transformation = TransformationFlattenConditionalBranch(
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
5, true, 0, 0, 0,
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
{MakeSideEffectWrapperInfo(
MakeInstructionDescriptor(20, spv::Op::OpLoad, 0), 100, 101, 102, 103,
104, 21)});
spirv-fuzz: Do not allow creation of constants of block-decorated structs (#3903) Fixes #3902.
2020-10-13 17:35:41 +00:00
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
spirv-fuzz: Fix to TransformationInlineFunction (#3913) 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.
2020-10-16 21:58:09 +00:00
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Do not allow creation of constants of block-decorated structs (#3903) Fixes #3902.
2020-10-13 17:35:41 +00:00
}
spirv-fuzz: Do not allow sampled image load when flattening conditionals (#3930) Fixes #3928.
2020-10-19 16:32:26 +00:00
TEST(TransformationFlattenConditionalBranchTest, InapplicableSampledImageLoad) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main" %12 %96
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
OpDecorate %12 BuiltIn FragCoord
OpDecorate %91 DescriptorSet 0
OpDecorate %91 Binding 0
OpDecorate %96 Location 0
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeFloat 32
%7 = OpTypeVector %6 2
%10 = OpTypeVector %6 4
%11 = OpTypePointer Input %10
%12 = OpVariable %11 Input
%21 = OpConstant %6 2
%24 = OpTypeInt 32 1
%33 = OpTypeBool
%35 = OpConstantTrue %33
%88 = OpTypeImage %6 2D 0 0 0 1 Unknown
%89 = OpTypeSampledImage %88
%90 = OpTypePointer UniformConstant %89
%91 = OpVariable %90 UniformConstant
%95 = OpTypePointer Output %10
%96 = OpVariable %95 Output
%200 = OpUndef %89
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %28
%28 = OpLabel
OpSelectionMerge %38 None
OpBranchConditional %35 %32 %37
%32 = OpLabel
%40 = OpLoad %89 %91
OpBranch %38
%37 = OpLabel
OpBranch %38
%38 = 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);
ASSERT_FALSE(TransformationFlattenConditionalBranch(
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
28, true, 0, 0, 0,
spirv-fuzz: Do not allow sampled image load when flattening conditionals (#3930) Fixes #3928.
2020-10-19 16:32:26 +00:00
{MakeSideEffectWrapperInfo(
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
MakeInstructionDescriptor(40, spv::Op::OpLoad, 0), 100,
101, 102, 103, 104, 200)})
spirv-fuzz: Do not allow sampled image load when flattening conditionals (#3930) Fixes #3928.
2020-10-19 16:32:26 +00:00
.IsApplicable(context.get(), transformation_context));
}
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
TEST(TransformationFlattenConditionalBranchTest,
InapplicablePhiToSelectVector) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%7 = OpConstantTrue %6
%10 = OpTypeInt 32 1
%11 = OpTypeVector %10 3
%12 = OpUndef %11
%4 = OpFunction %2 None %3
%5 = OpLabel
OpSelectionMerge %20 None
OpBranchConditional %7 %8 %9
%8 = OpLabel
OpBranch %20
%9 = OpLabel
OpBranch %20
%20 = OpLabel
%21 = OpPhi %11 %12 %8 %12 %9
OpReturn
OpFunctionEnd
)";
spirv-fuzz: Handle Vulkan SPIR-V versions (#4156) Fixes #4155.
2021-03-03 22:29:57 +00:00
for (auto env :
{SPV_ENV_UNIVERSAL_1_0, SPV_ENV_UNIVERSAL_1_1, SPV_ENV_UNIVERSAL_1_2,
SPV_ENV_UNIVERSAL_1_3, SPV_ENV_VULKAN_1_0, SPV_ENV_VULKAN_1_1}) {
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 transformation =
TransformationFlattenConditionalBranch(5, true, 0, 0, 0, {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
}
TEST(TransformationFlattenConditionalBranchTest,
InapplicablePhiToSelectVector2) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%30 = OpTypeVector %6 3
%31 = OpTypeVector %6 2
%7 = OpConstantTrue %6
%10 = OpTypeInt 32 1
%11 = OpTypeVector %10 3
%40 = OpTypeFloat 32
%41 = OpTypeVector %40 4
%12 = OpUndef %11
%60 = OpUndef %41
%61 = OpConstantComposite %31 %7 %7
%4 = OpFunction %2 None %3
%5 = OpLabel
OpSelectionMerge %20 None
OpBranchConditional %7 %8 %9
%8 = OpLabel
OpBranch %20
%9 = OpLabel
OpBranch %20
%20 = OpLabel
%21 = OpPhi %11 %12 %8 %12 %9
%22 = OpPhi %11 %12 %8 %12 %9
%23 = OpPhi %41 %60 %8 %60 %9
%24 = OpPhi %31 %61 %8 %61 %9
%25 = OpPhi %41 %60 %8 %60 %9
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_3;
const auto consumer = nullptr;
const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption);
spvtools::ValidatorOptions validator_options;
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
TransformationContext transformation_context(
MakeUnique<FactManager>(context.get()), validator_options);
auto transformation =
TransformationFlattenConditionalBranch(5, true, 101, 102, 103, {});
// bvec4 is not present in the module.
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
}
TEST(TransformationFlattenConditionalBranchTest,
InapplicablePhiToSelectMatrix) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%7 = OpConstantTrue %6
%10 = OpTypeFloat 32
%30 = OpTypeVector %10 3
%11 = OpTypeMatrix %30 3
%12 = OpUndef %11
%4 = OpFunction %2 None %3
%5 = OpLabel
OpSelectionMerge %20 None
OpBranchConditional %7 %8 %9
%8 = OpLabel
OpBranch %20
%9 = OpLabel
OpBranch %20
%20 = OpLabel
%21 = OpPhi %11 %12 %8 %12 %9
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_3;
const auto consumer = nullptr;
const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption);
spvtools::ValidatorOptions validator_options;
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
TransformationContext transformation_context(
MakeUnique<FactManager>(context.get()), validator_options);
auto transformation =
TransformationFlattenConditionalBranch(5, true, 0, 0, 0, {});
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationFlattenConditionalBranchTest, ApplicablePhiToSelectVector) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%7 = OpConstantTrue %6
%10 = OpTypeInt 32 1
%11 = OpTypeVector %10 3
%12 = OpUndef %11
%4 = OpFunction %2 None %3
%5 = OpLabel
OpSelectionMerge %20 None
OpBranchConditional %7 %8 %9
%8 = OpLabel
OpBranch %20
%9 = OpLabel
OpBranch %20
%20 = OpLabel
%21 = OpPhi %11 %12 %8 %12 %9
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);
auto transformation =
TransformationFlattenConditionalBranch(5, true, 0, 0, 0, {});
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 expected_shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%7 = OpConstantTrue %6
%10 = OpTypeInt 32 1
%11 = OpTypeVector %10 3
%12 = OpUndef %11
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %8
%8 = OpLabel
OpBranch %9
%9 = OpLabel
OpBranch %20
%20 = OpLabel
%21 = OpSelect %11 %7 %12 %12
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, expected_shader, context.get()));
}
TEST(TransformationFlattenConditionalBranchTest, ApplicablePhiToSelectVector2) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%30 = OpTypeVector %6 3
%31 = OpTypeVector %6 2
%32 = OpTypeVector %6 4
%7 = OpConstantTrue %6
%10 = OpTypeInt 32 1
%11 = OpTypeVector %10 3
%40 = OpTypeFloat 32
%41 = OpTypeVector %40 4
%12 = OpUndef %11
%60 = OpUndef %41
%61 = OpConstantComposite %31 %7 %7
%4 = OpFunction %2 None %3
%5 = OpLabel
OpSelectionMerge %20 None
OpBranchConditional %7 %8 %9
%8 = OpLabel
OpBranch %20
%9 = OpLabel
OpBranch %20
%20 = OpLabel
%21 = OpPhi %11 %12 %8 %12 %9
%22 = OpPhi %11 %12 %8 %12 %9
%23 = OpPhi %41 %60 %8 %60 %9
%24 = OpPhi %31 %61 %8 %61 %9
%25 = OpPhi %41 %60 %8 %60 %9
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_3;
const auto consumer = nullptr;
const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption);
spvtools::ValidatorOptions validator_options;
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
TransformationContext transformation_context(
MakeUnique<FactManager>(context.get()), validator_options);
// No id for the 2D vector case is provided.
ASSERT_FALSE(TransformationFlattenConditionalBranch(5, true, 0, 102, 103, {})
.IsApplicable(context.get(), transformation_context));
// No id for the 3D vector case is provided.
ASSERT_FALSE(TransformationFlattenConditionalBranch(5, true, 101, 0, 103, {})
.IsApplicable(context.get(), transformation_context));
// No id for the 4D vector case is provided.
ASSERT_FALSE(TransformationFlattenConditionalBranch(5, true, 101, 102, 0, {})
.IsApplicable(context.get(), transformation_context));
// %10 is not fresh
ASSERT_FALSE(TransformationFlattenConditionalBranch(5, true, 10, 102, 103, {})
.IsApplicable(context.get(), transformation_context));
// %10 is not fresh
ASSERT_FALSE(TransformationFlattenConditionalBranch(5, true, 101, 10, 103, {})
.IsApplicable(context.get(), transformation_context));
// %10 is not fresh
ASSERT_FALSE(TransformationFlattenConditionalBranch(5, true, 101, 102, 10, {})
.IsApplicable(context.get(), transformation_context));
// Duplicate "fresh" ids used for boolean vector constructors
ASSERT_FALSE(
TransformationFlattenConditionalBranch(5, true, 101, 102, 102, {})
.IsApplicable(context.get(), transformation_context));
auto transformation =
TransformationFlattenConditionalBranch(5, true, 101, 102, 103, {});
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 expected_shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%30 = OpTypeVector %6 3
%31 = OpTypeVector %6 2
%32 = OpTypeVector %6 4
%7 = OpConstantTrue %6
%10 = OpTypeInt 32 1
%11 = OpTypeVector %10 3
%40 = OpTypeFloat 32
%41 = OpTypeVector %40 4
%12 = OpUndef %11
%60 = OpUndef %41
%61 = OpConstantComposite %31 %7 %7
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %8
%8 = OpLabel
OpBranch %9
%9 = OpLabel
OpBranch %20
%20 = OpLabel
%103 = OpCompositeConstruct %32 %7 %7 %7 %7
%102 = OpCompositeConstruct %30 %7 %7 %7
%101 = OpCompositeConstruct %31 %7 %7
%21 = OpSelect %11 %102 %12 %12
%22 = OpSelect %11 %102 %12 %12
%23 = OpSelect %41 %103 %60 %60
%24 = OpSelect %31 %101 %61 %61
%25 = OpSelect %41 %103 %60 %60
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, expected_shader, context.get()));
}
TEST(TransformationFlattenConditionalBranchTest, ApplicablePhiToSelectVector3) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%30 = OpTypeVector %6 3
%31 = OpTypeVector %6 2
%32 = OpTypeVector %6 4
%7 = OpConstantTrue %6
%10 = OpTypeInt 32 1
%11 = OpTypeVector %10 3
%40 = OpTypeFloat 32
%41 = OpTypeVector %40 4
%12 = OpUndef %11
%60 = OpUndef %41
%61 = OpConstantComposite %31 %7 %7
%4 = OpFunction %2 None %3
%5 = OpLabel
OpSelectionMerge %20 None
OpBranchConditional %7 %8 %9
%8 = OpLabel
OpBranch %20
%9 = OpLabel
OpBranch %20
%20 = OpLabel
%21 = OpPhi %11 %12 %8 %12 %9
%22 = OpPhi %11 %12 %8 %12 %9
%23 = OpPhi %41 %60 %8 %60 %9
%24 = OpPhi %31 %61 %8 %61 %9
%25 = OpPhi %41 %60 %8 %60 %9
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);
auto transformation =
TransformationFlattenConditionalBranch(5, true, 101, 0, 103, {});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
ApplyAndCheckFreshIds(transformation, context.get(), &transformation_context);
ASSERT_TRUE(fuzzerutil::IsValidAndWellFormed(context.get(), validator_options,
kConsoleMessageConsumer));
spirv-fuzz: Fix operand types (#3962) Fixes #3945. Fixes #3946.
2020-10-21 21:41:30 +00:00
// Check that the in operands of any OpSelect instructions all have the
// appropriate operand type.
context->module()->ForEachInst([](opt::Instruction* inst) {
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
if (inst->opcode() == spv::Op::OpSelect) {
spirv-fuzz: Fix operand types (#3962) Fixes #3945. Fixes #3946.
2020-10-21 21:41:30 +00:00
ASSERT_EQ(SPV_OPERAND_TYPE_ID, inst->GetInOperand(0).type);
ASSERT_EQ(SPV_OPERAND_TYPE_ID, inst->GetInOperand(1).type);
ASSERT_EQ(SPV_OPERAND_TYPE_ID, inst->GetInOperand(2).type);
}
});
spirv-fuzz: Use component-wise selectors when flattening conditional branches (#3921) Fixes #3920.
2020-10-20 17:57:56 +00:00
std::string expected_shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%30 = OpTypeVector %6 3
%31 = OpTypeVector %6 2
%32 = OpTypeVector %6 4
%7 = OpConstantTrue %6
%10 = OpTypeInt 32 1
%11 = OpTypeVector %10 3
%40 = OpTypeFloat 32
%41 = OpTypeVector %40 4
%12 = OpUndef %11
%60 = OpUndef %41
%61 = OpConstantComposite %31 %7 %7
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %8
%8 = OpLabel
OpBranch %9
%9 = OpLabel
OpBranch %20
%20 = OpLabel
%103 = OpCompositeConstruct %32 %7 %7 %7 %7
%101 = OpCompositeConstruct %31 %7 %7
%21 = OpSelect %11 %7 %12 %12
%22 = OpSelect %11 %7 %12 %12
%23 = OpSelect %41 %103 %60 %60
%24 = OpSelect %31 %101 %61 %61
%25 = OpSelect %41 %103 %60 %60
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, expected_shader, context.get()));
}
TEST(TransformationFlattenConditionalBranchTest, ApplicablePhiToSelectMatrix) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%7 = OpConstantTrue %6
%10 = OpTypeFloat 32
%30 = OpTypeVector %10 3
%11 = OpTypeMatrix %30 3
%12 = OpUndef %11
%4 = OpFunction %2 None %3
%5 = OpLabel
OpSelectionMerge %20 None
OpBranchConditional %7 %8 %9
%8 = OpLabel
OpBranch %20
%9 = OpLabel
OpBranch %20
%20 = OpLabel
%21 = OpPhi %11 %12 %8 %12 %9
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);
auto transformation =
TransformationFlattenConditionalBranch(5, true, 0, 0, 0, {});
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 expected_shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%7 = OpConstantTrue %6
%10 = OpTypeFloat 32
%30 = OpTypeVector %10 3
%11 = OpTypeMatrix %30 3
%12 = OpUndef %11
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %8
%8 = OpLabel
OpBranch %9
%9 = OpLabel
OpBranch %20
%20 = OpLabel
%21 = OpSelect %11 %7 %12 %12
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, expected_shader, context.get()));
}
spirv-fuzz: Don't flatten conditional if condition is irrelevant (#3944) Fixes #3942.
2020-10-21 20:26:59 +00:00
TEST(TransformationFlattenConditionalBranchTest,
InapplicableConditionIsIrrelevant) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%7 = OpConstantTrue %6
%10 = OpTypeInt 32 1
%4 = OpFunction %2 None %3
%5 = OpLabel
OpSelectionMerge %9 None
OpBranchConditional %7 %8 %9
%8 = OpLabel
OpBranch %9
%9 = 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);
transformation_context.GetFactManager()->AddFactIdIsIrrelevant(7);
// Inapplicable because the branch condition, %7, is irrelevant.
ASSERT_FALSE(TransformationFlattenConditionalBranch(5, true, 0, 0, 0, {})
.IsApplicable(context.get(), transformation_context));
}
spirv-fuzz: Get order right for OpSelect arguments (#3974) Fixes #3948.
2020-10-22 15:05:51 +00:00
TEST(TransformationFlattenConditionalBranchTest,
OpPhiWhenTrueBranchIsConvergenceBlock) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
OpName %4 "main"
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%7 = OpConstantTrue %6
%4 = OpFunction %2 None %3
%5 = OpLabel
OpSelectionMerge %9 None
OpBranchConditional %7 %9 %8
%8 = OpLabel
%10 = OpCopyObject %6 %7
OpBranch %9
%9 = OpLabel
%11 = OpPhi %6 %10 %8 %7 %5
%12 = OpPhi %6 %7 %5 %10 %8
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);
TransformationFlattenConditionalBranch transformation(5, true, 0, 0, 0, {});
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 expected = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
OpName %4 "main"
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%7 = OpConstantTrue %6
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %8
%8 = OpLabel
%10 = OpCopyObject %6 %7
OpBranch %9
%9 = OpLabel
%11 = OpSelect %6 %7 %7 %10
%12 = OpSelect %6 %7 %7 %10
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, expected, context.get()));
}
TEST(TransformationFlattenConditionalBranchTest,
OpPhiWhenFalseBranchIsConvergenceBlock) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
OpName %4 "main"
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%7 = OpConstantTrue %6
%4 = OpFunction %2 None %3
%5 = OpLabel
OpSelectionMerge %9 None
OpBranchConditional %7 %8 %9
%8 = OpLabel
%10 = OpCopyObject %6 %7
OpBranch %9
%9 = OpLabel
%11 = OpPhi %6 %10 %8 %7 %5
%12 = OpPhi %6 %7 %5 %10 %8
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);
TransformationFlattenConditionalBranch transformation(5, true, 0, 0, 0, {});
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 expected = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
OpName %4 "main"
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%7 = OpConstantTrue %6
%4 = OpFunction %2 None %3
%5 = OpLabel
OpBranch %8
%8 = OpLabel
%10 = OpCopyObject %6 %7
OpBranch %9
%9 = OpLabel
%11 = OpSelect %6 %7 %10 %7
%12 = OpSelect %6 %7 %10 %7
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, expected, context.get()));
}
spirv-fuzz: Fix bugs in TransformationFlattenConditionalBranch (#4006) Fixes #4005. Fixes #3993.
2020-11-03 15:03:08 +00:00
TEST(TransformationFlattenConditionalBranchTest, ContainsDeadBlocksTest) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
OpName %4 "main"
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%7 = OpConstantFalse %6
%4 = OpFunction %2 None %3
%5 = OpLabel
OpSelectionMerge %9 None
OpBranchConditional %7 %8 %9
%8 = OpLabel
%10 = OpCopyObject %6 %7
OpBranch %9
%9 = OpLabel
%11 = OpPhi %6 %10 %8 %7 %5
%12 = OpPhi %6 %7 %5 %10 %8
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);
TransformationFlattenConditionalBranch transformation(5, true, 0, 0, 0, {});
ASSERT_TRUE(
transformation.IsApplicable(context.get(), transformation_context));
transformation_context.GetFactManager()->AddFactBlockIsDead(8);
ASSERT_FALSE(
transformation.IsApplicable(context.get(), transformation_context));
}
TEST(TransformationFlattenConditionalBranchTest, ContainsContinueBlockTest) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
OpName %4 "main"
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%7 = OpConstantFalse %6
%4 = OpFunction %2 None %3
%12 = OpLabel
OpBranch %13
%13 = OpLabel
OpLoopMerge %15 %14 None
OpBranchConditional %7 %5 %15
%5 = OpLabel
OpSelectionMerge %11 None
OpBranchConditional %7 %9 %10
%9 = OpLabel
OpBranch %11
%10 = OpLabel
OpBranch %14
%11 = OpLabel
OpBranch %14
%14 = OpLabel
OpBranch %13
%15 = 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);
ASSERT_FALSE(TransformationFlattenConditionalBranch(5, true, 0, 0, 0, {})
.IsApplicable(context.get(), transformation_context));
}
spirv-fuzz: Do not flatten conditionals that create synonyms (#4030) Fixes #4024.
2020-11-24 20:18:23 +00:00
TEST(TransformationFlattenConditionalBranchTest, ContainsSynonymCreation) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 320
OpName %4 "main"
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeBool
%7 = OpConstantFalse %6
%8 = OpTypeInt 32 0
%9 = OpTypePointer Function %8
%10 = OpConstant %8 42
%80 = OpConstant %8 0
%4 = OpFunction %2 None %3
%11 = OpLabel
%20 = OpVariable %9 Function
OpBranch %12
%12 = OpLabel
OpSelectionMerge %31 None
OpBranchConditional %7 %30 %31
%30 = OpLabel
OpStore %20 %10
%21 = OpLoad %8 %20
OpBranch %31
%31 = OpLabel
OpBranch %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);
transformation_context.GetFactManager()->AddFactDataSynonym(
MakeDataDescriptor(10, {}), MakeDataDescriptor(21, {}));
Switch SPIRV-Tools to use spirv.hpp11 internally (#4981) Fixes #4960 * Switches to using enum classes with an underlying type to avoid undefined behaviour
2022-11-04 21:27:10 +00:00
ASSERT_FALSE(
TransformationFlattenConditionalBranch(
12, true, 0, 0, 0,
{MakeSideEffectWrapperInfo(
MakeInstructionDescriptor(30, spv::Op::OpStore, 0), 100, 101),
MakeSideEffectWrapperInfo(
MakeInstructionDescriptor(21, spv::Op::OpLoad, 0), 102, 103, 104,
105, 106, 80)})
.IsApplicable(context.get(), transformation_context));
spirv-fuzz: Do not flatten conditionals that create synonyms (#4030) Fixes #4024.
2020-11-24 20:18:23 +00:00
}
spirv-fuzz: Transformation to flatten conditional branch (#3667) This transformation, given the header of a selection construct with branching instruction OpBranchConditional, flattens it. Side-effecting operations such as OpLoad, OpStore and OpFunctionCall are enclosed within smaller conditionals. It is applicable if the construct does not contain inner selection constructs or loops, or atomic or barrier instructions. The corresponding fuzzer pass looks for selection headers and tries to flatten them. Needed for the issue #3544, but it does not fix it completely.
2020-09-15 09:31:01 +00:00
} // namespace
} // namespace fuzz
} // namespace spvtools
Reference in New Issue Copy Permalink