source/fuzz/transformation_set_loop_control.cpp - external/github.com/KhronosGroup/SPIRV-Tools - Git at Google

 // 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
	// 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