AuroraMiddleware/SPIRV-Tools
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Tools synced 2024-11-23 12:10:06 +00:00
Code Issues Packages Projects Releases Wiki Activity
c9b254d045
SPIRV-Tools/source/fuzz/transformation_add_constant_boolean.cpp

66 lines
2.3 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"
#include "source/fuzz/fuzzer_util.h"
#include "source/opt/types.h"
namespace spvtools {
namespace fuzz {
Refactor fuzzer transformations (#2694) Introduced abstract class for transformations, and refactored all transformations to inherit from this abstract class.
2019-06-25 19:49:46 +00:00
TransformationAddConstantBoolean::TransformationAddConstantBoolean(
const protobufs::TransformationAddConstantBoolean& message)
: message_(message) {}
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
Refactor fuzzer transformations (#2694) Introduced abstract class for transformations, and refactored all transformations to inherit from this abstract class.
2019-06-25 19:49:46 +00:00
TransformationAddConstantBoolean::TransformationAddConstantBoolean(
uint32_t fresh_id, bool is_true) {
message_.set_fresh_id(fresh_id);
message_.set_is_true(is_true);
}
bool TransformationAddConstantBoolean::IsApplicable(
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
opt::IRContext* ir_context, const TransformationContext& /*unused*/) const {
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
opt::analysis::Bool bool_type;
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
if (!ir_context->get_type_mgr()->GetId(&bool_type)) {
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
// No OpTypeBool is present.
return 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
return fuzzerutil::IsFreshId(ir_context, message_.fresh_id());
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
void TransformationAddConstantBoolean::Apply(
opt::IRContext* ir_context, TransformationContext* /*unused*/) const {
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
opt::analysis::Bool bool_type;
// Add the boolean constant to the module, ensuring the module's id bound is
// high enough.
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
fuzzerutil::UpdateModuleIdBound(ir_context, message_.fresh_id());
ir_context->module()->AddGlobalValue(
Refactor fuzzer transformations (#2694) Introduced abstract class for transformations, and refactored all transformations to inherit from this abstract class.
2019-06-25 19:49:46 +00:00
message_.is_true() ? SpvOpConstantTrue : SpvOpConstantFalse,
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
message_.fresh_id(), ir_context->get_type_mgr()->GetId(&bool_type));
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
// We have added an instruction to the module, so need to be careful about the
// validity of existing analyses.
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
ir_context->InvalidateAnalysesExceptFor(
opt::IRContext::Analysis::kAnalysisNone);
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
}
Refactor fuzzer transformations (#2694) Introduced abstract class for transformations, and refactored all transformations to inherit from this abstract class.
2019-06-25 19:49:46 +00:00
protobufs::Transformation TransformationAddConstantBoolean::ToMessage() const {
protobufs::Transformation result;
*result.mutable_add_constant_boolean() = message_;
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
return result;
}
} // namespace fuzz
} // namespace spvtools
Reference in New Issue Copy Permalink