SPIRV-Tools/source/fuzz/transformation_set_loop_control.cpp

217 lines
8.4 KiB
C++
Raw Normal View History

// Copyright (c) 2019 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "source/fuzz/transformation_set_loop_control.h"
namespace spvtools {
namespace fuzz {
TransformationSetLoopControl::TransformationSetLoopControl(
const spvtools::fuzz::protobufs::TransformationSetLoopControl& message)
: message_(message) {}
TransformationSetLoopControl::TransformationSetLoopControl(
uint32_t block_id, uint32_t loop_control, uint32_t peel_count,
uint32_t partial_count) {
message_.set_block_id(block_id);
message_.set_loop_control(loop_control);
message_.set_peel_count(peel_count);
message_.set_partial_count(partial_count);
}
bool TransformationSetLoopControl::IsApplicable(
opt::IRContext* context, const FactManager& /*unused*/) const {
// |message_.block_id| must identify a block that ends with OpLoopMerge.
auto block = context->get_instr_block(message_.block_id());
if (!block) {
return false;
}
auto merge_inst = block->GetMergeInst();
if (!merge_inst || merge_inst->opcode() != SpvOpLoopMerge) {
return false;
}
// We sanity-check that the transformation does not try to set any meaningless
// bits of the loop control mask.
uint32_t all_loop_control_mask_bits_set =
SpvLoopControlUnrollMask | SpvLoopControlDontUnrollMask |
SpvLoopControlDependencyInfiniteMask |
SpvLoopControlDependencyLengthMask | SpvLoopControlMinIterationsMask |
SpvLoopControlMaxIterationsMask | SpvLoopControlIterationMultipleMask |
SpvLoopControlPeelCountMask | SpvLoopControlPartialCountMask;
// The variable is only used in an assertion; the following keeps release-mode
// compilers happy.
(void)(all_loop_control_mask_bits_set);
// No additional bits should be set.
assert(!(message_.loop_control() & ~all_loop_control_mask_bits_set));
// Grab the loop control mask currently associated with the OpLoopMerge
// instruction.
auto existing_loop_control_mask =
merge_inst->GetSingleWordInOperand(kLoopControlMaskInOperandIndex);
// Check that there is no attempt to set one of the loop controls that
// requires guarantees to hold.
for (SpvLoopControlMask mask :
{SpvLoopControlDependencyInfiniteMask,
SpvLoopControlDependencyLengthMask, SpvLoopControlMinIterationsMask,
SpvLoopControlMaxIterationsMask, SpvLoopControlIterationMultipleMask}) {
// We have a problem if this loop control bit was not set in the original
// loop control mask but is set by the transformation.
if (LoopControlBitIsAddedByTransformation(mask,
existing_loop_control_mask)) {
return false;
}
}
if ((message_.loop_control() &
(SpvLoopControlPeelCountMask | SpvLoopControlPartialCountMask)) &&
!(PeelCountIsSupported(context) && PartialCountIsSupported(context))) {
// At least one of PeelCount or PartialCount is used, but the SPIR-V version
// in question does not support these loop controls.
return false;
}
if (message_.peel_count() > 0 &&
!(message_.loop_control() & SpvLoopControlPeelCountMask)) {
// Peel count provided, but peel count mask bit not set.
return false;
}
if (message_.partial_count() > 0 &&
!(message_.loop_control() & SpvLoopControlPartialCountMask)) {
// Partial count provided, but partial count mask bit not set.
return false;
}
// We must not set both 'don't unroll' and one of 'peel count' or 'partial
// count'.
return !((message_.loop_control() & SpvLoopControlDontUnrollMask) &&
(message_.loop_control() &
(SpvLoopControlPeelCountMask | SpvLoopControlPartialCountMask)));
}
void TransformationSetLoopControl::Apply(opt::IRContext* context,
FactManager* /*unused*/) const {
// Grab the loop merge instruction and its associated loop control mask.
auto merge_inst =
context->get_instr_block(message_.block_id())->GetMergeInst();
auto existing_loop_control_mask =
merge_inst->GetSingleWordInOperand(kLoopControlMaskInOperandIndex);
// We are going to replace the OpLoopMerge's operands with this list.
opt::Instruction::OperandList new_operands;
// We add the existing merge block and continue target ids.
new_operands.push_back(merge_inst->GetInOperand(0));
new_operands.push_back(merge_inst->GetInOperand(1));
// We use the loop control mask from the transformation.
new_operands.push_back(
{SPV_OPERAND_TYPE_LOOP_CONTROL, {message_.loop_control()}});
// It remains to determine what literals to provide, in association with
// the new loop control mask.
//
// For the loop controls that require guarantees to hold about the number
// of loop iterations, we need to keep, from the original OpLoopMerge, any
// literals associated with loop control bits that are still set.
uint32_t literal_index = 0; // Indexes into the literals from the original
// instruction.
for (SpvLoopControlMask mask :
{SpvLoopControlDependencyLengthMask, SpvLoopControlMinIterationsMask,
SpvLoopControlMaxIterationsMask, SpvLoopControlIterationMultipleMask}) {
// Check whether the bit was set in the original loop control mask.
if (existing_loop_control_mask & mask) {
// Check whether the bit is set in the new loop control mask.
if (message_.loop_control() & mask) {
// Add the associated literal to our sequence of replacement operands.
new_operands.push_back(
{SPV_OPERAND_TYPE_LITERAL_INTEGER,
{merge_inst->GetSingleWordInOperand(
kLoopControlFirstLiteralInOperandIndex + literal_index)}});
}
// Increment our index into the original loop control mask's literals,
// whether or not the bit was set in the new mask.
literal_index++;
}
}
// If PeelCount is set in the new mask, |message_.peel_count| provides the
// associated peel count.
if (message_.loop_control() & SpvLoopControlPeelCountMask) {
new_operands.push_back(
{SPV_OPERAND_TYPE_LITERAL_INTEGER, {message_.peel_count()}});
}
// Similar, but for PartialCount.
if (message_.loop_control() & SpvLoopControlPartialCountMask) {
new_operands.push_back(
{SPV_OPERAND_TYPE_LITERAL_INTEGER, {message_.partial_count()}});
}
// Replace the input operands of the OpLoopMerge with the new operands we have
// accumulated.
merge_inst->SetInOperands(std::move(new_operands));
}
protobufs::Transformation TransformationSetLoopControl::ToMessage() const {
protobufs::Transformation result;
*result.mutable_set_loop_control() = message_;
return result;
}
bool TransformationSetLoopControl::LoopControlBitIsAddedByTransformation(
SpvLoopControlMask loop_control_single_bit_mask,
uint32_t existing_loop_control_mask) const {
return !(loop_control_single_bit_mask & existing_loop_control_mask) &&
(loop_control_single_bit_mask & message_.loop_control());
}
bool TransformationSetLoopControl::PartialCountIsSupported(
opt::IRContext* context) {
// TODO(afd): We capture the universal environments for which this loop
// control is definitely not supported. The check should be refined on
// demand for other target environments.
switch (context->grammar().target_env()) {
case SPV_ENV_UNIVERSAL_1_0:
case SPV_ENV_UNIVERSAL_1_1:
case SPV_ENV_UNIVERSAL_1_2:
case SPV_ENV_UNIVERSAL_1_3:
return false;
default:
return true;
}
}
bool TransformationSetLoopControl::PeelCountIsSupported(
opt::IRContext* context) {
// TODO(afd): We capture the universal environments for which this loop
// control is definitely not supported. The check should be refined on
// demand for other target environments.
switch (context->grammar().target_env()) {
case SPV_ENV_UNIVERSAL_1_0:
case SPV_ENV_UNIVERSAL_1_1:
case SPV_ENV_UNIVERSAL_1_2:
case SPV_ENV_UNIVERSAL_1_3:
return false;
default:
return true;
}
}
} // namespace fuzz
} // namespace spvtools