Optimizing: Construct intrinsic HIR in builder.
To help baseline compiler emit better code, construct
intermediate representation for intrinsics that have
corresponding HIR classes in the instruction builder,
instead of doing it in the instruction simplifier.
Note: The generated code is sometimes different than
before because GVN uses instruction ids for input
ordering for commutative operations.
Test: m test-art-host-gtest
Test: testrunner.py --host --optimizing
Test: aosp_taimen-userdebug boots.
Change-Id: Ifa3a5774f8f3fbff4e3ca359c38eceee993d62cd
diff --git a/compiler/optimizing/instruction_builder.cc b/compiler/optimizing/instruction_builder.cc
index aff059f..ea3d3c0 100644
--- a/compiler/optimizing/instruction_builder.cc
+++ b/compiler/optimizing/instruction_builder.cc
@@ -431,38 +431,43 @@
InitializeBlockLocals();
DCHECK(!IsBlockPopulated(current_block_));
- // Add the invoke and return instruction. Use HInvokeStaticOrDirect even
- // for methods that would normally use an HInvokeVirtual (sharpen the call).
+ // Add the intermediate representation, if available, or invoke instruction.
size_t in_vregs = graph_->GetNumberOfInVRegs();
size_t number_of_arguments =
in_vregs - std::count(current_locals_->end() - in_vregs, current_locals_->end(), nullptr);
uint32_t method_idx = dex_compilation_unit_->GetDexMethodIndex();
- MethodReference target_method(dex_file_, method_idx);
- HInvokeStaticOrDirect::DispatchInfo dispatch_info = {
- HInvokeStaticOrDirect::MethodLoadKind::kRuntimeCall,
- HInvokeStaticOrDirect::CodePtrLocation::kCallArtMethod,
- /* method_load_data= */ 0u
- };
- InvokeType invoke_type = dex_compilation_unit_->IsStatic() ? kStatic : kDirect;
- HInvokeStaticOrDirect* invoke = new (allocator_) HInvokeStaticOrDirect(
- allocator_,
- number_of_arguments,
- return_type_,
- kNoDexPc,
- method_idx,
- method,
- dispatch_info,
- invoke_type,
- target_method,
- HInvokeStaticOrDirect::ClinitCheckRequirement::kNone);
+ const char* shorty = dex_file_->GetMethodShorty(method_idx);
RangeInstructionOperands operands(graph_->GetNumberOfVRegs() - in_vregs, in_vregs);
- HandleInvoke(invoke, operands, dex_file_->GetMethodShorty(method_idx), /* is_unresolved= */ false);
+ if (!BuildSimpleIntrinsic(method, kNoDexPc, operands, shorty)) {
+ // Some intrinsics without intermediate representation still yield a leaf method,
+ // so build the invoke. Use HInvokeStaticOrDirect even for methods that would
+ // normally use an HInvokeVirtual (sharpen the call).
+ MethodReference target_method(dex_file_, method_idx);
+ HInvokeStaticOrDirect::DispatchInfo dispatch_info = {
+ HInvokeStaticOrDirect::MethodLoadKind::kRuntimeCall,
+ HInvokeStaticOrDirect::CodePtrLocation::kCallArtMethod,
+ /* method_load_data= */ 0u
+ };
+ InvokeType invoke_type = dex_compilation_unit_->IsStatic() ? kStatic : kDirect;
+ HInvokeStaticOrDirect* invoke = new (allocator_) HInvokeStaticOrDirect(
+ allocator_,
+ number_of_arguments,
+ return_type_,
+ kNoDexPc,
+ method_idx,
+ method,
+ dispatch_info,
+ invoke_type,
+ target_method,
+ HInvokeStaticOrDirect::ClinitCheckRequirement::kNone);
+ HandleInvoke(invoke, operands, shorty, /* is_unresolved= */ false);
+ }
// Add the return instruction.
if (return_type_ == DataType::Type::kVoid) {
AppendInstruction(new (allocator_) HReturnVoid());
} else {
- AppendInstruction(new (allocator_) HReturn(invoke));
+ AppendInstruction(new (allocator_) HReturn(latest_result_));
}
// Fill the exit block.
@@ -1007,6 +1012,17 @@
clinit_check = ProcessClinitCheckForInvoke(dex_pc, resolved_method, &clinit_check_requirement);
}
+ // Try to build an HIR replacement for the intrinsic.
+ if (UNLIKELY(resolved_method->IsIntrinsic())) {
+ // All intrinsics are in the primary boot image, so their class can always be referenced
+ // and we do not need to rely on the implicit class initialization check. The class should
+ // be initialized but we do not require that here.
+ DCHECK_NE(clinit_check_requirement, HInvokeStaticOrDirect::ClinitCheckRequirement::kImplicit);
+ if (BuildSimpleIntrinsic(resolved_method, dex_pc, operands, shorty)) {
+ return true;
+ }
+ }
+
HInvoke* invoke = nullptr;
if (invoke_type == kDirect || invoke_type == kStatic || invoke_type == kSuper) {
if (invoke_type == kSuper) {
@@ -1029,6 +1045,13 @@
invoke_type,
target_method,
clinit_check_requirement);
+ if (clinit_check != nullptr) {
+ // Add the class initialization check as last input of `invoke`.
+ DCHECK_EQ(clinit_check_requirement, HInvokeStaticOrDirect::ClinitCheckRequirement::kExplicit);
+ size_t clinit_check_index = invoke->InputCount() - 1u;
+ DCHECK(invoke->InputAt(clinit_check_index) == nullptr);
+ invoke->SetArgumentAt(clinit_check_index, clinit_check);
+ }
} else if (invoke_type == kVirtual) {
DCHECK(target_method.dex_file == nullptr);
invoke = new (allocator_) HInvokeVirtual(allocator_,
@@ -1048,7 +1071,7 @@
resolved_method,
/*imt_index=*/ target_method.index);
}
- return HandleInvoke(invoke, operands, shorty, /* is_unresolved= */ false, clinit_check);
+ return HandleInvoke(invoke, operands, shorty, /* is_unresolved= */ false);
}
bool HInstructionBuilder::BuildInvokePolymorphic(uint32_t dex_pc,
@@ -1431,54 +1454,86 @@
return clinit_check;
}
-bool HInstructionBuilder::SetupInvokeArguments(HInvoke* invoke,
+bool HInstructionBuilder::SetupInvokeArguments(HInstruction* invoke,
const InstructionOperands& operands,
const char* shorty,
- size_t start_index,
- size_t* argument_index) {
+ ReceiverArg receiver_arg) {
+ // Note: The `invoke` can be an intrinsic replacement, so not necessaritly HInvoke.
+ // In that case, do not log errors, they shall be reported when we try to build the HInvoke.
uint32_t shorty_index = 1; // Skip the return type.
const size_t number_of_operands = operands.GetNumberOfOperands();
- for (size_t i = start_index;
- // Make sure we don't go over the expected arguments or over the number of
- // dex registers given. If the instruction was seen as dead by the verifier,
- // it hasn't been properly checked.
- (i < number_of_operands) && (*argument_index < invoke->GetNumberOfArguments());
- i++, (*argument_index)++) {
+ bool argument_length_error = false;
+
+ size_t start_index = 0u;
+ size_t argument_index = 0u;
+ if (receiver_arg != ReceiverArg::kNone) {
+ if (number_of_operands == 0u) {
+ argument_length_error = true;
+ } else {
+ start_index = 1u;
+ if (receiver_arg != ReceiverArg::kIgnored) {
+ uint32_t obj_reg = operands.GetOperand(0u);
+ HInstruction* arg = (receiver_arg == ReceiverArg::kPlainArg)
+ ? LoadLocal(obj_reg, DataType::Type::kReference)
+ : LoadNullCheckedLocal(obj_reg, invoke->GetDexPc());
+ if (receiver_arg != ReceiverArg::kNullCheckedOnly) {
+ invoke->SetRawInputAt(0u, arg);
+ argument_index = 1u;
+ }
+ }
+ }
+ }
+
+ for (size_t i = start_index; i < number_of_operands; ++i, ++argument_index) {
+ // Make sure we don't go over the expected arguments or over the number of
+ // dex registers given. If the instruction was seen as dead by the verifier,
+ // it hasn't been properly checked.
+ if (UNLIKELY(shorty[shorty_index] == 0)) {
+ argument_length_error = true;
+ break;
+ }
DataType::Type type = DataType::FromShorty(shorty[shorty_index++]);
bool is_wide = (type == DataType::Type::kInt64) || (type == DataType::Type::kFloat64);
if (is_wide && ((i + 1 == number_of_operands) ||
(operands.GetOperand(i) + 1 != operands.GetOperand(i + 1)))) {
- // Longs and doubles should be in pairs, that is, sequential registers. The verifier should
- // reject any class where this is violated. However, the verifier only does these checks
- // on non trivially dead instructions, so we just bailout the compilation.
- VLOG(compiler) << "Did not compile "
- << dex_file_->PrettyMethod(dex_compilation_unit_->GetDexMethodIndex())
- << " because of non-sequential dex register pair in wide argument";
- MaybeRecordStat(compilation_stats_,
- MethodCompilationStat::kNotCompiledMalformedOpcode);
+ if (invoke->IsInvoke()) {
+ // Longs and doubles should be in pairs, that is, sequential registers. The verifier should
+ // reject any class where this is violated. However, the verifier only does these checks
+ // on non trivially dead instructions, so we just bailout the compilation.
+ VLOG(compiler) << "Did not compile "
+ << dex_file_->PrettyMethod(dex_compilation_unit_->GetDexMethodIndex())
+ << " because of non-sequential dex register pair in wide argument";
+ MaybeRecordStat(compilation_stats_,
+ MethodCompilationStat::kNotCompiledMalformedOpcode);
+ }
return false;
}
HInstruction* arg = LoadLocal(operands.GetOperand(i), type);
- invoke->SetArgumentAt(*argument_index, arg);
+ DCHECK(invoke->InputAt(argument_index) == nullptr);
+ invoke->SetRawInputAt(argument_index, arg);
if (is_wide) {
- i++;
+ ++i;
}
}
- if (*argument_index != invoke->GetNumberOfArguments()) {
- VLOG(compiler) << "Did not compile "
- << dex_file_->PrettyMethod(dex_compilation_unit_->GetDexMethodIndex())
- << " because of wrong number of arguments in invoke instruction";
- MaybeRecordStat(compilation_stats_,
- MethodCompilationStat::kNotCompiledMalformedOpcode);
+ argument_length_error = argument_length_error || shorty[shorty_index] != 0;
+ if (argument_length_error) {
+ if (invoke->IsInvoke()) {
+ VLOG(compiler) << "Did not compile "
+ << dex_file_->PrettyMethod(dex_compilation_unit_->GetDexMethodIndex())
+ << " because of wrong number of arguments in invoke instruction";
+ MaybeRecordStat(compilation_stats_,
+ MethodCompilationStat::kNotCompiledMalformedOpcode);
+ }
return false;
}
if (invoke->IsInvokeStaticOrDirect() &&
HInvokeStaticOrDirect::NeedsCurrentMethodInput(
invoke->AsInvokeStaticOrDirect()->GetMethodLoadKind())) {
- invoke->SetArgumentAt(*argument_index, graph_->GetCurrentMethod());
- (*argument_index)++;
+ DCHECK_EQ(argument_index, invoke->AsInvokeStaticOrDirect()->GetSpecialInputIndex());
+ DCHECK(invoke->InputAt(argument_index) == nullptr);
+ invoke->SetRawInputAt(argument_index, graph_->GetCurrentMethod());
}
return true;
@@ -1487,50 +1542,212 @@
bool HInstructionBuilder::HandleInvoke(HInvoke* invoke,
const InstructionOperands& operands,
const char* shorty,
- bool is_unresolved,
- HClinitCheck* clinit_check) {
+ bool is_unresolved) {
DCHECK(!invoke->IsInvokeStaticOrDirect() || !invoke->AsInvokeStaticOrDirect()->IsStringInit());
- size_t start_index = 0;
- size_t argument_index = 0;
- if (invoke->GetInvokeType() != InvokeType::kStatic) { // Instance call.
- uint32_t obj_reg = operands.GetOperand(0);
- HInstruction* arg = is_unresolved
- ? LoadLocal(obj_reg, DataType::Type::kReference)
- : LoadNullCheckedLocal(obj_reg, invoke->GetDexPc());
- invoke->SetArgumentAt(0, arg);
- start_index = 1;
- argument_index = 1;
- }
-
- if (!SetupInvokeArguments(invoke, operands, shorty, start_index, &argument_index)) {
+ ReceiverArg receiver_arg = (invoke->GetInvokeType() == InvokeType::kStatic)
+ ? ReceiverArg::kNone
+ : (is_unresolved ? ReceiverArg::kPlainArg : ReceiverArg::kNullCheckedArg);
+ if (!SetupInvokeArguments(invoke, operands, shorty, receiver_arg)) {
return false;
}
- if (clinit_check != nullptr) {
- // Add the class initialization check as last input of `invoke`.
- DCHECK(invoke->IsInvokeStaticOrDirect());
- DCHECK(invoke->AsInvokeStaticOrDirect()->GetClinitCheckRequirement()
- == HInvokeStaticOrDirect::ClinitCheckRequirement::kExplicit);
- invoke->SetArgumentAt(argument_index, clinit_check);
- argument_index++;
- }
-
AppendInstruction(invoke);
latest_result_ = invoke;
return true;
}
+bool HInstructionBuilder::BuildSimpleIntrinsic(ArtMethod* method,
+ uint32_t dex_pc,
+ const InstructionOperands& operands,
+ const char* shorty) {
+ Intrinsics intrinsic = static_cast<Intrinsics>(method->GetIntrinsic());
+ DCHECK_NE(intrinsic, Intrinsics::kNone);
+ constexpr DataType::Type kInt32 = DataType::Type::kInt32;
+ constexpr DataType::Type kInt64 = DataType::Type::kInt64;
+ constexpr DataType::Type kFloat32 = DataType::Type::kFloat32;
+ constexpr DataType::Type kFloat64 = DataType::Type::kFloat64;
+ ReceiverArg receiver_arg = method->IsStatic() ? ReceiverArg::kNone : ReceiverArg::kNullCheckedArg;
+ HInstruction* instruction = nullptr;
+ switch (intrinsic) {
+ case Intrinsics::kIntegerRotateRight:
+ case Intrinsics::kIntegerRotateLeft:
+ // For rotate left, we negate the distance below.
+ instruction = new (allocator_) HRor(kInt32, /*value=*/ nullptr, /*distance=*/ nullptr);
+ break;
+ case Intrinsics::kLongRotateRight:
+ case Intrinsics::kLongRotateLeft:
+ // For rotate left, we negate the distance below.
+ instruction = new (allocator_) HRor(kInt64, /*value=*/ nullptr, /*distance=*/ nullptr);
+ break;
+ case Intrinsics::kIntegerCompare:
+ instruction = new (allocator_) HCompare(
+ kInt32, /*first=*/ nullptr, /*second=*/ nullptr, ComparisonBias::kNoBias, dex_pc);
+ break;
+ case Intrinsics::kLongCompare:
+ instruction = new (allocator_) HCompare(
+ kInt64, /*first=*/ nullptr, /*second=*/ nullptr, ComparisonBias::kNoBias, dex_pc);
+ break;
+ case Intrinsics::kIntegerSignum:
+ instruction = new (allocator_) HCompare(
+ kInt32, /*first=*/ nullptr, graph_->GetIntConstant(0), ComparisonBias::kNoBias, dex_pc);
+ break;
+ case Intrinsics::kLongSignum:
+ instruction = new (allocator_) HCompare(
+ kInt64, /*first=*/ nullptr, graph_->GetLongConstant(0), ComparisonBias::kNoBias, dex_pc);
+ break;
+ case Intrinsics::kFloatIsNaN:
+ case Intrinsics::kDoubleIsNaN: {
+ // IsNaN(x) is the same as x != x.
+ instruction = new (allocator_) HNotEqual(/*first=*/ nullptr, /*second=*/ nullptr, dex_pc);
+ instruction->AsCondition()->SetBias(ComparisonBias::kLtBias);
+ break;
+ }
+ case Intrinsics::kStringCharAt:
+ // We treat String as an array to allow DCE and BCE to seamlessly work on strings.
+ instruction = new (allocator_) HArrayGet(/*array=*/ nullptr,
+ /*index=*/ nullptr,
+ DataType::Type::kUint16,
+ SideEffects::None(), // Strings are immutable.
+ dex_pc,
+ /*is_string_char_at=*/ true);
+ break;
+ case Intrinsics::kStringIsEmpty:
+ case Intrinsics::kStringLength:
+ // We treat String as an array to allow DCE and BCE to seamlessly work on strings.
+ // For String.isEmpty(), we add a comparison with 0 below.
+ instruction =
+ new (allocator_) HArrayLength(/*array=*/ nullptr, dex_pc, /* is_string_length= */ true);
+ break;
+ case Intrinsics::kUnsafeLoadFence:
+ receiver_arg = ReceiverArg::kNullCheckedOnly;
+ instruction = new (allocator_) HMemoryBarrier(MemBarrierKind::kLoadAny, dex_pc);
+ break;
+ case Intrinsics::kUnsafeStoreFence:
+ receiver_arg = ReceiverArg::kNullCheckedOnly;
+ instruction = new (allocator_) HMemoryBarrier(MemBarrierKind::kAnyStore, dex_pc);
+ break;
+ case Intrinsics::kUnsafeFullFence:
+ receiver_arg = ReceiverArg::kNullCheckedOnly;
+ instruction = new (allocator_) HMemoryBarrier(MemBarrierKind::kAnyAny, dex_pc);
+ break;
+ case Intrinsics::kVarHandleFullFence:
+ instruction = new (allocator_) HMemoryBarrier(MemBarrierKind::kAnyAny, dex_pc);
+ break;
+ case Intrinsics::kVarHandleAcquireFence:
+ instruction = new (allocator_) HMemoryBarrier(MemBarrierKind::kLoadAny, dex_pc);
+ break;
+ case Intrinsics::kVarHandleReleaseFence:
+ instruction = new (allocator_) HMemoryBarrier(MemBarrierKind::kAnyStore, dex_pc);
+ break;
+ case Intrinsics::kVarHandleLoadLoadFence:
+ instruction = new (allocator_) HMemoryBarrier(MemBarrierKind::kLoadAny, dex_pc);
+ break;
+ case Intrinsics::kVarHandleStoreStoreFence:
+ instruction = new (allocator_) HMemoryBarrier(MemBarrierKind::kStoreStore, dex_pc);
+ break;
+ case Intrinsics::kMathMinIntInt:
+ instruction = new (allocator_) HMin(kInt32, /*left=*/ nullptr, /*right=*/ nullptr, dex_pc);
+ break;
+ case Intrinsics::kMathMinLongLong:
+ instruction = new (allocator_) HMin(kInt64, /*left=*/ nullptr, /*right=*/ nullptr, dex_pc);
+ break;
+ case Intrinsics::kMathMinFloatFloat:
+ instruction = new (allocator_) HMin(kFloat32, /*left=*/ nullptr, /*right=*/ nullptr, dex_pc);
+ break;
+ case Intrinsics::kMathMinDoubleDouble:
+ instruction = new (allocator_) HMin(kFloat64, /*left=*/ nullptr, /*right=*/ nullptr, dex_pc);
+ break;
+ case Intrinsics::kMathMaxIntInt:
+ instruction = new (allocator_) HMax(kInt32, /*left=*/ nullptr, /*right=*/ nullptr, dex_pc);
+ break;
+ case Intrinsics::kMathMaxLongLong:
+ instruction = new (allocator_) HMax(kInt64, /*left=*/ nullptr, /*right=*/ nullptr, dex_pc);
+ break;
+ case Intrinsics::kMathMaxFloatFloat:
+ instruction = new (allocator_) HMax(kFloat32, /*left=*/ nullptr, /*right=*/ nullptr, dex_pc);
+ break;
+ case Intrinsics::kMathMaxDoubleDouble:
+ instruction = new (allocator_) HMax(kFloat64, /*left=*/ nullptr, /*right=*/ nullptr, dex_pc);
+ break;
+ case Intrinsics::kMathAbsInt:
+ instruction = new (allocator_) HAbs(kInt32, /*input=*/ nullptr, dex_pc);
+ break;
+ case Intrinsics::kMathAbsLong:
+ instruction = new (allocator_) HAbs(kInt64, /*input=*/ nullptr, dex_pc);
+ break;
+ case Intrinsics::kMathAbsFloat:
+ instruction = new (allocator_) HAbs(kFloat32, /*input=*/ nullptr, dex_pc);
+ break;
+ case Intrinsics::kMathAbsDouble:
+ instruction = new (allocator_) HAbs(kFloat64, /*input=*/ nullptr, dex_pc);
+ break;
+ default:
+ // We do not have intermediate representation for other intrinsics.
+ return false;
+ }
+ DCHECK(instruction != nullptr);
+ if (!SetupInvokeArguments(instruction, operands, shorty, receiver_arg)) {
+ return false;
+ }
+
+ switch (intrinsic) {
+ case Intrinsics::kIntegerRotateLeft:
+ case Intrinsics::kLongRotateLeft: {
+ // Negate the distance value for rotate left.
+ DCHECK(instruction->IsRor());
+ HNeg* neg = new (allocator_) HNeg(kInt32, instruction->InputAt(1u));
+ AppendInstruction(neg);
+ instruction->SetRawInputAt(1u, neg);
+ break;
+ }
+ case Intrinsics::kFloatIsNaN:
+ case Intrinsics::kDoubleIsNaN:
+ // Set the second input to be the same as first.
+ DCHECK(instruction->IsNotEqual());
+ DCHECK(instruction->InputAt(1u) == nullptr);
+ instruction->SetRawInputAt(1u, instruction->InputAt(0u));
+ break;
+ case Intrinsics::kStringCharAt: {
+ // Add bounds check.
+ HInstruction* array = instruction->InputAt(0u);
+ HInstruction* index = instruction->InputAt(1u);
+ HInstruction* length =
+ new (allocator_) HArrayLength(array, dex_pc, /*is_string_length=*/ true);
+ AppendInstruction(length);
+ HBoundsCheck* bounds_check =
+ new (allocator_) HBoundsCheck(index, length, dex_pc, /*is_string_char_at=*/ true);
+ AppendInstruction(bounds_check);
+ graph_->SetHasBoundsChecks(true);
+ instruction->SetRawInputAt(1u, bounds_check);
+ break;
+ }
+ case Intrinsics::kStringIsEmpty: {
+ // Compare the length with 0.
+ DCHECK(instruction->IsArrayLength());
+ AppendInstruction(instruction);
+ HEqual* equal = new (allocator_) HEqual(instruction, graph_->GetIntConstant(0), dex_pc);
+ instruction = equal;
+ break;
+ }
+ default:
+ break;
+ }
+
+ AppendInstruction(instruction);
+ latest_result_ = instruction;
+
+ return true;
+}
+
bool HInstructionBuilder::HandleStringInit(HInvoke* invoke,
const InstructionOperands& operands,
const char* shorty) {
DCHECK(invoke->IsInvokeStaticOrDirect());
DCHECK(invoke->AsInvokeStaticOrDirect()->IsStringInit());
- size_t start_index = 1;
- size_t argument_index = 0;
- if (!SetupInvokeArguments(invoke, operands, shorty, start_index, &argument_index)) {
+ if (!SetupInvokeArguments(invoke, operands, shorty, ReceiverArg::kIgnored)) {
return false;
}
diff --git a/compiler/optimizing/instruction_builder.h b/compiler/optimizing/instruction_builder.h
index c021134..95d3315 100644
--- a/compiler/optimizing/instruction_builder.h
+++ b/compiler/optimizing/instruction_builder.h
@@ -243,17 +243,22 @@
uint32_t dex_pc,
HInvoke* invoke);
- bool SetupInvokeArguments(HInvoke* invoke,
+ enum class ReceiverArg {
+ kNone, // No receiver, static method.
+ kNullCheckedArg, // Normal instance invoke, null check and pass the argument.
+ kNullCheckedOnly, // Null check but do not use the arg, used for intrinsic replacements.
+ kPlainArg, // Do not null check but pass the argument, used for unresolved methods.
+ kIgnored, // No receiver despite allocated vreg, used for String.<init>.
+ };
+ bool SetupInvokeArguments(HInstruction* invoke,
const InstructionOperands& operands,
const char* shorty,
- size_t start_index,
- size_t* argument_index);
+ ReceiverArg receiver_arg);
bool HandleInvoke(HInvoke* invoke,
const InstructionOperands& operands,
const char* shorty,
- bool is_unresolved,
- HClinitCheck* clinit_check = nullptr);
+ bool is_unresolved);
bool HandleStringInit(HInvoke* invoke,
const InstructionOperands& operands,
@@ -265,6 +270,14 @@
ArtMethod* method,
HInvokeStaticOrDirect::ClinitCheckRequirement* clinit_check_requirement);
+ // Try to build a replacement for an intrinsic invoke. Returns true on success,
+ // false on failure. Failure can be either lack of replacement HIR classes, or
+ // input register mismatch.
+ bool BuildSimpleIntrinsic(ArtMethod* method,
+ uint32_t dex_pc,
+ const InstructionOperands& operands,
+ const char* shorty);
+
// Build a HNewInstance instruction.
HNewInstance* BuildNewInstance(dex::TypeIndex type_index, uint32_t dex_pc);
diff --git a/compiler/optimizing/instruction_simplifier.cc b/compiler/optimizing/instruction_simplifier.cc
index 84297ec..8e0b414 100644
--- a/compiler/optimizing/instruction_simplifier.cc
+++ b/compiler/optimizing/instruction_simplifier.cc
@@ -108,22 +108,15 @@
bool CanEnsureNotNullAt(HInstruction* instr, HInstruction* at) const;
- void SimplifyRotate(HInvoke* invoke, bool is_left, DataType::Type type);
void SimplifySystemArrayCopy(HInvoke* invoke);
void SimplifyStringEquals(HInvoke* invoke);
- void SimplifyCompare(HInvoke* invoke, bool is_signum, DataType::Type type);
- void SimplifyIsNaN(HInvoke* invoke);
void SimplifyFP2Int(HInvoke* invoke);
void SimplifyStringCharAt(HInvoke* invoke);
- void SimplifyStringIsEmptyOrLength(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 SimplifyMemBarrier(HInvoke* invoke, MemBarrierKind barrier_kind);
- void SimplifyMin(HInvoke* invoke, DataType::Type type);
- void SimplifyMax(HInvoke* invoke, DataType::Type type);
- void SimplifyAbs(HInvoke* invoke, DataType::Type type);
CodeGenerator* codegen_;
OptimizingCompilerStats* stats_;
@@ -2127,34 +2120,6 @@
}
}
-void InstructionSimplifierVisitor::SimplifyRotate(HInvoke* invoke,
- bool is_left,
- DataType::Type type) {
- DCHECK(invoke->IsInvokeStaticOrDirect());
- DCHECK_EQ(invoke->GetInvokeType(), InvokeType::kStatic);
- HInstruction* value = invoke->InputAt(0);
- HInstruction* distance = invoke->InputAt(1);
- // Replace the invoke with an HRor.
- if (is_left) {
- // Unconditionally set the type of the negated distance to `int`,
- // as shift and rotate operations expect a 32-bit (or narrower)
- // value for their distance input.
- distance = new (GetGraph()->GetAllocator()) HNeg(DataType::Type::kInt32, distance);
- invoke->GetBlock()->InsertInstructionBefore(distance, invoke);
- }
- HRor* ror = new (GetGraph()->GetAllocator()) HRor(type, value, distance);
- invoke->GetBlock()->ReplaceAndRemoveInstructionWith(invoke, ror);
- // Remove ClinitCheck and LoadClass, if possible.
- HInstruction* clinit = invoke->GetInputs().back();
- if (clinit->IsClinitCheck() && !clinit->HasUses()) {
- clinit->GetBlock()->RemoveInstruction(clinit);
- HInstruction* ldclass = clinit->InputAt(0);
- if (ldclass->IsLoadClass() && !ldclass->HasUses()) {
- ldclass->GetBlock()->RemoveInstruction(ldclass);
- }
- }
-}
-
static bool IsArrayLengthOf(HInstruction* potential_length, HInstruction* potential_array) {
if (potential_length->IsArrayLength()) {
return potential_length->InputAt(0) == potential_array;
@@ -2272,35 +2237,6 @@
}
}
-void InstructionSimplifierVisitor::SimplifyCompare(HInvoke* invoke,
- bool is_signum,
- DataType::Type type) {
- DCHECK(invoke->IsInvokeStaticOrDirect());
- uint32_t dex_pc = invoke->GetDexPc();
- HInstruction* left = invoke->InputAt(0);
- HInstruction* right;
- if (!is_signum) {
- right = invoke->InputAt(1);
- } else if (type == DataType::Type::kInt64) {
- right = GetGraph()->GetLongConstant(0);
- } else {
- right = GetGraph()->GetIntConstant(0);
- }
- HCompare* compare = new (GetGraph()->GetAllocator())
- HCompare(type, left, right, ComparisonBias::kNoBias, dex_pc);
- invoke->GetBlock()->ReplaceAndRemoveInstructionWith(invoke, compare);
-}
-
-void InstructionSimplifierVisitor::SimplifyIsNaN(HInvoke* invoke) {
- DCHECK(invoke->IsInvokeStaticOrDirect());
- uint32_t dex_pc = invoke->GetDexPc();
- // IsNaN(x) is the same as x != x.
- HInstruction* x = invoke->InputAt(0);
- HCondition* condition = new (GetGraph()->GetAllocator()) HNotEqual(x, x, dex_pc);
- condition->SetBias(ComparisonBias::kLtBias);
- invoke->GetBlock()->ReplaceAndRemoveInstructionWith(invoke, condition);
-}
-
void InstructionSimplifierVisitor::SimplifyFP2Int(HInvoke* invoke) {
DCHECK(invoke->IsInvokeStaticOrDirect());
uint32_t dex_pc = invoke->GetDexPc();
@@ -2355,25 +2291,14 @@
GetGraph()->SetHasBoundsChecks(true);
}
-void InstructionSimplifierVisitor::SimplifyStringIsEmptyOrLength(HInvoke* invoke) {
+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);
- HInstruction* replacement;
- if (invoke->GetIntrinsic() == Intrinsics::kStringIsEmpty) {
- // For String.isEmpty(), create the `HEqual` representing the `length == 0`.
- invoke->GetBlock()->InsertInstructionBefore(length, invoke);
- HIntConstant* zero = GetGraph()->GetIntConstant(0);
- HEqual* equal = new (GetGraph()->GetAllocator()) HEqual(length, zero, dex_pc);
- replacement = equal;
- } else {
- DCHECK_EQ(invoke->GetIntrinsic(), Intrinsics::kStringLength);
- replacement = length;
- }
- invoke->GetBlock()->ReplaceAndRemoveInstructionWith(invoke, replacement);
+ invoke->GetBlock()->ReplaceAndRemoveInstructionWith(invoke, length);
}
void InstructionSimplifierVisitor::SimplifyStringIndexOf(HInvoke* invoke) {
@@ -2663,35 +2588,6 @@
}
}
-void InstructionSimplifierVisitor::SimplifyMemBarrier(HInvoke* invoke,
- MemBarrierKind barrier_kind) {
- uint32_t dex_pc = invoke->GetDexPc();
- HMemoryBarrier* mem_barrier =
- new (GetGraph()->GetAllocator()) HMemoryBarrier(barrier_kind, dex_pc);
- invoke->GetBlock()->ReplaceAndRemoveInstructionWith(invoke, mem_barrier);
-}
-
-void InstructionSimplifierVisitor::SimplifyMin(HInvoke* invoke, DataType::Type type) {
- DCHECK(invoke->IsInvokeStaticOrDirect());
- HMin* min = new (GetGraph()->GetAllocator())
- HMin(type, invoke->InputAt(0), invoke->InputAt(1), invoke->GetDexPc());
- invoke->GetBlock()->ReplaceAndRemoveInstructionWith(invoke, min);
-}
-
-void InstructionSimplifierVisitor::SimplifyMax(HInvoke* invoke, DataType::Type type) {
- DCHECK(invoke->IsInvokeStaticOrDirect());
- HMax* max = new (GetGraph()->GetAllocator())
- HMax(type, invoke->InputAt(0), invoke->InputAt(1), invoke->GetDexPc());
- invoke->GetBlock()->ReplaceAndRemoveInstructionWith(invoke, max);
-}
-
-void InstructionSimplifierVisitor::SimplifyAbs(HInvoke* invoke, DataType::Type type) {
- DCHECK(invoke->IsInvokeStaticOrDirect());
- HAbs* abs = new (GetGraph()->GetAllocator())
- HAbs(type, invoke->InputAt(0), invoke->GetDexPc());
- invoke->GetBlock()->ReplaceAndRemoveInstructionWith(invoke, abs);
-}
-
void InstructionSimplifierVisitor::VisitInvoke(HInvoke* instruction) {
switch (instruction->GetIntrinsic()) {
case Intrinsics::kStringEquals:
@@ -2700,44 +2596,19 @@
case Intrinsics::kSystemArrayCopy:
SimplifySystemArrayCopy(instruction);
break;
- case Intrinsics::kIntegerRotateRight:
- SimplifyRotate(instruction, /* is_left= */ false, DataType::Type::kInt32);
- break;
- case Intrinsics::kLongRotateRight:
- SimplifyRotate(instruction, /* is_left= */ false, DataType::Type::kInt64);
- break;
- case Intrinsics::kIntegerRotateLeft:
- SimplifyRotate(instruction, /* is_left= */ true, DataType::Type::kInt32);
- break;
- case Intrinsics::kLongRotateLeft:
- SimplifyRotate(instruction, /* is_left= */ true, DataType::Type::kInt64);
- break;
- case Intrinsics::kIntegerCompare:
- SimplifyCompare(instruction, /* is_signum= */ false, DataType::Type::kInt32);
- break;
- case Intrinsics::kLongCompare:
- SimplifyCompare(instruction, /* is_signum= */ false, DataType::Type::kInt64);
- break;
- case Intrinsics::kIntegerSignum:
- SimplifyCompare(instruction, /* is_signum= */ true, DataType::Type::kInt32);
- break;
- case Intrinsics::kLongSignum:
- SimplifyCompare(instruction, /* is_signum= */ true, DataType::Type::kInt64);
- break;
- case Intrinsics::kFloatIsNaN:
- case Intrinsics::kDoubleIsNaN:
- SimplifyIsNaN(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::kStringIsEmpty:
case Intrinsics::kStringLength:
- SimplifyStringIsEmptyOrLength(instruction);
+ // 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:
@@ -2764,66 +2635,40 @@
case Intrinsics::kStringBuilderToString:
SimplifyAllocationIntrinsic(instruction);
break;
+ case Intrinsics::kIntegerRotateRight:
+ case Intrinsics::kLongRotateRight:
+ case Intrinsics::kIntegerRotateLeft:
+ case Intrinsics::kLongRotateLeft:
+ case Intrinsics::kIntegerCompare:
+ case Intrinsics::kLongCompare:
+ case Intrinsics::kIntegerSignum:
+ case Intrinsics::kLongSignum:
+ case Intrinsics::kFloatIsNaN:
+ case Intrinsics::kDoubleIsNaN:
+ case Intrinsics::kStringIsEmpty:
case Intrinsics::kUnsafeLoadFence:
- SimplifyMemBarrier(instruction, MemBarrierKind::kLoadAny);
- break;
case Intrinsics::kUnsafeStoreFence:
- SimplifyMemBarrier(instruction, MemBarrierKind::kAnyStore);
- break;
case Intrinsics::kUnsafeFullFence:
- SimplifyMemBarrier(instruction, MemBarrierKind::kAnyAny);
- break;
case Intrinsics::kVarHandleFullFence:
- SimplifyMemBarrier(instruction, MemBarrierKind::kAnyAny);
- break;
case Intrinsics::kVarHandleAcquireFence:
- SimplifyMemBarrier(instruction, MemBarrierKind::kLoadAny);
- break;
case Intrinsics::kVarHandleReleaseFence:
- SimplifyMemBarrier(instruction, MemBarrierKind::kAnyStore);
- break;
case Intrinsics::kVarHandleLoadLoadFence:
- SimplifyMemBarrier(instruction, MemBarrierKind::kLoadAny);
- break;
case Intrinsics::kVarHandleStoreStoreFence:
- SimplifyMemBarrier(instruction, MemBarrierKind::kStoreStore);
- break;
case Intrinsics::kMathMinIntInt:
- SimplifyMin(instruction, DataType::Type::kInt32);
- break;
case Intrinsics::kMathMinLongLong:
- SimplifyMin(instruction, DataType::Type::kInt64);
- break;
case Intrinsics::kMathMinFloatFloat:
- SimplifyMin(instruction, DataType::Type::kFloat32);
- break;
case Intrinsics::kMathMinDoubleDouble:
- SimplifyMin(instruction, DataType::Type::kFloat64);
- break;
case Intrinsics::kMathMaxIntInt:
- SimplifyMax(instruction, DataType::Type::kInt32);
- break;
case Intrinsics::kMathMaxLongLong:
- SimplifyMax(instruction, DataType::Type::kInt64);
- break;
case Intrinsics::kMathMaxFloatFloat:
- SimplifyMax(instruction, DataType::Type::kFloat32);
- break;
case Intrinsics::kMathMaxDoubleDouble:
- SimplifyMax(instruction, DataType::Type::kFloat64);
- break;
case Intrinsics::kMathAbsInt:
- SimplifyAbs(instruction, DataType::Type::kInt32);
- break;
case Intrinsics::kMathAbsLong:
- SimplifyAbs(instruction, DataType::Type::kInt64);
- break;
case Intrinsics::kMathAbsFloat:
- SimplifyAbs(instruction, DataType::Type::kFloat32);
- break;
case Intrinsics::kMathAbsDouble:
- SimplifyAbs(instruction, DataType::Type::kFloat64);
- break;
+ // These are replaced by intermediate representation in the instruction builder.
+ LOG(FATAL) << "Unexpected " << static_cast<Intrinsics>(instruction->GetIntrinsic());
+ UNREACHABLE();
default:
break;
}
diff --git a/compiler/optimizing/nodes.h b/compiler/optimizing/nodes.h
index 611e0e7..3427893 100644
--- a/compiler/optimizing/nodes.h
+++ b/compiler/optimizing/nodes.h
@@ -4149,8 +4149,6 @@
SideEffectsForArchRuntimeCalls(comparison_type),
dex_pc) {
SetPackedField<ComparisonBiasField>(bias);
- DCHECK_EQ(comparison_type, DataType::Kind(first->GetType()));
- DCHECK_EQ(comparison_type, DataType::Kind(second->GetType()));
}
template <typename T>
@@ -5542,8 +5540,6 @@
public:
HRor(DataType::Type result_type, HInstruction* value, HInstruction* distance)
: HBinaryOperation(kRor, result_type, value, distance) {
- DCHECK_EQ(result_type, DataType::Kind(value->GetType()));
- DCHECK_EQ(DataType::Type::kInt32, DataType::Kind(distance->GetType()));
}
template <typename T>