AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-11-26 21:30:07 +00:00
Code Issues Packages Projects Releases Wiki Activity
c1a75bfabf
SPIRV-Tools/test/fuzz/transformation_add_constant_boolean_test.cpp

199 lines
8.7 KiB
C++
Raw Normal View History

Add fuzzer pass that adds useful constructs to a module (#2647) This new pass adds some basic ingredients to a module on which future passes are likely to depend, such as boolean constants and some specfic integer and floating-point values. This is not a fuzzer pass in the true sense in that it does not employ randomization, but it makes sense to define it as a fuzzer pass since it is the first of a number of transformations passes that the fuzzer will run on a module.
2019-06-04 13:55:00 +00:00
// Copyright (c) 2019 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "source/fuzz/transformation_add_constant_boolean.h"
spirv-fuzz: Test usages of IdIsIrrelevant fact (#3578) Part of #3177. Fixes #3579.
2020-07-23 16:19:13 +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
#include "gtest/gtest.h"
#include "source/fuzz/fuzzer_util.h"
Add fuzzer pass that adds useful constructs to a module (#2647) This new pass adds some basic ingredients to a module on which future passes are likely to depend, such as boolean constants and some specfic integer and floating-point values. This is not a fuzzer pass in the true sense in that it does not employ randomization, but it makes sense to define it as a fuzzer pass since it is the first of a number of transformations passes that the fuzzer will run on a module.
2019-06-04 13:55:00 +00:00
#include "test/fuzz/fuzz_test_util.h"
namespace spvtools {
namespace fuzz {
namespace {
TEST(TransformationAddConstantBooleanTest, NeitherPresentInitiallyAddBoth) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 310
OpName %4 "main"
%2 = OpTypeVoid
%6 = OpTypeBool
%3 = OpTypeFunction %2
%4 = OpFunction %2 None %3
%5 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_3;
const auto consumer = nullptr;
const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption);
spirv-fuzz: Introduce TransformationContext (#3272) Some transformations (e.g. TransformationAddFunction) rely on running the validator to decide whether the transformation is applicable. A recent change allowed spirv-fuzz to take validator options, to cater for the case where a module should be considered valid under particular conditions. However, validation during the checking of transformations had no access to these validator options. This change introduced TransformationContext, which currently consists of a fact manager and a set of validator options, but could in the future have other fields corresponding to other objects that it is useful to have access to when applying transformations. Now, instead of checking and applying transformations in the context of a FactManager, a TransformationContext is used. This gives access to the fact manager as before, and also access to the validator options when they are needed.
2020-04-02 14:54:46 +00:00
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: Avoid invalidating analyses in various transformations (#4205) Avoids invalidating all analyses in transformations that add constants, OpUndef and global and local variables.
2021-03-20 22:48:02 +00:00
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);
Add fuzzer pass that adds useful constructs to a module (#2647) This new pass adds some basic ingredients to a module on which future passes are likely to depend, such as boolean constants and some specfic integer and floating-point values. This is not a fuzzer pass in the true sense in that it does not employ randomization, but it makes sense to define it as a fuzzer pass since it is the first of a number of transformations passes that the fuzzer will run on a module.
2019-06-04 13:55:00 +00:00
// True and false can both be added as neither is present.
spirv-fuzz: Test usages of IdIsIrrelevant fact (#3578) Part of #3177. Fixes #3579.
2020-07-23 16:19:13 +00:00
ASSERT_TRUE(TransformationAddConstantBoolean(7, true, false)
.IsApplicable(context.get(), transformation_context));
ASSERT_TRUE(TransformationAddConstantBoolean(7, false, false)
.IsApplicable(context.get(), transformation_context));
// Irrelevant true and false can both be added as neither is present.
ASSERT_TRUE(TransformationAddConstantBoolean(7, true, true)
.IsApplicable(context.get(), transformation_context));
ASSERT_TRUE(TransformationAddConstantBoolean(7, false, true)
.IsApplicable(context.get(), transformation_context));
Add fuzzer pass that adds useful constructs to a module (#2647) This new pass adds some basic ingredients to a module on which future passes are likely to depend, such as boolean constants and some specfic integer and floating-point values. This is not a fuzzer pass in the true sense in that it does not employ randomization, but it makes sense to define it as a fuzzer pass since it is the first of a number of transformations passes that the fuzzer will run on a module.
2019-06-04 13:55:00 +00:00
// Id 5 is already taken.
spirv-fuzz: Test usages of IdIsIrrelevant fact (#3578) Part of #3177. Fixes #3579.
2020-07-23 16:19:13 +00:00
ASSERT_FALSE(TransformationAddConstantBoolean(5, true, false)
.IsApplicable(context.get(), transformation_context));
Add fuzzer pass that adds useful constructs to a module (#2647) This new pass adds some basic ingredients to a module on which future passes are likely to depend, such as boolean constants and some specfic integer and floating-point values. This is not a fuzzer pass in the true sense in that it does not employ randomization, but it makes sense to define it as a fuzzer pass since it is the first of a number of transformations passes that the fuzzer will run on a module.
2019-06-04 13:55:00 +00:00
spirv-fuzz: Test usages of IdIsIrrelevant fact (#3578) Part of #3177. Fixes #3579.
2020-07-23 16:19:13 +00:00
auto add_true = TransformationAddConstantBoolean(7, true, false);
auto add_false = TransformationAddConstantBoolean(8, false, false);
Add fuzzer pass that adds useful constructs to a module (#2647) This new pass adds some basic ingredients to a module on which future passes are likely to depend, such as boolean constants and some specfic integer and floating-point values. This is not a fuzzer pass in the true sense in that it does not employ randomization, but it makes sense to define it as a fuzzer pass since it is the first of a number of transformations passes that the fuzzer will run on a module.
2019-06-04 13:55:00 +00:00
spirv-fuzz: Introduce TransformationContext (#3272) Some transformations (e.g. TransformationAddFunction) rely on running the validator to decide whether the transformation is applicable. A recent change allowed spirv-fuzz to take validator options, to cater for the case where a module should be considered valid under particular conditions. However, validation during the checking of transformations had no access to these validator options. This change introduced TransformationContext, which currently consists of a fact manager and a set of validator options, but could in the future have other fields corresponding to other objects that it is useful to have access to when applying transformations. Now, instead of checking and applying transformations in the context of a FactManager, a TransformationContext is used. This gives access to the fact manager as before, and also access to the validator options when they are needed.
2020-04-02 14:54:46 +00:00
ASSERT_TRUE(add_true.IsApplicable(context.get(), transformation_context));
spirv-fuzz: Avoid invalidating analyses in various transformations (#4205) Avoids invalidating all analyses in transformations that add constants, OpUndef and global and local variables.
2021-03-20 22:48:02 +00:00
ASSERT_EQ(nullptr, context->get_def_use_mgr()->GetDef(7));
ASSERT_EQ(nullptr, context->get_constant_mgr()->FindDeclaredConstant(7));
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(add_true, context.get(), &transformation_context);
spirv-fuzz: Avoid invalidating analyses in various transformations (#4205) Avoids invalidating all analyses in transformations that add constants, OpUndef and global and local variables.
2021-03-20 22:48:02 +00:00
ASSERT_EQ(SpvOpConstantTrue, context->get_def_use_mgr()->GetDef(7)->opcode());
ASSERT_TRUE(context->get_constant_mgr()
->FindDeclaredConstant(7)
->AsBoolConstant()
->value());
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));
Add fuzzer pass that adds useful constructs to a module (#2647) This new pass adds some basic ingredients to a module on which future passes are likely to depend, such as boolean constants and some specfic integer and floating-point values. This is not a fuzzer pass in the true sense in that it does not employ randomization, but it makes sense to define it as a fuzzer pass since it is the first of a number of transformations passes that the fuzzer will run on a module.
2019-06-04 13:55:00 +00:00
// Having added true, we cannot add it again with the same id.
spirv-fuzz: Introduce TransformationContext (#3272) Some transformations (e.g. TransformationAddFunction) rely on running the validator to decide whether the transformation is applicable. A recent change allowed spirv-fuzz to take validator options, to cater for the case where a module should be considered valid under particular conditions. However, validation during the checking of transformations had no access to these validator options. This change introduced TransformationContext, which currently consists of a fact manager and a set of validator options, but could in the future have other fields corresponding to other objects that it is useful to have access to when applying transformations. Now, instead of checking and applying transformations in the context of a FactManager, a TransformationContext is used. This gives access to the fact manager as before, and also access to the validator options when they are needed.
2020-04-02 14:54:46 +00:00
ASSERT_FALSE(add_true.IsApplicable(context.get(), transformation_context));
Add fuzzer pass that adds useful constructs to a module (#2647) This new pass adds some basic ingredients to a module on which future passes are likely to depend, such as boolean constants and some specfic integer and floating-point values. This is not a fuzzer pass in the true sense in that it does not employ randomization, but it makes sense to define it as a fuzzer pass since it is the first of a number of transformations passes that the fuzzer will run on a module.
2019-06-04 13:55:00 +00:00
// But we can add it with a different id.
spirv-fuzz: Test usages of IdIsIrrelevant fact (#3578) Part of #3177. Fixes #3579.
2020-07-23 16:19:13 +00:00
auto add_true_again = TransformationAddConstantBoolean(100, true, false);
spirv-fuzz: Introduce TransformationContext (#3272) Some transformations (e.g. TransformationAddFunction) rely on running the validator to decide whether the transformation is applicable. A recent change allowed spirv-fuzz to take validator options, to cater for the case where a module should be considered valid under particular conditions. However, validation during the checking of transformations had no access to these validator options. This change introduced TransformationContext, which currently consists of a fact manager and a set of validator options, but could in the future have other fields corresponding to other objects that it is useful to have access to when applying transformations. Now, instead of checking and applying transformations in the context of a FactManager, a TransformationContext is used. This gives access to the fact manager as before, and also access to the validator options when they are needed.
2020-04-02 14:54:46 +00:00
ASSERT_TRUE(
add_true_again.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(add_true_again, 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));
Add fuzzer pass that adds useful constructs to a module (#2647) This new pass adds some basic ingredients to a module on which future passes are likely to depend, such as boolean constants and some specfic integer and floating-point values. This is not a fuzzer pass in the true sense in that it does not employ randomization, but it makes sense to define it as a fuzzer pass since it is the first of a number of transformations passes that the fuzzer will run on a module.
2019-06-04 13:55:00 +00:00
spirv-fuzz: Introduce TransformationContext (#3272) Some transformations (e.g. TransformationAddFunction) rely on running the validator to decide whether the transformation is applicable. A recent change allowed spirv-fuzz to take validator options, to cater for the case where a module should be considered valid under particular conditions. However, validation during the checking of transformations had no access to these validator options. This change introduced TransformationContext, which currently consists of a fact manager and a set of validator options, but could in the future have other fields corresponding to other objects that it is useful to have access to when applying transformations. Now, instead of checking and applying transformations in the context of a FactManager, a TransformationContext is used. This gives access to the fact manager as before, and also access to the validator options when they are needed.
2020-04-02 14:54:46 +00:00
ASSERT_TRUE(add_false.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(add_false, 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));
Add fuzzer pass that adds useful constructs to a module (#2647) This new pass adds some basic ingredients to a module on which future passes are likely to depend, such as boolean constants and some specfic integer and floating-point values. This is not a fuzzer pass in the true sense in that it does not employ randomization, but it makes sense to define it as a fuzzer pass since it is the first of a number of transformations passes that the fuzzer will run on a module.
2019-06-04 13:55:00 +00:00
// Having added false, we cannot add it again with the same id.
spirv-fuzz: Introduce TransformationContext (#3272) Some transformations (e.g. TransformationAddFunction) rely on running the validator to decide whether the transformation is applicable. A recent change allowed spirv-fuzz to take validator options, to cater for the case where a module should be considered valid under particular conditions. However, validation during the checking of transformations had no access to these validator options. This change introduced TransformationContext, which currently consists of a fact manager and a set of validator options, but could in the future have other fields corresponding to other objects that it is useful to have access to when applying transformations. Now, instead of checking and applying transformations in the context of a FactManager, a TransformationContext is used. This gives access to the fact manager as before, and also access to the validator options when they are needed.
2020-04-02 14:54:46 +00:00
ASSERT_FALSE(add_false.IsApplicable(context.get(), transformation_context));
Add fuzzer pass that adds useful constructs to a module (#2647) This new pass adds some basic ingredients to a module on which future passes are likely to depend, such as boolean constants and some specfic integer and floating-point values. This is not a fuzzer pass in the true sense in that it does not employ randomization, but it makes sense to define it as a fuzzer pass since it is the first of a number of transformations passes that the fuzzer will run on a module.
2019-06-04 13:55:00 +00:00
// But we can add it with a different id.
spirv-fuzz: Test usages of IdIsIrrelevant fact (#3578) Part of #3177. Fixes #3579.
2020-07-23 16:19:13 +00:00
auto add_false_again = TransformationAddConstantBoolean(101, false, false);
spirv-fuzz: Introduce TransformationContext (#3272) Some transformations (e.g. TransformationAddFunction) rely on running the validator to decide whether the transformation is applicable. A recent change allowed spirv-fuzz to take validator options, to cater for the case where a module should be considered valid under particular conditions. However, validation during the checking of transformations had no access to these validator options. This change introduced TransformationContext, which currently consists of a fact manager and a set of validator options, but could in the future have other fields corresponding to other objects that it is useful to have access to when applying transformations. Now, instead of checking and applying transformations in the context of a FactManager, a TransformationContext is used. This gives access to the fact manager as before, and also access to the validator options when they are needed.
2020-04-02 14:54:46 +00:00
ASSERT_TRUE(
add_false_again.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(add_false_again, 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));
Add fuzzer pass that adds useful constructs to a module (#2647) This new pass adds some basic ingredients to a module on which future passes are likely to depend, such as boolean constants and some specfic integer and floating-point values. This is not a fuzzer pass in the true sense in that it does not employ randomization, but it makes sense to define it as a fuzzer pass since it is the first of a number of transformations passes that the fuzzer will run on a module.
2019-06-04 13:55:00 +00:00
spirv-fuzz: Test usages of IdIsIrrelevant fact (#3578) Part of #3177. Fixes #3579.
2020-07-23 16:19:13 +00:00
// We can create an irrelevant OpConstantTrue.
TransformationAddConstantBoolean irrelevant_true(102, true, true);
ASSERT_TRUE(
irrelevant_true.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(irrelevant_true, 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: Test usages of IdIsIrrelevant fact (#3578) Part of #3177. Fixes #3579.
2020-07-23 16:19:13 +00:00
// We can create an irrelevant OpConstantFalse.
TransformationAddConstantBoolean irrelevant_false(103, false, true);
ASSERT_TRUE(
irrelevant_false.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(irrelevant_false, 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: Test usages of IdIsIrrelevant fact (#3578) Part of #3177. Fixes #3579.
2020-07-23 16:19:13 +00:00
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
ASSERT_FALSE(transformation_context.GetFactManager()->IdIsIrrelevant(100));
ASSERT_FALSE(transformation_context.GetFactManager()->IdIsIrrelevant(101));
ASSERT_TRUE(transformation_context.GetFactManager()->IdIsIrrelevant(102));
ASSERT_TRUE(transformation_context.GetFactManager()->IdIsIrrelevant(103));
spirv-fuzz: Test usages of IdIsIrrelevant fact (#3578) Part of #3177. Fixes #3579.
2020-07-23 16:19:13 +00:00
Add fuzzer pass that adds useful constructs to a module (#2647) This new pass adds some basic ingredients to a module on which future passes are likely to depend, such as boolean constants and some specfic integer and floating-point values. This is not a fuzzer pass in the true sense in that it does not employ randomization, but it makes sense to define it as a fuzzer pass since it is the first of a number of transformations passes that the fuzzer will run on a module.
2019-06-04 13:55:00 +00:00
std::string after_transformation = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 310
OpName %4 "main"
%2 = OpTypeVoid
%6 = OpTypeBool
%3 = OpTypeFunction %2
%7 = OpConstantTrue %6
%100 = OpConstantTrue %6
%8 = OpConstantFalse %6
%101 = OpConstantFalse %6
spirv-fuzz: Test usages of IdIsIrrelevant fact (#3578) Part of #3177. Fixes #3579.
2020-07-23 16:19:13 +00:00
%102 = OpConstantTrue %6
%103 = OpConstantFalse %6
Add fuzzer pass that adds useful constructs to a module (#2647) This new pass adds some basic ingredients to a module on which future passes are likely to depend, such as boolean constants and some specfic integer and floating-point values. This is not a fuzzer pass in the true sense in that it does not employ randomization, but it makes sense to define it as a fuzzer pass since it is the first of a number of transformations passes that the fuzzer will run on a module.
2019-06-04 13:55:00 +00:00
%4 = OpFunction %2 None %3
%5 = OpLabel
OpReturn
OpFunctionEnd
)";
ASSERT_TRUE(IsEqual(env, after_transformation, context.get()));
}
TEST(TransformationAddConstantBooleanTest, NoOpTypeBoolPresent) {
std::string shader = R"(
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main"
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 310
OpName %4 "main"
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%4 = OpFunction %2 None %3
%5 = OpLabel
OpReturn
OpFunctionEnd
)";
const auto env = SPV_ENV_UNIVERSAL_1_3;
const auto consumer = nullptr;
const auto context = BuildModule(env, consumer, shader, kFuzzAssembleOption);
spirv-fuzz: Introduce TransformationContext (#3272) Some transformations (e.g. TransformationAddFunction) rely on running the validator to decide whether the transformation is applicable. A recent change allowed spirv-fuzz to take validator options, to cater for the case where a module should be considered valid under particular conditions. However, validation during the checking of transformations had no access to these validator options. This change introduced TransformationContext, which currently consists of a fact manager and a set of validator options, but could in the future have other fields corresponding to other objects that it is useful to have access to when applying transformations. Now, instead of checking and applying transformations in the context of a FactManager, a TransformationContext is used. This gives access to the fact manager as before, and also access to the validator options when they are needed.
2020-04-02 14:54:46 +00:00
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);
Add fuzzer pass that adds useful constructs to a module (#2647) This new pass adds some basic ingredients to a module on which future passes are likely to depend, such as boolean constants and some specfic integer and floating-point values. This is not a fuzzer pass in the true sense in that it does not employ randomization, but it makes sense to define it as a fuzzer pass since it is the first of a number of transformations passes that the fuzzer will run on a module.
2019-06-04 13:55:00 +00:00
// Neither true nor false can be added as OpTypeBool is not present.
spirv-fuzz: Test usages of IdIsIrrelevant fact (#3578) Part of #3177. Fixes #3579.
2020-07-23 16:19:13 +00:00
ASSERT_FALSE(TransformationAddConstantBoolean(6, true, false)
.IsApplicable(context.get(), transformation_context));
ASSERT_FALSE(TransformationAddConstantBoolean(6, false, false)
.IsApplicable(context.get(), transformation_context));
// This does not depend on whether the constant is relevant or not.
ASSERT_FALSE(TransformationAddConstantBoolean(6, true, true)
.IsApplicable(context.get(), transformation_context));
ASSERT_FALSE(TransformationAddConstantBoolean(6, false, true)
.IsApplicable(context.get(), transformation_context));
Add fuzzer pass that adds useful constructs to a module (#2647) This new pass adds some basic ingredients to a module on which future passes are likely to depend, such as boolean constants and some specfic integer and floating-point values. This is not a fuzzer pass in the true sense in that it does not employ randomization, but it makes sense to define it as a fuzzer pass since it is the first of a number of transformations passes that the fuzzer will run on a module.
2019-06-04 13:55:00 +00:00
}
} // namespace
} // namespace fuzz
} // namespace spvtools
Reference in New Issue Copy Permalink