compiler/optimizing/instruction_simplifier_shared.cc - platform/art - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * 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 "instruction_simplifier_shared.h"

 #include "mirror/array-inl.h"

 namespace art {

 namespace {

 bool TrySimpleMultiplyAccumulatePatterns(HMul* mul,
                                          HBinaryOperation* input_binop,
                                          HInstruction* input_other) {
   DCHECK(DataType::IsIntOrLongType(mul->GetType()));
   DCHECK(input_binop->IsAdd() || input_binop->IsSub());
   DCHECK_NE(input_binop, input_other);
   if (!input_binop->HasOnlyOneNonEnvironmentUse()) {
     return false;
   }

   // Try to interpret patterns like
   //    a * (b <+/-> 1)
   // as
   //    (a * b) <+/-> a
   HInstruction* input_a = input_other;
   HInstruction* input_b = nullptr;  // Set to a non-null value if we found a pattern to optimize.
   HInstruction::InstructionKind op_kind;

   if (input_binop->IsAdd()) {
     if ((input_binop->GetConstantRight() != nullptr) && input_binop->GetConstantRight()->IsOne()) {
       // Interpret
       //    a * (b + 1)
       // as
       //    (a * b) + a
       input_b = input_binop->GetLeastConstantLeft();
       op_kind = HInstruction::kAdd;
     }
   } else {
     DCHECK(input_binop->IsSub());
     if (input_binop->GetRight()->IsConstant() &&
         input_binop->GetRight()->AsConstant()->IsMinusOne()) {
       // Interpret
       //    a * (b - (-1))
       // as
       //    a + (a * b)
       input_b = input_binop->GetLeft();
       op_kind = HInstruction::kAdd;
     } else if (input_binop->GetLeft()->IsConstant() &&
                input_binop->GetLeft()->AsConstant()->IsOne()) {
       // Interpret
       //    a * (1 - b)
       // as
       //    a - (a * b)
       input_b = input_binop->GetRight();
       op_kind = HInstruction::kSub;
     }
   }

   if (input_b == nullptr) {
     // We did not find a pattern we can optimize.
     return false;
   }

   ArenaAllocator* allocator = mul->GetBlock()->GetGraph()->GetAllocator();
   HMultiplyAccumulate* mulacc = new (allocator) HMultiplyAccumulate(
       mul->GetType(), op_kind, input_a, input_a, input_b, mul->GetDexPc());

   mul->GetBlock()->ReplaceAndRemoveInstructionWith(mul, mulacc);
   input_binop->GetBlock()->RemoveInstruction(input_binop);

   return true;
 }

 }  // namespace

 bool TryCombineMultiplyAccumulate(HMul* mul, InstructionSet isa) {
   DataType::Type type = mul->GetType();
   switch (isa) {
     case InstructionSet::kArm:
     case InstructionSet::kThumb2:
       if (type != DataType::Type::kInt32) {
         return false;
       }
       break;
     case InstructionSet::kArm64:
       if (!DataType::IsIntOrLongType(type)) {
         return false;
       }
       break;
     default:
       return false;
   }

   ArenaAllocator* allocator = mul->GetBlock()->GetGraph()->GetAllocator();

   if (mul->HasOnlyOneNonEnvironmentUse()) {
     HInstruction* use = mul->GetUses().front().GetUser();
     if (use->IsAdd() || use->IsSub()) {
       // Replace code looking like
       //    MUL tmp, x, y
       //    SUB dst, acc, tmp
       // with
       //    MULSUB dst, acc, x, y
       // Note that we do not want to (unconditionally) perform the merge when the
       // multiplication has multiple uses and it can be merged in all of them.
       // Multiple uses could happen on the same control-flow path, and we would
       // then increase the amount of work. In the future we could try to evaluate
       // whether all uses are on different control-flow paths (using dominance and
       // reverse-dominance information) and only perform the merge when they are.
       HInstruction* accumulator = nullptr;
       HBinaryOperation* binop = use->AsBinaryOperation();
       HInstruction* binop_left = binop->GetLeft();
       HInstruction* binop_right = binop->GetRight();
       // Be careful after GVN. This should not happen since the `HMul` has only
       // one use.
       DCHECK_NE(binop_left, binop_right);
       if (binop_right == mul) {
         accumulator = binop_left;
       } else if (use->IsAdd()) {
         DCHECK_EQ(binop_left, mul);
         accumulator = binop_right;
       }

       if (accumulator != nullptr) {
         HMultiplyAccumulate* mulacc =
             new (allocator) HMultiplyAccumulate(type,
                                                 binop->GetKind(),
                                                 accumulator,
                                                 mul->GetLeft(),
                                                 mul->GetRight());

         binop->GetBlock()->ReplaceAndRemoveInstructionWith(binop, mulacc);
         DCHECK(!mul->HasUses());
         mul->GetBlock()->RemoveInstruction(mul);
         return true;
       }
     } else if (use->IsNeg() && isa != InstructionSet::kArm) {
       HMultiplyAccumulate* mulacc =
           new (allocator) HMultiplyAccumulate(type,
                                               HInstruction::kSub,
                                               mul->GetBlock()->GetGraph()->GetConstant(type, 0),
                                               mul->GetLeft(),
                                               mul->GetRight());

       use->GetBlock()->ReplaceAndRemoveInstructionWith(use, mulacc);
       DCHECK(!mul->HasUses());
       mul->GetBlock()->RemoveInstruction(mul);
       return true;
     }
   }

   // Use multiply accumulate instruction for a few simple patterns.
   // We prefer not applying the following transformations if the left and
   // right inputs perform the same operation.
   // We rely on GVN having squashed the inputs if appropriate. However the
   // results are still correct even if that did not happen.
   if (mul->GetLeft() == mul->GetRight()) {
     return false;
   }

   HInstruction* left = mul->GetLeft();
   HInstruction* right = mul->GetRight();
   if ((right->IsAdd() || right->IsSub()) &&
       TrySimpleMultiplyAccumulatePatterns(mul, right->AsBinaryOperation(), left)) {
     return true;
   }
   if ((left->IsAdd() || left->IsSub()) &&
       TrySimpleMultiplyAccumulatePatterns(mul, left->AsBinaryOperation(), right)) {
     return true;
   }
   return false;
 }


 bool TryMergeNegatedInput(HBinaryOperation* op) {
   DCHECK(op->IsAnd() || op->IsOr() || op->IsXor()) << op->DebugName();
   HInstruction* left = op->GetLeft();
   HInstruction* right = op->GetRight();

   // Only consider the case where there is exactly one Not, with 2 Not's De
   // Morgan's laws should be applied instead.
   if (left->IsNot() ^ right->IsNot()) {
     HInstruction* hnot = (left->IsNot() ? left : right);
     HInstruction* hother = (left->IsNot() ? right : left);

     // Only do the simplification if the Not has only one use and can thus be
     // safely removed. Even though ARM64 negated bitwise operations do not have
     // an immediate variant (only register), we still do the simplification when
     // `hother` is a constant, because it removes an instruction if the constant
     // cannot be encoded as an immediate:
     //   mov r0, #large_constant
     //   neg r2, r1
     //   and r0, r0, r2
     // becomes:
     //   mov r0, #large_constant
     //   bic r0, r0, r1
     if (hnot->HasOnlyOneNonEnvironmentUse()) {
       // Replace code looking like
       //    NOT tmp, mask
       //    AND dst, src, tmp   (respectively ORR, EOR)
       // with
       //    BIC dst, src, mask  (respectively ORN, EON)
       HInstruction* src = hnot->AsNot()->GetInput();

       HBitwiseNegatedRight* neg_op = new (hnot->GetBlock()->GetGraph()->GetAllocator())
           HBitwiseNegatedRight(op->GetType(), op->GetKind(), hother, src, op->GetDexPc());

       op->GetBlock()->ReplaceAndRemoveInstructionWith(op, neg_op);
       hnot->GetBlock()->RemoveInstruction(hnot);
       return true;
     }
   }

   return false;
 }


 bool TryExtractArrayAccessAddress(HInstruction* access,
                                   HInstruction* array,
                                   HInstruction* index,
                                   size_t data_offset) {
   if (index->IsConstant() ||
       (index->IsBoundsCheck() && index->AsBoundsCheck()->GetIndex()->IsConstant())) {
     // When the index is a constant all the addressing can be fitted in the
     // memory access instruction, so do not split the access.
     return false;
   }
   if (access->IsArraySet() &&
       access->AsArraySet()->GetValue()->GetType() == DataType::Type::kReference) {
     // The access may require a runtime call or the original array pointer.
     return false;
   }
   if (kEmitCompilerReadBarrier &&
       access->IsArrayGet() &&
       access->GetType() == DataType::Type::kReference) {
     // For object arrays, the read barrier instrumentation requires
     // the original array pointer.
     // TODO: This can be relaxed for Baker CC.
     return false;
   }

   // Proceed to extract the base address computation.
   HGraph* graph = access->GetBlock()->GetGraph();
   ArenaAllocator* allocator = graph->GetAllocator();

   HIntConstant* offset = graph->GetIntConstant(data_offset);
   HIntermediateAddress* address = new (allocator) HIntermediateAddress(array, offset, kNoDexPc);
   // TODO: Is it ok to not have this on the intermediate address?
   // address->SetReferenceTypeInfo(array->GetReferenceTypeInfo());
   access->GetBlock()->InsertInstructionBefore(address, access);
   access->ReplaceInput(address, 0);
   // Both instructions must depend on GC to prevent any instruction that can
   // trigger GC to be inserted between the two.
   access->AddSideEffects(SideEffects::DependsOnGC());
   DCHECK(address->GetSideEffects().Includes(SideEffects::DependsOnGC()));
   DCHECK(access->GetSideEffects().Includes(SideEffects::DependsOnGC()));
   // TODO: Code generation for HArrayGet and HArraySet will check whether the input address
   // is an HIntermediateAddress and generate appropriate code.
   // We would like to replace the `HArrayGet` and `HArraySet` with custom instructions (maybe
   // `HArm64Load` and `HArm64Store`,`HArmLoad` and `HArmStore`). We defer these changes
   // because these new instructions would not bring any advantages yet.
   // Also see the comments in
   // `InstructionCodeGeneratorARMVIXL::VisitArrayGet()`
   // `InstructionCodeGeneratorARMVIXL::VisitArraySet()`
   // `InstructionCodeGeneratorARM64::VisitArrayGet()`
   // `InstructionCodeGeneratorARM64::VisitArraySet()`.
   return true;
 }

 bool TryExtractVecArrayAccessAddress(HVecMemoryOperation* access, HInstruction* index) {
   if (index->IsConstant()) {
     // If index is constant the whole address calculation often can be done by LDR/STR themselves.
     // TODO: Treat the case with not-embedable constant.
     return false;
   }

   HGraph* graph = access->GetBlock()->GetGraph();
   ArenaAllocator* allocator = graph->GetAllocator();
   DataType::Type packed_type = access->GetPackedType();
   uint32_t data_offset = mirror::Array::DataOffset(
       DataType::Size(packed_type)).Uint32Value();
   size_t component_shift = DataType::SizeShift(packed_type);

   bool is_extracting_beneficial = false;
   // It is beneficial to extract index intermediate address only if there are at least 2 users.
   for (const HUseListNode<HInstruction*>& use : index->GetUses()) {
     HInstruction* user = use.GetUser();
     if (user->IsVecMemoryOperation() && user != access) {
       HVecMemoryOperation* another_access = user->AsVecMemoryOperation();
       DataType::Type another_packed_type = another_access->GetPackedType();
       uint32_t another_data_offset = mirror::Array::DataOffset(
           DataType::Size(another_packed_type)).Uint32Value();
       size_t another_component_shift = DataType::SizeShift(another_packed_type);
       if (another_data_offset == data_offset && another_component_shift == component_shift) {
         is_extracting_beneficial = true;
         break;
       }
     } else if (user->IsIntermediateAddressIndex()) {
       HIntermediateAddressIndex* another_access = user->AsIntermediateAddressIndex();
       uint32_t another_data_offset = another_access->GetOffset()->AsIntConstant()->GetValue();
       size_t another_component_shift = another_access->GetShift()->AsIntConstant()->GetValue();
       if (another_data_offset == data_offset && another_component_shift == component_shift) {
         is_extracting_beneficial = true;
         break;
       }
     }
   }

   if (!is_extracting_beneficial) {
     return false;
   }

   // Proceed to extract the index + data_offset address computation.
   HIntConstant* offset = graph->GetIntConstant(data_offset);
   HIntConstant* shift = graph->GetIntConstant(component_shift);
   HIntermediateAddressIndex* address =
       new (allocator) HIntermediateAddressIndex(index, offset, shift, kNoDexPc);

   access->GetBlock()->InsertInstructionBefore(address, access);
   access->ReplaceInput(address, 1);

   return true;
 }

 }  // namespace art
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* 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 "instruction_simplifier_shared.h"

	#include "mirror/array-inl.h"

	namespace art {

	namespace {

	bool TrySimpleMultiplyAccumulatePatterns(HMul* mul,
	HBinaryOperation* input_binop,
	HInstruction* input_other) {
	DCHECK(DataType::IsIntOrLongType(mul->GetType()));
	DCHECK(input_binop->IsAdd() \|\| input_binop->IsSub());
	DCHECK_NE(input_binop, input_other);
	if (!input_binop->HasOnlyOneNonEnvironmentUse()) {
	return false;
	}

	// Try to interpret patterns like
	// a * (b <+/-> 1)
	// as
	// (a * b) <+/-> a
	HInstruction* input_a = input_other;
	HInstruction* input_b = nullptr; // Set to a non-null value if we found a pattern to optimize.
	HInstruction::InstructionKind op_kind;

	if (input_binop->IsAdd()) {
	if ((input_binop->GetConstantRight() != nullptr) && input_binop->GetConstantRight()->IsOne()) {
	// Interpret
	// a * (b + 1)
	// as
	// (a * b) + a
	input_b = input_binop->GetLeastConstantLeft();
	op_kind = HInstruction::kAdd;
	}
	} else {
	DCHECK(input_binop->IsSub());
	if (input_binop->GetRight()->IsConstant() &&
	input_binop->GetRight()->AsConstant()->IsMinusOne()) {
	// Interpret
	// a * (b - (-1))
	// as
	// a + (a * b)
	input_b = input_binop->GetLeft();
	op_kind = HInstruction::kAdd;
	} else if (input_binop->GetLeft()->IsConstant() &&
	input_binop->GetLeft()->AsConstant()->IsOne()) {
	// Interpret
	// a * (1 - b)
	// as
	// a - (a * b)
	input_b = input_binop->GetRight();
	op_kind = HInstruction::kSub;
	}
	}

	if (input_b == nullptr) {
	// We did not find a pattern we can optimize.
	return false;
	}

	ArenaAllocator* allocator = mul->GetBlock()->GetGraph()->GetAllocator();
	HMultiplyAccumulate* mulacc = new (allocator) HMultiplyAccumulate(
	mul->GetType(), op_kind, input_a, input_a, input_b, mul->GetDexPc());

	mul->GetBlock()->ReplaceAndRemoveInstructionWith(mul, mulacc);
	input_binop->GetBlock()->RemoveInstruction(input_binop);

	return true;
	}

	} // namespace

	bool TryCombineMultiplyAccumulate(HMul* mul, InstructionSet isa) {
	DataType::Type type = mul->GetType();
	switch (isa) {
	case InstructionSet::kArm:
	case InstructionSet::kThumb2:
	if (type != DataType::Type::kInt32) {
	return false;
	}
	break;
	case InstructionSet::kArm64:
	if (!DataType::IsIntOrLongType(type)) {
	return false;
	}
	break;
	default:
	return false;
	}

	ArenaAllocator* allocator = mul->GetBlock()->GetGraph()->GetAllocator();

	if (mul->HasOnlyOneNonEnvironmentUse()) {
	HInstruction* use = mul->GetUses().front().GetUser();
	if (use->IsAdd() \|\| use->IsSub()) {
	// Replace code looking like
	// MUL tmp, x, y
	// SUB dst, acc, tmp
	// with
	// MULSUB dst, acc, x, y
	// Note that we do not want to (unconditionally) perform the merge when the
	// multiplication has multiple uses and it can be merged in all of them.
	// Multiple uses could happen on the same control-flow path, and we would
	// then increase the amount of work. In the future we could try to evaluate
	// whether all uses are on different control-flow paths (using dominance and
	// reverse-dominance information) and only perform the merge when they are.
	HInstruction* accumulator = nullptr;
	HBinaryOperation* binop = use->AsBinaryOperation();
	HInstruction* binop_left = binop->GetLeft();
	HInstruction* binop_right = binop->GetRight();
	// Be careful after GVN. This should not happen since the `HMul` has only
	// one use.
	DCHECK_NE(binop_left, binop_right);
	if (binop_right == mul) {
	accumulator = binop_left;
	} else if (use->IsAdd()) {
	DCHECK_EQ(binop_left, mul);
	accumulator = binop_right;
	}

	if (accumulator != nullptr) {
	HMultiplyAccumulate* mulacc =
	new (allocator) HMultiplyAccumulate(type,
	binop->GetKind(),
	accumulator,
	mul->GetLeft(),
	mul->GetRight());

	binop->GetBlock()->ReplaceAndRemoveInstructionWith(binop, mulacc);
	DCHECK(!mul->HasUses());
	mul->GetBlock()->RemoveInstruction(mul);
	return true;
	}
	} else if (use->IsNeg() && isa != InstructionSet::kArm) {
	HMultiplyAccumulate* mulacc =
	new (allocator) HMultiplyAccumulate(type,
	HInstruction::kSub,
	mul->GetBlock()->GetGraph()->GetConstant(type, 0),
	mul->GetLeft(),
	mul->GetRight());

	use->GetBlock()->ReplaceAndRemoveInstructionWith(use, mulacc);
	DCHECK(!mul->HasUses());
	mul->GetBlock()->RemoveInstruction(mul);
	return true;
	}
	}

	// Use multiply accumulate instruction for a few simple patterns.
	// We prefer not applying the following transformations if the left and
	// right inputs perform the same operation.
	// We rely on GVN having squashed the inputs if appropriate. However the
	// results are still correct even if that did not happen.
	if (mul->GetLeft() == mul->GetRight()) {
	return false;
	}

	HInstruction* left = mul->GetLeft();
	HInstruction* right = mul->GetRight();
	if ((right->IsAdd() \|\| right->IsSub()) &&
	TrySimpleMultiplyAccumulatePatterns(mul, right->AsBinaryOperation(), left)) {
	return true;
	}
	if ((left->IsAdd() \|\| left->IsSub()) &&
	TrySimpleMultiplyAccumulatePatterns(mul, left->AsBinaryOperation(), right)) {
	return true;
	}
	return false;
	}


	bool TryMergeNegatedInput(HBinaryOperation* op) {
	DCHECK(op->IsAnd() \|\| op->IsOr() \|\| op->IsXor()) << op->DebugName();
	HInstruction* left = op->GetLeft();
	HInstruction* right = op->GetRight();

	// Only consider the case where there is exactly one Not, with 2 Not's De
	// Morgan's laws should be applied instead.
	if (left->IsNot() ^ right->IsNot()) {
	HInstruction* hnot = (left->IsNot() ? left : right);
	HInstruction* hother = (left->IsNot() ? right : left);

	// Only do the simplification if the Not has only one use and can thus be
	// safely removed. Even though ARM64 negated bitwise operations do not have
	// an immediate variant (only register), we still do the simplification when
	// `hother` is a constant, because it removes an instruction if the constant
	// cannot be encoded as an immediate:
	// mov r0, #large_constant
	// neg r2, r1
	// and r0, r0, r2
	// becomes:
	// mov r0, #large_constant
	// bic r0, r0, r1
	if (hnot->HasOnlyOneNonEnvironmentUse()) {
	// Replace code looking like
	// NOT tmp, mask
	// AND dst, src, tmp (respectively ORR, EOR)
	// with
	// BIC dst, src, mask (respectively ORN, EON)
	HInstruction* src = hnot->AsNot()->GetInput();

	HBitwiseNegatedRight* neg_op = new (hnot->GetBlock()->GetGraph()->GetAllocator())
	HBitwiseNegatedRight(op->GetType(), op->GetKind(), hother, src, op->GetDexPc());

	op->GetBlock()->ReplaceAndRemoveInstructionWith(op, neg_op);
	hnot->GetBlock()->RemoveInstruction(hnot);
	return true;
	}
	}

	return false;
	}


	bool TryExtractArrayAccessAddress(HInstruction* access,
	HInstruction* array,
	HInstruction* index,
	size_t data_offset) {
	if (index->IsConstant() \|\|
	(index->IsBoundsCheck() && index->AsBoundsCheck()->GetIndex()->IsConstant())) {
	// When the index is a constant all the addressing can be fitted in the
	// memory access instruction, so do not split the access.
	return false;
	}
	if (access->IsArraySet() &&
	access->AsArraySet()->GetValue()->GetType() == DataType::Type::kReference) {
	// The access may require a runtime call or the original array pointer.
	return false;
	}
	if (kEmitCompilerReadBarrier &&
	access->IsArrayGet() &&
	access->GetType() == DataType::Type::kReference) {
	// For object arrays, the read barrier instrumentation requires
	// the original array pointer.
	// TODO: This can be relaxed for Baker CC.
	return false;
	}

	// Proceed to extract the base address computation.
	HGraph* graph = access->GetBlock()->GetGraph();
	ArenaAllocator* allocator = graph->GetAllocator();

	HIntConstant* offset = graph->GetIntConstant(data_offset);
	HIntermediateAddress* address = new (allocator) HIntermediateAddress(array, offset, kNoDexPc);
	// TODO: Is it ok to not have this on the intermediate address?
	// address->SetReferenceTypeInfo(array->GetReferenceTypeInfo());
	access->GetBlock()->InsertInstructionBefore(address, access);
	access->ReplaceInput(address, 0);
	// Both instructions must depend on GC to prevent any instruction that can
	// trigger GC to be inserted between the two.
	access->AddSideEffects(SideEffects::DependsOnGC());
	DCHECK(address->GetSideEffects().Includes(SideEffects::DependsOnGC()));
	DCHECK(access->GetSideEffects().Includes(SideEffects::DependsOnGC()));
	// TODO: Code generation for HArrayGet and HArraySet will check whether the input address
	// is an HIntermediateAddress and generate appropriate code.
	// We would like to replace the `HArrayGet` and `HArraySet` with custom instructions (maybe
	// `HArm64Load` and `HArm64Store`,`HArmLoad` and `HArmStore`). We defer these changes
	// because these new instructions would not bring any advantages yet.
	// Also see the comments in
	// `InstructionCodeGeneratorARMVIXL::VisitArrayGet()`
	// `InstructionCodeGeneratorARMVIXL::VisitArraySet()`
	// `InstructionCodeGeneratorARM64::VisitArrayGet()`
	// `InstructionCodeGeneratorARM64::VisitArraySet()`.
	return true;
	}

	bool TryExtractVecArrayAccessAddress(HVecMemoryOperation* access, HInstruction* index) {
	if (index->IsConstant()) {
	// If index is constant the whole address calculation often can be done by LDR/STR themselves.
	// TODO: Treat the case with not-embedable constant.
	return false;
	}

	HGraph* graph = access->GetBlock()->GetGraph();
	ArenaAllocator* allocator = graph->GetAllocator();
	DataType::Type packed_type = access->GetPackedType();
	uint32_t data_offset = mirror::Array::DataOffset(
	DataType::Size(packed_type)).Uint32Value();
	size_t component_shift = DataType::SizeShift(packed_type);

	bool is_extracting_beneficial = false;
	// It is beneficial to extract index intermediate address only if there are at least 2 users.
	for (const HUseListNode<HInstruction*>& use : index->GetUses()) {
	HInstruction* user = use.GetUser();
	if (user->IsVecMemoryOperation() && user != access) {
	HVecMemoryOperation* another_access = user->AsVecMemoryOperation();
	DataType::Type another_packed_type = another_access->GetPackedType();
	uint32_t another_data_offset = mirror::Array::DataOffset(
	DataType::Size(another_packed_type)).Uint32Value();
	size_t another_component_shift = DataType::SizeShift(another_packed_type);
	if (another_data_offset == data_offset && another_component_shift == component_shift) {
	is_extracting_beneficial = true;
	break;
	}
	} else if (user->IsIntermediateAddressIndex()) {
	HIntermediateAddressIndex* another_access = user->AsIntermediateAddressIndex();
	uint32_t another_data_offset = another_access->GetOffset()->AsIntConstant()->GetValue();
	size_t another_component_shift = another_access->GetShift()->AsIntConstant()->GetValue();
	if (another_data_offset == data_offset && another_component_shift == component_shift) {
	is_extracting_beneficial = true;
	break;
	}
	}
	}

	if (!is_extracting_beneficial) {
	return false;
	}

	// Proceed to extract the index + data_offset address computation.
	HIntConstant* offset = graph->GetIntConstant(data_offset);
	HIntConstant* shift = graph->GetIntConstant(component_shift);
	HIntermediateAddressIndex* address =
	new (allocator) HIntermediateAddressIndex(index, offset, shift, kNoDexPc);

	access->GetBlock()->InsertInstructionBefore(address, access);
	access->ReplaceInput(address, 1);

	return true;
	}

	} // namespace art