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>
diff --git a/test/004-checker-UnsafeTest18/src/Main.java b/test/004-checker-UnsafeTest18/src/Main.java
index 927d0da..26e76ea 100644
--- a/test/004-checker-UnsafeTest18/src/Main.java
+++ b/test/004-checker-UnsafeTest18/src/Main.java
@@ -91,36 +91,27 @@
//
/// CHECK-START: void Main.load() builder (after)
- /// CHECK-DAG: InvokeVirtual intrinsic:UnsafeLoadFence
+ /// CHECK-NOT: InvokeVirtual
//
- /// CHECK-START: void Main.load() instruction_simplifier (after)
- /// CHECK-NOT: InvokeVirtual intrinsic:UnsafeLoadFence
- //
- /// CHECK-START: void Main.load() instruction_simplifier (after)
+ /// CHECK-START: void Main.load() builder (after)
/// CHECK-DAG: MemoryBarrier kind:LoadAny
private static void load() {
unsafe.loadFence();
}
/// CHECK-START: void Main.store() builder (after)
- /// CHECK-DAG: InvokeVirtual intrinsic:UnsafeStoreFence
+ /// CHECK-NOT: InvokeVirtual
//
- /// CHECK-START: void Main.store() instruction_simplifier (after)
- /// CHECK-NOT: InvokeVirtual intrinsic:UnsafeStoreFence
- //
- /// CHECK-START: void Main.store() instruction_simplifier (after)
+ /// CHECK-START: void Main.store() builder (after)
/// CHECK-DAG: MemoryBarrier kind:AnyStore
private static void store() {
unsafe.storeFence();
}
/// CHECK-START: void Main.full() builder (after)
- /// CHECK-DAG: InvokeVirtual intrinsic:UnsafeFullFence
+ /// CHECK-NOT: InvokeVirtual
//
- /// CHECK-START: void Main.full() instruction_simplifier (after)
- /// CHECK-NOT: InvokeVirtual intrinsic:UnsafeFullFence
- //
- /// CHECK-START: void Main.full() instruction_simplifier (after)
+ /// CHECK-START: void Main.full() builder (after)
/// CHECK-DAG: MemoryBarrier kind:AnyAny
private static void full() {
unsafe.fullFence();
diff --git a/test/441-checker-inliner/src/Main.java b/test/441-checker-inliner/src/Main.java
index 6c75962..1dfe5f6 100644
--- a/test/441-checker-inliner/src/Main.java
+++ b/test/441-checker-inliner/src/Main.java
@@ -136,7 +136,7 @@
}
/// CHECK-START: int Main.returnAbs(int) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:MathAbsInt
+ /// CHECK-DAG: <<Result:i\d+>> Abs
/// CHECK-DAG: Return [<<Result>>]
private static int returnAbs(int i) {
diff --git a/test/445-checker-licm/src/Main.java b/test/445-checker-licm/src/Main.java
index 517aacd..5f2c4ea 100644
--- a/test/445-checker-licm/src/Main.java
+++ b/test/445-checker-licm/src/Main.java
@@ -153,9 +153,6 @@
return result;
}
- /// CHECK-START: int Main.invariantBoundIntrinsic(int) instruction_simplifier (before)
- /// CHECK-DAG: InvokeStaticOrDirect loop:{{B\d+}}
- //
/// CHECK-START: int Main.invariantBoundIntrinsic(int) licm (before)
/// CHECK-DAG: Abs loop:{{B\d+}}
@@ -175,9 +172,6 @@
return result;
}
- /// CHECK-START: int Main.invariantBodyIntrinsic(int, int) instruction_simplifier (before)
- /// CHECK-DAG: InvokeStaticOrDirect loop:{{B\d+}}
-
/// CHECK-START: int Main.invariantBodyIntrinsic(int, int) licm (before)
/// CHECK-DAG: Max loop:{{B\d+}}
diff --git a/test/536-checker-intrinsic-optimization/smali/SmaliTests.smali b/test/536-checker-intrinsic-optimization/smali/SmaliTests.smali
index 87aca6f..53b52f7 100644
--- a/test/536-checker-intrinsic-optimization/smali/SmaliTests.smali
+++ b/test/536-checker-intrinsic-optimization/smali/SmaliTests.smali
@@ -15,11 +15,7 @@
.class public LSmaliTests;
.super Ljava/lang/Object;
-## CHECK-START: char SmaliTests.$noinline$stringCharAtCatch(java.lang.String, int) instruction_simplifier (before)
-## CHECK-DAG: <<Char:c\d+>> InvokeVirtual intrinsic:StringCharAt
-## CHECK-DAG: Return [<<Char>>]
-
-## CHECK-START: char SmaliTests.$noinline$stringCharAtCatch(java.lang.String, int) instruction_simplifier (after)
+## CHECK-START: char SmaliTests.$noinline$stringCharAtCatch(java.lang.String, int) builder (after)
## CHECK-DAG: <<String:l\d+>> ParameterValue
## CHECK-DAG: <<Pos:i\d+>> ParameterValue
## CHECK-DAG: <<NullCk:l\d+>> NullCheck [<<String>>]
@@ -54,13 +50,7 @@
return v1
.end method
-## CHECK-START: char SmaliTests.stringCharAtCatchPhiReturn(java.lang.String, int) instruction_simplifier (before)
-## CHECK-DAG: <<Int:i\d+>> IntConstant 0
-## CHECK-DAG: <<Char:c\d+>> InvokeVirtual intrinsic:StringCharAt
-## CHECK-DAG: <<Phi:i\d+>> Phi [<<Char>>,<<Int>>]
-## CHECK-DAG: Return [<<Phi>>]
-
-## CHECK-START: char SmaliTests.stringCharAtCatchPhiReturn(java.lang.String, int) instruction_simplifier (after)
+## CHECK-START: char SmaliTests.stringCharAtCatchPhiReturn(java.lang.String, int) builder (after)
## CHECK-DAG: <<String:l\d+>> ParameterValue
## CHECK-DAG: <<Pos:i\d+>> ParameterValue
## CHECK-DAG: <<Int:i\d+>> IntConstant 0
diff --git a/test/536-checker-intrinsic-optimization/src/Main.java b/test/536-checker-intrinsic-optimization/src/Main.java
index 980df70..711920e 100644
--- a/test/536-checker-intrinsic-optimization/src/Main.java
+++ b/test/536-checker-intrinsic-optimization/src/Main.java
@@ -152,28 +152,20 @@
}
}
- /// CHECK-START: int Main.$opt$noinline$getStringLength(java.lang.String) instruction_simplifier (before)
- /// CHECK-DAG: <<Length:i\d+>> InvokeVirtual intrinsic:StringLength
- /// CHECK-DAG: Return [<<Length>>]
-
- /// CHECK-START: int Main.$opt$noinline$getStringLength(java.lang.String) instruction_simplifier (after)
+ /// CHECK-START: int Main.$opt$noinline$getStringLength(java.lang.String) builder (after)
/// CHECK-DAG: <<String:l\d+>> ParameterValue
/// CHECK-DAG: <<NullCk:l\d+>> NullCheck [<<String>>]
/// CHECK-DAG: <<Length:i\d+>> ArrayLength [<<NullCk>>] is_string_length:true
/// CHECK-DAG: Return [<<Length>>]
- /// CHECK-START: int Main.$opt$noinline$getStringLength(java.lang.String) instruction_simplifier (after)
- /// CHECK-NOT: InvokeVirtual intrinsic:StringLength
+ /// CHECK-START: int Main.$opt$noinline$getStringLength(java.lang.String) builder (after)
+ /// CHECK-NOT: InvokeVirtual
static public int $opt$noinline$getStringLength(String s) {
return s.length();
}
- /// CHECK-START: boolean Main.$opt$noinline$isStringEmpty(java.lang.String) instruction_simplifier (before)
- /// CHECK-DAG: <<IsEmpty:z\d+>> InvokeVirtual intrinsic:StringIsEmpty
- /// CHECK-DAG: Return [<<IsEmpty>>]
-
- /// CHECK-START: boolean Main.$opt$noinline$isStringEmpty(java.lang.String) instruction_simplifier (after)
+ /// CHECK-START: boolean Main.$opt$noinline$isStringEmpty(java.lang.String) builder (after)
/// CHECK-DAG: <<String:l\d+>> ParameterValue
/// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
/// CHECK-DAG: <<NullCk:l\d+>> NullCheck [<<String>>]
@@ -181,18 +173,14 @@
/// CHECK-DAG: <<IsEmpty:z\d+>> Equal [<<Length>>,<<Const0>>]
/// CHECK-DAG: Return [<<IsEmpty>>]
- /// CHECK-START: boolean Main.$opt$noinline$isStringEmpty(java.lang.String) instruction_simplifier (after)
- /// CHECK-NOT: InvokeVirtual intrinsic:StringIsEmpty
+ /// CHECK-START: boolean Main.$opt$noinline$isStringEmpty(java.lang.String) builder (after)
+ /// CHECK-NOT: InvokeVirtual
static public boolean $opt$noinline$isStringEmpty(String s) {
return s.isEmpty();
}
- /// CHECK-START: char Main.$opt$noinline$stringCharAt(java.lang.String, int) instruction_simplifier (before)
- /// CHECK-DAG: <<Char:c\d+>> InvokeVirtual intrinsic:StringCharAt
- /// CHECK-DAG: Return [<<Char>>]
-
- /// CHECK-START: char Main.$opt$noinline$stringCharAt(java.lang.String, int) instruction_simplifier (after)
+ /// CHECK-START: char Main.$opt$noinline$stringCharAt(java.lang.String, int) builder (after)
/// CHECK-DAG: <<String:l\d+>> ParameterValue
/// CHECK-DAG: <<Pos:i\d+>> ParameterValue
/// CHECK-DAG: <<NullCk:l\d+>> NullCheck [<<String>>]
@@ -201,23 +189,14 @@
/// CHECK-DAG: <<Char:c\d+>> ArrayGet [<<NullCk>>,<<Bounds>>] is_string_char_at:true
/// CHECK-DAG: Return [<<Char>>]
- /// CHECK-START: char Main.$opt$noinline$stringCharAt(java.lang.String, int) instruction_simplifier (after)
- /// CHECK-NOT: InvokeVirtual intrinsic:StringCharAt
+ /// CHECK-START: char Main.$opt$noinline$stringCharAt(java.lang.String, int) builder (after)
+ /// CHECK-NOT: InvokeVirtual
static public char $opt$noinline$stringCharAt(String s, int pos) {
return s.charAt(pos);
}
- /// CHECK-START: char Main.$opt$noinline$stringCharAtCatch(java.lang.String, int) instruction_simplifier (before)
- /// CHECK-DAG: <<Int:i\d+>> IntConstant 0
- /// CHECK-DAG: <<Char:c\d+>> InvokeVirtual intrinsic:StringCharAt
-
- // The return value can come from a Phi should the two returns be merged.
- // Please refer to the Smali code for a more detailed verification.
-
- /// CHECK-DAG: Return [{{(c|i)\d+}}]
-
- /// CHECK-START: char Main.$opt$noinline$stringCharAtCatch(java.lang.String, int) instruction_simplifier (after)
+ /// CHECK-START: char Main.$opt$noinline$stringCharAtCatch(java.lang.String, int) builder (after)
/// CHECK-DAG: <<String:l\d+>> ParameterValue
/// CHECK-DAG: <<Pos:i\d+>> ParameterValue
/// CHECK-DAG: <<Int:i\d+>> IntConstant 0
@@ -227,8 +206,8 @@
/// CHECK-DAG: <<Char:c\d+>> ArrayGet [<<NullCk>>,<<Bounds>>] is_string_char_at:true
/// CHECK-DAG: Return [{{(c|i)\d+}}]
- /// CHECK-START: char Main.$opt$noinline$stringCharAtCatch(java.lang.String, int) instruction_simplifier (after)
- /// CHECK-NOT: InvokeVirtual intrinsic:StringCharAt
+ /// CHECK-START: char Main.$opt$noinline$stringCharAtCatch(java.lang.String, int) builder (after)
+ /// CHECK-NOT: InvokeVirtual
static public char $opt$noinline$stringCharAtCatch(String s, int pos) {
try {
@@ -238,19 +217,14 @@
}
}
- /// CHECK-START: int Main.$opt$noinline$stringSumChars(java.lang.String) instruction_simplifier (before)
- /// CHECK-DAG: InvokeVirtual intrinsic:StringLength
- /// CHECK-DAG: InvokeVirtual intrinsic:StringCharAt
-
- /// CHECK-START: int Main.$opt$noinline$stringSumChars(java.lang.String) instruction_simplifier (after)
+ /// CHECK-START: int Main.$opt$noinline$stringSumChars(java.lang.String) builder (after)
/// CHECK-DAG: ArrayLength is_string_length:true
/// CHECK-DAG: ArrayLength is_string_length:true
/// CHECK-DAG: BoundsCheck is_string_char_at:true
/// CHECK-DAG: ArrayGet is_string_char_at:true
- /// CHECK-START: int Main.$opt$noinline$stringSumChars(java.lang.String) instruction_simplifier (after)
- /// CHECK-NOT: InvokeVirtual intrinsic:StringLength
- /// CHECK-NOT: InvokeVirtual intrinsic:StringCharAt
+ /// CHECK-START: int Main.$opt$noinline$stringSumChars(java.lang.String) builder (after)
+ /// CHECK-NOT: InvokeVirtual
/// CHECK-START: int Main.$opt$noinline$stringSumChars(java.lang.String) GVN (after)
/// CHECK-DAG: ArrayLength is_string_length:true
@@ -268,16 +242,13 @@
return sum;
}
- /// CHECK-START: int Main.$opt$noinline$stringSumLeadingChars(java.lang.String, int) instruction_simplifier (before)
- /// CHECK-DAG: InvokeVirtual intrinsic:StringCharAt
-
- /// CHECK-START: int Main.$opt$noinline$stringSumLeadingChars(java.lang.String, int) instruction_simplifier (after)
+ /// CHECK-START: int Main.$opt$noinline$stringSumLeadingChars(java.lang.String, int) builder (after)
/// CHECK-DAG: ArrayLength is_string_length:true
/// CHECK-DAG: BoundsCheck is_string_char_at:true
/// CHECK-DAG: ArrayGet is_string_char_at:true
- /// CHECK-START: int Main.$opt$noinline$stringSumLeadingChars(java.lang.String, int) instruction_simplifier (after)
- /// CHECK-NOT: InvokeVirtual intrinsic:StringCharAt
+ /// CHECK-START: int Main.$opt$noinline$stringSumLeadingChars(java.lang.String, int) builder (after)
+ /// CHECK-NOT: InvokeVirtual
/// CHECK-START: int Main.$opt$noinline$stringSumLeadingChars(java.lang.String, int) BCE (after)
/// CHECK-DAG: Deoptimize env:[[{{[^\]]*}}]]
@@ -293,13 +264,7 @@
return sum;
}
- /// CHECK-START: int Main.$opt$noinline$stringSum4LeadingChars(java.lang.String) instruction_simplifier (before)
- /// CHECK-DAG: InvokeVirtual intrinsic:StringCharAt
- /// CHECK-DAG: InvokeVirtual intrinsic:StringCharAt
- /// CHECK-DAG: InvokeVirtual intrinsic:StringCharAt
- /// CHECK-DAG: InvokeVirtual intrinsic:StringCharAt
-
- /// CHECK-START: int Main.$opt$noinline$stringSum4LeadingChars(java.lang.String) instruction_simplifier (after)
+ /// CHECK-START: int Main.$opt$noinline$stringSum4LeadingChars(java.lang.String) builder (after)
/// CHECK-DAG: ArrayLength is_string_length:true
/// CHECK-DAG: BoundsCheck is_string_char_at:true
/// CHECK-DAG: ArrayGet is_string_char_at:true
@@ -313,8 +278,8 @@
/// CHECK-DAG: BoundsCheck is_string_char_at:true
/// CHECK-DAG: ArrayGet is_string_char_at:true
- /// CHECK-START: int Main.$opt$noinline$stringSum4LeadingChars(java.lang.String) instruction_simplifier (after)
- /// CHECK-NOT: InvokeVirtual intrinsic:StringCharAt
+ /// CHECK-START: int Main.$opt$noinline$stringSum4LeadingChars(java.lang.String) builder (after)
+ /// CHECK-NOT: InvokeVirtual
/// CHECK-START: int Main.$opt$noinline$stringSum4LeadingChars(java.lang.String) BCE (after)
/// CHECK-DAG: Deoptimize env:[[{{[^\]]*}}]]
diff --git a/test/557-checker-instruct-simplifier-ror/src/Main.java b/test/557-checker-instruct-simplifier-ror/src/Main.java
index 3631353..1c52f07 100644
--- a/test/557-checker-instruct-simplifier-ror/src/Main.java
+++ b/test/557-checker-instruct-simplifier-ror/src/Main.java
@@ -28,82 +28,62 @@
}
}
- /// CHECK-START: int Main.rotateIntegerRight(int, int) instruction_simplifier (before)
- /// CHECK: <<ArgValue:i\d+>> ParameterValue
- /// CHECK: <<ArgDistance:i\d+>> ParameterValue
- /// CHECK: <<Invoke:i\d+>> InvokeStaticOrDirect intrinsic:IntegerRotateRight
-
- /// CHECK-START: int Main.rotateIntegerRight(int, int) instruction_simplifier (after)
+ /// CHECK-START: int Main.rotateIntegerRight(int, int) builder (after)
/// CHECK: <<ArgValue:i\d+>> ParameterValue
/// CHECK: <<ArgDistance:i\d+>> ParameterValue
/// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<ArgDistance>>]
/// CHECK: Return [<<Ror>>]
- /// CHECK-START: int Main.rotateIntegerRight(int, int) instruction_simplifier (after)
+ /// CHECK-START: int Main.rotateIntegerRight(int, int) builder (after)
/// CHECK-NOT: LoadClass
/// CHECK-NOT: ClinitCheck
/// CHECK-NOT: InvokeStaticOrDirect
public static int rotateIntegerRight(int value, int distance) {
- return java.lang.Integer.rotateRight(value, distance);
+ return Integer.rotateRight(value, distance);
}
- /// CHECK-START: int Main.rotateIntegerLeft(int, int) instruction_simplifier (before)
- /// CHECK: <<ArgValue:i\d+>> ParameterValue
- /// CHECK: <<ArgDistance:i\d+>> ParameterValue
- /// CHECK: <<Invoke:i\d+>> InvokeStaticOrDirect intrinsic:IntegerRotateLeft
-
- /// CHECK-START: int Main.rotateIntegerLeft(int, int) instruction_simplifier (after)
+ /// CHECK-START: int Main.rotateIntegerLeft(int, int) builder (after)
/// CHECK: <<ArgValue:i\d+>> ParameterValue
/// CHECK: <<ArgDistance:i\d+>> ParameterValue
/// CHECK: <<Neg:i\d+>> Neg [<<ArgDistance>>]
/// CHECK: <<Ror:i\d+>> Ror [<<ArgValue>>,<<Neg>>]
/// CHECK: Return [<<Ror>>]
- /// CHECK-START: int Main.rotateIntegerLeft(int, int) instruction_simplifier (after)
+ /// CHECK-START: int Main.rotateIntegerLeft(int, int) builder (after)
/// CHECK-NOT: LoadClass
/// CHECK-NOT: ClinitCheck
/// CHECK-NOT: InvokeStaticOrDirect
public static int rotateIntegerLeft(int value, int distance) {
- return java.lang.Integer.rotateLeft(value, distance);
+ return Integer.rotateLeft(value, distance);
}
- /// CHECK-START: long Main.rotateLongRight(long, int) instruction_simplifier (before)
- /// CHECK: <<ArgValue:j\d+>> ParameterValue
- /// CHECK: <<ArgDistance:i\d+>> ParameterValue
- /// CHECK: <<Invoke:j\d+>> InvokeStaticOrDirect intrinsic:LongRotateRight
-
- /// CHECK-START: long Main.rotateLongRight(long, int) instruction_simplifier (after)
+ /// CHECK-START: long Main.rotateLongRight(long, int) builder (after)
/// CHECK: <<ArgValue:j\d+>> ParameterValue
/// CHECK: <<ArgDistance:i\d+>> ParameterValue
/// CHECK: <<Ror:j\d+>> Ror [<<ArgValue>>,<<ArgDistance>>]
/// CHECK: Return [<<Ror>>]
- /// CHECK-START: long Main.rotateLongRight(long, int) instruction_simplifier (after)
+ /// CHECK-START: long Main.rotateLongRight(long, int) builder (after)
/// CHECK-NOT: LoadClass
/// CHECK-NOT: ClinitCheck
/// CHECK-NOT: InvokeStaticOrDirect
public static long rotateLongRight(long value, int distance) {
- return java.lang.Long.rotateRight(value, distance);
+ return Long.rotateRight(value, distance);
}
- /// CHECK-START: long Main.rotateLongLeft(long, int) instruction_simplifier (before)
- /// CHECK: <<ArgValue:j\d+>> ParameterValue
- /// CHECK: <<ArgDistance:i\d+>> ParameterValue
- /// CHECK: <<Invoke:j\d+>> InvokeStaticOrDirect intrinsic:LongRotateLeft
-
- /// CHECK-START: long Main.rotateLongLeft(long, int) instruction_simplifier (after)
+ /// CHECK-START: long Main.rotateLongLeft(long, int) builder (after)
/// CHECK: <<ArgValue:j\d+>> ParameterValue
/// CHECK: <<ArgDistance:i\d+>> ParameterValue
/// CHECK: <<Neg:i\d+>> Neg [<<ArgDistance>>]
/// CHECK: <<Ror:j\d+>> Ror [<<ArgValue>>,<<Neg>>]
/// CHECK: Return [<<Ror>>]
- /// CHECK-START: long Main.rotateLongLeft(long, int) instruction_simplifier (after)
+ /// CHECK-START: long Main.rotateLongLeft(long, int) builder (after)
/// CHECK-NOT: LoadClass
/// CHECK-NOT: ClinitCheck
/// CHECK-NOT: InvokeStaticOrDirect
public static long rotateLongLeft(long value, int distance) {
- return java.lang.Long.rotateLeft(value, distance);
+ return Long.rotateLeft(value, distance);
}
// (i >>> #distance) | (i << #(reg_bits - distance))
diff --git a/test/565-checker-rotate/smali/Main2.smali b/test/565-checker-rotate/smali/Main2.smali
index 768c9d0..4b9e1cd 100644
--- a/test/565-checker-rotate/smali/Main2.smali
+++ b/test/565-checker-rotate/smali/Main2.smali
@@ -21,20 +21,11 @@
## CHECK-DAG: <<Zero:i\d+>> IntConstant 0
## CHECK-DAG: <<One:i\d+>> IntConstant 1
## CHECK-DAG: <<Val:i\d+>> Phi [<<One>>,<<Zero>>]
-## CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<Val>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateLeft
-## CHECK-DAG: Return [<<Result>>]
-
-## CHECK-START: int Main2.rotateLeftBoolean(boolean, int) instruction_simplifier (after)
-## CHECK: <<ArgVal:z\d+>> ParameterValue
-## CHECK: <<ArgDist:i\d+>> ParameterValue
-## CHECK-DAG: <<Zero:i\d+>> IntConstant 0
-## CHECK-DAG: <<One:i\d+>> IntConstant 1
-## CHECK-DAG: <<Val:i\d+>> Phi [<<One>>,<<Zero>>]
## CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
## CHECK-DAG: <<Result:i\d+>> Ror [<<Val>>,<<NegDist>>]
## CHECK-DAG: Return [<<Result>>]
-## CHECK-START: int Main2.rotateLeftBoolean(boolean, int) instruction_simplifier (after)
+## CHECK-START: int Main2.rotateLeftBoolean(boolean, int) builder (after)
## CHECK-NOT: InvokeStaticOrDirect
## CHECK-START: int Main2.rotateLeftBoolean(boolean, int) select_generator (after)
@@ -96,19 +87,10 @@
## CHECK-DAG: <<Zero:i\d+>> IntConstant 0
## CHECK-DAG: <<One:i\d+>> IntConstant 1
## CHECK-DAG: <<Val:i\d+>> Phi [<<One>>,<<Zero>>]
-## CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<Val>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateRight
-## CHECK-DAG: Return [<<Result>>]
-
-## CHECK-START: int Main2.rotateRightBoolean(boolean, int) instruction_simplifier (after)
-## CHECK: <<ArgVal:z\d+>> ParameterValue
-## CHECK: <<ArgDist:i\d+>> ParameterValue
-## CHECK-DAG: <<Zero:i\d+>> IntConstant 0
-## CHECK-DAG: <<One:i\d+>> IntConstant 1
-## CHECK-DAG: <<Val:i\d+>> Phi [<<One>>,<<Zero>>]
## CHECK-DAG: <<Result:i\d+>> Ror [<<Val>>,<<ArgDist>>]
## CHECK-DAG: Return [<<Result>>]
-## CHECK-START: int Main2.rotateRightBoolean(boolean, int) instruction_simplifier (after)
+## CHECK-START: int Main2.rotateRightBoolean(boolean, int) builder (after)
## CHECK-NOT: InvokeStaticOrDirect
## CHECK-START: int Main2.rotateRightBoolean(boolean, int) select_generator (after)
diff --git a/test/565-checker-rotate/src-art/Main.java b/test/565-checker-rotate/src-art/Main.java
index 867feb8..3dc7709 100644
--- a/test/565-checker-rotate/src-art/Main.java
+++ b/test/565-checker-rotate/src-art/Main.java
@@ -23,17 +23,11 @@
/// CHECK-START: int Main.rotateLeftByte(byte, int) builder (after)
/// CHECK: <<ArgVal:b\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateLeft
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.rotateLeftByte(byte, int) instruction_simplifier (after)
- /// CHECK: <<ArgVal:b\d+>> ParameterValue
- /// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<NegDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateLeftByte(byte, int) instruction_simplifier (after)
+ /// CHECK-START: int Main.rotateLeftByte(byte, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateLeftByte(byte value, int distance) {
@@ -43,17 +37,11 @@
/// CHECK-START: int Main.rotateLeftShort(short, int) builder (after)
/// CHECK: <<ArgVal:s\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateLeft
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.rotateLeftShort(short, int) instruction_simplifier (after)
- /// CHECK: <<ArgVal:s\d+>> ParameterValue
- /// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<NegDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateLeftShort(short, int) instruction_simplifier (after)
+ /// CHECK-START: int Main.rotateLeftShort(short, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateLeftShort(short value, int distance) {
@@ -63,17 +51,11 @@
/// CHECK-START: int Main.rotateLeftChar(char, int) builder (after)
/// CHECK: <<ArgVal:c\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateLeft
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.rotateLeftChar(char, int) instruction_simplifier (after)
- /// CHECK: <<ArgVal:c\d+>> ParameterValue
- /// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<NegDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateLeftChar(char, int) instruction_simplifier (after)
+ /// CHECK-START: int Main.rotateLeftChar(char, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateLeftChar(char value, int distance) {
@@ -83,17 +65,11 @@
/// CHECK-START: int Main.rotateLeftInt(int, int) builder (after)
/// CHECK: <<ArgVal:i\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateLeft
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.rotateLeftInt(int, int) instruction_simplifier (after)
- /// CHECK: <<ArgVal:i\d+>> ParameterValue
- /// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<NegDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateLeftInt(int, int) instruction_simplifier (after)
+ /// CHECK-START: int Main.rotateLeftInt(int, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateLeftInt(int value, int distance) {
@@ -103,17 +79,11 @@
/// CHECK-START: long Main.rotateLeftLong(long, int) builder (after)
/// CHECK: <<ArgVal:j\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
- /// CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:LongRotateLeft
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: long Main.rotateLeftLong(long, int) instruction_simplifier (after)
- /// CHECK: <<ArgVal:j\d+>> ParameterValue
- /// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
/// CHECK-DAG: <<Result:j\d+>> Ror [<<ArgVal>>,<<NegDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: long Main.rotateLeftLong(long, int) instruction_simplifier (after)
+ /// CHECK-START: long Main.rotateLeftLong(long, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static long rotateLeftLong(long value, int distance) {
@@ -123,16 +93,10 @@
/// CHECK-START: int Main.rotateRightByte(byte, int) builder (after)
/// CHECK: <<ArgVal:b\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateRight
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.rotateRightByte(byte, int) instruction_simplifier (after)
- /// CHECK: <<ArgVal:b\d+>> ParameterValue
- /// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateRightByte(byte, int) instruction_simplifier (after)
+ /// CHECK-START: int Main.rotateRightByte(byte, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateRightByte(byte value, int distance) {
@@ -142,16 +106,10 @@
/// CHECK-START: int Main.rotateRightShort(short, int) builder (after)
/// CHECK: <<ArgVal:s\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateRight
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.rotateRightShort(short, int) instruction_simplifier (after)
- /// CHECK: <<ArgVal:s\d+>> ParameterValue
- /// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateRightShort(short, int) instruction_simplifier (after)
+ /// CHECK-START: int Main.rotateRightShort(short, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateRightShort(short value, int distance) {
@@ -161,16 +119,10 @@
/// CHECK-START: int Main.rotateRightChar(char, int) builder (after)
/// CHECK: <<ArgVal:c\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateRight
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.rotateRightChar(char, int) instruction_simplifier (after)
- /// CHECK: <<ArgVal:c\d+>> ParameterValue
- /// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateRightChar(char, int) instruction_simplifier (after)
+ /// CHECK-START: int Main.rotateRightChar(char, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateRightChar(char value, int distance) {
@@ -180,16 +132,10 @@
/// CHECK-START: int Main.rotateRightInt(int, int) builder (after)
/// CHECK: <<ArgVal:i\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateRight
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.rotateRightInt(int, int) instruction_simplifier (after)
- /// CHECK: <<ArgVal:i\d+>> ParameterValue
- /// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateRightInt(int, int) instruction_simplifier (after)
+ /// CHECK-START: int Main.rotateRightInt(int, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateRightInt(int value, int distance) {
@@ -199,16 +145,10 @@
/// CHECK-START: long Main.rotateRightLong(long, int) builder (after)
/// CHECK: <<ArgVal:j\d+>> ParameterValue
/// CHECK: <<ArgDist:i\d+>> ParameterValue
- /// CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:LongRotateRight
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: long Main.rotateRightLong(long, int) instruction_simplifier (after)
- /// CHECK: <<ArgVal:j\d+>> ParameterValue
- /// CHECK: <<ArgDist:i\d+>> ParameterValue
/// CHECK-DAG: <<Result:j\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: long Main.rotateRightLong(long, int) instruction_simplifier (after)
+ /// CHECK-START: long Main.rotateRightLong(long, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static long rotateRightLong(long value, int distance) {
@@ -219,17 +159,11 @@
/// CHECK-START: int Main.rotateLeftIntWithByteDistance(int, byte) builder (after)
/// CHECK: <<ArgVal:i\d+>> ParameterValue
/// CHECK: <<ArgDist:b\d+>> ParameterValue
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateLeft
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.rotateLeftIntWithByteDistance(int, byte) instruction_simplifier (after)
- /// CHECK: <<ArgVal:i\d+>> ParameterValue
- /// CHECK: <<ArgDist:b\d+>> ParameterValue
/// CHECK-DAG: <<NegDist:i\d+>> Neg [<<ArgDist>>]
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<NegDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateLeftIntWithByteDistance(int, byte) instruction_simplifier (after)
+ /// CHECK-START: int Main.rotateLeftIntWithByteDistance(int, byte) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateLeftIntWithByteDistance(int value, byte distance) {
@@ -239,16 +173,10 @@
/// CHECK-START: int Main.rotateRightIntWithByteDistance(int, byte) builder (after)
/// CHECK: <<ArgVal:i\d+>> ParameterValue
/// CHECK: <<ArgDist:b\d+>> ParameterValue
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<ArgVal>>,<<ArgDist>>{{(,[ij]\d+)?}}] intrinsic:IntegerRotateRight
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.rotateRightIntWithByteDistance(int, byte) instruction_simplifier (after)
- /// CHECK: <<ArgVal:i\d+>> ParameterValue
- /// CHECK: <<ArgDist:b\d+>> ParameterValue
/// CHECK-DAG: <<Result:i\d+>> Ror [<<ArgVal>>,<<ArgDist>>]
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.rotateRightIntWithByteDistance(int, byte) instruction_simplifier (after)
+ /// CHECK-START: int Main.rotateRightIntWithByteDistance(int, byte) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int rotateRightIntWithByteDistance(int value, byte distance) {
diff --git a/test/566-checker-signum/smali/Main2.smali b/test/566-checker-signum/smali/Main2.smali
index 767bed2..66d4524 100644
--- a/test/566-checker-signum/smali/Main2.smali
+++ b/test/566-checker-signum/smali/Main2.smali
@@ -19,17 +19,10 @@
## CHECK-DAG: <<Zero:i\d+>> IntConstant 0
## CHECK-DAG: <<One:i\d+>> IntConstant 1
## CHECK-DAG: <<Phi:i\d+>> Phi [<<One>>,<<Zero>>]
-## CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<Phi>>{{(,[ij]\d+)?}}] intrinsic:IntegerSignum
-## CHECK-DAG: Return [<<Result>>]
-
-## CHECK-START: int Main2.signBoolean(boolean) instruction_simplifier (after)
-## CHECK-DAG: <<Zero:i\d+>> IntConstant 0
-## CHECK-DAG: <<One:i\d+>> IntConstant 1
-## CHECK-DAG: <<Phi:i\d+>> Phi [<<One>>,<<Zero>>]
## CHECK-DAG: <<Result:i\d+>> Compare [<<Phi>>,<<Zero>>]
## CHECK-DAG: Return [<<Result>>]
-## CHECK-START: int Main2.signBoolean(boolean) instruction_simplifier (after)
+## CHECK-START: int Main2.signBoolean(boolean) builder (after)
## CHECK-NOT: InvokeStaticOrDirect
## CHECK-START: int Main2.signBoolean(boolean) select_generator (after)
diff --git a/test/566-checker-signum/src-art/Main.java b/test/566-checker-signum/src-art/Main.java
index ea01785..9a8abb3 100644
--- a/test/566-checker-signum/src-art/Main.java
+++ b/test/566-checker-signum/src-art/Main.java
@@ -19,14 +19,10 @@
public class Main {
/// CHECK-START: int Main.signByte(byte) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerSignum
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.signByte(byte) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.signByte(byte) instruction_simplifier (after)
+ /// CHECK-START: int Main.signByte(byte) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int signByte(byte x) {
@@ -34,14 +30,10 @@
}
/// CHECK-START: int Main.signShort(short) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerSignum
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.signShort(short) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.signShort(short) instruction_simplifier (after)
+ /// CHECK-START: int Main.signShort(short) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int signShort(short x) {
@@ -49,14 +41,10 @@
}
/// CHECK-START: int Main.signChar(char) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerSignum
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.signChar(char) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.signChar(char) instruction_simplifier (after)
+ /// CHECK-START: int Main.signChar(char) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int signChar(char x) {
@@ -64,14 +52,10 @@
}
/// CHECK-START: int Main.signInt(int) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerSignum
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.signInt(int) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.signInt(int) instruction_simplifier (after)
+ /// CHECK-START: int Main.signInt(int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int signInt(int x) {
@@ -79,14 +63,10 @@
}
/// CHECK-START: int Main.signLong(long) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:LongSignum
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.signLong(long) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.signLong(long) instruction_simplifier (after)
+ /// CHECK-START: int Main.signLong(long) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int signLong(long x) {
diff --git a/test/567-checker-compare/smali/Smali.smali b/test/567-checker-compare/smali/Smali.smali
index fb6d241..f7648f3 100644
--- a/test/567-checker-compare/smali/Smali.smali
+++ b/test/567-checker-compare/smali/Smali.smali
@@ -20,18 +20,10 @@
## CHECK-DAG: <<One:i\d+>> IntConstant 1
## CHECK-DAG: <<PhiX:i\d+>> Phi [<<One>>,<<Zero>>]
## CHECK-DAG: <<PhiY:i\d+>> Phi [<<One>>,<<Zero>>]
-## CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<PhiX>>,<<PhiY>>{{(,[ij]\d+)?}}] intrinsic:IntegerCompare
-## CHECK-DAG: Return [<<Result>>]
-
-## CHECK-START: int Smali.compareBooleans(boolean, boolean) instruction_simplifier (after)
-## CHECK-DAG: <<Zero:i\d+>> IntConstant 0
-## CHECK-DAG: <<One:i\d+>> IntConstant 1
-## CHECK-DAG: <<PhiX:i\d+>> Phi [<<One>>,<<Zero>>]
-## CHECK-DAG: <<PhiY:i\d+>> Phi [<<One>>,<<Zero>>]
## CHECK-DAG: <<Result:i\d+>> Compare [<<PhiX>>,<<PhiY>>]
## CHECK-DAG: Return [<<Result>>]
-## CHECK-START: int Smali.compareBooleans(boolean, boolean) instruction_simplifier (after)
+## CHECK-START: int Smali.compareBooleans(boolean, boolean) builder (after)
## CHECK-NOT: InvokeStaticOrDirect
## CHECK-START: int Smali.compareBooleans(boolean, boolean) select_generator (after)
diff --git a/test/567-checker-compare/src/Main.java b/test/567-checker-compare/src/Main.java
index 25d88aa..589224e 100644
--- a/test/567-checker-compare/src/Main.java
+++ b/test/567-checker-compare/src/Main.java
@@ -21,7 +21,7 @@
/// CHECK-START: void Main.$opt$noinline$testReplaceInputWithItself(int) builder (after)
/// CHECK-DAG: <<ArgX:i\d+>> ParameterValue
/// CHECK-DAG: <<Zero:i\d+>> IntConstant 0
- /// CHECK-DAG: <<Cmp:i\d+>> InvokeStaticOrDirect [<<ArgX>>,<<Zero>>{{(,[ij]\d+)?}}] intrinsic:IntegerCompare
+ /// CHECK-DAG: <<Cmp:i\d+>> Compare [<<ArgX>>,<<Zero>>]
/// CHECK-DAG: GreaterThanOrEqual [<<Cmp>>,<<Zero>>]
/// CHECK-START: void Main.$opt$noinline$testReplaceInputWithItself(int) instruction_simplifier (after)
@@ -62,14 +62,10 @@
}
/// CHECK-START: int Main.compareBytes(byte, byte) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.compareBytes(byte, byte) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareBytes(byte, byte) instruction_simplifier (after)
+ /// CHECK-START: int Main.compareBytes(byte, byte) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int compareBytes(byte x, byte y) {
@@ -77,14 +73,10 @@
}
/// CHECK-START: int Main.compareShorts(short, short) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.compareShorts(short, short) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareShorts(short, short) instruction_simplifier (after)
+ /// CHECK-START: int Main.compareShorts(short, short) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int compareShorts(short x, short y) {
@@ -92,14 +84,10 @@
}
/// CHECK-START: int Main.compareChars(char, char) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.compareChars(char, char) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareChars(char, char) instruction_simplifier (after)
+ /// CHECK-START: int Main.compareChars(char, char) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int compareChars(char x, char y) {
@@ -107,14 +95,10 @@
}
/// CHECK-START: int Main.compareInts(int, int) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.compareInts(int, int) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareInts(int, int) instruction_simplifier (after)
+ /// CHECK-START: int Main.compareInts(int, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int compareInts(int x, int y) {
@@ -122,14 +106,10 @@
}
/// CHECK-START: int Main.compareLongs(long, long) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:LongCompare
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.compareLongs(long, long) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareLongs(long, long) instruction_simplifier (after)
+ /// CHECK-START: int Main.compareLongs(long, long) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static int compareLongs(long x, long y) {
@@ -138,14 +118,10 @@
/// CHECK-START: int Main.compareByteShort(byte, short) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.compareByteShort(byte, short) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareByteShort(byte, short) instruction_simplifier (after)
+ /// CHECK-START: int Main.compareByteShort(byte, short) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareByteShort(byte x, short y) {
@@ -153,14 +129,10 @@
}
/// CHECK-START: int Main.compareByteChar(byte, char) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.compareByteChar(byte, char) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareByteChar(byte, char) instruction_simplifier (after)
+ /// CHECK-START: int Main.compareByteChar(byte, char) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareByteChar(byte x, char y) {
@@ -168,14 +140,10 @@
}
/// CHECK-START: int Main.compareByteInt(byte, int) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.compareByteInt(byte, int) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareByteInt(byte, int) instruction_simplifier (after)
+ /// CHECK-START: int Main.compareByteInt(byte, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareByteInt(byte x, int y) {
@@ -184,14 +152,10 @@
/// CHECK-START: int Main.compareShortByte(short, byte) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.compareShortByte(short, byte) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareShortByte(short, byte) instruction_simplifier (after)
+ /// CHECK-START: int Main.compareShortByte(short, byte) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareShortByte(short x, byte y) {
@@ -199,14 +163,10 @@
}
/// CHECK-START: int Main.compareShortChar(short, char) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.compareShortChar(short, char) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareShortChar(short, char) instruction_simplifier (after)
+ /// CHECK-START: int Main.compareShortChar(short, char) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareShortChar(short x, char y) {
@@ -214,14 +174,10 @@
}
/// CHECK-START: int Main.compareShortInt(short, int) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.compareShortInt(short, int) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareShortInt(short, int) instruction_simplifier (after)
+ /// CHECK-START: int Main.compareShortInt(short, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareShortInt(short x, int y) {
@@ -230,14 +186,10 @@
/// CHECK-START: int Main.compareCharByte(char, byte) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.compareCharByte(char, byte) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareCharByte(char, byte) instruction_simplifier (after)
+ /// CHECK-START: int Main.compareCharByte(char, byte) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareCharByte(char x, byte y) {
@@ -245,14 +197,10 @@
}
/// CHECK-START: int Main.compareCharShort(char, short) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.compareCharShort(char, short) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareCharShort(char, short) instruction_simplifier (after)
+ /// CHECK-START: int Main.compareCharShort(char, short) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareCharShort(char x, short y) {
@@ -260,14 +208,10 @@
}
/// CHECK-START: int Main.compareCharInt(char, int) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.compareCharInt(char, int) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareCharInt(char, int) instruction_simplifier (after)
+ /// CHECK-START: int Main.compareCharInt(char, int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareCharInt(char x, int y) {
@@ -276,14 +220,10 @@
/// CHECK-START: int Main.compareIntByte(int, byte) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.compareIntByte(int, byte) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareIntByte(int, byte) instruction_simplifier (after)
+ /// CHECK-START: int Main.compareIntByte(int, byte) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareIntByte(int x, byte y) {
@@ -291,14 +231,10 @@
}
/// CHECK-START: int Main.compareIntShort(int, short) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.compareIntShort(int, short) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareIntShort(int, short) instruction_simplifier (after)
+ /// CHECK-START: int Main.compareIntShort(int, short) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareIntShort(int x, short y) {
@@ -306,14 +242,10 @@
}
/// CHECK-START: int Main.compareIntChar(int, char) builder (after)
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect intrinsic:IntegerCompare
- /// CHECK-DAG: Return [<<Result>>]
-
- /// CHECK-START: int Main.compareIntChar(int, char) instruction_simplifier (after)
/// CHECK-DAG: <<Result:i\d+>> Compare
/// CHECK-DAG: Return [<<Result>>]
- /// CHECK-START: int Main.compareIntChar(int, char) instruction_simplifier (after)
+ /// CHECK-START: int Main.compareIntChar(int, char) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int compareIntChar(int x, char y) {
diff --git a/test/575-checker-isnan/src/Main.java b/test/575-checker-isnan/src/Main.java
index cc71e5e..4773f63 100644
--- a/test/575-checker-isnan/src/Main.java
+++ b/test/575-checker-isnan/src/Main.java
@@ -16,29 +16,21 @@
public class Main {
- /// CHECK-START: boolean Main.isNaN32(float) instruction_simplifier (before)
- /// CHECK-DAG: <<Result:z\d+>> InvokeStaticOrDirect
- /// CHECK-DAG: Return [<<Result>>]
- //
- /// CHECK-START: boolean Main.isNaN32(float) instruction_simplifier (after)
+ /// CHECK-START: boolean Main.isNaN32(float) builder (after)
/// CHECK-DAG: <<Result:z\d+>> NotEqual
/// CHECK-DAG: Return [<<Result>>]
//
- /// CHECK-START: boolean Main.isNaN32(float) instruction_simplifier (after)
+ /// CHECK-START: boolean Main.isNaN32(float) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static boolean isNaN32(float x) {
return Float.isNaN(x);
}
- /// CHECK-START: boolean Main.isNaN64(double) instruction_simplifier (before)
- /// CHECK-DAG: <<Result:z\d+>> InvokeStaticOrDirect
- /// CHECK-DAG: Return [<<Result>>]
- //
- /// CHECK-START: boolean Main.isNaN64(double) instruction_simplifier (after)
+ /// CHECK-START: boolean Main.isNaN64(double) builder (after)
/// CHECK-DAG: <<Result:z\d+>> NotEqual
/// CHECK-DAG: Return [<<Result>>]
//
- /// CHECK-START: boolean Main.isNaN64(double) instruction_simplifier (after)
+ /// CHECK-START: boolean Main.isNaN64(double) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
private static boolean isNaN64(double x) {
return Double.isNaN(x);
diff --git a/test/631-checker-fp-abs/src/Main.java b/test/631-checker-fp-abs/src/Main.java
index 2d04e36..6e0e6db 100644
--- a/test/631-checker-fp-abs/src/Main.java
+++ b/test/631-checker-fp-abs/src/Main.java
@@ -32,22 +32,16 @@
public static boolean doThrow = false;
/// CHECK-START: float Main.$opt$noinline$absSP(float) builder (after)
- /// CHECK-DAG: <<Result:f\d+>> InvokeStaticOrDirect intrinsic:MathAbsFloat
+ /// CHECK-DAG: <<Result:f\d+>> Abs
/// CHECK-DAG: Return [<<Result>>]
private static float $opt$noinline$absSP(float f) {
- if (doThrow) {
- throw new Error("Something to prevent inlining");
- }
return Math.abs(f);
}
/// CHECK-START: double Main.$opt$noinline$absDP(double) builder (after)
- /// CHECK-DAG: <<Result:d\d+>> InvokeStaticOrDirect intrinsic:MathAbsDouble
+ /// CHECK-DAG: <<Result:d\d+>> Abs
/// CHECK-DAG: Return [<<Result>>]
private static double $opt$noinline$absDP(double d) {
- if (doThrow) {
- throw new Error("Something to prevent inlining");
- }
return Math.abs(d);
}
diff --git a/test/660-checker-simd-sad/src/SimdSadShort2.java b/test/660-checker-simd-sad/src/SimdSadShort2.java
index b110bb4..020d8d8 100644
--- a/test/660-checker-simd-sad/src/SimdSadShort2.java
+++ b/test/660-checker-simd-sad/src/SimdSadShort2.java
@@ -68,8 +68,8 @@
/// CHECK-DAG: <<Cnv1:s\d+>> TypeConversion [<<Get1>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: <<Cnv2:s\d+>> TypeConversion [<<Get2>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: <<Sub:i\d+>> Sub [<<Cnv1>>,<<Cnv2>>] loop:<<Loop>> outer_loop:none
- /// CHECK-DAG: <<Intrin:i\d+>> InvokeStaticOrDirect [<<Sub>>] intrinsic:MathAbsInt loop:<<Loop>> outer_loop:none
- /// CHECK-DAG: Add [<<Phi2>>,<<Intrin>>] loop:<<Loop>> outer_loop:none
+ /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Sub>>] loop:<<Loop>> outer_loop:none
+ /// CHECK-DAG: Add [<<Phi2>>,<<Abs>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop>> outer_loop:none
//
/// CHECK-START: int SimdSadShort2.sadCastedChar2Int(char[], char[]) loop_optimization (before)
@@ -80,8 +80,8 @@
/// CHECK-DAG: <<Get1:s\d+>> ArrayGet [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: <<Get2:s\d+>> ArrayGet [{{l\d+}},<<Phi1>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: <<Sub:i\d+>> Sub [<<Get1>>,<<Get2>>] loop:<<Loop>> outer_loop:none
- /// CHECK-DAG: <<Intrin:i\d+>> Abs [<<Sub>>] loop:<<Loop>> outer_loop:none
- /// CHECK-DAG: Add [<<Phi2>>,<<Intrin>>] loop:<<Loop>> outer_loop:none
+ /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Sub>>] loop:<<Loop>> outer_loop:none
+ /// CHECK-DAG: Add [<<Phi2>>,<<Abs>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop>> outer_loop:none
//
/// CHECK-START-ARM64: int SimdSadShort2.sadCastedChar2Int(char[], char[]) loop_optimization (after)
@@ -220,8 +220,8 @@
/// CHECK-DAG: <<Cnv3:j\d+>> TypeConversion [<<Cnv1>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: <<Cnv4:j\d+>> TypeConversion [<<Cnv2>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: <<Sub:j\d+>> Sub [<<Cnv3>>,<<Cnv4>>] loop:<<Loop>> outer_loop:none
- /// CHECK-DAG: <<Intrin:j\d+>> InvokeStaticOrDirect [<<Sub>>] intrinsic:MathAbsLong loop:<<Loop>> outer_loop:none
- /// CHECK-DAG: Add [<<Phi2>>,<<Intrin>>] loop:<<Loop>> outer_loop:none
+ /// CHECK-DAG: <<Abs:j\d+>> Abs [<<Sub>>] loop:<<Loop>> outer_loop:none
+ /// CHECK-DAG: Add [<<Phi2>>,<<Abs>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop>> outer_loop:none
//
/// CHECK-START: long SimdSadShort2.sadCastedChar2Long(char[], char[]) loop_optimization (before)
@@ -235,8 +235,8 @@
/// CHECK-DAG: <<Cnv1:j\d+>> TypeConversion [<<Get1>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: <<Cnv2:j\d+>> TypeConversion [<<Get2>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: <<Sub:j\d+>> Sub [<<Cnv1>>,<<Cnv2>>] loop:<<Loop>> outer_loop:none
- /// CHECK-DAG: <<Intrin:j\d+>> Abs [<<Sub>>] loop:<<Loop>> outer_loop:none
- /// CHECK-DAG: Add [<<Phi2>>,<<Intrin>>] loop:<<Loop>> outer_loop:none
+ /// CHECK-DAG: <<Abs:j\d+>> Abs [<<Sub>>] loop:<<Loop>> outer_loop:none
+ /// CHECK-DAG: Add [<<Phi2>>,<<Abs>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop>> outer_loop:none
//
/// CHECK-START-ARM64: long SimdSadShort2.sadCastedChar2Long(char[], char[]) loop_optimization (after)
@@ -276,8 +276,8 @@
/// CHECK-DAG: <<Cnv3:j\d+>> TypeConversion [<<Cnv1>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: <<Cnv4:j\d+>> TypeConversion [<<Cnv2>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: <<Sub:j\d+>> Sub [<<Cnv3>>,<<Cnv4>>] loop:<<Loop>> outer_loop:none
- /// CHECK-DAG: <<Intrin:j\d+>> InvokeStaticOrDirect [<<Sub>>] intrinsic:MathAbsLong loop:<<Loop>> outer_loop:none
- /// CHECK-DAG: Add [<<Phi2>>,<<Intrin>>] loop:<<Loop>> outer_loop:none
+ /// CHECK-DAG: <<Abs:j\d+>> Abs [<<Sub>>] loop:<<Loop>> outer_loop:none
+ /// CHECK-DAG: Add [<<Phi2>>,<<Abs>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop>> outer_loop:none
//
/// CHECK-START: long SimdSadShort2.sadCastedChar2LongAt1(char[], char[]) loop_optimization (before)
@@ -291,8 +291,8 @@
/// CHECK-DAG: <<Cnv1:j\d+>> TypeConversion [<<Get1>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: <<Cnv2:j\d+>> TypeConversion [<<Get2>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: <<Sub:j\d+>> Sub [<<Cnv1>>,<<Cnv2>>] loop:<<Loop>> outer_loop:none
- /// CHECK-DAG: <<Intrin:j\d+>> Abs [<<Sub>>] loop:<<Loop>> outer_loop:none
- /// CHECK-DAG: Add [<<Phi2>>,<<Intrin>>] loop:<<Loop>> outer_loop:none
+ /// CHECK-DAG: <<Abs:j\d+>> Abs [<<Sub>>] loop:<<Loop>> outer_loop:none
+ /// CHECK-DAG: Add [<<Phi2>>,<<Abs>>] loop:<<Loop>> outer_loop:none
/// CHECK-DAG: Add [<<Phi1>>,<<Cons1>>] loop:<<Loop>> outer_loop:none
//
/// CHECK-START-ARM64: long SimdSadShort2.sadCastedChar2LongAt1(char[], char[]) loop_optimization (after)
diff --git a/test/679-checker-minmax/src/Main.java b/test/679-checker-minmax/src/Main.java
index 4b72656..0e13264 100644
--- a/test/679-checker-minmax/src/Main.java
+++ b/test/679-checker-minmax/src/Main.java
@@ -23,19 +23,13 @@
// Direct intrinsics.
//
- /// CHECK-START: int Main.minI(int) instruction_simplifier (before)
- /// CHECK-DAG: <<Par:i\d+>> ParameterValue
- /// CHECK-DAG: <<Con:i\d+>> IntConstant 20
- /// CHECK-DAG: <<Min:i\d+>> InvokeStaticOrDirect [<<Par>>,<<Con>>] intrinsic:MathMinIntInt
- /// CHECK-DAG: Return [<<Min>>]
- //
- /// CHECK-START: int Main.minI(int) instruction_simplifier (after)
+ /// CHECK-START: int Main.minI(int) builder (after)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<Con:i\d+>> IntConstant 20
/// CHECK-DAG: <<Min:i\d+>> Min [<<Par>>,<<Con>>]
/// CHECK-DAG: Return [<<Min>>]
//
- /// CHECK-START: int Main.minI(int) instruction_simplifier (after)
+ /// CHECK-START: int Main.minI(int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
//
/// CHECK-START-ARM64: int Main.minI(int) disassembly (after)
@@ -48,19 +42,13 @@
return Math.min(a, 20);
}
- /// CHECK-START: long Main.minL(long) instruction_simplifier (before)
- /// CHECK-DAG: <<Par:j\d+>> ParameterValue
- /// CHECK-DAG: <<Con:j\d+>> LongConstant 20
- /// CHECK-DAG: <<Min:j\d+>> InvokeStaticOrDirect [<<Par>>,<<Con>>] intrinsic:MathMinLongLong
- /// CHECK-DAG: Return [<<Min>>]
- //
- /// CHECK-START: long Main.minL(long) instruction_simplifier (after)
+ /// CHECK-START: long Main.minL(long) builder (after)
/// CHECK-DAG: <<Par:j\d+>> ParameterValue
/// CHECK-DAG: <<Con:j\d+>> LongConstant 20
/// CHECK-DAG: <<Min:j\d+>> Min [<<Par>>,<<Con>>]
/// CHECK-DAG: Return [<<Min>>]
//
- /// CHECK-START: long Main.minL(long) instruction_simplifier (after)
+ /// CHECK-START: long Main.minL(long) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
//
/// CHECK-START-ARM64: long Main.minL(long) disassembly (after)
@@ -73,19 +61,13 @@
return Math.min(a, 20L);
}
- /// CHECK-START: int Main.maxI(int) instruction_simplifier (before)
- /// CHECK-DAG: <<Par:i\d+>> ParameterValue
- /// CHECK-DAG: <<Con:i\d+>> IntConstant 20
- /// CHECK-DAG: <<Max:i\d+>> InvokeStaticOrDirect [<<Par>>,<<Con>>] intrinsic:MathMaxIntInt
- /// CHECK-DAG: Return [<<Max>>]
- //
- /// CHECK-START: int Main.maxI(int) instruction_simplifier (after)
+ /// CHECK-START: int Main.maxI(int) builder (after)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<Con:i\d+>> IntConstant 20
/// CHECK-DAG: <<Max:i\d+>> Max [<<Par>>,<<Con>>]
/// CHECK-DAG: Return [<<Max>>]
//
- /// CHECK-START: int Main.maxI(int) instruction_simplifier (after)
+ /// CHECK-START: int Main.maxI(int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
//
/// CHECK-START-ARM64: int Main.maxI(int) disassembly (after)
@@ -98,19 +80,13 @@
return Math.max(a, 20);
}
- /// CHECK-START: long Main.maxL(long) instruction_simplifier (before)
- /// CHECK-DAG: <<Par:j\d+>> ParameterValue
- /// CHECK-DAG: <<Con:j\d+>> LongConstant 20
- /// CHECK-DAG: <<Max:j\d+>> InvokeStaticOrDirect [<<Par>>,<<Con>>] intrinsic:MathMaxLongLong
- /// CHECK-DAG: Return [<<Max>>]
- //
- /// CHECK-START: long Main.maxL(long) instruction_simplifier (after)
+ /// CHECK-START: long Main.maxL(long) builder (after)
/// CHECK-DAG: <<Par:j\d+>> ParameterValue
/// CHECK-DAG: <<Con:j\d+>> LongConstant 20
/// CHECK-DAG: <<Max:j\d+>> Max [<<Par>>,<<Con>>]
/// CHECK-DAG: Return [<<Max>>]
//
- /// CHECK-START: long Main.maxL(long) instruction_simplifier (after)
+ /// CHECK-START: long Main.maxL(long) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
//
/// CHECK-START-ARM64: long Main.maxL(long) disassembly (after)
diff --git a/test/681-checker-abs/src/Main.java b/test/681-checker-abs/src/Main.java
index 00390c3..7c68e17 100644
--- a/test/681-checker-abs/src/Main.java
+++ b/test/681-checker-abs/src/Main.java
@@ -23,33 +23,23 @@
// Intrinsics.
//
- /// CHECK-START: int Main.absI(int) instruction_simplifier (before)
- /// CHECK-DAG: <<Par:i\d+>> ParameterValue
- /// CHECK-DAG: <<Abs:i\d+>> InvokeStaticOrDirect [<<Par>>] intrinsic:MathAbsInt
- /// CHECK-DAG: Return [<<Abs>>]
- //
- /// CHECK-START: int Main.absI(int) instruction_simplifier (after)
+ /// CHECK-START: int Main.absI(int) builder (after)
/// CHECK-DAG: <<Par:i\d+>> ParameterValue
/// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
/// CHECK-DAG: Return [<<Abs>>]
//
- /// CHECK-START: int Main.absI(int) instruction_simplifier (after)
+ /// CHECK-START: int Main.absI(int) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static int absI(int a) {
return Math.abs(a);
}
- /// CHECK-START: long Main.absL(long) instruction_simplifier (before)
- /// CHECK-DAG: <<Par:j\d+>> ParameterValue
- /// CHECK-DAG: <<Abs:j\d+>> InvokeStaticOrDirect [<<Par>>] intrinsic:MathAbsLong
- /// CHECK-DAG: Return [<<Abs>>]
- //
- /// CHECK-START: long Main.absL(long) instruction_simplifier (after)
+ /// CHECK-START: long Main.absL(long) builder (after)
/// CHECK-DAG: <<Par:j\d+>> ParameterValue
/// CHECK-DAG: <<Abs:j\d+>> Abs [<<Par>>]
/// CHECK-DAG: Return [<<Abs>>]
//
- /// CHECK-START: long Main.absL(long) instruction_simplifier (after)
+ /// CHECK-START: long Main.absL(long) builder (after)
/// CHECK-NOT: InvokeStaticOrDirect
public static long absL(long a) {
return Math.abs(a);
@@ -223,7 +213,7 @@
/// CHECK-DAG: <<Par:b\d+>> ParameterValue
/// CHECK-DAG: <<Msk:i\d+>> IntConstant 255
/// CHECK-DAG: <<And:i\d+>> [<<Par>>,<<Msk>>]
- /// CHECK-DAG: <<Abs:i\d+>> InvokeStaticOrDirect [<<And>>] intrinsic:MathAbsInt
+ /// CHECK-DAG: <<Abs:i\d+>> Abs
/// CHECK-DAG: Return [<<Abs>>]
//
/// CHECK-START: int Main.zabs1(byte) instruction_simplifier (after)
@@ -232,7 +222,6 @@
/// CHECK-DAG: Return [<<Cnv>>]
//
/// CHECK-START: int Main.zabs1(byte) instruction_simplifier (after)
- /// CHECK-NOT: InvokeStaticOrDirect
/// CHECK-NOT: Abs
public static int zabs1(byte a) {
return Math.abs(a & 0xff);
@@ -242,7 +231,7 @@
/// CHECK-DAG: <<Par:s\d+>> ParameterValue
/// CHECK-DAG: <<Msk:i\d+>> IntConstant 65535
/// CHECK-DAG: <<And:i\d+>> [<<Msk>>,<<Par>>]
- /// CHECK-DAG: <<Abs:i\d+>> InvokeStaticOrDirect [<<And>>] intrinsic:MathAbsInt
+ /// CHECK-DAG: <<Abs:i\d+>> Abs
/// CHECK-DAG: Return [<<Abs>>]
//
/// CHECK-START: int Main.zabs2(short) instruction_simplifier (after)
@@ -251,7 +240,6 @@
/// CHECK-DAG: Return [<<Cnv>>]
//
/// CHECK-START: int Main.zabs2(short) instruction_simplifier (after)
- /// CHECK-NOT: InvokeStaticOrDirect
/// CHECK-NOT: Abs
public static int zabs2(short a) {
return Math.abs(a & 0xffff);
@@ -259,20 +247,14 @@
/// CHECK-START: int Main.zabs3(char) instruction_simplifier (before)
/// CHECK-DAG: <<Par:c\d+>> ParameterValue
- /// CHECK-DAG: <<Abs:i\d+>> InvokeStaticOrDirect [<<Par>>] intrinsic:MathAbsInt
+ /// CHECK-DAG: <<Abs:i\d+>> Abs
/// CHECK-DAG: Return [<<Abs>>]
//
/// CHECK-START: int Main.zabs3(char) instruction_simplifier (after)
/// CHECK-DAG: <<Par:c\d+>> ParameterValue
- /// CHECK-DAG: <<Abs:i\d+>> Abs [<<Par>>]
- /// CHECK-DAG: Return [<<Abs>>]
- //
- /// CHECK-START: int Main.zabs3(char) instruction_simplifier$after_gvn (after)
- /// CHECK-DAG: <<Par:c\d+>> ParameterValue
/// CHECK-DAG: Return [<<Par>>]
//
- /// CHECK-START: int Main.zabs3(char) instruction_simplifier$after_gvn (after)
- /// CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-START: int Main.zabs3(char) instruction_simplifier (after)
/// CHECK-NOT: Abs
public static int zabs3(char a) {
return Math.abs(a);
diff --git a/test/709-checker-varhandles/src/Main.java b/test/709-checker-varhandles/src/Main.java
index d0ea834..8bb0434 100644
--- a/test/709-checker-varhandles/src/Main.java
+++ b/test/709-checker-varhandles/src/Main.java
@@ -29,60 +29,45 @@
//
/// CHECK-START: void Main.fullFence() builder (after)
- /// CHECK-DAG: InvokeStaticOrDirect intrinsic:VarHandleFullFence
+ /// CHECK-NOT: InvokeStaticOrDirect
//
- /// CHECK-START: void Main.fullFence() instruction_simplifier (after)
- /// CHECK-NOT: InvokeStaticOrDirect intrinsic:VarHandleFullFence
- //
- /// CHECK-START: void Main.fullFence() instruction_simplifier (after)
+ /// CHECK-START: void Main.fullFence() builder (after)
/// CHECK-DAG: MemoryBarrier kind:AnyAny
private static void fullFence() {
VarHandle.fullFence();
}
/// CHECK-START: void Main.acquireFence() builder (after)
- /// CHECK-DAG: InvokeStaticOrDirect intrinsic:VarHandleAcquireFence
+ /// CHECK-NOT: InvokeStaticOrDirect
//
- /// CHECK-START: void Main.acquireFence() instruction_simplifier (after)
- /// CHECK-NOT: InvokeStaticOrDirect intrinsic:VarHandleAcquireFence
- //
- /// CHECK-START: void Main.acquireFence() instruction_simplifier (after)
+ /// CHECK-START: void Main.acquireFence() builder (after)
/// CHECK-DAG: MemoryBarrier kind:LoadAny
private static void acquireFence() {
VarHandle.acquireFence();
}
/// CHECK-START: void Main.releaseFence() builder (after)
- /// CHECK-DAG: InvokeStaticOrDirect intrinsic:VarHandleReleaseFence
+ /// CHECK-NOT: InvokeStaticOrDirect
//
- /// CHECK-START: void Main.releaseFence() instruction_simplifier (after)
- /// CHECK-NOT: InvokeStaticOrDirect intrinsic:VarHandleReleaseFence
- //
- /// CHECK-START: void Main.releaseFence() instruction_simplifier (after)
+ /// CHECK-START: void Main.releaseFence() builder (after)
/// CHECK-DAG: MemoryBarrier kind:AnyStore
private static void releaseFence() {
VarHandle.releaseFence();
}
/// CHECK-START: void Main.loadLoadFence() builder (after)
- /// CHECK-DAG: InvokeStaticOrDirect intrinsic:VarHandleLoadLoadFence
+ /// CHECK-NOT: InvokeStaticOrDirect
//
- /// CHECK-START: void Main.loadLoadFence() instruction_simplifier (after)
- /// CHECK-NOT: InvokeStaticOrDirect intrinsic:VarHandleLoadLoadFence
- //
- /// CHECK-START: void Main.loadLoadFence() instruction_simplifier (after)
+ /// CHECK-START: void Main.loadLoadFence() builder (after)
/// CHECK-DAG: MemoryBarrier kind:LoadAny
private static void loadLoadFence() {
VarHandle.loadLoadFence();
}
/// CHECK-START: void Main.storeStoreFence() builder (after)
- /// CHECK-DAG: InvokeStaticOrDirect intrinsic:VarHandleStoreStoreFence
+ /// CHECK-NOT: InvokeStaticOrDirect
//
- /// CHECK-START: void Main.storeStoreFence() instruction_simplifier (after)
- /// CHECK-NOT: InvokeStaticOrDirect intrinsic:VarHandleStoreStoreFence
- //
- /// CHECK-START: void Main.storeStoreFence() instruction_simplifier (after)
+ /// CHECK-START: void Main.storeStoreFence() builder (after)
/// CHECK-DAG: MemoryBarrier kind:StoreStore
private static void storeStoreFence() {
VarHandle.storeStoreFence();