/* * Copyright (C) 2014 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.h" #include "art_method-inl.h" #include "class_linker-inl.h" #include "class_root-inl.h" #include "data_type-inl.h" #include "driver/compiler_options.h" #include "escape.h" #include "intrinsic_objects.h" #include "intrinsics.h" #include "intrinsics_utils.h" #include "mirror/class-inl.h" #include "optimizing/data_type.h" #include "optimizing/nodes.h" #include "scoped_thread_state_change-inl.h" #include "sharpening.h" #include "string_builder_append.h" #include "well_known_classes.h" namespace art HIDDEN { // Whether to run an exhaustive test of individual HInstructions cloning when each instruction // is replaced with its copy if it is clonable. static constexpr bool kTestInstructionClonerExhaustively = false; class InstructionSimplifierVisitor final : public HGraphDelegateVisitor { public: InstructionSimplifierVisitor(HGraph* graph, CodeGenerator* codegen, OptimizingCompilerStats* stats, bool be_loop_friendly) : HGraphDelegateVisitor(graph), codegen_(codegen), stats_(stats), be_loop_friendly_(be_loop_friendly) {} bool Run(); private: void RecordSimplification() { simplification_occurred_ = true; simplifications_at_current_position_++; MaybeRecordStat(stats_, MethodCompilationStat::kInstructionSimplifications); } bool ReplaceRotateWithRor(HBinaryOperation* op, HUShr* ushr, HShl* shl); bool TryReplaceWithRotate(HBinaryOperation* instruction); bool TryReplaceWithRotateConstantPattern(HBinaryOperation* op, HUShr* ushr, HShl* shl); bool TryReplaceWithRotateRegisterNegPattern(HBinaryOperation* op, HUShr* ushr, HShl* shl); bool TryReplaceWithRotateRegisterSubPattern(HBinaryOperation* op, HUShr* ushr, HShl* shl); bool TryMoveNegOnInputsAfterBinop(HBinaryOperation* binop); // `op` should be either HOr or HAnd. // De Morgan's laws: // ~a & ~b = ~(a | b) and ~a | ~b = ~(a & b) bool TryDeMorganNegationFactoring(HBinaryOperation* op); bool TryHandleAssociativeAndCommutativeOperation(HBinaryOperation* instruction); bool TrySubtractionChainSimplification(HBinaryOperation* instruction); bool TryCombineVecMultiplyAccumulate(HVecMul* mul); void TryToReuseDiv(HRem* rem); void VisitShift(HBinaryOperation* shift); void VisitEqual(HEqual* equal) override; void VisitNotEqual(HNotEqual* equal) override; void VisitBooleanNot(HBooleanNot* bool_not) override; void VisitInstanceFieldSet(HInstanceFieldSet* equal) override; void VisitStaticFieldSet(HStaticFieldSet* equal) override; void VisitArraySet(HArraySet* equal) override; void VisitTypeConversion(HTypeConversion* instruction) override; void VisitNullCheck(HNullCheck* instruction) override; void VisitArrayLength(HArrayLength* instruction) override; void VisitCheckCast(HCheckCast* instruction) override; void VisitAbs(HAbs* instruction) override; void VisitAdd(HAdd* instruction) override; void VisitAnd(HAnd* instruction) override; void VisitCompare(HCompare* instruction) override; void VisitCondition(HCondition* instruction) override; void VisitGreaterThan(HGreaterThan* condition) override; void VisitGreaterThanOrEqual(HGreaterThanOrEqual* condition) override; void VisitLessThan(HLessThan* condition) override; void VisitLessThanOrEqual(HLessThanOrEqual* condition) override; void VisitBelow(HBelow* condition) override; void VisitBelowOrEqual(HBelowOrEqual* condition) override; void VisitAbove(HAbove* condition) override; void VisitAboveOrEqual(HAboveOrEqual* condition) override; void VisitDiv(HDiv* instruction) override; void VisitRem(HRem* instruction) override; void VisitMul(HMul* instruction) override; void VisitNeg(HNeg* instruction) override; void VisitNot(HNot* instruction) override; void VisitOr(HOr* instruction) override; void VisitShl(HShl* instruction) override; void VisitShr(HShr* instruction) override; void VisitSub(HSub* instruction) override; void VisitUShr(HUShr* instruction) override; void VisitXor(HXor* instruction) override; void VisitSelect(HSelect* select) override; void VisitIf(HIf* instruction) override; void VisitInstanceOf(HInstanceOf* instruction) override; void VisitInvoke(HInvoke* invoke) override; void VisitDeoptimize(HDeoptimize* deoptimize) override; void VisitVecMul(HVecMul* instruction) override; void SimplifyBoxUnbox(HInvoke* instruction, ArtField* field, DataType::Type type); void SimplifySystemArrayCopy(HInvoke* invoke); void SimplifyStringEquals(HInvoke* invoke); void SimplifyFP2Int(HInvoke* invoke); void SimplifyStringCharAt(HInvoke* invoke); void SimplifyStringLength(HInvoke* invoke); void SimplifyStringIndexOf(HInvoke* invoke); void SimplifyNPEOnArgN(HInvoke* invoke, size_t); void SimplifyReturnThis(HInvoke* invoke); void SimplifyAllocationIntrinsic(HInvoke* invoke); void SimplifyVarHandleIntrinsic(HInvoke* invoke); void SimplifyArrayBaseOffset(HInvoke* invoke); bool CanUseKnownImageVarHandle(HInvoke* invoke); static bool CanEnsureNotNullAt(HInstruction* input, HInstruction* at); // Returns an instruction with the opposite Boolean value from 'cond'. // The instruction is inserted into the graph, either in the entry block // (constant), or before the `cursor` (otherwise). HInstruction* InsertOppositeCondition(HInstruction* cond, HInstruction* cursor); CodeGenerator* codegen_; OptimizingCompilerStats* stats_; bool simplification_occurred_ = false; int simplifications_at_current_position_ = 0; // Prohibit optimizations which can affect HInductionVarAnalysis/HLoopOptimization // and prevent loop optimizations: // true - avoid such optimizations. // false - allow such optimizations. // Checked by the following optimizations: // - TryToReuseDiv: simplification of Div+Rem into Div+Mul+Sub. bool be_loop_friendly_; // We ensure we do not loop infinitely. The value should not be too high, since that // would allow looping around the same basic block too many times. The value should // not be too low either, however, since we want to allow revisiting a basic block // with many statements and simplifications at least once. static constexpr int kMaxSamePositionSimplifications = 50; }; bool InstructionSimplifier::Run() { if (kTestInstructionClonerExhaustively) { CloneAndReplaceInstructionVisitor visitor(graph_); visitor.VisitReversePostOrder(); } bool be_loop_friendly = (use_all_optimizations_ == false); InstructionSimplifierVisitor visitor(graph_, codegen_, stats_, be_loop_friendly); return visitor.Run(); } bool InstructionSimplifierVisitor::Run() { bool didSimplify = false; // Iterate in reverse post order to open up more simplifications to users // of instructions that got simplified. for (HBasicBlock* block : GetGraph()->GetReversePostOrder()) { // The simplification of an instruction to another instruction may yield // possibilities for other simplifications. So although we perform a reverse // post order visit, we sometimes need to revisit an instruction index. do { simplification_occurred_ = false; VisitNonPhiInstructions(block); if (simplification_occurred_) { didSimplify = true; } } while (simplification_occurred_ && (simplifications_at_current_position_ < kMaxSamePositionSimplifications)); simplifications_at_current_position_ = 0; } return didSimplify; } namespace { bool AreAllBitsSet(HConstant* constant) { return Int64FromConstant(constant) == -1; } } // namespace // Returns true if the code was simplified to use only one negation operation // after the binary operation instead of one on each of the inputs. bool InstructionSimplifierVisitor::TryMoveNegOnInputsAfterBinop(HBinaryOperation* binop) { DCHECK(binop->IsAdd() || binop->IsSub()); DCHECK(binop->GetLeft()->IsNeg() && binop->GetRight()->IsNeg()); HNeg* left_neg = binop->GetLeft()->AsNeg(); HNeg* right_neg = binop->GetRight()->AsNeg(); if (!left_neg->HasOnlyOneNonEnvironmentUse() || !right_neg->HasOnlyOneNonEnvironmentUse()) { return false; } // Replace code looking like // NEG tmp1, a // NEG tmp2, b // ADD dst, tmp1, tmp2 // with // ADD tmp, a, b // NEG dst, tmp // Note that we cannot optimize `(-a) + (-b)` to `-(a + b)` for floating-point. // When `a` is `-0.0` and `b` is `0.0`, the former expression yields `0.0`, // while the later yields `-0.0`. if (!DataType::IsIntegralType(binop->GetType())) { return false; } binop->ReplaceInput(left_neg->GetInput(), 0); binop->ReplaceInput(right_neg->GetInput(), 1); left_neg->GetBlock()->RemoveInstruction(left_neg); right_neg->GetBlock()->RemoveInstruction(right_neg); HNeg* neg = new (GetGraph()->GetAllocator()) HNeg(binop->GetType(), binop); binop->GetBlock()->InsertInstructionBefore(neg, binop->GetNext()); binop->ReplaceWithExceptInReplacementAtIndex(neg, 0); RecordSimplification(); return true; } bool InstructionSimplifierVisitor::TryDeMorganNegationFactoring(HBinaryOperation* op) { DCHECK(op->IsAnd() || op->IsOr()) << op->DebugName(); DataType::Type type = op->GetType(); HInstruction* left = op->GetLeft(); HInstruction* right = op->GetRight(); // We can apply De Morgan's laws if both inputs are Not's and are only used // by `op`. if (((left->IsNot() && right->IsNot()) || (left->IsBooleanNot() && right->IsBooleanNot())) && left->HasOnlyOneNonEnvironmentUse() && right->HasOnlyOneNonEnvironmentUse()) { // Replace code looking like // NOT nota, a // NOT notb, b // AND dst, nota, notb (respectively OR) // with // OR or, a, b (respectively AND) // NOT dest, or HInstruction* src_left = left->InputAt(0); HInstruction* src_right = right->InputAt(0); uint32_t dex_pc = op->GetDexPc(); // Remove the negations on the inputs. left->ReplaceWith(src_left); right->ReplaceWith(src_right); left->GetBlock()->RemoveInstruction(left); right->GetBlock()->RemoveInstruction(right); // Replace the `HAnd` or `HOr`. HBinaryOperation* hbin; if (op->IsAnd()) { hbin = new (GetGraph()->GetAllocator()) HOr(type, src_left, src_right, dex_pc); } else { hbin = new (GetGraph()->GetAllocator()) HAnd(type, src_left, src_right, dex_pc); } HInstruction* hnot; if (left->IsBooleanNot()) { hnot = new (GetGraph()->GetAllocator()) HBooleanNot(hbin, dex_pc); } else { hnot = new (GetGraph()->GetAllocator()) HNot(type, hbin, dex_pc); } op->GetBlock()->InsertInstructionBefore(hbin, op); op->GetBlock()->ReplaceAndRemoveInstructionWith(op, hnot); RecordSimplification(); return true; } return false; } bool InstructionSimplifierVisitor::TryCombineVecMultiplyAccumulate(HVecMul* mul) { DataType::Type type = mul->GetPackedType(); InstructionSet isa = codegen_->GetInstructionSet(); switch (isa) { case InstructionSet::kArm64: if (!(type == DataType::Type::kUint8 || type == DataType::Type::kInt8 || type == DataType::Type::kUint16 || type == DataType::Type::kInt16 || type == DataType::Type::kInt32)) { return false; } break; default: return false; } ArenaAllocator* allocator = mul->GetBlock()->GetGraph()->GetAllocator(); if (!mul->HasOnlyOneNonEnvironmentUse()) { return false; } HInstruction* binop = mul->GetUses().front().GetUser(); if (!binop->IsVecAdd() && !binop->IsVecSub()) { return false; } // Replace code looking like // VECMUL tmp, x, y // VECADD/SUB dst, acc, tmp // with // VECMULACC 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; HVecBinaryOperation* vec_binop = binop->AsVecBinaryOperation(); HInstruction* binop_left = vec_binop->GetLeft(); HInstruction* binop_right = vec_binop->GetRight(); // This is always true since the `HVecMul` has only one use (which is checked above). DCHECK_NE(binop_left, binop_right); if (binop_right == mul) { accumulator = binop_left; } else { DCHECK_EQ(binop_left, mul); // Only addition is commutative. if (!binop->IsVecAdd()) { return false; } accumulator = binop_right; } DCHECK(accumulator != nullptr); HInstruction::InstructionKind kind = binop->IsVecAdd() ? HInstruction::kAdd : HInstruction::kSub; bool predicated_simd = vec_binop->IsPredicated(); if (predicated_simd && !HVecOperation::HaveSamePredicate(vec_binop, mul)) { return false; } HVecMultiplyAccumulate* mulacc = new (allocator) HVecMultiplyAccumulate(allocator, kind, accumulator, mul->GetLeft(), mul->GetRight(), vec_binop->GetPackedType(), vec_binop->GetVectorLength(), vec_binop->GetDexPc()); vec_binop->GetBlock()->ReplaceAndRemoveInstructionWith(vec_binop, mulacc); if (predicated_simd) { mulacc->SetGoverningPredicate(vec_binop->GetGoverningPredicate(), vec_binop->GetPredicationKind()); } DCHECK(!mul->HasUses()); mul->GetBlock()->RemoveInstruction(mul); return true; } // Replace code looking like (x << N >>> N or x << N >> N): // SHL tmp, x, N // USHR/SHR dst, tmp, N // with the corresponding type conversion: // TypeConversion/Signed> dst, x // if // SHL has only one non environment use // TypeOf(tmp) is not 64-bit type (they are not supported yet) // N % kBitsPerByte = 0 // where // T = SignedIntegralTypeFromSize(source_integral_size) // source_integral_size = ByteSize(tmp) - N / kBitsPerByte // // We calculate source_integral_size from shift amount instead of // assuming that it is equal to ByteSize(x) to be able to optimize // cases like this: // int x = ... // int y = x << 24 >>> 24 // that is equavalent to // int y = (unsigned byte) x // in this case: // N = 24 // tmp = x << 24 // source_integral_size is 1 (= 4 - 24 / 8) that corresponds to unsigned byte. static bool TryReplaceShiftsByConstantWithTypeConversion(HBinaryOperation *instruction) { if (!instruction->IsUShr() && !instruction->IsShr()) { return false; } if (DataType::Is64BitType(instruction->GetResultType())) { return false; } HInstruction* shr_amount = instruction->GetRight(); if (!shr_amount->IsIntConstant()) { return false; } int32_t shr_amount_cst = shr_amount->AsIntConstant()->GetValue(); // We assume that shift amount simplification was applied first so it doesn't // exceed maximum distance that is kMaxIntShiftDistance as 64-bit shifts aren't // supported. DCHECK_LE(shr_amount_cst, kMaxIntShiftDistance); if ((shr_amount_cst % kBitsPerByte) != 0) { return false; } // Calculate size of the significant part of the input, e.g. a part that is not // discarded due to left shift. // Shift amount here should be less than size of right shift type. DCHECK_GT(DataType::Size(instruction->GetType()), shr_amount_cst / kBitsPerByte); size_t source_significant_part_size = DataType::Size(instruction->GetType()) - shr_amount_cst / kBitsPerByte; // Look for the smallest signed integer type that is suitable to store the // significant part of the input. DataType::Type source_integral_type = DataType::SignedIntegralTypeFromSize(source_significant_part_size); // If the size of the significant part of the input isn't equal to the size of the // found type, shifts cannot be replaced by type conversion. if (DataType::Size(source_integral_type) != source_significant_part_size) { return false; } HInstruction* shr_value = instruction->GetLeft(); if (!shr_value->IsShl()) { return false; } HShl *shl = shr_value->AsShl(); if (!shl->HasOnlyOneNonEnvironmentUse()) { return false; } // Constants are unique so we just compare pointer here. if (shl->GetRight() != shr_amount) { return false; } // Type of shift's value is always int so sign/zero extension only // depends on the type of the shift (shr/ushr). bool is_signed = instruction->IsShr(); DataType::Type conv_type = is_signed ? source_integral_type : DataType::ToUnsigned(source_integral_type); DCHECK(DataType::IsTypeConversionImplicit(conv_type, instruction->GetResultType())); HInstruction* shl_value = shl->GetLeft(); HBasicBlock *block = instruction->GetBlock(); // We shouldn't introduce new implicit type conversions during simplification. if (DataType::IsTypeConversionImplicit(shl_value->GetType(), conv_type)) { instruction->ReplaceWith(shl_value); instruction->GetBlock()->RemoveInstruction(instruction); } else { HTypeConversion* new_conversion = new (block->GetGraph()->GetAllocator()) HTypeConversion(conv_type, shl_value); block->ReplaceAndRemoveInstructionWith(instruction, new_conversion); } shl->GetBlock()->RemoveInstruction(shl); return true; } void InstructionSimplifierVisitor::VisitShift(HBinaryOperation* instruction) { DCHECK(instruction->IsShl() || instruction->IsShr() || instruction->IsUShr()); HInstruction* shift_amount = instruction->GetRight(); HInstruction* value = instruction->GetLeft(); int64_t implicit_mask = (value->GetType() == DataType::Type::kInt64) ? kMaxLongShiftDistance : kMaxIntShiftDistance; if (shift_amount->IsConstant()) { int64_t cst = Int64FromConstant(shift_amount->AsConstant()); int64_t masked_cst = cst & implicit_mask; if (masked_cst == 0) { // Replace code looking like // SHL dst, value, 0 // with // value instruction->ReplaceWith(value); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); return; } else if (masked_cst != cst) { // Replace code looking like // SHL dst, value, cst // where cst exceeds maximum distance with the equivalent // SHL dst, value, cst & implicit_mask // (as defined by shift semantics). This ensures other // optimizations do not need to special case for such situations. DCHECK_EQ(shift_amount->GetType(), DataType::Type::kInt32); instruction->ReplaceInput(GetGraph()->GetIntConstant(masked_cst), /* index= */ 1); RecordSimplification(); return; } if (TryReplaceShiftsByConstantWithTypeConversion(instruction)) { RecordSimplification(); return; } } // Shift operations implicitly mask the shift amount according to the type width. Get rid of // unnecessary And/Or/Xor/Add/Sub/TypeConversion operations on the shift amount that do not // affect the relevant bits. // Replace code looking like // AND adjusted_shift, shift, // [OR/XOR/ADD/SUB adjusted_shift, shift, ] // [ adjusted_shift, shift] // SHL dst, value, adjusted_shift // with // SHL dst, value, shift if (shift_amount->IsAnd() || shift_amount->IsOr() || shift_amount->IsXor() || shift_amount->IsAdd() || shift_amount->IsSub()) { int64_t required_result = shift_amount->IsAnd() ? implicit_mask : 0; HBinaryOperation* bin_op = shift_amount->AsBinaryOperation(); HConstant* mask = bin_op->GetConstantRight(); if (mask != nullptr && (Int64FromConstant(mask) & implicit_mask) == required_result) { instruction->ReplaceInput(bin_op->GetLeastConstantLeft(), 1); RecordSimplification(); return; } } else if (shift_amount->IsTypeConversion()) { DCHECK_NE(shift_amount->GetType(), DataType::Type::kBool); // We never convert to bool. DataType::Type source_type = shift_amount->InputAt(0)->GetType(); // Non-integral and 64-bit source types require an explicit type conversion. if (DataType::IsIntegralType(source_type) && !DataType::Is64BitType(source_type)) { instruction->ReplaceInput(shift_amount->AsTypeConversion()->GetInput(), 1); RecordSimplification(); return; } } } static bool IsSubRegBitsMinusOther(HSub* sub, size_t reg_bits, HInstruction* other) { return (sub->GetRight() == other && sub->GetLeft()->IsConstant() && (Int64FromConstant(sub->GetLeft()->AsConstant()) & (reg_bits - 1)) == 0); } bool InstructionSimplifierVisitor::ReplaceRotateWithRor(HBinaryOperation* op, HUShr* ushr, HShl* shl) { DCHECK(op->IsAdd() || op->IsXor() || op->IsOr()) << op->DebugName(); HRor* ror = new (GetGraph()->GetAllocator()) HRor(ushr->GetType(), ushr->GetLeft(), ushr->GetRight()); op->GetBlock()->ReplaceAndRemoveInstructionWith(op, ror); if (!ushr->HasUses()) { ushr->GetBlock()->RemoveInstruction(ushr); } if (!ushr->GetRight()->HasUses()) { ushr->GetRight()->GetBlock()->RemoveInstruction(ushr->GetRight()); } if (!shl->HasUses()) { shl->GetBlock()->RemoveInstruction(shl); } if (!shl->GetRight()->HasUses()) { shl->GetRight()->GetBlock()->RemoveInstruction(shl->GetRight()); } RecordSimplification(); return true; } // Try to replace a binary operation flanked by one UShr and one Shl with a bitfield rotation. bool InstructionSimplifierVisitor::TryReplaceWithRotate(HBinaryOperation* op) { DCHECK(op->IsAdd() || op->IsXor() || op->IsOr()); HInstruction* left = op->GetLeft(); HInstruction* right = op->GetRight(); // If we have an UShr and a Shl (in either order). if ((left->IsUShr() && right->IsShl()) || (left->IsShl() && right->IsUShr())) { HUShr* ushr = left->IsUShr() ? left->AsUShr() : right->AsUShr(); HShl* shl = left->IsShl() ? left->AsShl() : right->AsShl(); DCHECK(DataType::IsIntOrLongType(ushr->GetType())); if (ushr->GetType() == shl->GetType() && ushr->GetLeft() == shl->GetLeft()) { if (ushr->GetRight()->IsConstant() && shl->GetRight()->IsConstant()) { // Shift distances are both constant, try replacing with Ror if they // add up to the register size. return TryReplaceWithRotateConstantPattern(op, ushr, shl); } else if (ushr->GetRight()->IsSub() || shl->GetRight()->IsSub()) { // Shift distances are potentially of the form x and (reg_size - x). return TryReplaceWithRotateRegisterSubPattern(op, ushr, shl); } else if (ushr->GetRight()->IsNeg() || shl->GetRight()->IsNeg()) { // Shift distances are potentially of the form d and -d. return TryReplaceWithRotateRegisterNegPattern(op, ushr, shl); } } } return false; } // Try replacing code looking like (x >>> #rdist OP x << #ldist): // UShr dst, x, #rdist // Shl tmp, x, #ldist // OP dst, dst, tmp // or like (x >>> #rdist OP x << #-ldist): // UShr dst, x, #rdist // Shl tmp, x, #-ldist // OP dst, dst, tmp // with // Ror dst, x, #rdist bool InstructionSimplifierVisitor::TryReplaceWithRotateConstantPattern(HBinaryOperation* op, HUShr* ushr, HShl* shl) { DCHECK(op->IsAdd() || op->IsXor() || op->IsOr()); size_t reg_bits = DataType::Size(ushr->GetType()) * kBitsPerByte; size_t rdist = Int64FromConstant(ushr->GetRight()->AsConstant()); size_t ldist = Int64FromConstant(shl->GetRight()->AsConstant()); if (((ldist + rdist) & (reg_bits - 1)) == 0) { return ReplaceRotateWithRor(op, ushr, shl); } return false; } // Replace code looking like (x >>> -d OP x << d): // Neg neg, d // UShr dst, x, neg // Shl tmp, x, d // OP dst, dst, tmp // with // Neg neg, d // Ror dst, x, neg // *** OR *** // Replace code looking like (x >>> d OP x << -d): // UShr dst, x, d // Neg neg, d // Shl tmp, x, neg // OP dst, dst, tmp // with // Ror dst, x, d // // Requires `d` to be non-zero for the HAdd and HXor case. If `d` is 0 the shifts and rotate are // no-ops and the `OP` is never executed. This is fine for HOr since the result is the same, but the // result is different for HAdd and HXor. bool InstructionSimplifierVisitor::TryReplaceWithRotateRegisterNegPattern(HBinaryOperation* op, HUShr* ushr, HShl* shl) { DCHECK(op->IsAdd() || op->IsXor() || op->IsOr()); DCHECK(ushr->GetRight()->IsNeg() || shl->GetRight()->IsNeg()); bool neg_is_left = shl->GetRight()->IsNeg(); HNeg* neg = neg_is_left ? shl->GetRight()->AsNeg() : ushr->GetRight()->AsNeg(); HInstruction* value = neg->InputAt(0); // The shift distance being negated is the distance being shifted the other way. if (value != (neg_is_left ? ushr->GetRight() : shl->GetRight())) { return false; } const bool needs_non_zero_value = !op->IsOr(); if (needs_non_zero_value) { if (!value->IsConstant() || value->AsConstant()->IsArithmeticZero()) { return false; } } return ReplaceRotateWithRor(op, ushr, shl); } // Try replacing code looking like (x >>> d OP x << (#bits - d)): // UShr dst, x, d // Sub ld, #bits, d // Shl tmp, x, ld // OP dst, dst, tmp // with // Ror dst, x, d // *** OR *** // Replace code looking like (x >>> (#bits - d) OP x << d): // Sub rd, #bits, d // UShr dst, x, rd // Shl tmp, x, d // OP dst, dst, tmp // with // Neg neg, d // Ror dst, x, neg bool InstructionSimplifierVisitor::TryReplaceWithRotateRegisterSubPattern(HBinaryOperation* op, HUShr* ushr, HShl* shl) { DCHECK(op->IsAdd() || op->IsXor() || op->IsOr()); DCHECK(ushr->GetRight()->IsSub() || shl->GetRight()->IsSub()); size_t reg_bits = DataType::Size(ushr->GetType()) * kBitsPerByte; HInstruction* shl_shift = shl->GetRight(); HInstruction* ushr_shift = ushr->GetRight(); if ((shl_shift->IsSub() && IsSubRegBitsMinusOther(shl_shift->AsSub(), reg_bits, ushr_shift)) || (ushr_shift->IsSub() && IsSubRegBitsMinusOther(ushr_shift->AsSub(), reg_bits, shl_shift))) { return ReplaceRotateWithRor(op, ushr, shl); } return false; } void InstructionSimplifierVisitor::VisitNullCheck(HNullCheck* null_check) { HInstruction* obj = null_check->InputAt(0); // Note we don't do `CanEnsureNotNullAt` here. If we do that, we may get rid of a NullCheck but // what we should do instead is coalesce them. This is what GVN does, and so InstructionSimplifier // doesn't do this. if (!obj->CanBeNull()) { null_check->ReplaceWith(obj); null_check->GetBlock()->RemoveInstruction(null_check); if (stats_ != nullptr) { stats_->RecordStat(MethodCompilationStat::kRemovedNullCheck); } } } bool InstructionSimplifierVisitor::CanEnsureNotNullAt(HInstruction* input, HInstruction* at) { if (!input->CanBeNull()) { return true; } for (const HUseListNode& use : input->GetUses()) { HInstruction* user = use.GetUser(); if (user->IsNullCheck() && user->StrictlyDominates(at)) { return true; } } return false; } // Returns whether doing a type test between the class of `object` against `klass` has // a statically known outcome. The result of the test is stored in `outcome`. static bool TypeCheckHasKnownOutcome(ReferenceTypeInfo class_rti, HInstruction* object, /*out*/bool* outcome) { DCHECK(!object->IsNullConstant()) << "Null constants should be special cased"; ReferenceTypeInfo obj_rti = object->GetReferenceTypeInfo(); ScopedObjectAccess soa(Thread::Current()); if (!obj_rti.IsValid()) { // We run the simplifier before the reference type propagation so type info might not be // available. return false; } if (!class_rti.IsValid()) { // Happens when the loaded class is unresolved. if (obj_rti.IsExact()) { // outcome == 'true' && obj_rti is valid implies that class_rti is valid. // Since that's a contradiction we must not pass this check. *outcome = false; return true; } else { // We aren't able to say anything in particular since we don't know the // exact type of the object. return false; } } DCHECK(class_rti.IsExact()); if (class_rti.IsSupertypeOf(obj_rti)) { *outcome = true; return true; } else if (obj_rti.IsExact()) { // The test failed at compile time so will also fail at runtime. *outcome = false; return true; } else if (!class_rti.IsInterface() && !obj_rti.IsInterface() && !obj_rti.IsSupertypeOf(class_rti)) { // Different type hierarchy. The test will fail. *outcome = false; return true; } return false; } void InstructionSimplifierVisitor::VisitCheckCast(HCheckCast* check_cast) { HInstruction* object = check_cast->InputAt(0); if (CanEnsureNotNullAt(object, check_cast)) { check_cast->ClearMustDoNullCheck(); } if (object->IsNullConstant()) { check_cast->GetBlock()->RemoveInstruction(check_cast); MaybeRecordStat(stats_, MethodCompilationStat::kRemovedCheckedCast); return; } // Minor correctness check. DCHECK(check_cast->GetTargetClass()->StrictlyDominates(check_cast)) << "Illegal graph!\n" << check_cast->DumpWithArgs(); // Historical note: The `outcome` was initialized to please Valgrind - the compiler can reorder // the return value check with the `outcome` check, b/27651442. bool outcome = false; if (TypeCheckHasKnownOutcome(check_cast->GetTargetClassRTI(), object, &outcome)) { if (outcome) { check_cast->GetBlock()->RemoveInstruction(check_cast); MaybeRecordStat(stats_, MethodCompilationStat::kRemovedCheckedCast); if (check_cast->GetTypeCheckKind() != TypeCheckKind::kBitstringCheck) { HLoadClass* load_class = check_cast->GetTargetClass(); if (!load_class->HasUses() && !load_class->NeedsAccessCheck()) { // We cannot rely on DCE to remove the class because the `HLoadClass` thinks it can throw. // However, here we know that it cannot because the checkcast was successful, hence // the class was already loaded. load_class->GetBlock()->RemoveInstruction(load_class); } } } else { // TODO Don't do anything for exceptional cases for now. Ideally we should // remove all instructions and blocks this instruction dominates and // replace it with a manual throw. } } } void InstructionSimplifierVisitor::VisitInstanceOf(HInstanceOf* instruction) { HInstruction* object = instruction->InputAt(0); bool can_be_null = true; if (CanEnsureNotNullAt(object, instruction)) { can_be_null = false; instruction->ClearMustDoNullCheck(); } HGraph* graph = GetGraph(); if (object->IsNullConstant()) { MaybeRecordStat(stats_, MethodCompilationStat::kRemovedInstanceOf); instruction->ReplaceWith(graph->GetIntConstant(0)); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); return; } // Minor correctness check. DCHECK(instruction->GetTargetClass()->StrictlyDominates(instruction)) << "Illegal graph!\n" << instruction->DumpWithArgs(); // Historical note: The `outcome` was initialized to please Valgrind - the compiler can reorder // the return value check with the `outcome` check, b/27651442. bool outcome = false; if (TypeCheckHasKnownOutcome(instruction->GetTargetClassRTI(), object, &outcome)) { MaybeRecordStat(stats_, MethodCompilationStat::kRemovedInstanceOf); if (outcome && can_be_null) { // Type test will succeed, we just need a null test. HNotEqual* test = new (graph->GetAllocator()) HNotEqual(graph->GetNullConstant(), object); instruction->GetBlock()->InsertInstructionBefore(test, instruction); instruction->ReplaceWith(test); } else { // We've statically determined the result of the instanceof. instruction->ReplaceWith(graph->GetIntConstant(outcome)); } RecordSimplification(); instruction->GetBlock()->RemoveInstruction(instruction); if (outcome && instruction->GetTypeCheckKind() != TypeCheckKind::kBitstringCheck) { HLoadClass* load_class = instruction->GetTargetClass(); if (!load_class->HasUses() && !load_class->NeedsAccessCheck()) { // We cannot rely on DCE to remove the class because the `HLoadClass` // thinks it can throw. However, here we know that it cannot because the // instanceof check was successful and we don't need to check the // access, hence the class was already loaded. load_class->GetBlock()->RemoveInstruction(load_class); } } } } void InstructionSimplifierVisitor::VisitInstanceFieldSet(HInstanceFieldSet* instruction) { if ((instruction->GetValue()->GetType() == DataType::Type::kReference) && CanEnsureNotNullAt(instruction->GetValue(), instruction)) { instruction->ClearValueCanBeNull(); } } void InstructionSimplifierVisitor::VisitStaticFieldSet(HStaticFieldSet* instruction) { if ((instruction->GetValue()->GetType() == DataType::Type::kReference) && CanEnsureNotNullAt(instruction->GetValue(), instruction)) { instruction->ClearValueCanBeNull(); } } static IfCondition GetOppositeConditionForOperandSwap(IfCondition cond) { switch (cond) { case kCondEQ: return kCondEQ; case kCondNE: return kCondNE; case kCondLT: return kCondGT; case kCondLE: return kCondGE; case kCondGT: return kCondLT; case kCondGE: return kCondLE; case kCondB: return kCondA; case kCondBE: return kCondAE; case kCondA: return kCondB; case kCondAE: return kCondBE; default: LOG(FATAL) << "Unknown ConditionType " << cond; UNREACHABLE(); } } HInstruction* InstructionSimplifierVisitor::InsertOppositeCondition(HInstruction* cond, HInstruction* cursor) { if (cond->IsCondition() && !DataType::IsFloatingPointType(cond->InputAt(0)->GetType())) { // Can't reverse floating point conditions. We have to use `HBooleanNot` in that case. HInstruction* lhs = cond->InputAt(0); HInstruction* rhs = cond->InputAt(1); HInstruction* replacement = HCondition::Create(GetGraph(), cond->AsCondition()->GetOppositeCondition(), lhs, rhs); cursor->GetBlock()->InsertInstructionBefore(replacement, cursor); return replacement; } else if (cond->IsIntConstant()) { HIntConstant* int_const = cond->AsIntConstant(); if (int_const->IsFalse()) { return GetGraph()->GetIntConstant(1); } else { DCHECK(int_const->IsTrue()) << int_const->GetValue(); return GetGraph()->GetIntConstant(0); } } else { HInstruction* replacement = new (GetGraph()->GetAllocator()) HBooleanNot(cond); cursor->GetBlock()->InsertInstructionBefore(replacement, cursor); return replacement; } } void InstructionSimplifierVisitor::VisitEqual(HEqual* equal) { HInstruction* input_const = equal->GetConstantRight(); if (input_const != nullptr) { HInstruction* input_value = equal->GetLeastConstantLeft(); if ((input_value->GetType() == DataType::Type::kBool) && input_const->IsIntConstant()) { HBasicBlock* block = equal->GetBlock(); // We are comparing the boolean to a constant which is of type int and can // be any constant. if (input_const->AsIntConstant()->IsTrue()) { // Replace (bool_value == true) with bool_value equal->ReplaceWith(input_value); block->RemoveInstruction(equal); RecordSimplification(); } else if (input_const->AsIntConstant()->IsFalse()) { // Replace (bool_value == false) with !bool_value equal->ReplaceWith(InsertOppositeCondition(input_value, equal)); block->RemoveInstruction(equal); RecordSimplification(); } else { // Replace (bool_value == integer_not_zero_nor_one_constant) with false equal->ReplaceWith(GetGraph()->GetIntConstant(0)); block->RemoveInstruction(equal); RecordSimplification(); } } else { VisitCondition(equal); } } else { VisitCondition(equal); } } void InstructionSimplifierVisitor::VisitNotEqual(HNotEqual* not_equal) { HInstruction* input_const = not_equal->GetConstantRight(); if (input_const != nullptr) { HInstruction* input_value = not_equal->GetLeastConstantLeft(); if ((input_value->GetType() == DataType::Type::kBool) && input_const->IsIntConstant()) { HBasicBlock* block = not_equal->GetBlock(); // We are comparing the boolean to a constant which is of type int and can // be any constant. if (input_const->AsIntConstant()->IsTrue()) { // Replace (bool_value != true) with !bool_value not_equal->ReplaceWith(InsertOppositeCondition(input_value, not_equal)); block->RemoveInstruction(not_equal); RecordSimplification(); } else if (input_const->AsIntConstant()->IsFalse()) { // Replace (bool_value != false) with bool_value not_equal->ReplaceWith(input_value); block->RemoveInstruction(not_equal); RecordSimplification(); } else { // Replace (bool_value != integer_not_zero_nor_one_constant) with true not_equal->ReplaceWith(GetGraph()->GetIntConstant(1)); block->RemoveInstruction(not_equal); RecordSimplification(); } } else { VisitCondition(not_equal); } } else { VisitCondition(not_equal); } } void InstructionSimplifierVisitor::VisitBooleanNot(HBooleanNot* bool_not) { HInstruction* input = bool_not->InputAt(0); HInstruction* replace_with = nullptr; if (input->IsIntConstant()) { // Replace !(true/false) with false/true. if (input->AsIntConstant()->IsTrue()) { replace_with = GetGraph()->GetIntConstant(0); } else { DCHECK(input->AsIntConstant()->IsFalse()) << input->AsIntConstant()->GetValue(); replace_with = GetGraph()->GetIntConstant(1); } } else if (input->IsBooleanNot()) { // Replace (!(!bool_value)) with bool_value. replace_with = input->InputAt(0); } else if (input->IsCondition() && // Don't change FP compares. The definition of compares involving // NaNs forces the compares to be done as written by the user. !DataType::IsFloatingPointType(input->InputAt(0)->GetType())) { // Replace condition with its opposite. replace_with = InsertOppositeCondition(input->AsCondition(), bool_not); } if (replace_with != nullptr) { bool_not->ReplaceWith(replace_with); bool_not->GetBlock()->RemoveInstruction(bool_not); RecordSimplification(); } } // Constructs a new ABS(x) node in the HIR. static HInstruction* NewIntegralAbs(ArenaAllocator* allocator, HInstruction* x, HInstruction* cursor) { DataType::Type type = DataType::Kind(x->GetType()); DCHECK(type == DataType::Type::kInt32 || type == DataType::Type::kInt64); HAbs* abs = new (allocator) HAbs(type, x, cursor->GetDexPc()); cursor->GetBlock()->InsertInstructionBefore(abs, cursor); return abs; } // Constructs a new MIN/MAX(x, y) node in the HIR. static HInstruction* NewIntegralMinMax(ArenaAllocator* allocator, HInstruction* x, HInstruction* y, HInstruction* cursor, bool is_min) { DataType::Type type = DataType::Kind(x->GetType()); DCHECK(type == DataType::Type::kInt32 || type == DataType::Type::kInt64); HBinaryOperation* minmax = nullptr; if (is_min) { minmax = new (allocator) HMin(type, x, y, cursor->GetDexPc()); } else { minmax = new (allocator) HMax(type, x, y, cursor->GetDexPc()); } cursor->GetBlock()->InsertInstructionBefore(minmax, cursor); return minmax; } // Returns true if operands a and b consists of widening type conversions // (either explicit or implicit) to the given to_type. static bool AreLowerPrecisionArgs(DataType::Type to_type, HInstruction* a, HInstruction* b) { if (a->IsTypeConversion() && a->GetType() == to_type) { a = a->InputAt(0); } if (b->IsTypeConversion() && b->GetType() == to_type) { b = b->InputAt(0); } DataType::Type type1 = a->GetType(); DataType::Type type2 = b->GetType(); return (type1 == DataType::Type::kUint8 && type2 == DataType::Type::kUint8) || (type1 == DataType::Type::kInt8 && type2 == DataType::Type::kInt8) || (type1 == DataType::Type::kInt16 && type2 == DataType::Type::kInt16) || (type1 == DataType::Type::kUint16 && type2 == DataType::Type::kUint16) || (type1 == DataType::Type::kInt32 && type2 == DataType::Type::kInt32 && to_type == DataType::Type::kInt64); } // Returns an acceptable substitution for "a" on the select // construct "a b ? c : .." during MIN/MAX recognition. static HInstruction* AllowInMinMax(IfCondition cmp, HInstruction* a, HInstruction* b, HInstruction* c) { int64_t value = 0; if (IsInt64AndGet(b, /*out*/ &value) && (((cmp == kCondLT || cmp == kCondLE) && c->IsMax()) || ((cmp == kCondGT || cmp == kCondGE) && c->IsMin()))) { HConstant* other = c->AsBinaryOperation()->GetConstantRight(); if (other != nullptr && a == c->AsBinaryOperation()->GetLeastConstantLeft()) { int64_t other_value = Int64FromConstant(other); bool is_max = (cmp == kCondLT || cmp == kCondLE); // Allow the max for a < 100 ? max(a, -100) : .. // or the min for a > -100 ? min(a, 100) : .. if (is_max ? (value >= other_value) : (value <= other_value)) { return c; } } } return nullptr; } void InstructionSimplifierVisitor::VisitSelect(HSelect* select) { HInstruction* replace_with = nullptr; HInstruction* condition = select->GetCondition(); HInstruction* true_value = select->GetTrueValue(); HInstruction* false_value = select->GetFalseValue(); if (condition->IsBooleanNot()) { // Change ((!cond) ? x : y) to (cond ? y : x). condition = condition->InputAt(0); std::swap(true_value, false_value); select->ReplaceInput(false_value, 0); select->ReplaceInput(true_value, 1); select->ReplaceInput(condition, 2); RecordSimplification(); } if (true_value == false_value) { // Replace (cond ? x : x) with (x). replace_with = true_value; } else if (condition->IsIntConstant()) { if (condition->AsIntConstant()->IsTrue()) { // Replace (true ? x : y) with (x). replace_with = true_value; } else { // Replace (false ? x : y) with (y). DCHECK(condition->AsIntConstant()->IsFalse()) << condition->AsIntConstant()->GetValue(); replace_with = false_value; } } else if (true_value->IsIntConstant() && false_value->IsIntConstant()) { if (true_value->AsIntConstant()->IsTrue() && false_value->AsIntConstant()->IsFalse()) { // Replace (cond ? true : false) with (cond). replace_with = condition; } else if (true_value->AsIntConstant()->IsFalse() && false_value->AsIntConstant()->IsTrue()) { // Replace (cond ? false : true) with (!cond). replace_with = InsertOppositeCondition(condition, select); } } else if (condition->IsCondition()) { IfCondition cmp = condition->AsCondition()->GetCondition(); HInstruction* a = condition->InputAt(0); HInstruction* b = condition->InputAt(1); DataType::Type t_type = true_value->GetType(); DataType::Type f_type = false_value->GetType(); if (DataType::IsIntegralType(t_type) && DataType::Kind(t_type) == DataType::Kind(f_type)) { if (cmp == kCondEQ || cmp == kCondNE) { // Turns // * Select[a, b, EQ(a,b)] / Select[a, b, EQ(b,a)] into a // * Select[a, b, NE(a,b)] / Select[a, b, NE(b,a)] into b // Note that the order in EQ/NE is irrelevant. if ((a == true_value && b == false_value) || (a == false_value && b == true_value)) { replace_with = cmp == kCondEQ ? false_value : true_value; } } else { // Test if both values are compatible integral types (resulting MIN/MAX/ABS // type will be int or long, like the condition). Replacements are general, // but assume conditions prefer constants on the right. // Allow a < 100 ? max(a, -100) : .. // or a > -100 ? min(a, 100) : .. // to use min/max instead of a to detect nested min/max expressions. HInstruction* new_a = AllowInMinMax(cmp, a, b, true_value); if (new_a != nullptr) { a = new_a; } // Try to replace typical integral MIN/MAX/ABS constructs. if ((cmp == kCondLT || cmp == kCondLE || cmp == kCondGT || cmp == kCondGE) && ((a == true_value && b == false_value) || (b == true_value && a == false_value))) { // Found a < b ? a : b (MIN) or a < b ? b : a (MAX) // or a > b ? a : b (MAX) or a > b ? b : a (MIN). bool is_min = (cmp == kCondLT || cmp == kCondLE) == (a == true_value); replace_with = NewIntegralMinMax(GetGraph()->GetAllocator(), a, b, select, is_min); } else if (((cmp == kCondLT || cmp == kCondLE) && true_value->IsNeg()) || ((cmp == kCondGT || cmp == kCondGE) && false_value->IsNeg())) { bool negLeft = (cmp == kCondLT || cmp == kCondLE); HInstruction* the_negated = negLeft ? true_value->InputAt(0) : false_value->InputAt(0); HInstruction* not_negated = negLeft ? false_value : true_value; if (a == the_negated && a == not_negated && IsInt64Value(b, 0)) { // Found a < 0 ? -a : a // or a > 0 ? a : -a // which can be replaced by ABS(a). replace_with = NewIntegralAbs(GetGraph()->GetAllocator(), a, select); } } else if (true_value->IsSub() && false_value->IsSub()) { HInstruction* true_sub1 = true_value->InputAt(0); HInstruction* true_sub2 = true_value->InputAt(1); HInstruction* false_sub1 = false_value->InputAt(0); HInstruction* false_sub2 = false_value->InputAt(1); if ((((cmp == kCondGT || cmp == kCondGE) && (a == true_sub1 && b == true_sub2 && a == false_sub2 && b == false_sub1)) || ((cmp == kCondLT || cmp == kCondLE) && (a == true_sub2 && b == true_sub1 && a == false_sub1 && b == false_sub2))) && AreLowerPrecisionArgs(t_type, a, b)) { // Found a > b ? a - b : b - a // or a < b ? b - a : a - b // which can be replaced by ABS(a - b) for lower precision operands a, b. replace_with = NewIntegralAbs(GetGraph()->GetAllocator(), true_value, select); } } } } } if (replace_with != nullptr) { select->ReplaceWith(replace_with); select->GetBlock()->RemoveInstruction(select); RecordSimplification(); } } void InstructionSimplifierVisitor::VisitIf(HIf* instruction) { HInstruction* condition = instruction->InputAt(0); if (condition->IsBooleanNot()) { // Swap successors if input is negated. instruction->ReplaceInput(condition->InputAt(0), 0); instruction->GetBlock()->SwapSuccessors(); RecordSimplification(); } } // TODO(solanes): This optimization should be in ConstantFolding since we are folding to a constant. // However, we get code size regressions when we do that since we sometimes have a NullCheck between // HArrayLength and IsNewArray, and said NullCheck is eliminated in InstructionSimplifier. If we run // ConstantFolding and InstructionSimplifier in lockstep this wouldn't be an issue. void InstructionSimplifierVisitor::VisitArrayLength(HArrayLength* instruction) { HInstruction* input = instruction->InputAt(0); // If the array is a NewArray with constant size, replace the array length // with the constant instruction. This helps the bounds check elimination phase. if (input->IsNewArray()) { input = input->AsNewArray()->GetLength(); if (input->IsIntConstant()) { instruction->ReplaceWith(input); } } } void InstructionSimplifierVisitor::VisitArraySet(HArraySet* instruction) { HInstruction* value = instruction->GetValue(); if (value->GetType() != DataType::Type::kReference) { return; } if (CanEnsureNotNullAt(value, instruction)) { instruction->ClearValueCanBeNull(); } if (value->IsArrayGet()) { if (value->AsArrayGet()->GetArray() == instruction->GetArray()) { // If the code is just swapping elements in the array, no need for a type check. instruction->ClearTypeCheck(); return; } } if (value->IsNullConstant()) { instruction->ClearTypeCheck(); return; } ScopedObjectAccess soa(Thread::Current()); ReferenceTypeInfo array_rti = instruction->GetArray()->GetReferenceTypeInfo(); ReferenceTypeInfo value_rti = value->GetReferenceTypeInfo(); if (!array_rti.IsValid()) { return; } if (value_rti.IsValid() && array_rti.CanArrayHold(value_rti)) { instruction->ClearTypeCheck(); return; } if (array_rti.IsObjectArray()) { if (array_rti.IsExact()) { instruction->ClearTypeCheck(); return; } instruction->SetStaticTypeOfArrayIsObjectArray(); } } static bool IsTypeConversionLossless(DataType::Type input_type, DataType::Type result_type) { // Make sure all implicit conversions have been simplified and no new ones have been introduced. DCHECK(!DataType::IsTypeConversionImplicit(input_type, result_type)) << input_type << "," << result_type; // The conversion to a larger type is loss-less with the exception of two cases, // - conversion to the unsigned type Uint16, where we may lose some bits, and // - conversion from float to long, the only FP to integral conversion with smaller FP type. // For integral to FP conversions this holds because the FP mantissa is large enough. // Note: The size check excludes Uint8 as the result type. return DataType::Size(result_type) > DataType::Size(input_type) && result_type != DataType::Type::kUint16 && !(result_type == DataType::Type::kInt64 && input_type == DataType::Type::kFloat32); } static bool CanRemoveRedundantAnd(HConstant* and_right, HConstant* shr_right, DataType::Type result_type) { int64_t and_cst = Int64FromConstant(and_right); int64_t shr_cst = Int64FromConstant(shr_right); // In the following sequence A is the input value, D is the result: // B := A & x // C := B >> r // D := TypeConv(n-bit type) C // The value of D is entirely dependent on the bits [n-1:0] of C, which in turn are dependent // on bits [r+n-1:r] of B. // Therefore, if the AND does not change bits [r+n-1:r] of A then it will not affect D. // This can be checked by ensuring that bits [r+n-1:r] of the AND Constant are 1. // For example: return (byte) ((value & 0xff00) >> 8) // return (byte) ((value & 0xff000000) >> 31) // The mask sets bits [r+n-1:r] to 1, and all others to 0. int64_t mask = DataType::MaxValueOfIntegralType(DataType::ToUnsigned(result_type)) << shr_cst; // If the result of a bitwise AND between the mask and the AND constant is the original mask, then // the AND does not change bits [r+n-1:r], meaning that it is redundant and can be removed. return ((and_cst & mask) == mask); } static inline bool TryReplaceFieldOrArrayGetType(HInstruction* maybe_get, DataType::Type new_type) { if (maybe_get->IsInstanceFieldGet()) { maybe_get->AsInstanceFieldGet()->SetType(new_type); return true; } else if (maybe_get->IsStaticFieldGet()) { maybe_get->AsStaticFieldGet()->SetType(new_type); return true; } else if (maybe_get->IsArrayGet() && !maybe_get->AsArrayGet()->IsStringCharAt()) { maybe_get->AsArrayGet()->SetType(new_type); return true; } else { return false; } } // The type conversion is only used for storing into a field/element of the // same/narrower size. static bool IsTypeConversionForStoringIntoNoWiderFieldOnly(HTypeConversion* type_conversion) { if (type_conversion->HasEnvironmentUses()) { return false; } DataType::Type input_type = type_conversion->GetInputType(); DataType::Type result_type = type_conversion->GetResultType(); if (!DataType::IsIntegralType(input_type) || !DataType::IsIntegralType(result_type) || input_type == DataType::Type::kInt64 || result_type == DataType::Type::kInt64) { // Type conversion is needed if non-integer types are involved, or 64-bit // types are involved, which may use different number of registers. return false; } if (DataType::Size(input_type) >= DataType::Size(result_type)) { // Type conversion is not necessary when storing to a field/element of the // same/smaller size. } else { // We do not handle this case here. return false; } // Check if the converted value is only used for storing into heap. for (const HUseListNode& use : type_conversion->GetUses()) { HInstruction* instruction = use.GetUser(); if (instruction->IsInstanceFieldSet() && instruction->AsInstanceFieldSet()->GetFieldType() == result_type) { DCHECK_EQ(instruction->AsInstanceFieldSet()->GetValue(), type_conversion); continue; } if (instruction->IsStaticFieldSet() && instruction->AsStaticFieldSet()->GetFieldType() == result_type) { DCHECK_EQ(instruction->AsStaticFieldSet()->GetValue(), type_conversion); continue; } if (instruction->IsArraySet() && instruction->AsArraySet()->GetComponentType() == result_type && // not index use. instruction->AsArraySet()->GetIndex() != type_conversion) { DCHECK_EQ(instruction->AsArraySet()->GetValue(), type_conversion); continue; } // The use is not as a store value, or the field/element type is not the // same as the result_type, keep the type conversion. return false; } // Codegen automatically handles the type conversion during the store. return true; } void InstructionSimplifierVisitor::VisitTypeConversion(HTypeConversion* instruction) { HInstruction* input = instruction->GetInput(); DataType::Type input_type = input->GetType(); DataType::Type result_type = instruction->GetResultType(); if (instruction->IsImplicitConversion()) { instruction->ReplaceWith(input); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); return; } if (input->IsTypeConversion()) { HTypeConversion* input_conversion = input->AsTypeConversion(); HInstruction* original_input = input_conversion->GetInput(); DataType::Type original_type = original_input->GetType(); // When the first conversion is lossless, a direct conversion from the original type // to the final type yields the same result, even for a lossy second conversion, for // example float->double->int or int->double->float. bool is_first_conversion_lossless = IsTypeConversionLossless(original_type, input_type); // For integral conversions, see if the first conversion loses only bits that the second // doesn't need, i.e. the final type is no wider than the intermediate. If so, direct // conversion yields the same result, for example long->int->short or int->char->short. bool integral_conversions_with_non_widening_second = DataType::IsIntegralType(input_type) && DataType::IsIntegralType(original_type) && DataType::IsIntegralType(result_type) && DataType::Size(result_type) <= DataType::Size(input_type); if (is_first_conversion_lossless || integral_conversions_with_non_widening_second) { // If the merged conversion is implicit, do the simplification unconditionally. if (DataType::IsTypeConversionImplicit(original_type, result_type)) { instruction->ReplaceWith(original_input); instruction->GetBlock()->RemoveInstruction(instruction); if (!input_conversion->HasUses()) { // Don't wait for DCE. input_conversion->GetBlock()->RemoveInstruction(input_conversion); } RecordSimplification(); return; } // Otherwise simplify only if the first conversion has no other use. if (input_conversion->HasOnlyOneNonEnvironmentUse()) { input_conversion->ReplaceWith(original_input); input_conversion->GetBlock()->RemoveInstruction(input_conversion); RecordSimplification(); return; } } } else if (input->IsShr() && DataType::IsIntegralType(result_type) && // Optimization only applies to lossy Type Conversions. !IsTypeConversionLossless(input_type, result_type)) { DCHECK(DataType::IsIntegralType(input_type)); HShr* shr_op = input->AsShr(); HConstant* shr_right = shr_op->GetConstantRight(); HInstruction* shr_left = shr_op->GetLeastConstantLeft(); if (shr_right != nullptr && shr_left->IsAnd()) { // Optimization needs AND -> SHR -> TypeConversion pattern. HAnd* and_op = shr_left->AsAnd(); HConstant* and_right = and_op->GetConstantRight(); HInstruction* and_left = and_op->GetLeastConstantLeft(); if (and_right != nullptr && !DataType::IsUnsignedType(and_left->GetType()) && !DataType::IsUnsignedType(result_type) && !DataType::IsUnsignedType(and_right->GetType()) && (DataType::Size(and_left->GetType()) < 8) && (DataType::Size(result_type) == 1)) { // TODO: Support Unsigned Types. // TODO: Support Long Types. // TODO: Support result types other than byte. if (and_op->HasOnlyOneNonEnvironmentUse() && CanRemoveRedundantAnd(and_right, shr_right, result_type)) { and_op->ReplaceWith(and_left); and_op->GetBlock()->RemoveInstruction(and_op); RecordSimplification(); return; } } } } else if (input->IsAnd() && DataType::IsIntegralType(result_type)) { DCHECK(DataType::IsIntegralType(input_type)); HAnd* input_and = input->AsAnd(); HConstant* constant = input_and->GetConstantRight(); if (constant != nullptr) { int64_t value = Int64FromConstant(constant); DCHECK_NE(value, -1); // "& -1" would have been optimized away in VisitAnd(). size_t trailing_ones = CTZ(~static_cast(value)); if (trailing_ones >= kBitsPerByte * DataType::Size(result_type)) { // The `HAnd` is useless, for example in `(byte) (x & 0xff)`, get rid of it. HInstruction* original_input = input_and->GetLeastConstantLeft(); if (DataType::IsTypeConversionImplicit(original_input->GetType(), result_type)) { instruction->ReplaceWith(original_input); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); return; } else if (input->HasOnlyOneNonEnvironmentUse()) { input_and->ReplaceWith(original_input); input_and->GetBlock()->RemoveInstruction(input_and); RecordSimplification(); return; } } } } else if (input->HasOnlyOneNonEnvironmentUse() && ((input_type == DataType::Type::kInt8 && result_type == DataType::Type::kUint8) || (input_type == DataType::Type::kUint8 && result_type == DataType::Type::kInt8) || (input_type == DataType::Type::kInt16 && result_type == DataType::Type::kUint16) || (input_type == DataType::Type::kUint16 && result_type == DataType::Type::kInt16))) { // Try to modify the type of the load to `result_type` and remove the explicit type conversion. if (TryReplaceFieldOrArrayGetType(input, result_type)) { instruction->ReplaceWith(input); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); return; } } if (IsTypeConversionForStoringIntoNoWiderFieldOnly(instruction)) { instruction->ReplaceWith(input); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); return; } } void InstructionSimplifierVisitor::VisitAbs(HAbs* instruction) { HInstruction* input = instruction->GetInput(); if (DataType::IsZeroExtension(input->GetType(), instruction->GetResultType())) { // Zero extension from narrow to wide can never set sign bit in the wider // operand, making the subsequent Abs redundant (e.g., abs(b & 0xff) for byte b). instruction->ReplaceWith(input); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); } } void InstructionSimplifierVisitor::VisitAdd(HAdd* instruction) { HConstant* input_cst = instruction->GetConstantRight(); HInstruction* input_other = instruction->GetLeastConstantLeft(); bool integral_type = DataType::IsIntegralType(instruction->GetType()); if ((input_cst != nullptr) && input_cst->IsArithmeticZero()) { // Replace code looking like // ADD dst, src, 0 // with // src // Note that we cannot optimize `x + 0.0` to `x` for floating-point. When // `x` is `-0.0`, the former expression yields `0.0`, while the later // yields `-0.0`. if (integral_type) { instruction->ReplaceWith(input_other); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); return; } } HInstruction* left = instruction->GetLeft(); HInstruction* right = instruction->GetRight(); bool left_is_neg = left->IsNeg(); bool right_is_neg = right->IsNeg(); if (left_is_neg && right_is_neg) { if (TryMoveNegOnInputsAfterBinop(instruction)) { return; } } if (left_is_neg != right_is_neg) { HNeg* neg = left_is_neg ? left->AsNeg() : right->AsNeg(); if (neg->HasOnlyOneNonEnvironmentUse()) { // Replace code looking like // NEG tmp, b // ADD dst, a, tmp // with // SUB dst, a, b // We do not perform the optimization if the input negation has environment // uses or multiple non-environment uses as it could lead to worse code. In // particular, we do not want the live range of `b` to be extended if we are // not sure the initial 'NEG' instruction can be removed. HInstruction* other = left_is_neg ? right : left; HSub* sub = new(GetGraph()->GetAllocator()) HSub(instruction->GetType(), other, neg->GetInput()); instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, sub); RecordSimplification(); neg->GetBlock()->RemoveInstruction(neg); return; } } if (TryReplaceWithRotate(instruction)) { return; } // TryHandleAssociativeAndCommutativeOperation() does not remove its input, // so no need to return. TryHandleAssociativeAndCommutativeOperation(instruction); if ((left->IsSub() || right->IsSub()) && TrySubtractionChainSimplification(instruction)) { return; } if (integral_type) { // Replace code patterns looking like // SUB dst1, x, y SUB dst1, x, y // ADD dst2, dst1, y ADD dst2, y, dst1 // with // SUB dst1, x, y // ADD instruction is not needed in this case, we may use // one of inputs of SUB instead. if (left->IsSub() && left->InputAt(1) == right) { instruction->ReplaceWith(left->InputAt(0)); RecordSimplification(); instruction->GetBlock()->RemoveInstruction(instruction); return; } else if (right->IsSub() && right->InputAt(1) == left) { instruction->ReplaceWith(right->InputAt(0)); RecordSimplification(); instruction->GetBlock()->RemoveInstruction(instruction); return; } } } void InstructionSimplifierVisitor::VisitAnd(HAnd* instruction) { DCHECK(DataType::IsIntegralType(instruction->GetType())); HConstant* input_cst = instruction->GetConstantRight(); HInstruction* input_other = instruction->GetLeastConstantLeft(); if (input_cst != nullptr) { int64_t value = Int64FromConstant(input_cst); if (value == -1 || // Similar cases under zero extension. (DataType::IsUnsignedType(input_other->GetType()) && ((DataType::MaxValueOfIntegralType(input_other->GetType()) & ~value) == 0))) { // Replace code looking like // AND dst, src, 0xFFF...FF // with // src instruction->ReplaceWith(input_other); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); return; } if (input_other->IsTypeConversion() && input_other->GetType() == DataType::Type::kInt64 && DataType::IsIntegralType(input_other->InputAt(0)->GetType()) && IsInt<32>(value) && input_other->HasOnlyOneNonEnvironmentUse()) { // The AND can be reordered before the TypeConversion. Replace // LongConstant cst, <32-bit-constant-sign-extended-to-64-bits> // TypeConversion tmp, src // AND dst, tmp, cst // with // IntConstant cst, <32-bit-constant> // AND tmp, src, cst // TypeConversion dst, tmp // This helps 32-bit targets and does not hurt 64-bit targets. // This also simplifies detection of other patterns, such as Uint8 loads. HInstruction* new_and_input = input_other->InputAt(0); // Implicit conversion Int64->Int64 would have been removed previously. DCHECK_NE(new_and_input->GetType(), DataType::Type::kInt64); HConstant* new_const = GetGraph()->GetConstant(DataType::Type::kInt32, value); HAnd* new_and = new (GetGraph()->GetAllocator()) HAnd(DataType::Type::kInt32, new_and_input, new_const); instruction->GetBlock()->InsertInstructionBefore(new_and, instruction); HTypeConversion* new_conversion = new (GetGraph()->GetAllocator()) HTypeConversion(DataType::Type::kInt64, new_and); instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, new_conversion); input_other->GetBlock()->RemoveInstruction(input_other); RecordSimplification(); // Try to process the new And now, do not wait for the next round of simplifications. instruction = new_and; input_other = new_and_input; } // Eliminate And from UShr+And if the And-mask contains all the bits that // can be non-zero after UShr. Transform Shr+And to UShr if the And-mask // precisely clears the shifted-in sign bits. if ((input_other->IsUShr() || input_other->IsShr()) && input_other->InputAt(1)->IsConstant()) { size_t reg_bits = (instruction->GetResultType() == DataType::Type::kInt64) ? 64 : 32; size_t shift = Int64FromConstant(input_other->InputAt(1)->AsConstant()) & (reg_bits - 1); size_t num_tail_bits_set = CTZ(value + 1); if ((num_tail_bits_set >= reg_bits - shift) && input_other->IsUShr()) { // This AND clears only bits known to be clear, for example "(x >>> 24) & 0xff". instruction->ReplaceWith(input_other); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); return; } else if ((num_tail_bits_set == reg_bits - shift) && IsPowerOfTwo(value + 1) && input_other->HasOnlyOneNonEnvironmentUse()) { DCHECK(input_other->IsShr()); // For UShr, we would have taken the branch above. // Replace SHR+AND with USHR, for example "(x >> 24) & 0xff" -> "x >>> 24". HUShr* ushr = new (GetGraph()->GetAllocator()) HUShr(instruction->GetType(), input_other->InputAt(0), input_other->InputAt(1), input_other->GetDexPc()); instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, ushr); input_other->GetBlock()->RemoveInstruction(input_other); RecordSimplification(); return; } } if ((value == 0xff || value == 0xffff) && instruction->GetType() != DataType::Type::kInt64) { // Transform AND to a type conversion to Uint8/Uint16. If `input_other` is a field // or array Get with only a single use, short-circuit the subsequent simplification // of the Get+TypeConversion and change the Get's type to `new_type` instead. DataType::Type new_type = (value == 0xff) ? DataType::Type::kUint8 : DataType::Type::kUint16; DataType::Type find_type = (value == 0xff) ? DataType::Type::kInt8 : DataType::Type::kInt16; if (input_other->GetType() == find_type && input_other->HasOnlyOneNonEnvironmentUse() && TryReplaceFieldOrArrayGetType(input_other, new_type)) { instruction->ReplaceWith(input_other); instruction->GetBlock()->RemoveInstruction(instruction); } else if (DataType::IsTypeConversionImplicit(input_other->GetType(), new_type)) { instruction->ReplaceWith(input_other); instruction->GetBlock()->RemoveInstruction(instruction); } else { HTypeConversion* type_conversion = new (GetGraph()->GetAllocator()) HTypeConversion( new_type, input_other, instruction->GetDexPc()); instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, type_conversion); } RecordSimplification(); return; } } // We assume that GVN has run before, so we only perform a pointer comparison. // If for some reason the values are equal but the pointers are different, we // are still correct and only miss an optimization opportunity. if (instruction->GetLeft() == instruction->GetRight()) { // Replace code looking like // AND dst, src, src // with // src instruction->ReplaceWith(instruction->GetLeft()); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); return; } if (TryDeMorganNegationFactoring(instruction)) { return; } // TryHandleAssociativeAndCommutativeOperation() does not remove its input, // so no need to return. TryHandleAssociativeAndCommutativeOperation(instruction); } void InstructionSimplifierVisitor::VisitGreaterThan(HGreaterThan* condition) { VisitCondition(condition); } void InstructionSimplifierVisitor::VisitGreaterThanOrEqual(HGreaterThanOrEqual* condition) { VisitCondition(condition); } void InstructionSimplifierVisitor::VisitLessThan(HLessThan* condition) { VisitCondition(condition); } void InstructionSimplifierVisitor::VisitLessThanOrEqual(HLessThanOrEqual* condition) { VisitCondition(condition); } void InstructionSimplifierVisitor::VisitBelow(HBelow* condition) { VisitCondition(condition); } void InstructionSimplifierVisitor::VisitBelowOrEqual(HBelowOrEqual* condition) { VisitCondition(condition); } void InstructionSimplifierVisitor::VisitAbove(HAbove* condition) { VisitCondition(condition); } void InstructionSimplifierVisitor::VisitAboveOrEqual(HAboveOrEqual* condition) { VisitCondition(condition); } // Recognize the following pattern: // obj.getClass() ==/!= Foo.class // And replace it with a constant value if the type of `obj` is statically known. static bool RecognizeAndSimplifyClassCheck(HCondition* condition) { HInstruction* input_one = condition->InputAt(0); HInstruction* input_two = condition->InputAt(1); HLoadClass* load_class = input_one->IsLoadClass() ? input_one->AsLoadClass() : input_two->AsLoadClassOrNull(); if (load_class == nullptr) { return false; } ReferenceTypeInfo class_rti = load_class->GetLoadedClassRTI(); if (!class_rti.IsValid()) { // Unresolved class. return false; } HInstanceFieldGet* field_get = (load_class == input_one) ? input_two->AsInstanceFieldGetOrNull() : input_one->AsInstanceFieldGetOrNull(); if (field_get == nullptr) { return false; } HInstruction* receiver = field_get->InputAt(0); ReferenceTypeInfo receiver_type = receiver->GetReferenceTypeInfo(); if (!receiver_type.IsExact()) { return false; } { ScopedObjectAccess soa(Thread::Current()); ArtField* field = GetClassRoot()->GetInstanceField(0); DCHECK_EQ(std::string(field->GetName()), "shadow$_klass_"); if (field_get->GetFieldInfo().GetField() != field) { return false; } // We can replace the compare. int value = 0; if (receiver_type.IsEqual(class_rti)) { value = condition->IsEqual() ? 1 : 0; } else { value = condition->IsNotEqual() ? 1 : 0; } condition->ReplaceWith(condition->GetBlock()->GetGraph()->GetIntConstant(value)); return true; } } static HInstruction* CreateUnsignedConditionReplacement(ArenaAllocator* allocator, HCondition* cond, HCompare* compare) { DCHECK(cond->InputAt(1)->IsIntConstant()); DCHECK_EQ(cond->InputAt(1)->AsIntConstant()->GetValue(), 0); DCHECK(cond->InputAt(0) == compare); HBasicBlock* block = cond->GetBlock(); HInstruction* lhs = compare->InputAt(0); HInstruction* rhs = compare->InputAt(1); switch (cond->GetKind()) { case HInstruction::kLessThan: return new (allocator) HBelow(lhs, rhs, cond->GetDexPc()); case HInstruction::kLessThanOrEqual: return new (allocator) HBelowOrEqual(lhs, rhs, cond->GetDexPc()); case HInstruction::kGreaterThan: return new (allocator) HAbove(lhs, rhs, cond->GetDexPc()); case HInstruction::kGreaterThanOrEqual: return new (allocator) HAboveOrEqual(lhs, rhs, cond->GetDexPc()); case HInstruction::kBelow: // Below(Compare(x, y), 0) always False since // unsigned(-1) < 0 -> False // 0 < 0 -> False // 1 < 0 -> False return block->GetGraph()->GetConstant(DataType::Type::kBool, 0); case HInstruction::kBelowOrEqual: // BelowOrEqual(Compare(x, y), 0) transforms into Equal(x, y) // unsigned(-1) <= 0 -> False // 0 <= 0 -> True // 1 <= 0 -> False return new (allocator) HEqual(lhs, rhs, cond->GetDexPc()); case HInstruction::kAbove: // Above(Compare(x, y), 0) transforms into NotEqual(x, y) // unsigned(-1) > 0 -> True // 0 > 0 -> False // 1 > 0 -> True return new (allocator) HNotEqual(lhs, rhs, cond->GetDexPc()); case HInstruction::kAboveOrEqual: // AboveOrEqual(Compare(x, y), 0) always True since // unsigned(-1) >= 0 -> True // 0 >= 0 -> True // 1 >= 0 -> True return block->GetGraph()->GetConstant(DataType::Type::kBool, 1); default: LOG(FATAL) << "Unknown ConditionType " << cond->GetKind(); UNREACHABLE(); } } void InstructionSimplifierVisitor::VisitCondition(HCondition* condition) { if (condition->IsEqual() || condition->IsNotEqual()) { if (RecognizeAndSimplifyClassCheck(condition)) { return; } } // Reverse condition if left is constant. Our code generators prefer constant // on the right hand side. HBasicBlock* block = condition->GetBlock(); HInstruction* left = condition->GetLeft(); HInstruction* right = condition->GetRight(); if (left->IsConstant() && !right->IsConstant()) { IfCondition new_cond = GetOppositeConditionForOperandSwap(condition->GetCondition()); HCondition* replacement = HCondition::Create(GetGraph(), new_cond, right, left); block->ReplaceAndRemoveInstructionWith(condition, replacement); // If it is a FP condition, we must set the opposite bias. if (condition->IsLtBias()) { replacement->SetBias(ComparisonBias::kGtBias); } else if (condition->IsGtBias()) { replacement->SetBias(ComparisonBias::kLtBias); } RecordSimplification(); condition = replacement; std::swap(left, right); } // Try to fold an HCompare into this HCondition. // We can only replace an HCondition which compares a Compare to 0. // Both 'dx' and 'jack' generate a compare to 0 when compiling a // condition with a long, float or double comparison as input. if (!left->IsCompare() || !right->IsConstant() || right->AsIntConstant()->GetValue() != 0) { // Conversion is not possible. return; } // Is the Compare only used for this purpose? if (!left->GetUses().HasExactlyOneElement()) { // Someone else also wants the result of the compare. return; } if (!left->GetEnvUses().empty()) { // There is a reference to the compare result in an environment. Do we really need it? if (GetGraph()->IsDebuggable()) { return; } // We have to ensure that there are no deopt points in the sequence. if (left->HasAnyEnvironmentUseBefore(condition)) { return; } } // Clean up any environment uses from the HCompare, if any. left->RemoveEnvironmentUsers(); // We have decided to fold the HCompare into the HCondition. Transfer the information. if (DataType::IsUnsignedType(left->AsCompare()->GetComparisonType()) && !condition->IsEqual() && !condition->IsNotEqual()) { DCHECK_EQ(condition->GetBias(), ComparisonBias::kNoBias); HInstruction* replacement = CreateUnsignedConditionReplacement( block->GetGraph()->GetAllocator(), condition, left->AsCompare()); if (replacement->IsConstant()) { condition->ReplaceWith(replacement); block->RemoveInstruction(condition); } else { block->ReplaceAndRemoveInstructionWith(condition, replacement); } } else { condition->SetBias(left->AsCompare()->GetBias()); // Replace the operands of the HCondition. condition->ReplaceInput(left->InputAt(0), 0); condition->ReplaceInput(left->InputAt(1), 1); } // Remove the HCompare. left->GetBlock()->RemoveInstruction(left); RecordSimplification(); } static HInstruction* CheckSignedToUnsignedCompareConversion(HInstruction* operand, HCompare* compare) { // Check if operand looks like `ADD op, MIN_INTEGRAL` if (operand->IsConstant()) { // CONSTANT #x -> CONSTANT #(x - MIN_INTEGRAL) HConstant* constant = operand->AsConstant(); if (constant->IsIntConstant()) { HIntConstant* int_constant = constant->AsIntConstant(); int32_t old_value = int_constant->GetValue(); int32_t new_value = old_value - std::numeric_limits::min(); return operand->GetBlock()->GetGraph()->GetIntConstant(new_value); } else if (constant->IsLongConstant()) { HLongConstant* long_constant = constant->AsLongConstant(); int64_t old_value = long_constant->GetValue(); int64_t new_value = old_value - std::numeric_limits::min(); return operand->GetBlock()->GetGraph()->GetLongConstant(new_value); } else { return nullptr; } } if (!operand->IsAdd() && !operand->IsXor()) { return nullptr; } if (!operand->GetEnvUses().empty()) { // There is a reference to the compare result in an environment. Do we really need it? if (operand->GetBlock()->GetGraph()->IsDebuggable()) { return nullptr; } // We have to ensure that there are no deopt points in the sequence. if (operand->HasAnyEnvironmentUseBefore(compare)) { return nullptr; } } HBinaryOperation* additive_operand = operand->AsBinaryOperation(); HInstruction* left = additive_operand->GetLeft(); HInstruction* right = additive_operand->GetRight(); HConstant* constant = nullptr; HInstruction* value = nullptr; if (left->IsConstant() && !right->IsConstant()) { constant = left->AsConstant(); value = right; } else if (!left->IsConstant() && right->IsConstant()) { value = left; constant = right->AsConstant(); } else { return nullptr; } if (constant->IsIntConstant()) { HIntConstant* int_constant = constant->AsIntConstant(); if (int_constant->GetValue() != std::numeric_limits::min()) { return nullptr; } } else if (constant->IsLongConstant()) { HLongConstant* long_constant = constant->AsLongConstant(); if (long_constant->GetValue() != std::numeric_limits::min()) { return nullptr; } } else { return nullptr; } return value; } static DataType::Type GetOpositeSignType(DataType::Type type) { return DataType::IsUnsignedType(type) ? DataType::ToSigned(type) : DataType::ToUnsigned(type); } void InstructionSimplifierVisitor::VisitCompare(HCompare* compare) { // Transform signed compare into unsigned if possible // Replace code looking like // ADD normalizedLeft, left, MIN_INTEGRAL // ADD normalizedRight, right, MIN_INTEGRAL // COMPARE normalizedLeft, normalizedRight, sign // with // COMPARE left, right, !sign if (!DataType::IsIntegralType(compare->GetComparisonType())) { return; } HInstruction* compare_left = compare->GetLeft(); HInstruction* compare_right = compare->GetRight(); if (compare_left->IsConstant() && compare_right->IsConstant()) { // Do not simplify, let it be folded. return; } HInstruction* left = CheckSignedToUnsignedCompareConversion(compare_left, compare); if (left == nullptr) { return; } HInstruction* right = CheckSignedToUnsignedCompareConversion(compare_right, compare); if (right == nullptr) { return; } compare->SetComparisonType(GetOpositeSignType(compare->GetComparisonType())); compare->ReplaceInput(left, 0); compare->ReplaceInput(right, 1); RecordSimplification(); if (compare_left->GetUses().empty()) { compare_left->RemoveEnvironmentUsers(); compare_left->GetBlock()->RemoveInstruction(compare_left); } if (compare_right->GetUses().empty()) { compare_right->RemoveEnvironmentUsers(); compare_right->GetBlock()->RemoveInstruction(compare_right); } } // Return whether x / divisor == x * (1.0f / divisor), for every float x. static constexpr bool CanDivideByReciprocalMultiplyFloat(int32_t divisor) { // True, if the most significant bits of divisor are 0. return ((divisor & 0x7fffff) == 0); } // Return whether x / divisor == x * (1.0 / divisor), for every double x. static constexpr bool CanDivideByReciprocalMultiplyDouble(int64_t divisor) { // True, if the most significant bits of divisor are 0. return ((divisor & ((UINT64_C(1) << 52) - 1)) == 0); } void InstructionSimplifierVisitor::VisitDiv(HDiv* instruction) { HConstant* input_cst = instruction->GetConstantRight(); HInstruction* input_other = instruction->GetLeastConstantLeft(); DataType::Type type = instruction->GetType(); if ((input_cst != nullptr) && input_cst->IsOne()) { // Replace code looking like // DIV dst, src, 1 // with // src instruction->ReplaceWith(input_other); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); return; } if ((input_cst != nullptr) && input_cst->IsMinusOne()) { // Replace code looking like // DIV dst, src, -1 // with // NEG dst, src instruction->GetBlock()->ReplaceAndRemoveInstructionWith( instruction, new (GetGraph()->GetAllocator()) HNeg(type, input_other)); RecordSimplification(); return; } if ((input_cst != nullptr) && DataType::IsFloatingPointType(type)) { // Try replacing code looking like // DIV dst, src, constant // with // MUL dst, src, 1 / constant HConstant* reciprocal = nullptr; if (type == DataType::Type::kFloat64) { double value = input_cst->AsDoubleConstant()->GetValue(); if (CanDivideByReciprocalMultiplyDouble(bit_cast(value))) { reciprocal = GetGraph()->GetDoubleConstant(1.0 / value); } } else { DCHECK_EQ(type, DataType::Type::kFloat32); float value = input_cst->AsFloatConstant()->GetValue(); if (CanDivideByReciprocalMultiplyFloat(bit_cast(value))) { reciprocal = GetGraph()->GetFloatConstant(1.0f / value); } } if (reciprocal != nullptr) { instruction->GetBlock()->ReplaceAndRemoveInstructionWith( instruction, new (GetGraph()->GetAllocator()) HMul(type, input_other, reciprocal)); RecordSimplification(); return; } } } // Search HDiv having the specified dividend and divisor which is in the specified basic block. // Return nullptr if nothing has been found. static HDiv* FindDivWithInputsInBasicBlock(HInstruction* dividend, HInstruction* divisor, HBasicBlock* basic_block) { for (const HUseListNode& use : dividend->GetUses()) { HInstruction* user = use.GetUser(); if (user->GetBlock() == basic_block && user->IsDiv() && user->InputAt(0) == dividend && user->InputAt(1) == divisor) { return user->AsDiv(); } } return nullptr; } // If there is Div with the same inputs as Rem and in the same basic block, it can be reused. // Rem is replaced with Mul+Sub which use the found Div. void InstructionSimplifierVisitor::TryToReuseDiv(HRem* rem) { // As the optimization replaces Rem with Mul+Sub they prevent some loop optimizations // if the Rem is in a loop. // Check if it is allowed to optimize such Rems. if (rem->IsInLoop() && be_loop_friendly_) { return; } DataType::Type type = rem->GetResultType(); if (!DataType::IsIntOrLongType(type)) { return; } HBasicBlock* basic_block = rem->GetBlock(); HInstruction* dividend = rem->GetLeft(); HInstruction* divisor = rem->GetRight(); if (divisor->IsConstant()) { HConstant* input_cst = rem->GetConstantRight(); DCHECK(input_cst->IsIntConstant() || input_cst->IsLongConstant()); int64_t cst_value = Int64FromConstant(input_cst); if (cst_value == std::numeric_limits::min() || IsPowerOfTwo(std::abs(cst_value))) { // Such cases are usually handled in the code generator because they don't need Div at all. return; } } HDiv* quotient = FindDivWithInputsInBasicBlock(dividend, divisor, basic_block); if (quotient == nullptr) { return; } if (!quotient->StrictlyDominates(rem)) { quotient->MoveBefore(rem); } ArenaAllocator* allocator = GetGraph()->GetAllocator(); HInstruction* mul = new (allocator) HMul(type, quotient, divisor); basic_block->InsertInstructionBefore(mul, rem); HInstruction* sub = new (allocator) HSub(type, dividend, mul); basic_block->InsertInstructionBefore(sub, rem); rem->ReplaceWith(sub); basic_block->RemoveInstruction(rem); RecordSimplification(); } void InstructionSimplifierVisitor::VisitRem(HRem* rem) { TryToReuseDiv(rem); } void InstructionSimplifierVisitor::VisitMul(HMul* instruction) { HConstant* input_cst = instruction->GetConstantRight(); HInstruction* input_other = instruction->GetLeastConstantLeft(); DataType::Type type = instruction->GetType(); HBasicBlock* block = instruction->GetBlock(); ArenaAllocator* allocator = GetGraph()->GetAllocator(); if (input_cst == nullptr) { return; } if (input_cst->IsOne()) { // Replace code looking like // MUL dst, src, 1 // with // src instruction->ReplaceWith(input_other); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); return; } if (input_cst->IsMinusOne() && (DataType::IsFloatingPointType(type) || DataType::IsIntOrLongType(type))) { // Replace code looking like // MUL dst, src, -1 // with // NEG dst, src HNeg* neg = new (allocator) HNeg(type, input_other); block->ReplaceAndRemoveInstructionWith(instruction, neg); RecordSimplification(); return; } if (DataType::IsFloatingPointType(type) && ((input_cst->IsFloatConstant() && input_cst->AsFloatConstant()->GetValue() == 2.0f) || (input_cst->IsDoubleConstant() && input_cst->AsDoubleConstant()->GetValue() == 2.0))) { // Replace code looking like // FP_MUL dst, src, 2.0 // with // FP_ADD dst, src, src // The 'int' and 'long' cases are handled below. block->ReplaceAndRemoveInstructionWith(instruction, new (allocator) HAdd(type, input_other, input_other)); RecordSimplification(); return; } if (DataType::IsIntOrLongType(type)) { int64_t factor = Int64FromConstant(input_cst); // Even though constant propagation also takes care of the zero case, other // optimizations can lead to having a zero multiplication. if (factor == 0) { // Replace code looking like // MUL dst, src, 0 // with // 0 instruction->ReplaceWith(input_cst); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); return; } else if (IsPowerOfTwo(factor)) { // Replace code looking like // MUL dst, src, pow_of_2 // with // SHL dst, src, log2(pow_of_2) HIntConstant* shift = GetGraph()->GetIntConstant(WhichPowerOf2(factor)); HShl* shl = new (allocator) HShl(type, input_other, shift); block->ReplaceAndRemoveInstructionWith(instruction, shl); RecordSimplification(); return; } else if (IsPowerOfTwo(factor - 1)) { // Transform code looking like // MUL dst, src, (2^n + 1) // into // SHL tmp, src, n // ADD dst, src, tmp HShl* shl = new (allocator) HShl(type, input_other, GetGraph()->GetIntConstant(WhichPowerOf2(factor - 1))); HAdd* add = new (allocator) HAdd(type, input_other, shl); block->InsertInstructionBefore(shl, instruction); block->ReplaceAndRemoveInstructionWith(instruction, add); RecordSimplification(); return; } else if (IsPowerOfTwo(factor + 1)) { // Transform code looking like // MUL dst, src, (2^n - 1) // into // SHL tmp, src, n // SUB dst, tmp, src HShl* shl = new (allocator) HShl(type, input_other, GetGraph()->GetIntConstant(WhichPowerOf2(factor + 1))); HSub* sub = new (allocator) HSub(type, shl, input_other); block->InsertInstructionBefore(shl, instruction); block->ReplaceAndRemoveInstructionWith(instruction, sub); RecordSimplification(); return; } } // TryHandleAssociativeAndCommutativeOperation() does not remove its input, // so no need to return. TryHandleAssociativeAndCommutativeOperation(instruction); } void InstructionSimplifierVisitor::VisitNeg(HNeg* instruction) { HInstruction* input = instruction->GetInput(); if (input->IsNeg()) { // Replace code looking like // NEG tmp, src // NEG dst, tmp // with // src HNeg* previous_neg = input->AsNeg(); instruction->ReplaceWith(previous_neg->GetInput()); instruction->GetBlock()->RemoveInstruction(instruction); // We perform the optimization even if the input negation has environment // uses since it allows removing the current instruction. But we only delete // the input negation only if it is does not have any uses left. if (!previous_neg->HasUses()) { previous_neg->GetBlock()->RemoveInstruction(previous_neg); } RecordSimplification(); return; } if (input->IsSub() && input->HasOnlyOneNonEnvironmentUse() && !DataType::IsFloatingPointType(input->GetType())) { // Replace code looking like // SUB tmp, a, b // NEG dst, tmp // with // SUB dst, b, a // We do not perform the optimization if the input subtraction has // environment uses or multiple non-environment uses as it could lead to // worse code. In particular, we do not want the live ranges of `a` and `b` // to be extended if we are not sure the initial 'SUB' instruction can be // removed. // We do not perform optimization for fp because we could lose the sign of zero. HSub* sub = input->AsSub(); HSub* new_sub = new (GetGraph()->GetAllocator()) HSub( instruction->GetType(), sub->GetRight(), sub->GetLeft()); instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, new_sub); if (!sub->HasUses()) { sub->GetBlock()->RemoveInstruction(sub); } RecordSimplification(); } } void InstructionSimplifierVisitor::VisitNot(HNot* instruction) { HInstruction* input = instruction->GetInput(); if (input->IsNot()) { // Replace code looking like // NOT tmp, src // NOT dst, tmp // with // src // We perform the optimization even if the input negation has environment // uses since it allows removing the current instruction. But we only delete // the input negation only if it is does not have any uses left. HNot* previous_not = input->AsNot(); instruction->ReplaceWith(previous_not->GetInput()); instruction->GetBlock()->RemoveInstruction(instruction); if (!previous_not->HasUses()) { previous_not->GetBlock()->RemoveInstruction(previous_not); } RecordSimplification(); } } void InstructionSimplifierVisitor::VisitOr(HOr* instruction) { HConstant* input_cst = instruction->GetConstantRight(); HInstruction* input_other = instruction->GetLeastConstantLeft(); if ((input_cst != nullptr) && input_cst->IsZeroBitPattern()) { // Replace code looking like // OR dst, src, 0 // with // src instruction->ReplaceWith(input_other); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); return; } // We assume that GVN has run before, so we only perform a pointer comparison. // If for some reason the values are equal but the pointers are different, we // are still correct and only miss an optimization opportunity. if (instruction->GetLeft() == instruction->GetRight()) { // Replace code looking like // OR dst, src, src // with // src instruction->ReplaceWith(instruction->GetLeft()); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); return; } if (TryDeMorganNegationFactoring(instruction)) return; if (TryReplaceWithRotate(instruction)) { return; } // TryHandleAssociativeAndCommutativeOperation() does not remove its input, // so no need to return. TryHandleAssociativeAndCommutativeOperation(instruction); } void InstructionSimplifierVisitor::VisitShl(HShl* instruction) { VisitShift(instruction); } void InstructionSimplifierVisitor::VisitShr(HShr* instruction) { VisitShift(instruction); } void InstructionSimplifierVisitor::VisitSub(HSub* instruction) { HConstant* input_cst = instruction->GetConstantRight(); HInstruction* input_other = instruction->GetLeastConstantLeft(); DataType::Type type = instruction->GetType(); if (DataType::IsFloatingPointType(type)) { return; } if ((input_cst != nullptr) && input_cst->IsArithmeticZero()) { // Replace code looking like // SUB dst, src, 0 // with // src // Note that we cannot optimize `x - 0.0` to `x` for floating-point. When // `x` is `-0.0`, the former expression yields `0.0`, while the later // yields `-0.0`. instruction->ReplaceWith(input_other); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); return; } HBasicBlock* block = instruction->GetBlock(); ArenaAllocator* allocator = GetGraph()->GetAllocator(); HInstruction* left = instruction->GetLeft(); HInstruction* right = instruction->GetRight(); if (left->IsConstant()) { if (Int64FromConstant(left->AsConstant()) == 0) { // Replace code looking like // SUB dst, 0, src // with // NEG dst, src // Note that we cannot optimize `0.0 - x` to `-x` for floating-point. When // `x` is `0.0`, the former expression yields `0.0`, while the later // yields `-0.0`. HNeg* neg = new (allocator) HNeg(type, right); block->ReplaceAndRemoveInstructionWith(instruction, neg); RecordSimplification(); return; } } if (left->IsNeg() && right->IsNeg()) { if (TryMoveNegOnInputsAfterBinop(instruction)) { return; } } if (right->IsNeg() && right->HasOnlyOneNonEnvironmentUse()) { // Replace code looking like // NEG tmp, b // SUB dst, a, tmp // with // ADD dst, a, b HAdd* add = new(GetGraph()->GetAllocator()) HAdd(type, left, right->AsNeg()->GetInput()); instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, add); RecordSimplification(); right->GetBlock()->RemoveInstruction(right); return; } if (left->IsNeg() && left->HasOnlyOneNonEnvironmentUse()) { // Replace code looking like // NEG tmp, a // SUB dst, tmp, b // with // ADD tmp, a, b // NEG dst, tmp // The second version is not intrinsically better, but enables more // transformations. HAdd* add = new(GetGraph()->GetAllocator()) HAdd(type, left->AsNeg()->GetInput(), right); instruction->GetBlock()->InsertInstructionBefore(add, instruction); HNeg* neg = new (GetGraph()->GetAllocator()) HNeg(instruction->GetType(), add); instruction->GetBlock()->InsertInstructionBefore(neg, instruction); instruction->ReplaceWith(neg); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); left->GetBlock()->RemoveInstruction(left); return; } if (TrySubtractionChainSimplification(instruction)) { return; } if (left->IsAdd()) { // Cases (x + y) - y = x, and (x + y) - x = y. // Replace code patterns looking like // ADD dst1, x, y ADD dst1, x, y // SUB dst2, dst1, y SUB dst2, dst1, x // with // ADD dst1, x, y // SUB instruction is not needed in this case, we may use // one of inputs of ADD instead. // It is applicable to integral types only. HAdd* add = left->AsAdd(); DCHECK(DataType::IsIntegralType(type)); if (add->GetRight() == right) { instruction->ReplaceWith(add->GetLeft()); RecordSimplification(); instruction->GetBlock()->RemoveInstruction(instruction); return; } else if (add->GetLeft() == right) { instruction->ReplaceWith(add->GetRight()); RecordSimplification(); instruction->GetBlock()->RemoveInstruction(instruction); return; } } else if (right->IsAdd()) { // Cases y - (x + y) = -x, and x - (x + y) = -y. // Replace code patterns looking like // ADD dst1, x, y ADD dst1, x, y // SUB dst2, y, dst1 SUB dst2, x, dst1 // with // ADD dst1, x, y ADD dst1, x, y // NEG x NEG y // SUB instruction is not needed in this case, we may use // one of inputs of ADD instead with a NEG. // It is applicable to integral types only. HAdd* add = right->AsAdd(); DCHECK(DataType::IsIntegralType(type)); if (add->GetRight() == left) { HNeg* neg = new (GetGraph()->GetAllocator()) HNeg(add->GetType(), add->GetLeft()); instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, neg); RecordSimplification(); return; } else if (add->GetLeft() == left) { HNeg* neg = new (GetGraph()->GetAllocator()) HNeg(add->GetType(), add->GetRight()); instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, neg); RecordSimplification(); return; } } else if (left->IsSub()) { // Case (x - y) - x = -y. // Replace code patterns looking like // SUB dst1, x, y // SUB dst2, dst1, x // with // SUB dst1, x, y // NEG y // The second SUB is not needed in this case, we may use the second input of the first SUB // instead with a NEG. // It is applicable to integral types only. HSub* sub = left->AsSub(); DCHECK(DataType::IsIntegralType(type)); if (sub->GetLeft() == right) { HNeg* neg = new (GetGraph()->GetAllocator()) HNeg(sub->GetType(), sub->GetRight()); instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, neg); RecordSimplification(); return; } } else if (right->IsSub()) { // Case x - (x - y) = y. // Replace code patterns looking like // SUB dst1, x, y // SUB dst2, x, dst1 // with // SUB dst1, x, y // The second SUB is not needed in this case, we may use the second input of the first SUB. // It is applicable to integral types only. HSub* sub = right->AsSub(); DCHECK(DataType::IsIntegralType(type)); if (sub->GetLeft() == left) { instruction->ReplaceWith(sub->GetRight()); RecordSimplification(); instruction->GetBlock()->RemoveInstruction(instruction); return; } } } void InstructionSimplifierVisitor::VisitUShr(HUShr* instruction) { VisitShift(instruction); } void InstructionSimplifierVisitor::VisitXor(HXor* instruction) { HConstant* input_cst = instruction->GetConstantRight(); HInstruction* input_other = instruction->GetLeastConstantLeft(); if ((input_cst != nullptr) && input_cst->IsZeroBitPattern()) { // Replace code looking like // XOR dst, src, 0 // with // src instruction->ReplaceWith(input_other); instruction->GetBlock()->RemoveInstruction(instruction); RecordSimplification(); return; } if ((input_cst != nullptr) && input_cst->IsOne() && input_other->GetType() == DataType::Type::kBool) { // Replace code looking like // XOR dst, src, 1 // with // BOOLEAN_NOT dst, src HBooleanNot* boolean_not = new (GetGraph()->GetAllocator()) HBooleanNot(input_other); instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, boolean_not); RecordSimplification(); return; } if ((input_cst != nullptr) && AreAllBitsSet(input_cst)) { // Replace code looking like // XOR dst, src, 0xFFF...FF // with // NOT dst, src HNot* bitwise_not = new (GetGraph()->GetAllocator()) HNot(instruction->GetType(), input_other); instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, bitwise_not); RecordSimplification(); return; } HInstruction* left = instruction->GetLeft(); HInstruction* right = instruction->GetRight(); if (((left->IsNot() && right->IsNot()) || (left->IsBooleanNot() && right->IsBooleanNot())) && left->HasOnlyOneNonEnvironmentUse() && right->HasOnlyOneNonEnvironmentUse()) { // Replace code looking like // NOT nota, a // NOT notb, b // XOR dst, nota, notb // with // XOR dst, a, b instruction->ReplaceInput(left->InputAt(0), 0); instruction->ReplaceInput(right->InputAt(0), 1); left->GetBlock()->RemoveInstruction(left); right->GetBlock()->RemoveInstruction(right); RecordSimplification(); return; } if (TryReplaceWithRotate(instruction)) { return; } // TryHandleAssociativeAndCommutativeOperation() does not remove its input, // so no need to return. TryHandleAssociativeAndCommutativeOperation(instruction); } void InstructionSimplifierVisitor::SimplifyBoxUnbox( HInvoke* instruction, ArtField* field, DataType::Type type) { DCHECK(instruction->GetIntrinsic() == Intrinsics::kByteValueOf || instruction->GetIntrinsic() == Intrinsics::kShortValueOf || instruction->GetIntrinsic() == Intrinsics::kCharacterValueOf || instruction->GetIntrinsic() == Intrinsics::kIntegerValueOf); const HUseList& uses = instruction->GetUses(); for (auto it = uses.begin(), end = uses.end(); it != end;) { HInstruction* user = it->GetUser(); ++it; // Increment the iterator before we potentially remove the node from the list. if (user->IsInstanceFieldGet() && user->AsInstanceFieldGet()->GetFieldInfo().GetField() == field && // Note: Due to other simplifications, we may have an `HInstanceFieldGet` with // a different type (Int8 vs. Uint8, Int16 vs. Uint16) for the same field. // Do not optimize that case for now. (We would need to insert a `HTypeConversion`.) user->GetType() == type) { user->ReplaceWith(instruction->InputAt(0)); RecordSimplification(); // Do not remove `user` while we're iterating over the block's instructions. Let DCE do it. } } } void InstructionSimplifierVisitor::SimplifyStringEquals(HInvoke* instruction) { HInstruction* argument = instruction->InputAt(1); HInstruction* receiver = instruction->InputAt(0); if (receiver == argument) { // Because String.equals is an instance call, the receiver is // a null check if we don't know it's null. The argument however, will // be the actual object. So we cannot end up in a situation where both // are equal but could be null. DCHECK(CanEnsureNotNullAt(argument, instruction)); instruction->ReplaceWith(GetGraph()->GetIntConstant(1)); instruction->GetBlock()->RemoveInstruction(instruction); } else { StringEqualsOptimizations optimizations(instruction); if (CanEnsureNotNullAt(argument, instruction)) { optimizations.SetArgumentNotNull(); } ScopedObjectAccess soa(Thread::Current()); ReferenceTypeInfo argument_rti = argument->GetReferenceTypeInfo(); if (argument_rti.IsValid() && argument_rti.IsStringClass()) { optimizations.SetArgumentIsString(); } } } static bool IsArrayLengthOf(HInstruction* potential_length, HInstruction* potential_array) { if (potential_length->IsArrayLength()) { return potential_length->InputAt(0) == potential_array; } if (potential_array->IsNewArray()) { return potential_array->AsNewArray()->GetLength() == potential_length; } return false; } void InstructionSimplifierVisitor::SimplifySystemArrayCopy(HInvoke* instruction) { HInstruction* source = instruction->InputAt(0); HInstruction* source_pos = instruction->InputAt(1); HInstruction* destination = instruction->InputAt(2); HInstruction* destination_pos = instruction->InputAt(3); HInstruction* count = instruction->InputAt(4); SystemArrayCopyOptimizations optimizations(instruction); if (CanEnsureNotNullAt(source, instruction)) { optimizations.SetSourceIsNotNull(); } if (CanEnsureNotNullAt(destination, instruction)) { optimizations.SetDestinationIsNotNull(); } if (destination == source) { optimizations.SetDestinationIsSource(); } if (source_pos == destination_pos) { optimizations.SetSourcePositionIsDestinationPosition(); } if (IsArrayLengthOf(count, source)) { optimizations.SetCountIsSourceLength(); } if (IsArrayLengthOf(count, destination)) { optimizations.SetCountIsDestinationLength(); } { ScopedObjectAccess soa(Thread::Current()); DataType::Type source_component_type = DataType::Type::kVoid; DataType::Type destination_component_type = DataType::Type::kVoid; ReferenceTypeInfo destination_rti = destination->GetReferenceTypeInfo(); if (destination_rti.IsValid()) { if (destination_rti.IsObjectArray()) { if (destination_rti.IsExact()) { optimizations.SetDoesNotNeedTypeCheck(); } optimizations.SetDestinationIsTypedObjectArray(); } if (destination_rti.IsPrimitiveArrayClass()) { destination_component_type = DataTypeFromPrimitive( destination_rti.GetTypeHandle()->GetComponentType()->GetPrimitiveType()); optimizations.SetDestinationIsPrimitiveArray(); } else if (destination_rti.IsNonPrimitiveArrayClass()) { optimizations.SetDestinationIsNonPrimitiveArray(); } } ReferenceTypeInfo source_rti = source->GetReferenceTypeInfo(); if (source_rti.IsValid()) { if (destination_rti.IsValid() && destination_rti.CanArrayHoldValuesOf(source_rti)) { optimizations.SetDoesNotNeedTypeCheck(); } if (source_rti.IsPrimitiveArrayClass()) { optimizations.SetSourceIsPrimitiveArray(); source_component_type = DataTypeFromPrimitive( source_rti.GetTypeHandle()->GetComponentType()->GetPrimitiveType()); } else if (source_rti.IsNonPrimitiveArrayClass()) { optimizations.SetSourceIsNonPrimitiveArray(); } } // For primitive arrays, use their optimized ArtMethod implementations. if ((source_component_type != DataType::Type::kVoid) && (source_component_type == destination_component_type)) { ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); PointerSize image_size = class_linker->GetImagePointerSize(); HInvokeStaticOrDirect* invoke = instruction->AsInvokeStaticOrDirect(); ObjPtr system = invoke->GetResolvedMethod()->GetDeclaringClass(); ArtMethod* method = nullptr; switch (source_component_type) { case DataType::Type::kBool: method = system->FindClassMethod("arraycopy", "([ZI[ZII)V", image_size); break; case DataType::Type::kInt8: method = system->FindClassMethod("arraycopy", "([BI[BII)V", image_size); break; case DataType::Type::kUint16: method = system->FindClassMethod("arraycopy", "([CI[CII)V", image_size); break; case DataType::Type::kInt16: method = system->FindClassMethod("arraycopy", "([SI[SII)V", image_size); break; case DataType::Type::kInt32: method = system->FindClassMethod("arraycopy", "([II[III)V", image_size); break; case DataType::Type::kFloat32: method = system->FindClassMethod("arraycopy", "([FI[FII)V", image_size); break; case DataType::Type::kInt64: method = system->FindClassMethod("arraycopy", "([JI[JII)V", image_size); break; case DataType::Type::kFloat64: method = system->FindClassMethod("arraycopy", "([DI[DII)V", image_size); break; default: LOG(FATAL) << "Unreachable"; } DCHECK(method != nullptr); DCHECK(method->IsStatic()); DCHECK(method->GetDeclaringClass() == system); invoke->SetResolvedMethod(method, !codegen_->GetGraph()->IsDebuggable()); // Sharpen the new invoke. Note that we do not update the dex method index of // the invoke, as we would need to look it up in the current dex file, and it // is unlikely that it exists. The most usual situation for such typed // arraycopy methods is a direct pointer to the boot image. invoke->SetDispatchInfo(HSharpening::SharpenLoadMethod( method, /* has_method_id= */ true, /* for_interface_call= */ false, codegen_)); } } } void InstructionSimplifierVisitor::SimplifyFP2Int(HInvoke* invoke) { DCHECK(invoke->IsInvokeStaticOrDirect()); uint32_t dex_pc = invoke->GetDexPc(); HInstruction* x = invoke->InputAt(0); DataType::Type type = x->GetType(); // Set proper bit pattern for NaN and replace intrinsic with raw version. HInstruction* nan; if (type == DataType::Type::kFloat64) { nan = GetGraph()->GetLongConstant(0x7ff8000000000000L); invoke->SetIntrinsic(Intrinsics::kDoubleDoubleToRawLongBits, kNeedsEnvironment, kNoSideEffects, kNoThrow); } else { DCHECK_EQ(type, DataType::Type::kFloat32); nan = GetGraph()->GetIntConstant(0x7fc00000); invoke->SetIntrinsic(Intrinsics::kFloatFloatToRawIntBits, kNeedsEnvironment, kNoSideEffects, kNoThrow); } // Test IsNaN(x), which is the same as x != x. HCondition* condition = new (GetGraph()->GetAllocator()) HNotEqual(x, x, dex_pc); condition->SetBias(ComparisonBias::kLtBias); invoke->GetBlock()->InsertInstructionBefore(condition, invoke->GetNext()); // Select between the two. HInstruction* select = new (GetGraph()->GetAllocator()) HSelect(condition, nan, invoke, dex_pc); invoke->GetBlock()->InsertInstructionBefore(select, condition->GetNext()); invoke->ReplaceWithExceptInReplacementAtIndex(select, 0); // false at index 0 } void InstructionSimplifierVisitor::SimplifyStringCharAt(HInvoke* invoke) { HInstruction* str = invoke->InputAt(0); HInstruction* index = invoke->InputAt(1); uint32_t dex_pc = invoke->GetDexPc(); ArenaAllocator* allocator = GetGraph()->GetAllocator(); // We treat String as an array to allow DCE and BCE to seamlessly work on strings, // so create the HArrayLength, HBoundsCheck and HArrayGet. HArrayLength* length = new (allocator) HArrayLength(str, dex_pc, /* is_string_length= */ true); invoke->GetBlock()->InsertInstructionBefore(length, invoke); HBoundsCheck* bounds_check = new (allocator) HBoundsCheck( index, length, dex_pc, /* is_string_char_at= */ true); invoke->GetBlock()->InsertInstructionBefore(bounds_check, invoke); HArrayGet* array_get = new (allocator) HArrayGet(str, bounds_check, DataType::Type::kUint16, SideEffects::None(), // Strings are immutable. dex_pc, /* is_string_char_at= */ true); invoke->GetBlock()->ReplaceAndRemoveInstructionWith(invoke, array_get); bounds_check->CopyEnvironmentFrom(invoke->GetEnvironment()); GetGraph()->SetHasBoundsChecks(true); } void InstructionSimplifierVisitor::SimplifyStringLength(HInvoke* invoke) { HInstruction* str = invoke->InputAt(0); uint32_t dex_pc = invoke->GetDexPc(); // We treat String as an array to allow DCE and BCE to seamlessly work on strings, // so create the HArrayLength. HArrayLength* length = new (GetGraph()->GetAllocator()) HArrayLength(str, dex_pc, /* is_string_length= */ true); invoke->GetBlock()->ReplaceAndRemoveInstructionWith(invoke, length); } void InstructionSimplifierVisitor::SimplifyStringIndexOf(HInvoke* invoke) { DCHECK(invoke->GetIntrinsic() == Intrinsics::kStringIndexOf || invoke->GetIntrinsic() == Intrinsics::kStringIndexOfAfter); if (invoke->InputAt(0)->IsLoadString()) { HLoadString* load_string = invoke->InputAt(0)->AsLoadString(); const DexFile& dex_file = load_string->GetDexFile(); uint32_t utf16_length; const char* data = dex_file.GetStringDataAndUtf16Length(load_string->GetStringIndex(), &utf16_length); if (utf16_length == 0) { invoke->ReplaceWith(GetGraph()->GetIntConstant(-1)); invoke->GetBlock()->RemoveInstruction(invoke); RecordSimplification(); return; } if (utf16_length == 1 && invoke->GetIntrinsic() == Intrinsics::kStringIndexOf) { // Simplify to HSelect(HEquals(., load_string.charAt(0)), 0, -1). // If the sought character is supplementary, this gives the correct result, i.e. -1. uint32_t c = GetUtf16FromUtf8(&data); DCHECK_EQ(GetTrailingUtf16Char(c), 0u); DCHECK_EQ(GetLeadingUtf16Char(c), c); uint32_t dex_pc = invoke->GetDexPc(); ArenaAllocator* allocator = GetGraph()->GetAllocator(); HEqual* equal = new (allocator) HEqual(invoke->InputAt(1), GetGraph()->GetIntConstant(c), dex_pc); invoke->GetBlock()->InsertInstructionBefore(equal, invoke); HSelect* result = new (allocator) HSelect(equal, GetGraph()->GetIntConstant(0), GetGraph()->GetIntConstant(-1), dex_pc); invoke->GetBlock()->ReplaceAndRemoveInstructionWith(invoke, result); RecordSimplification(); return; } } } // This method should only be used on intrinsics whose sole way of throwing an // exception is raising a NPE when the nth argument is null. If that argument // is provably non-null, we can clear the flag. void InstructionSimplifierVisitor::SimplifyNPEOnArgN(HInvoke* invoke, size_t n) { HInstruction* arg = invoke->InputAt(n); if (invoke->CanThrow() && !arg->CanBeNull()) { invoke->SetCanThrow(false); } } // Methods that return "this" can replace the returned value with the receiver. void InstructionSimplifierVisitor::SimplifyReturnThis(HInvoke* invoke) { if (invoke->HasUses()) { HInstruction* receiver = invoke->InputAt(0); invoke->ReplaceWith(receiver); RecordSimplification(); } } // Helper method for StringBuffer escape analysis. static bool NoEscapeForStringBufferReference(HInstruction* reference, HInstruction* user) { if (user->IsInvoke()) { switch (user->AsInvoke()->GetIntrinsic()) { case Intrinsics::kStringBufferLength: case Intrinsics::kStringBufferToString: DCHECK_EQ(user->InputAt(0), reference); return true; case Intrinsics::kStringBufferAppend: // Returns "this", so only okay if no further uses. DCHECK_EQ(user->InputAt(0), reference); DCHECK_NE(user->InputAt(1), reference); return !user->HasUses(); default: break; } } if (user->IsInvokeStaticOrDirect()) { // Any constructor on StringBuffer is okay. return user->AsInvokeStaticOrDirect()->GetResolvedMethod() != nullptr && user->AsInvokeStaticOrDirect()->GetResolvedMethod()->IsConstructor() && user->InputAt(0) == reference; } return false; } static bool TryReplaceStringBuilderAppend(CodeGenerator* codegen, HInvoke* invoke) { DCHECK_EQ(invoke->GetIntrinsic(), Intrinsics::kStringBuilderToString); if (invoke->CanThrowIntoCatchBlock()) { return false; } HBasicBlock* block = invoke->GetBlock(); HInstruction* sb = invoke->InputAt(0); // We support only a new StringBuilder, otherwise we cannot ensure that // the StringBuilder data does not need to be populated for other users. if (!sb->IsNewInstance()) { return false; } // For now, we support only single-block recognition. // (Ternary operators feeding the append could be implemented.) for (const HUseListNode& use : sb->GetUses()) { if (use.GetUser()->GetBlock() != block) { return false; } // The append pattern uses the StringBuilder only as the first argument. if (use.GetIndex() != 0u) { return false; } } // Collect args and check for unexpected uses. // We expect one call to a constructor with no arguments, one constructor fence (unless // eliminated), some number of append calls and one call to StringBuilder.toString(). bool seen_constructor = false; bool seen_constructor_fence = false; bool seen_to_string = false; uint32_t format = 0u; uint32_t num_args = 0u; bool has_fp_args = false; HInstruction* args[StringBuilderAppend::kMaxArgs]; // Added in reverse order. for (HBackwardInstructionIterator iter(block->GetInstructions()); !iter.Done(); iter.Advance()) { HInstruction* user = iter.Current(); // Instructions of interest apply to `sb`, skip those that do not involve `sb`. if (user->InputCount() == 0u || user->InputAt(0u) != sb) { continue; } // We visit the uses in reverse order, so the StringBuilder.toString() must come first. if (!seen_to_string) { if (user == invoke) { seen_to_string = true; continue; } else { return false; } } // Pattern match seeing arguments, then constructor, then constructor fence. if (user->IsInvokeStaticOrDirect() && user->AsInvokeStaticOrDirect()->GetResolvedMethod() != nullptr && user->AsInvokeStaticOrDirect()->GetResolvedMethod()->IsConstructor() && user->AsInvokeStaticOrDirect()->GetNumberOfArguments() == 1u) { // After arguments, we should see the constructor. // We accept only the constructor with no extra arguments. DCHECK(!seen_constructor); DCHECK(!seen_constructor_fence); seen_constructor = true; } else if (user->IsInvoke()) { // The arguments. HInvoke* as_invoke = user->AsInvoke(); DCHECK(!seen_constructor); DCHECK(!seen_constructor_fence); StringBuilderAppend::Argument arg; switch (as_invoke->GetIntrinsic()) { case Intrinsics::kStringBuilderAppendObject: // TODO: Unimplemented, needs to call String.valueOf(). return false; case Intrinsics::kStringBuilderAppendString: arg = StringBuilderAppend::Argument::kString; break; case Intrinsics::kStringBuilderAppendCharArray: // TODO: Unimplemented, StringBuilder.append(char[]) can throw NPE and we would // not have the correct stack trace for it. return false; case Intrinsics::kStringBuilderAppendBoolean: arg = StringBuilderAppend::Argument::kBoolean; break; case Intrinsics::kStringBuilderAppendChar: arg = StringBuilderAppend::Argument::kChar; break; case Intrinsics::kStringBuilderAppendInt: arg = StringBuilderAppend::Argument::kInt; break; case Intrinsics::kStringBuilderAppendLong: arg = StringBuilderAppend::Argument::kLong; break; case Intrinsics::kStringBuilderAppendFloat: arg = StringBuilderAppend::Argument::kFloat; has_fp_args = true; break; case Intrinsics::kStringBuilderAppendDouble: arg = StringBuilderAppend::Argument::kDouble; has_fp_args = true; break; case Intrinsics::kStringBuilderAppendCharSequence: { ReferenceTypeInfo rti = as_invoke->InputAt(1)->GetReferenceTypeInfo(); if (!rti.IsValid()) { return false; } ScopedObjectAccess soa(Thread::Current()); Handle input_type = rti.GetTypeHandle(); DCHECK(input_type != nullptr); if (input_type.Get() == GetClassRoot()) { arg = StringBuilderAppend::Argument::kString; } else { // TODO: Check and implement for StringBuilder. We could find the StringBuilder's // internal char[] inconsistent with the length, or the string compression // of the result could be compromised with a concurrent modification, and // we would need to throw appropriate exceptions. return false; } break; } default: { return false; } } // Uses of the append return value should have been replaced with the first input. DCHECK(!as_invoke->HasUses()); DCHECK(!as_invoke->HasEnvironmentUses()); if (num_args == StringBuilderAppend::kMaxArgs) { return false; } format = (format << StringBuilderAppend::kBitsPerArg) | static_cast(arg); args[num_args] = as_invoke->InputAt(1u); ++num_args; } else if (user->IsConstructorFence()) { // The last use we see is the constructor fence. DCHECK(seen_constructor); DCHECK(!seen_constructor_fence); seen_constructor_fence = true; } else { return false; } } if (num_args == 0u) { return false; } // Check environment uses. for (const HUseListNode& use : sb->GetEnvUses()) { HInstruction* holder = use.GetUser()->GetHolder(); if (holder->GetBlock() != block) { return false; } // Accept only calls on the StringBuilder (which shall all be removed). // TODO: Carve-out for const-string? Or rely on environment pruning (to be implemented)? if (holder->InputCount() == 0 || holder->InputAt(0) != sb) { return false; } } // Calculate outgoing vregs, including padding for 64-bit arg alignment. const PointerSize pointer_size = InstructionSetPointerSize(codegen->GetInstructionSet()); const size_t method_vregs = static_cast(pointer_size) / kVRegSize; uint32_t number_of_out_vregs = method_vregs; // For correct alignment padding; subtracted below. for (uint32_t f = format; f != 0u; f >>= StringBuilderAppend::kBitsPerArg) { auto a = enum_cast(f & StringBuilderAppend::kArgMask); if (a == StringBuilderAppend::Argument::kLong || a == StringBuilderAppend::Argument::kDouble) { number_of_out_vregs += /* alignment */ ((number_of_out_vregs) & 1u) + /* vregs */ 2u; } else { number_of_out_vregs += /* vregs */ 1u; } } number_of_out_vregs -= method_vregs; // Create replacement instruction. HIntConstant* fmt = block->GetGraph()->GetIntConstant(static_cast(format)); ArenaAllocator* allocator = block->GetGraph()->GetAllocator(); HStringBuilderAppend* append = new (allocator) HStringBuilderAppend( fmt, num_args, number_of_out_vregs, has_fp_args, allocator, invoke->GetDexPc()); append->SetReferenceTypeInfoIfValid(invoke->GetReferenceTypeInfo()); for (size_t i = 0; i != num_args; ++i) { append->SetArgumentAt(i, args[num_args - 1u - i]); } block->InsertInstructionBefore(append, invoke); DCHECK(!invoke->CanBeNull()); DCHECK(!append->CanBeNull()); invoke->ReplaceWith(append); // Copy environment, except for the StringBuilder uses. for (HEnvironment* env = invoke->GetEnvironment(); env != nullptr; env = env->GetParent()) { for (size_t i = 0, size = env->Size(); i != size; ++i) { if (env->GetInstructionAt(i) == sb) { env->RemoveAsUserOfInput(i); env->SetRawEnvAt(i, /*instruction=*/ nullptr); } } } append->CopyEnvironmentFrom(invoke->GetEnvironment()); // Remove the old instruction. block->RemoveInstruction(invoke); // Remove the StringBuilder's uses and StringBuilder. while (sb->HasNonEnvironmentUses()) { block->RemoveInstruction(sb->GetUses().front().GetUser()); } DCHECK(!sb->HasEnvironmentUses()); block->RemoveInstruction(sb); return true; } // Certain allocation intrinsics are not removed by dead code elimination // because of potentially throwing an OOM exception or other side effects. // This method removes such intrinsics when special circumstances allow. void InstructionSimplifierVisitor::SimplifyAllocationIntrinsic(HInvoke* invoke) { if (!invoke->HasUses()) { // Instruction has no uses. If unsynchronized, we can remove right away, safely ignoring // the potential OOM of course. Otherwise, we must ensure the receiver object of this // call does not escape since only thread-local synchronization may be removed. bool is_synchronized = invoke->GetIntrinsic() == Intrinsics::kStringBufferToString; HInstruction* receiver = invoke->InputAt(0); if (!is_synchronized || DoesNotEscape(receiver, NoEscapeForStringBufferReference)) { invoke->GetBlock()->RemoveInstruction(invoke); RecordSimplification(); } } else if (invoke->GetIntrinsic() == Intrinsics::kStringBuilderToString && TryReplaceStringBuilderAppend(codegen_, invoke)) { RecordSimplification(); } } void InstructionSimplifierVisitor::SimplifyVarHandleIntrinsic(HInvoke* invoke) { DCHECK(invoke->IsInvokePolymorphic()); VarHandleOptimizations optimizations(invoke); if (optimizations.GetDoNotIntrinsify()) { // Preceding static checks disabled intrinsic, so no need to analyze further. return; } size_t expected_coordinates_count = GetExpectedVarHandleCoordinatesCount(invoke); if (expected_coordinates_count != 0u) { HInstruction* object = invoke->InputAt(1); // The following has been ensured by static checks in the instruction builder. DCHECK(object->GetType() == DataType::Type::kReference); // Re-check for null constant, as this might have changed after the inliner. if (object->IsNullConstant()) { optimizations.SetDoNotIntrinsify(); return; } // Test whether we can avoid the null check on the object. if (CanEnsureNotNullAt(object, invoke)) { optimizations.SetSkipObjectNullCheck(); } } if (CanUseKnownImageVarHandle(invoke)) { optimizations.SetUseKnownImageVarHandle(); } } bool InstructionSimplifierVisitor::CanUseKnownImageVarHandle(HInvoke* invoke) { // If the `VarHandle` comes from a static final field of an initialized class in an image // (boot image or app image), we can do the checks at compile time. We do this optimization // only for AOT and only for field handles when we can avoid all checks. This avoids the // possibility of the code concurrently messing with the `VarHandle` using reflection, // we simply perform the operation with the `VarHandle` as seen at compile time. // TODO: Extend this to arrays to support the `AtomicIntegerArray` class. const CompilerOptions& compiler_options = codegen_->GetCompilerOptions(); if (!compiler_options.IsAotCompiler()) { return false; } size_t expected_coordinates_count = GetExpectedVarHandleCoordinatesCount(invoke); if (expected_coordinates_count == 2u) { return false; } HInstruction* var_handle_instruction = invoke->InputAt(0); if (var_handle_instruction->IsNullCheck()) { var_handle_instruction = var_handle_instruction->InputAt(0); } if (!var_handle_instruction->IsStaticFieldGet()) { return false; } ArtField* field = var_handle_instruction->AsStaticFieldGet()->GetFieldInfo().GetField(); DCHECK(field->IsStatic()); if (!field->IsFinal()) { return false; } ScopedObjectAccess soa(Thread::Current()); ObjPtr declaring_class = field->GetDeclaringClass(); if (!declaring_class->IsVisiblyInitialized()) { // During AOT compilation, dex2oat ensures that initialized classes are visibly initialized. DCHECK(!declaring_class->IsInitialized()); return false; } HInstruction* load_class = var_handle_instruction->InputAt(0); if (kIsDebugBuild) { bool is_in_image = false; if (Runtime::Current()->GetHeap()->ObjectIsInBootImageSpace(declaring_class)) { is_in_image = true; } else if (compiler_options.IsGeneratingImage()) { std::string storage; const char* descriptor = declaring_class->GetDescriptor(&storage); is_in_image = compiler_options.IsImageClass(descriptor); } CHECK_EQ(is_in_image, load_class->IsLoadClass() && load_class->AsLoadClass()->IsInImage()); } if (!load_class->IsLoadClass() || !load_class->AsLoadClass()->IsInImage()) { return false; } // Get the `VarHandle` object and check its class. ObjPtr expected_var_handle_class; switch (expected_coordinates_count) { case 0: expected_var_handle_class = GetClassRoot(); break; default: DCHECK_EQ(expected_coordinates_count, 1u); expected_var_handle_class = GetClassRoot(); break; } ObjPtr var_handle_object = field->GetObject(declaring_class); if (var_handle_object == nullptr || var_handle_object->GetClass() != expected_var_handle_class) { return false; } ObjPtr var_handle = ObjPtr::DownCast(var_handle_object); // Check access mode. mirror::VarHandle::AccessMode access_mode = mirror::VarHandle::GetAccessModeByIntrinsic(invoke->GetIntrinsic()); if (!var_handle->IsAccessModeSupported(access_mode)) { return false; } // Check argument types. ObjPtr var_type = var_handle->GetVarType(); mirror::VarHandle::AccessModeTemplate access_mode_template = mirror::VarHandle::GetAccessModeTemplate(access_mode); // Note: The data type of input arguments does not need to match the type from shorty // due to implicit conversions or avoiding unnecessary conversions before narrow stores. DataType::Type type = (access_mode_template == mirror::VarHandle::AccessModeTemplate::kGet) ? invoke->GetType() : GetDataTypeFromShorty(invoke, invoke->GetNumberOfArguments() - 1u); if (type != DataTypeFromPrimitive(var_type->GetPrimitiveType())) { return false; } if (type == DataType::Type::kReference) { uint32_t arguments_start = /* VarHandle object */ 1u + expected_coordinates_count; uint32_t number_of_arguments = invoke->GetNumberOfArguments(); for (size_t arg_index = arguments_start; arg_index != number_of_arguments; ++arg_index) { HInstruction* arg = invoke->InputAt(arg_index); DCHECK_EQ(arg->GetType(), DataType::Type::kReference); if (!arg->IsNullConstant()) { ReferenceTypeInfo arg_type_info = arg->GetReferenceTypeInfo(); if (!arg_type_info.IsValid() || !var_type->IsAssignableFrom(arg_type_info.GetTypeHandle().Get())) { return false; } } } } // Check the first coordinate. if (expected_coordinates_count != 0u) { ObjPtr coordinate0_type = var_handle->GetCoordinateType0(); DCHECK(coordinate0_type != nullptr); ReferenceTypeInfo object_type_info = invoke->InputAt(1)->GetReferenceTypeInfo(); if (!object_type_info.IsValid() || !coordinate0_type->IsAssignableFrom(object_type_info.GetTypeHandle().Get())) { return false; } } // All required checks passed. return true; } void InstructionSimplifierVisitor::VisitInvoke(HInvoke* instruction) { switch (instruction->GetIntrinsic()) { #define SIMPLIFY_BOX_UNBOX(name, low, high, type, start_index) \ case Intrinsics::k ## name ## ValueOf: \ SimplifyBoxUnbox(instruction, WellKnownClasses::java_lang_##name##_value, type); \ break; BOXED_TYPES(SIMPLIFY_BOX_UNBOX) #undef SIMPLIFY_BOX_UNBOX case Intrinsics::kStringEquals: SimplifyStringEquals(instruction); break; case Intrinsics::kSystemArrayCopy: SimplifySystemArrayCopy(instruction); break; case Intrinsics::kFloatFloatToIntBits: case Intrinsics::kDoubleDoubleToLongBits: SimplifyFP2Int(instruction); break; case Intrinsics::kStringCharAt: // Instruction builder creates intermediate representation directly // but the inliner can sharpen CharSequence.charAt() to String.charAt(). SimplifyStringCharAt(instruction); break; case Intrinsics::kStringLength: // Instruction builder creates intermediate representation directly // but the inliner can sharpen CharSequence.length() to String.length(). SimplifyStringLength(instruction); break; case Intrinsics::kStringIndexOf: case Intrinsics::kStringIndexOfAfter: SimplifyStringIndexOf(instruction); break; case Intrinsics::kStringStringIndexOf: case Intrinsics::kStringStringIndexOfAfter: SimplifyNPEOnArgN(instruction, 1); // 0th has own NullCheck break; case Intrinsics::kStringBufferAppend: case Intrinsics::kStringBuilderAppendObject: case Intrinsics::kStringBuilderAppendString: case Intrinsics::kStringBuilderAppendCharSequence: case Intrinsics::kStringBuilderAppendCharArray: case Intrinsics::kStringBuilderAppendBoolean: case Intrinsics::kStringBuilderAppendChar: case Intrinsics::kStringBuilderAppendInt: case Intrinsics::kStringBuilderAppendLong: case Intrinsics::kStringBuilderAppendFloat: case Intrinsics::kStringBuilderAppendDouble: SimplifyReturnThis(instruction); break; case Intrinsics::kStringBufferToString: case Intrinsics::kStringBuilderToString: SimplifyAllocationIntrinsic(instruction); break; case Intrinsics::kVarHandleCompareAndExchange: case Intrinsics::kVarHandleCompareAndExchangeAcquire: case Intrinsics::kVarHandleCompareAndExchangeRelease: case Intrinsics::kVarHandleCompareAndSet: case Intrinsics::kVarHandleGet: case Intrinsics::kVarHandleGetAcquire: case Intrinsics::kVarHandleGetAndAdd: case Intrinsics::kVarHandleGetAndAddAcquire: case Intrinsics::kVarHandleGetAndAddRelease: case Intrinsics::kVarHandleGetAndBitwiseAnd: case Intrinsics::kVarHandleGetAndBitwiseAndAcquire: case Intrinsics::kVarHandleGetAndBitwiseAndRelease: case Intrinsics::kVarHandleGetAndBitwiseOr: case Intrinsics::kVarHandleGetAndBitwiseOrAcquire: case Intrinsics::kVarHandleGetAndBitwiseOrRelease: case Intrinsics::kVarHandleGetAndBitwiseXor: case Intrinsics::kVarHandleGetAndBitwiseXorAcquire: case Intrinsics::kVarHandleGetAndBitwiseXorRelease: case Intrinsics::kVarHandleGetAndSet: case Intrinsics::kVarHandleGetAndSetAcquire: case Intrinsics::kVarHandleGetAndSetRelease: case Intrinsics::kVarHandleGetOpaque: case Intrinsics::kVarHandleGetVolatile: case Intrinsics::kVarHandleSet: case Intrinsics::kVarHandleSetOpaque: case Intrinsics::kVarHandleSetRelease: case Intrinsics::kVarHandleSetVolatile: case Intrinsics::kVarHandleWeakCompareAndSet: case Intrinsics::kVarHandleWeakCompareAndSetAcquire: case Intrinsics::kVarHandleWeakCompareAndSetPlain: case Intrinsics::kVarHandleWeakCompareAndSetRelease: SimplifyVarHandleIntrinsic(instruction); break; case Intrinsics::kUnsafeArrayBaseOffset: case Intrinsics::kJdkUnsafeArrayBaseOffset: SimplifyArrayBaseOffset(instruction); break; default: break; } } void InstructionSimplifierVisitor::SimplifyArrayBaseOffset(HInvoke* invoke) { if (!invoke->InputAt(1)->IsLoadClass()) { return; } HLoadClass* load_class = invoke->InputAt(1)->AsLoadClass(); ReferenceTypeInfo info = load_class->GetLoadedClassRTI(); if (!info.IsValid()) { return; } ScopedObjectAccess soa(Thread::Current()); ObjPtr cls = info.GetTypeHandle()->GetComponentType(); if (cls == nullptr) { return; } uint32_t base_offset = mirror::Array::DataOffset(Primitive::ComponentSize(cls->GetPrimitiveType())).Int32Value(); invoke->ReplaceWith(GetGraph()->GetIntConstant(base_offset)); RecordSimplification(); return; } void InstructionSimplifierVisitor::VisitDeoptimize(HDeoptimize* deoptimize) { HInstruction* cond = deoptimize->InputAt(0); if (cond->IsConstant()) { if (cond->AsIntConstant()->IsFalse()) { // Never deopt: instruction can be removed. if (deoptimize->GuardsAnInput()) { deoptimize->ReplaceWith(deoptimize->GuardedInput()); } deoptimize->GetBlock()->RemoveInstruction(deoptimize); } else { // Always deopt. } } } // Replace code looking like // OP y, x, const1 // OP z, y, const2 // with // OP z, x, const3 // where OP is both an associative and a commutative operation. bool InstructionSimplifierVisitor::TryHandleAssociativeAndCommutativeOperation( HBinaryOperation* instruction) { DCHECK(instruction->IsCommutative()); if (!DataType::IsIntegralType(instruction->GetType())) { return false; } HInstruction* left = instruction->GetLeft(); HInstruction* right = instruction->GetRight(); // Variable names as described above. HConstant* const2; HBinaryOperation* y; if (instruction->GetKind() == left->GetKind() && right->IsConstant()) { const2 = right->AsConstant(); y = left->AsBinaryOperation(); } else if (left->IsConstant() && instruction->GetKind() == right->GetKind()) { const2 = left->AsConstant(); y = right->AsBinaryOperation(); } else { // The node does not match the pattern. return false; } // If `y` has more than one use, we do not perform the optimization // because it might increase code size (e.g. if the new constant is // no longer encodable as an immediate operand in the target ISA). if (!y->HasOnlyOneNonEnvironmentUse()) { return false; } // GetConstantRight() can return both left and right constants // for commutative operations. HConstant* const1 = y->GetConstantRight(); if (const1 == nullptr) { return false; } instruction->ReplaceInput(const1, 0); instruction->ReplaceInput(const2, 1); HConstant* const3 = instruction->TryStaticEvaluation(); DCHECK(const3 != nullptr); instruction->ReplaceInput(y->GetLeastConstantLeft(), 0); instruction->ReplaceInput(const3, 1); RecordSimplification(); return true; } static HBinaryOperation* AsAddOrSub(HInstruction* binop) { return (binop->IsAdd() || binop->IsSub()) ? binop->AsBinaryOperation() : nullptr; } // Helper function that performs addition statically, considering the result type. static int64_t ComputeAddition(DataType::Type type, int64_t x, int64_t y) { // Use the Compute() method for consistency with TryStaticEvaluation(). if (type == DataType::Type::kInt32) { return HAdd::Compute(x, y); } else { DCHECK_EQ(type, DataType::Type::kInt64); return HAdd::Compute(x, y); } } // Helper function that handles the child classes of HConstant // and returns an integer with the appropriate sign. static int64_t GetValue(HConstant* constant, bool is_negated) { int64_t ret = Int64FromConstant(constant); return is_negated ? -ret : ret; } // Replace code looking like // OP1 y, x, const1 // OP2 z, y, const2 // with // OP3 z, x, const3 // where OPx is either ADD or SUB, and at least one of OP{1,2} is SUB. bool InstructionSimplifierVisitor::TrySubtractionChainSimplification( HBinaryOperation* instruction) { DCHECK(instruction->IsAdd() || instruction->IsSub()) << instruction->DebugName(); DataType::Type type = instruction->GetType(); if (!DataType::IsIntegralType(type)) { return false; } HInstruction* left = instruction->GetLeft(); HInstruction* right = instruction->GetRight(); // Variable names as described above. HConstant* const2 = right->IsConstant() ? right->AsConstant() : left->AsConstantOrNull(); if (const2 == nullptr) { return false; } HBinaryOperation* y = (AsAddOrSub(left) != nullptr) ? left->AsBinaryOperation() : AsAddOrSub(right); // If y has more than one use, we do not perform the optimization because // it might increase code size (e.g. if the new constant is no longer // encodable as an immediate operand in the target ISA). if ((y == nullptr) || !y->HasOnlyOneNonEnvironmentUse()) { return false; } left = y->GetLeft(); HConstant* const1 = left->IsConstant() ? left->AsConstant() : y->GetRight()->AsConstantOrNull(); if (const1 == nullptr) { return false; } HInstruction* x = (const1 == left) ? y->GetRight() : left; // If both inputs are constants, let the constant folding pass deal with it. if (x->IsConstant()) { return false; } bool is_const2_negated = (const2 == right) && instruction->IsSub(); int64_t const2_val = GetValue(const2, is_const2_negated); bool is_y_negated = (y == right) && instruction->IsSub(); right = y->GetRight(); bool is_const1_negated = is_y_negated ^ ((const1 == right) && y->IsSub()); int64_t const1_val = GetValue(const1, is_const1_negated); bool is_x_negated = is_y_negated ^ ((x == right) && y->IsSub()); int64_t const3_val = ComputeAddition(type, const1_val, const2_val); HBasicBlock* block = instruction->GetBlock(); HConstant* const3 = block->GetGraph()->GetConstant(type, const3_val); ArenaAllocator* allocator = instruction->GetAllocator(); HInstruction* z; if (is_x_negated) { z = new (allocator) HSub(type, const3, x, instruction->GetDexPc()); } else { z = new (allocator) HAdd(type, x, const3, instruction->GetDexPc()); } block->ReplaceAndRemoveInstructionWith(instruction, z); RecordSimplification(); return true; } void InstructionSimplifierVisitor::VisitVecMul(HVecMul* instruction) { if (TryCombineVecMultiplyAccumulate(instruction)) { RecordSimplification(); } } 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 TryMergeWithAnd(HSub* instruction) { HAnd* and_instr = instruction->GetRight()->AsAndOrNull(); if (and_instr == nullptr) { return false; } HInstruction* value = instruction->GetLeft(); HInstruction* left = and_instr->GetLeft(); const bool left_is_equal = left == value; HInstruction* right = and_instr->GetRight(); const bool right_is_equal = right == value; if (!left_is_equal && !right_is_equal) { return false; } HBitwiseNegatedRight* bnr = new (instruction->GetBlock()->GetGraph()->GetAllocator()) HBitwiseNegatedRight(instruction->GetType(), HInstruction::InstructionKind::kAnd, value, left_is_equal ? right : left, instruction->GetDexPc()); instruction->GetBlock()->ReplaceAndRemoveInstructionWith(instruction, bnr); // Since we don't run DCE after this phase, try to manually remove the And instruction. if (!and_instr->HasUses()) { and_instr->GetBlock()->RemoveInstruction(and_instr); } return true; } } // namespace art