Merge "Support for inlining virtual and interface calls."
diff --git a/compiler/image_writer.cc b/compiler/image_writer.cc
index 11743f3..32bde8e 100644
--- a/compiler/image_writer.cc
+++ b/compiler/image_writer.cc
@@ -718,6 +718,9 @@
// contains data only valid during a real run.
dex_cache->SetFieldObject<false>(mirror::DexCache::DexOffset(), nullptr);
}
+
+ // Drop the array class cache in the ClassLinker, as these are roots holding those classes live.
+ class_linker->DropFindArrayClassCache();
}
bool ImageWriter::NonImageClassesVisitor(Class* klass, void* arg) {
diff --git a/compiler/optimizing/builder.cc b/compiler/optimizing/builder.cc
index f98029d..dbda63b 100644
--- a/compiler/optimizing/builder.cc
+++ b/compiler/optimizing/builder.cc
@@ -763,6 +763,11 @@
}
DCHECK_EQ(argument_index, number_of_arguments);
+ if (invoke->IsInvokeStaticOrDirect()) {
+ invoke->SetArgumentAt(argument_index, graph_->GetCurrentMethod());
+ argument_index++;
+ }
+
if (clinit_check_requirement == HInvokeStaticOrDirect::ClinitCheckRequirement::kExplicit) {
// Add the class initialization check as last input of `invoke`.
DCHECK(clinit_check != nullptr);
diff --git a/compiler/optimizing/code_generator.cc b/compiler/optimizing/code_generator.cc
index 08c0351..049b3e3 100644
--- a/compiler/optimizing/code_generator.cc
+++ b/compiler/optimizing/code_generator.cc
@@ -292,7 +292,6 @@
HInvoke* invoke, InvokeDexCallingConventionVisitor* visitor) {
ArenaAllocator* allocator = invoke->GetBlock()->GetGraph()->GetArena();
LocationSummary* locations = new (allocator) LocationSummary(invoke, LocationSummary::kCall);
- locations->AddTemp(visitor->GetMethodLocation());
for (size_t i = 0; i < invoke->GetNumberOfArguments(); i++) {
HInstruction* input = invoke->InputAt(i);
@@ -300,6 +299,20 @@
}
locations->SetOut(visitor->GetReturnLocation(invoke->GetType()));
+
+ if (invoke->IsInvokeStaticOrDirect()) {
+ HInvokeStaticOrDirect* call = invoke->AsInvokeStaticOrDirect();
+ if (call->IsStringInit()) {
+ locations->AddTemp(visitor->GetMethodLocation());
+ } else if (call->IsRecursive()) {
+ locations->SetInAt(call->GetCurrentMethodInputIndex(), visitor->GetMethodLocation());
+ } else {
+ locations->AddTemp(visitor->GetMethodLocation());
+ locations->SetInAt(call->GetCurrentMethodInputIndex(), Location::RequiresRegister());
+ }
+ } else {
+ locations->AddTemp(visitor->GetMethodLocation());
+ }
}
void CodeGenerator::BlockIfInRegister(Location location, bool is_out) const {
diff --git a/compiler/optimizing/code_generator_arm.cc b/compiler/optimizing/code_generator_arm.cc
index 04952be..f4544ea 100644
--- a/compiler/optimizing/code_generator_arm.cc
+++ b/compiler/optimizing/code_generator_arm.cc
@@ -1254,6 +1254,10 @@
IntrinsicLocationsBuilderARM intrinsic(GetGraph()->GetArena(),
codegen_->GetInstructionSetFeatures());
if (intrinsic.TryDispatch(invoke)) {
+ LocationSummary* locations = invoke->GetLocations();
+ if (locations->CanCall()) {
+ locations->SetInAt(invoke->GetCurrentMethodInputIndex(), Location::RequiresRegister());
+ }
return;
}
@@ -1283,9 +1287,9 @@
return;
}
- Register temp = invoke->GetLocations()->GetTemp(0).AsRegister<Register>();
-
- codegen_->GenerateStaticOrDirectCall(invoke, temp);
+ LocationSummary* locations = invoke->GetLocations();
+ codegen_->GenerateStaticOrDirectCall(
+ invoke, locations->HasTemps() ? locations->GetTemp(0) : Location::NoLocation());
codegen_->RecordPcInfo(invoke, invoke->GetDexPc());
}
@@ -1316,12 +1320,8 @@
Location receiver = locations->InAt(0);
uint32_t class_offset = mirror::Object::ClassOffset().Int32Value();
// temp = object->GetClass();
- if (receiver.IsStackSlot()) {
- __ LoadFromOffset(kLoadWord, temp, SP, receiver.GetStackIndex());
- __ LoadFromOffset(kLoadWord, temp, temp, class_offset);
- } else {
- __ LoadFromOffset(kLoadWord, temp, receiver.AsRegister<Register>(), class_offset);
- }
+ DCHECK(receiver.IsRegister());
+ __ LoadFromOffset(kLoadWord, temp, receiver.AsRegister<Register>(), class_offset);
codegen_->MaybeRecordImplicitNullCheck(invoke);
// temp = temp->GetMethodAt(method_offset);
uint32_t entry_point = ArtMethod::EntryPointFromQuickCompiledCodeOffset(
@@ -1638,8 +1638,7 @@
// Processing a Dex `long-to-double' instruction.
locations->SetInAt(0, Location::RequiresRegister());
locations->SetOut(Location::RequiresFpuRegister());
- locations->AddTemp(Location::RequiresRegister());
- locations->AddTemp(Location::RequiresRegister());
+ locations->AddTemp(Location::RequiresFpuRegister());
locations->AddTemp(Location::RequiresFpuRegister());
break;
@@ -1857,29 +1856,21 @@
Register high = in.AsRegisterPairHigh<Register>();
SRegister out_s = out.AsFpuRegisterPairLow<SRegister>();
DRegister out_d = FromLowSToD(out_s);
- Register constant_low = locations->GetTemp(0).AsRegister<Register>();
- Register constant_high = locations->GetTemp(1).AsRegister<Register>();
- SRegister temp_s = locations->GetTemp(2).AsFpuRegisterPairLow<SRegister>();
+ SRegister temp_s = locations->GetTemp(0).AsFpuRegisterPairLow<SRegister>();
DRegister temp_d = FromLowSToD(temp_s);
+ SRegister constant_s = locations->GetTemp(1).AsFpuRegisterPairLow<SRegister>();
+ DRegister constant_d = FromLowSToD(constant_s);
- // out_d = int-to-double(high)
- __ vmovsr(out_s, high);
- __ vcvtdi(out_d, out_s);
- // Using vmovd to load the `k2Pow32EncodingForDouble` constant
- // as an immediate value into `temp_d` does not work, as
- // this instruction only transfers 8 significant bits of its
- // immediate operand. Instead, use two 32-bit core
- // registers to load `k2Pow32EncodingForDouble` into `temp_d`.
- __ LoadImmediate(constant_low, Low32Bits(k2Pow32EncodingForDouble));
- __ LoadImmediate(constant_high, High32Bits(k2Pow32EncodingForDouble));
- __ vmovdrr(temp_d, constant_low, constant_high);
- // out_d = out_d * 2^32
- __ vmuld(out_d, out_d, temp_d);
- // temp_d = unsigned-to-double(low)
- __ vmovsr(temp_s, low);
- __ vcvtdu(temp_d, temp_s);
- // out_d = out_d + temp_d
- __ vaddd(out_d, out_d, temp_d);
+ // temp_d = int-to-double(high)
+ __ vmovsr(temp_s, high);
+ __ vcvtdi(temp_d, temp_s);
+ // constant_d = k2Pow32EncodingForDouble
+ __ LoadDImmediate(constant_d, bit_cast<double, int64_t>(k2Pow32EncodingForDouble));
+ // out_d = unsigned-to-double(low)
+ __ vmovsr(out_s, low);
+ __ vcvtdu(out_d, out_s);
+ // out_d += temp_d * constant_d
+ __ vmlad(out_d, temp_d, constant_d);
break;
}
@@ -2910,22 +2901,22 @@
void InstructionCodeGeneratorARM::GenerateMemoryBarrier(MemBarrierKind kind) {
// TODO (ported from quick): revisit Arm barrier kinds
- DmbOptions flavour = DmbOptions::ISH; // quiet c++ warnings
+ DmbOptions flavor = DmbOptions::ISH; // quiet c++ warnings
switch (kind) {
case MemBarrierKind::kAnyStore:
case MemBarrierKind::kLoadAny:
case MemBarrierKind::kAnyAny: {
- flavour = DmbOptions::ISH;
+ flavor = DmbOptions::ISH;
break;
}
case MemBarrierKind::kStoreStore: {
- flavour = DmbOptions::ISHST;
+ flavor = DmbOptions::ISHST;
break;
}
default:
LOG(FATAL) << "Unexpected memory barrier " << kind;
}
- __ dmb(flavour);
+ __ dmb(flavor);
}
void InstructionCodeGeneratorARM::GenerateWideAtomicLoad(Register addr,
@@ -4215,9 +4206,7 @@
}
}
-void CodeGeneratorARM::GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke, Register temp) {
- DCHECK_EQ(temp, kArtMethodRegister);
-
+void CodeGeneratorARM::GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke, Location temp) {
// TODO: Implement all kinds of calls:
// 1) boot -> boot
// 2) app -> boot
@@ -4226,32 +4215,32 @@
// Currently we implement the app -> app logic, which looks up in the resolve cache.
if (invoke->IsStringInit()) {
+ Register reg = temp.AsRegister<Register>();
// temp = thread->string_init_entrypoint
- __ LoadFromOffset(kLoadWord, temp, TR, invoke->GetStringInitOffset());
+ __ LoadFromOffset(kLoadWord, reg, TR, invoke->GetStringInitOffset());
// LR = temp[offset_of_quick_compiled_code]
- __ LoadFromOffset(kLoadWord, LR, temp,
+ __ LoadFromOffset(kLoadWord, LR, reg,
ArtMethod::EntryPointFromQuickCompiledCodeOffset(
kArmWordSize).Int32Value());
// LR()
__ blx(LR);
+ } else if (invoke->IsRecursive()) {
+ __ bl(GetFrameEntryLabel());
} else {
- // temp = method;
- LoadCurrentMethod(temp);
- if (!invoke->IsRecursive()) {
- // temp = temp->dex_cache_resolved_methods_;
- __ LoadFromOffset(
- kLoadWord, temp, temp, ArtMethod::DexCacheResolvedMethodsOffset().Int32Value());
- // temp = temp[index_in_cache]
- __ LoadFromOffset(
- kLoadWord, temp, temp, CodeGenerator::GetCacheOffset(invoke->GetDexMethodIndex()));
- // LR = temp[offset_of_quick_compiled_code]
- __ LoadFromOffset(kLoadWord, LR, temp, ArtMethod::EntryPointFromQuickCompiledCodeOffset(
- kArmWordSize).Int32Value());
- // LR()
- __ blx(LR);
- } else {
- __ bl(GetFrameEntryLabel());
- }
+ Register current_method =
+ invoke->GetLocations()->InAt(invoke->GetCurrentMethodInputIndex()).AsRegister<Register>();
+ Register reg = temp.AsRegister<Register>();
+ // reg = current_method->dex_cache_resolved_methods_;
+ __ LoadFromOffset(
+ kLoadWord, reg, current_method, ArtMethod::DexCacheResolvedMethodsOffset().Int32Value());
+ // reg = reg[index_in_cache]
+ __ LoadFromOffset(
+ kLoadWord, reg, reg, CodeGenerator::GetCacheOffset(invoke->GetDexMethodIndex()));
+ // LR = reg[offset_of_quick_compiled_code]
+ __ LoadFromOffset(kLoadWord, LR, reg, ArtMethod::EntryPointFromQuickCompiledCodeOffset(
+ kArmWordSize).Int32Value());
+ // LR()
+ __ blx(LR);
}
DCHECK(!IsLeafMethod());
diff --git a/compiler/optimizing/code_generator_arm.h b/compiler/optimizing/code_generator_arm.h
index d84f2d3..b871acd 100644
--- a/compiler/optimizing/code_generator_arm.h
+++ b/compiler/optimizing/code_generator_arm.h
@@ -301,7 +301,7 @@
Label* GetFrameEntryLabel() { return &frame_entry_label_; }
- void GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke, Register temp);
+ void GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke, Location temp);
private:
// Labels for each block that will be compiled.
diff --git a/compiler/optimizing/code_generator_arm64.cc b/compiler/optimizing/code_generator_arm64.cc
index 2f607f7..ac99d56 100644
--- a/compiler/optimizing/code_generator_arm64.cc
+++ b/compiler/optimizing/code_generator_arm64.cc
@@ -484,7 +484,7 @@
}
Location InvokeDexCallingConventionVisitorARM64::GetMethodLocation() const {
- return LocationFrom(x0);
+ return LocationFrom(kArtMethodRegister);
}
CodeGeneratorARM64::CodeGeneratorARM64(HGraph* graph,
@@ -2227,6 +2227,10 @@
IntrinsicLocationsBuilderARM64 intrinsic(GetGraph()->GetArena());
if (intrinsic.TryDispatch(invoke)) {
+ LocationSummary* locations = invoke->GetLocations();
+ if (locations->CanCall()) {
+ locations->SetInAt(invoke->GetCurrentMethodInputIndex(), Location::RequiresRegister());
+ }
return;
}
@@ -2242,9 +2246,8 @@
return false;
}
-void CodeGeneratorARM64::GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke, Register temp) {
+void CodeGeneratorARM64::GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke, Location temp) {
// Make sure that ArtMethod* is passed in kArtMethodRegister as per the calling convention.
- DCHECK(temp.Is(kArtMethodRegister));
size_t index_in_cache = GetCachePointerOffset(invoke->GetDexMethodIndex());
// TODO: Implement all kinds of calls:
@@ -2255,30 +2258,30 @@
// Currently we implement the app -> app logic, which looks up in the resolve cache.
if (invoke->IsStringInit()) {
+ Register reg = XRegisterFrom(temp);
// temp = thread->string_init_entrypoint
- __ Ldr(temp.X(), MemOperand(tr, invoke->GetStringInitOffset()));
+ __ Ldr(reg.X(), MemOperand(tr, invoke->GetStringInitOffset()));
// LR = temp->entry_point_from_quick_compiled_code_;
__ Ldr(lr, MemOperand(
- temp, ArtMethod::EntryPointFromQuickCompiledCodeOffset(kArm64WordSize).Int32Value()));
+ reg, ArtMethod::EntryPointFromQuickCompiledCodeOffset(kArm64WordSize).Int32Value()));
// lr()
__ Blr(lr);
+ } else if (invoke->IsRecursive()) {
+ __ Bl(&frame_entry_label_);
} else {
- // temp = method;
- LoadCurrentMethod(temp.X());
- if (!invoke->IsRecursive()) {
- // temp = temp->dex_cache_resolved_methods_;
- __ Ldr(temp.W(), MemOperand(temp.X(),
- ArtMethod::DexCacheResolvedMethodsOffset().Int32Value()));
- // temp = temp[index_in_cache];
- __ Ldr(temp.X(), MemOperand(temp, index_in_cache));
- // lr = temp->entry_point_from_quick_compiled_code_;
- __ Ldr(lr, MemOperand(temp.X(), ArtMethod::EntryPointFromQuickCompiledCodeOffset(
- kArm64WordSize).Int32Value()));
- // lr();
- __ Blr(lr);
- } else {
- __ Bl(&frame_entry_label_);
- }
+ Register current_method =
+ XRegisterFrom(invoke->GetLocations()->InAt(invoke->GetCurrentMethodInputIndex()));
+ Register reg = XRegisterFrom(temp);
+ // temp = current_method->dex_cache_resolved_methods_;
+ __ Ldr(reg.W(), MemOperand(current_method.X(),
+ ArtMethod::DexCacheResolvedMethodsOffset().Int32Value()));
+ // temp = temp[index_in_cache];
+ __ Ldr(reg.X(), MemOperand(reg, index_in_cache));
+ // lr = temp->entry_point_from_quick_compiled_code_;
+ __ Ldr(lr, MemOperand(reg.X(), ArtMethod::EntryPointFromQuickCompiledCodeOffset(
+ kArm64WordSize).Int32Value()));
+ // lr();
+ __ Blr(lr);
}
DCHECK(!IsLeafMethod());
@@ -2294,8 +2297,9 @@
}
BlockPoolsScope block_pools(GetVIXLAssembler());
- Register temp = XRegisterFrom(invoke->GetLocations()->GetTemp(0));
- codegen_->GenerateStaticOrDirectCall(invoke, temp);
+ LocationSummary* locations = invoke->GetLocations();
+ codegen_->GenerateStaticOrDirectCall(
+ invoke, locations->HasTemps() ? locations->GetTemp(0) : Location::NoLocation());
codegen_->RecordPcInfo(invoke, invoke->GetDexPc());
}
@@ -2314,14 +2318,8 @@
BlockPoolsScope block_pools(GetVIXLAssembler());
- // temp = object->GetClass();
- if (receiver.IsStackSlot()) {
- __ Ldr(temp.W(), MemOperand(sp, receiver.GetStackIndex()));
- __ Ldr(temp.W(), HeapOperand(temp.W(), class_offset));
- } else {
- DCHECK(receiver.IsRegister());
- __ Ldr(temp.W(), HeapOperandFrom(receiver, class_offset));
- }
+ DCHECK(receiver.IsRegister());
+ __ Ldr(temp.W(), HeapOperandFrom(receiver, class_offset));
codegen_->MaybeRecordImplicitNullCheck(invoke);
// temp = temp->GetMethodAt(method_offset);
__ Ldr(temp, MemOperand(temp, method_offset));
@@ -2674,7 +2672,7 @@
void LocationsBuilderARM64::VisitCurrentMethod(HCurrentMethod* instruction) {
LocationSummary* locations =
new (GetGraph()->GetArena()) LocationSummary(instruction, LocationSummary::kNoCall);
- locations->SetOut(LocationFrom(x0));
+ locations->SetOut(LocationFrom(kArtMethodRegister));
}
void InstructionCodeGeneratorARM64::VisitCurrentMethod(
diff --git a/compiler/optimizing/code_generator_arm64.h b/compiler/optimizing/code_generator_arm64.h
index c62ba95..3246648 100644
--- a/compiler/optimizing/code_generator_arm64.h
+++ b/compiler/optimizing/code_generator_arm64.h
@@ -344,7 +344,7 @@
return false;
}
- void GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke, vixl::Register temp);
+ void GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke, Location temp);
private:
// Labels for each block that will be compiled.
diff --git a/compiler/optimizing/code_generator_x86.cc b/compiler/optimizing/code_generator_x86.cc
index 8a7b52e..4065c44 100644
--- a/compiler/optimizing/code_generator_x86.cc
+++ b/compiler/optimizing/code_generator_x86.cc
@@ -1231,6 +1231,10 @@
IntrinsicLocationsBuilderX86 intrinsic(codegen_);
if (intrinsic.TryDispatch(invoke)) {
+ LocationSummary* locations = invoke->GetLocations();
+ if (locations->CanCall()) {
+ locations->SetInAt(invoke->GetCurrentMethodInputIndex(), Location::RequiresRegister());
+ }
return;
}
@@ -1255,8 +1259,9 @@
return;
}
+ LocationSummary* locations = invoke->GetLocations();
codegen_->GenerateStaticOrDirectCall(
- invoke, invoke->GetLocations()->GetTemp(0).AsRegister<Register>());
+ invoke, locations->HasTemps() ? locations->GetTemp(0) : Location::NoLocation());
codegen_->RecordPcInfo(invoke, invoke->GetDexPc());
}
@@ -1276,13 +1281,8 @@
LocationSummary* locations = invoke->GetLocations();
Location receiver = locations->InAt(0);
uint32_t class_offset = mirror::Object::ClassOffset().Int32Value();
- // temp = object->GetClass();
- if (receiver.IsStackSlot()) {
- __ movl(temp, Address(ESP, receiver.GetStackIndex()));
- __ movl(temp, Address(temp, class_offset));
- } else {
- __ movl(temp, Address(receiver.AsRegister<Register>(), class_offset));
- }
+ DCHECK(receiver.IsRegister());
+ __ movl(temp, Address(receiver.AsRegister<Register>(), class_offset));
codegen_->MaybeRecordImplicitNullCheck(invoke);
// temp = temp->GetMethodAt(method_offset);
__ movl(temp, Address(temp, method_offset));
@@ -3201,7 +3201,7 @@
void CodeGeneratorX86::GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke,
- Register temp) {
+ Location temp) {
// TODO: Implement all kinds of calls:
// 1) boot -> boot
// 2) app -> boot
@@ -3211,25 +3211,26 @@
if (invoke->IsStringInit()) {
// temp = thread->string_init_entrypoint
- __ fs()->movl(temp, Address::Absolute(invoke->GetStringInitOffset()));
+ Register reg = temp.AsRegister<Register>();
+ __ fs()->movl(reg, Address::Absolute(invoke->GetStringInitOffset()));
// (temp + offset_of_quick_compiled_code)()
__ call(Address(
- temp, ArtMethod::EntryPointFromQuickCompiledCodeOffset(kX86WordSize).Int32Value()));
+ reg, ArtMethod::EntryPointFromQuickCompiledCodeOffset(kX86WordSize).Int32Value()));
+ } else if (invoke->IsRecursive()) {
+ __ call(GetFrameEntryLabel());
} else {
- // temp = method;
- LoadCurrentMethod(temp);
- if (!invoke->IsRecursive()) {
- // temp = temp->dex_cache_resolved_methods_;
- __ movl(temp, Address(temp, ArtMethod::DexCacheResolvedMethodsOffset().Int32Value()));
- // temp = temp[index_in_cache]
- __ movl(temp, Address(temp,
- CodeGenerator::GetCachePointerOffset(invoke->GetDexMethodIndex())));
- // (temp + offset_of_quick_compiled_code)()
- __ call(Address(temp,
- ArtMethod::EntryPointFromQuickCompiledCodeOffset(kX86WordSize).Int32Value()));
- } else {
- __ call(GetFrameEntryLabel());
- }
+ Register current_method =
+ invoke->GetLocations()->InAt(invoke->GetCurrentMethodInputIndex()).AsRegister<Register>();
+ Register reg = temp.AsRegister<Register>();
+ // temp = temp->dex_cache_resolved_methods_;
+ __ movl(reg, Address(
+ current_method, ArtMethod::DexCacheResolvedMethodsOffset().Int32Value()));
+ // temp = temp[index_in_cache]
+ __ movl(reg, Address(reg,
+ CodeGenerator::GetCachePointerOffset(invoke->GetDexMethodIndex())));
+ // (temp + offset_of_quick_compiled_code)()
+ __ call(Address(reg,
+ ArtMethod::EntryPointFromQuickCompiledCodeOffset(kX86WordSize).Int32Value()));
}
DCHECK(!IsLeafMethod());
diff --git a/compiler/optimizing/code_generator_x86.h b/compiler/optimizing/code_generator_x86.h
index 61827a4..b8553d2 100644
--- a/compiler/optimizing/code_generator_x86.h
+++ b/compiler/optimizing/code_generator_x86.h
@@ -263,7 +263,7 @@
void Move64(Location destination, Location source);
// Generate a call to a static or direct method.
- void GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke, Register temp);
+ void GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke, Location temp);
// Emit a write barrier.
void MarkGCCard(Register temp,
diff --git a/compiler/optimizing/code_generator_x86_64.cc b/compiler/optimizing/code_generator_x86_64.cc
index a2a3cf5..c9fe813 100644
--- a/compiler/optimizing/code_generator_x86_64.cc
+++ b/compiler/optimizing/code_generator_x86_64.cc
@@ -360,7 +360,7 @@
}
void CodeGeneratorX86_64::GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke,
- CpuRegister temp) {
+ Location temp) {
// All registers are assumed to be correctly set up.
// TODO: Implement all kinds of calls:
@@ -371,26 +371,28 @@
// Currently we implement the app -> app logic, which looks up in the resolve cache.
if (invoke->IsStringInit()) {
+ CpuRegister reg = temp.AsRegister<CpuRegister>();
// temp = thread->string_init_entrypoint
- __ gs()->movl(temp, Address::Absolute(invoke->GetStringInitOffset()));
+ __ gs()->movl(reg, Address::Absolute(invoke->GetStringInitOffset()));
// (temp + offset_of_quick_compiled_code)()
- __ call(Address(temp, ArtMethod::EntryPointFromQuickCompiledCodeOffset(
+ __ call(Address(reg, ArtMethod::EntryPointFromQuickCompiledCodeOffset(
kX86_64WordSize).SizeValue()));
+ } else if (invoke->IsRecursive()) {
+ __ call(&frame_entry_label_);
} else {
- // temp = method;
- LoadCurrentMethod(temp);
- if (!invoke->IsRecursive()) {
- // temp = temp->dex_cache_resolved_methods_;
- __ movl(temp, Address(temp, ArtMethod::DexCacheResolvedMethodsOffset().SizeValue()));
- // temp = temp[index_in_cache]
- __ movq(temp, Address(
- temp, CodeGenerator::GetCachePointerOffset(invoke->GetDexMethodIndex())));
- // (temp + offset_of_quick_compiled_code)()
- __ call(Address(temp, ArtMethod::EntryPointFromQuickCompiledCodeOffset(
- kX86_64WordSize).SizeValue()));
- } else {
- __ call(&frame_entry_label_);
- }
+ LocationSummary* locations = invoke->GetLocations();
+ CpuRegister reg = temp.AsRegister<CpuRegister>();
+ CpuRegister current_method =
+ locations->InAt(invoke->GetCurrentMethodInputIndex()).AsRegister<CpuRegister>();
+ // temp = temp->dex_cache_resolved_methods_;
+ __ movl(reg, Address(
+ current_method, ArtMethod::DexCacheResolvedMethodsOffset().SizeValue()));
+ // temp = temp[index_in_cache]
+ __ movq(reg, Address(
+ reg, CodeGenerator::GetCachePointerOffset(invoke->GetDexMethodIndex())));
+ // (temp + offset_of_quick_compiled_code)()
+ __ call(Address(reg, ArtMethod::EntryPointFromQuickCompiledCodeOffset(
+ kX86_64WordSize).SizeValue()));
}
DCHECK(!IsLeafMethod());
@@ -1334,6 +1336,10 @@
IntrinsicLocationsBuilderX86_64 intrinsic(codegen_);
if (intrinsic.TryDispatch(invoke)) {
+ LocationSummary* locations = invoke->GetLocations();
+ if (locations->CanCall()) {
+ locations->SetInAt(invoke->GetCurrentMethodInputIndex(), Location::RequiresRegister());
+ }
return;
}
@@ -1358,9 +1364,9 @@
return;
}
+ LocationSummary* locations = invoke->GetLocations();
codegen_->GenerateStaticOrDirectCall(
- invoke,
- invoke->GetLocations()->GetTemp(0).AsRegister<CpuRegister>());
+ invoke, locations->HasTemps() ? locations->GetTemp(0) : Location::NoLocation());
codegen_->RecordPcInfo(invoke, invoke->GetDexPc());
}
@@ -1390,12 +1396,8 @@
Location receiver = locations->InAt(0);
size_t class_offset = mirror::Object::ClassOffset().SizeValue();
// temp = object->GetClass();
- if (receiver.IsStackSlot()) {
- __ movl(temp, Address(CpuRegister(RSP), receiver.GetStackIndex()));
- __ movl(temp, Address(temp, class_offset));
- } else {
- __ movl(temp, Address(receiver.AsRegister<CpuRegister>(), class_offset));
- }
+ DCHECK(receiver.IsRegister());
+ __ movl(temp, Address(receiver.AsRegister<CpuRegister>(), class_offset));
codegen_->MaybeRecordImplicitNullCheck(invoke);
// temp = temp->GetMethodAt(method_offset);
__ movq(temp, Address(temp, method_offset));
diff --git a/compiler/optimizing/code_generator_x86_64.h b/compiler/optimizing/code_generator_x86_64.h
index c19e686..61f863c 100644
--- a/compiler/optimizing/code_generator_x86_64.h
+++ b/compiler/optimizing/code_generator_x86_64.h
@@ -277,7 +277,7 @@
return false;
}
- void GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke, CpuRegister temp);
+ void GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke, Location temp);
const X86_64InstructionSetFeatures& GetInstructionSetFeatures() const {
return isa_features_;
diff --git a/compiler/optimizing/inliner.cc b/compiler/optimizing/inliner.cc
index b26afd1..ea613b2 100644
--- a/compiler/optimizing/inliner.cc
+++ b/compiler/optimizing/inliner.cc
@@ -70,6 +70,13 @@
bool should_inline = callee_name.find("$inline$") != std::string::npos;
CHECK(!should_inline) << "Could not inline " << callee_name;
}
+ } else {
+ if (kIsDebugBuild) {
+ std::string callee_name =
+ PrettyMethod(call->GetDexMethodIndex(), *outer_compilation_unit_.GetDexFile());
+ bool must_not_inline = callee_name.find("$noinline$") != std::string::npos;
+ CHECK(!must_not_inline) << "Should not have inlined " << callee_name;
+ }
}
}
instruction = next;
diff --git a/compiler/optimizing/intrinsics_arm.cc b/compiler/optimizing/intrinsics_arm.cc
index 5436ec2..749bedf 100644
--- a/compiler/optimizing/intrinsics_arm.cc
+++ b/compiler/optimizing/intrinsics_arm.cc
@@ -101,7 +101,8 @@
MoveArguments(invoke_, codegen);
if (invoke_->IsInvokeStaticOrDirect()) {
- codegen->GenerateStaticOrDirectCall(invoke_->AsInvokeStaticOrDirect(), kArtMethodRegister);
+ codegen->GenerateStaticOrDirectCall(invoke_->AsInvokeStaticOrDirect(),
+ Location::RegisterLocation(kArtMethodRegister));
RecordPcInfo(codegen, invoke_, invoke_->GetDexPc());
} else {
UNIMPLEMENTED(FATAL) << "Non-direct intrinsic slow-path not yet implemented";
diff --git a/compiler/optimizing/intrinsics_arm64.cc b/compiler/optimizing/intrinsics_arm64.cc
index d1dc5b3..c108ad5 100644
--- a/compiler/optimizing/intrinsics_arm64.cc
+++ b/compiler/optimizing/intrinsics_arm64.cc
@@ -110,7 +110,8 @@
MoveArguments(invoke_, codegen);
if (invoke_->IsInvokeStaticOrDirect()) {
- codegen->GenerateStaticOrDirectCall(invoke_->AsInvokeStaticOrDirect(), kArtMethodRegister);
+ codegen->GenerateStaticOrDirectCall(invoke_->AsInvokeStaticOrDirect(),
+ LocationFrom(kArtMethodRegister));
RecordPcInfo(codegen, invoke_, invoke_->GetDexPc());
} else {
UNIMPLEMENTED(FATAL) << "Non-direct intrinsic slow-path not yet implemented";
diff --git a/compiler/optimizing/intrinsics_x86.cc b/compiler/optimizing/intrinsics_x86.cc
index 5bbbc72..424ac7c 100644
--- a/compiler/optimizing/intrinsics_x86.cc
+++ b/compiler/optimizing/intrinsics_x86.cc
@@ -138,7 +138,8 @@
MoveArguments(invoke_, codegen);
if (invoke_->IsInvokeStaticOrDirect()) {
- codegen->GenerateStaticOrDirectCall(invoke_->AsInvokeStaticOrDirect(), EAX);
+ codegen->GenerateStaticOrDirectCall(invoke_->AsInvokeStaticOrDirect(),
+ Location::RegisterLocation(EAX));
RecordPcInfo(codegen, invoke_, invoke_->GetDexPc());
} else {
UNIMPLEMENTED(FATAL) << "Non-direct intrinsic slow-path not yet implemented";
@@ -732,7 +733,8 @@
MoveArguments(invoke, codegen);
DCHECK(invoke->IsInvokeStaticOrDirect());
- codegen->GenerateStaticOrDirectCall(invoke->AsInvokeStaticOrDirect(), EAX);
+ codegen->GenerateStaticOrDirectCall(invoke->AsInvokeStaticOrDirect(),
+ Location::RegisterLocation(EAX));
codegen->RecordPcInfo(invoke, invoke->GetDexPc());
// Copy the result back to the expected output.
diff --git a/compiler/optimizing/intrinsics_x86_64.cc b/compiler/optimizing/intrinsics_x86_64.cc
index d6c90ff..8915314 100644
--- a/compiler/optimizing/intrinsics_x86_64.cc
+++ b/compiler/optimizing/intrinsics_x86_64.cc
@@ -129,7 +129,8 @@
MoveArguments(invoke_, codegen);
if (invoke_->IsInvokeStaticOrDirect()) {
- codegen->GenerateStaticOrDirectCall(invoke_->AsInvokeStaticOrDirect(), CpuRegister(RDI));
+ codegen->GenerateStaticOrDirectCall(
+ invoke_->AsInvokeStaticOrDirect(), Location::RegisterLocation(RDI));
RecordPcInfo(codegen, invoke_, invoke_->GetDexPc());
} else {
UNIMPLEMENTED(FATAL) << "Non-direct intrinsic slow-path not yet implemented";
@@ -609,7 +610,8 @@
MoveArguments(invoke, codegen);
DCHECK(invoke->IsInvokeStaticOrDirect());
- codegen->GenerateStaticOrDirectCall(invoke->AsInvokeStaticOrDirect(), CpuRegister(RDI));
+ codegen->GenerateStaticOrDirectCall(
+ invoke->AsInvokeStaticOrDirect(), Location::RegisterLocation(RDI));
codegen->RecordPcInfo(invoke, invoke->GetDexPc());
// Copy the result back to the expected output.
diff --git a/compiler/optimizing/locations.h b/compiler/optimizing/locations.h
index 09bbb33..66c5fb1 100644
--- a/compiler/optimizing/locations.h
+++ b/compiler/optimizing/locations.h
@@ -525,6 +525,8 @@
return temps_.Size();
}
+ bool HasTemps() const { return !temps_.IsEmpty(); }
+
Location Out() const { return output_; }
bool CanCall() const { return call_kind_ != kNoCall; }
diff --git a/compiler/optimizing/nodes.h b/compiler/optimizing/nodes.h
index 4792734..d914363 100644
--- a/compiler/optimizing/nodes.h
+++ b/compiler/optimizing/nodes.h
@@ -2528,7 +2528,9 @@
ClinitCheckRequirement clinit_check_requirement)
: HInvoke(arena,
number_of_arguments,
- clinit_check_requirement == ClinitCheckRequirement::kExplicit ? 1u : 0u,
+ // There is one extra argument for the HCurrentMethod node, and
+ // potentially one other if the clinit check is explicit.
+ clinit_check_requirement == ClinitCheckRequirement::kExplicit ? 2u : 1u,
return_type,
dex_pc,
dex_method_index,
@@ -2550,6 +2552,7 @@
bool NeedsDexCache() const OVERRIDE { return !IsRecursive(); }
bool IsStringInit() const { return string_init_offset_ != 0; }
int32_t GetStringInitOffset() const { return string_init_offset_; }
+ uint32_t GetCurrentMethodInputIndex() const { return GetNumberOfArguments(); }
// Is this instruction a call to a static method?
bool IsStatic() const {
diff --git a/compiler/optimizing/register_allocator.cc b/compiler/optimizing/register_allocator.cc
index a381315..e38e49c 100644
--- a/compiler/optimizing/register_allocator.cc
+++ b/compiler/optimizing/register_allocator.cc
@@ -714,13 +714,15 @@
if (defined_by != nullptr && !current->IsSplit()) {
LocationSummary* locations = defined_by->GetLocations();
if (!locations->OutputCanOverlapWithInputs() && locations->Out().IsUnallocated()) {
- for (HInputIterator it(defined_by); !it.Done(); it.Advance()) {
+ for (size_t i = 0, e = defined_by->InputCount(); i < e; ++i) {
// Take the last interval of the input. It is the location of that interval
// that will be used at `defined_by`.
- LiveInterval* interval = it.Current()->GetLiveInterval()->GetLastSibling();
+ LiveInterval* interval = defined_by->InputAt(i)->GetLiveInterval()->GetLastSibling();
// Note that interval may have not been processed yet.
// TODO: Handle non-split intervals last in the work list.
- if (interval->HasRegister() && interval->SameRegisterKind(*current)) {
+ if (locations->InAt(i).IsValid()
+ && interval->HasRegister()
+ && interval->SameRegisterKind(*current)) {
// The input must be live until the end of `defined_by`, to comply to
// the linear scan algorithm. So we use `defined_by`'s end lifetime
// position to check whether the input is dead or is inactive after
diff --git a/compiler/optimizing/ssa_liveness_analysis.cc b/compiler/optimizing/ssa_liveness_analysis.cc
index d5f977f..701dbb0 100644
--- a/compiler/optimizing/ssa_liveness_analysis.cc
+++ b/compiler/optimizing/ssa_liveness_analysis.cc
@@ -242,7 +242,7 @@
HInstruction* input = current->InputAt(i);
// Some instructions 'inline' their inputs, that is they do not need
// to be materialized.
- if (input->HasSsaIndex()) {
+ if (input->HasSsaIndex() && current->GetLocations()->InAt(i).IsValid()) {
live_in->SetBit(input->GetSsaIndex());
input->GetLiveInterval()->AddUse(current, /* environment */ nullptr, i);
}
diff --git a/compiler/optimizing/ssa_liveness_analysis.h b/compiler/optimizing/ssa_liveness_analysis.h
index 4667825..220ee6a 100644
--- a/compiler/optimizing/ssa_liveness_analysis.h
+++ b/compiler/optimizing/ssa_liveness_analysis.h
@@ -394,7 +394,7 @@
first_range_->start_ = from;
} else {
// Instruction without uses.
- DCHECK(!defined_by_->HasNonEnvironmentUses());
+ DCHECK(first_use_ == nullptr);
DCHECK(from == defined_by_->GetLifetimePosition());
first_range_ = last_range_ = range_search_start_ =
new (allocator_) LiveRange(from, from + 2, nullptr);
diff --git a/runtime/asm_support.h b/runtime/asm_support.h
index d7efe1c..10ed0f4 100644
--- a/runtime/asm_support.h
+++ b/runtime/asm_support.h
@@ -104,11 +104,11 @@
art::Thread::TopOfManagedStackOffset<__SIZEOF_POINTER__>().Int32Value())
// Offset of field Thread::tlsPtr_.managed_stack.top_quick_frame_.
-#define THREAD_SELF_OFFSET (THREAD_CARD_TABLE_OFFSET + (8 * __SIZEOF_POINTER__))
+#define THREAD_SELF_OFFSET (THREAD_CARD_TABLE_OFFSET + (9 * __SIZEOF_POINTER__))
ADD_TEST_EQ(THREAD_SELF_OFFSET,
art::Thread::SelfOffset<__SIZEOF_POINTER__>().Int32Value())
-#define THREAD_LOCAL_POS_OFFSET (THREAD_CARD_TABLE_OFFSET + 146 * __SIZEOF_POINTER__)
+#define THREAD_LOCAL_POS_OFFSET (THREAD_CARD_TABLE_OFFSET + 147 * __SIZEOF_POINTER__)
ADD_TEST_EQ(THREAD_LOCAL_POS_OFFSET,
art::Thread::ThreadLocalPosOffset<__SIZEOF_POINTER__>().Int32Value())
#define THREAD_LOCAL_END_OFFSET (THREAD_LOCAL_POS_OFFSET + __SIZEOF_POINTER__)
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 431ef27..31140a8 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -277,9 +277,9 @@
quick_to_interpreter_bridge_trampoline_(nullptr),
image_pointer_size_(sizeof(void*)) {
CHECK(intern_table_ != nullptr);
- for (auto& root : find_array_class_cache_) {
- root = GcRoot<mirror::Class>(nullptr);
- }
+ static_assert(kFindArrayCacheSize == arraysize(find_array_class_cache_),
+ "Array cache size wrong.");
+ std::fill_n(find_array_class_cache_, kFindArrayCacheSize, GcRoot<mirror::Class>(nullptr));
}
void ClassLinker::InitWithoutImage(std::vector<std::unique_ptr<const DexFile>> boot_class_path) {
@@ -5886,4 +5886,9 @@
return method;
}
+void ClassLinker::DropFindArrayClassCache() {
+ std::fill_n(find_array_class_cache_, kFindArrayCacheSize, GcRoot<mirror::Class>(nullptr));
+ find_array_class_cache_next_victim_ = 0;
+}
+
} // namespace art
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index fa8b2e7..d9935cb 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -480,6 +480,10 @@
ArtMethod* CreateRuntimeMethod();
+ // Clear the ArrayClass cache. This is necessary when cleaning up for the image, as the cache
+ // entries are roots, but potentially not image classes.
+ void DropFindArrayClassCache() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
private:
const OatFile::OatMethod FindOatMethodFor(ArtMethod* method, bool* found)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
diff --git a/runtime/entrypoints_order_test.cc b/runtime/entrypoints_order_test.cc
index 482f656..963dd02 100644
--- a/runtime/entrypoints_order_test.cc
+++ b/runtime/entrypoints_order_test.cc
@@ -88,7 +88,8 @@
EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, stack_end, managed_stack, sizeof(void*));
EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, managed_stack, suspend_trigger, sizeof(ManagedStack));
EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, suspend_trigger, jni_env, sizeof(void*));
- EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, jni_env, self, sizeof(void*));
+ EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, jni_env, tmp_jni_env, sizeof(void*));
+ EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, tmp_jni_env, self, sizeof(void*));
EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, self, opeer, sizeof(void*));
EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, opeer, jpeer, sizeof(void*));
EXPECT_OFFSET_DIFFP(Thread, tlsPtr_, jpeer, stack_begin, sizeof(void*));
diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc
index 59d0259..20e791d 100644
--- a/runtime/gc/heap.cc
+++ b/runtime/gc/heap.cc
@@ -2253,6 +2253,7 @@
// to large objects.
mod_union_table->SetCards();
AddModUnionTable(mod_union_table);
+ large_object_space_->SetAllLargeObjectsAsZygoteObjects(self);
if (collector::SemiSpace::kUseRememberedSet) {
// Add a new remembered set for the post-zygote non-moving space.
accounting::RememberedSet* post_zygote_non_moving_space_rem_set =
diff --git a/runtime/gc/space/large_object_space.cc b/runtime/gc/space/large_object_space.cc
index da4a930..52192e2 100644
--- a/runtime/gc/space/large_object_space.cc
+++ b/runtime/gc/space/large_object_space.cc
@@ -41,13 +41,13 @@
// Keep valgrind happy if there is any large objects such as dex cache arrays which aren't
// freed since they are held live by the class linker.
MutexLock mu(Thread::Current(), lock_);
- for (auto& m : mem_maps_) {
- delete m.second;
+ for (auto& m : large_objects_) {
+ delete m.second.mem_map;
}
}
- virtual mirror::Object* Alloc(Thread* self, size_t num_bytes, size_t* bytes_allocated,
- size_t* usable_size, size_t* bytes_tl_bulk_allocated)
+ mirror::Object* Alloc(Thread* self, size_t num_bytes, size_t* bytes_allocated,
+ size_t* usable_size, size_t* bytes_tl_bulk_allocated)
OVERRIDE {
mirror::Object* obj =
LargeObjectMapSpace::Alloc(self, num_bytes + kValgrindRedZoneBytes * 2, bytes_allocated,
@@ -63,26 +63,35 @@
return object_without_rdz;
}
- virtual size_t AllocationSize(mirror::Object* obj, size_t* usable_size) OVERRIDE {
- mirror::Object* object_with_rdz = reinterpret_cast<mirror::Object*>(
- reinterpret_cast<uintptr_t>(obj) - kValgrindRedZoneBytes);
- return LargeObjectMapSpace::AllocationSize(object_with_rdz, usable_size);
+ size_t AllocationSize(mirror::Object* obj, size_t* usable_size) OVERRIDE {
+ return LargeObjectMapSpace::AllocationSize(ObjectWithRedzone(obj), usable_size);
}
- virtual size_t Free(Thread* self, mirror::Object* obj) OVERRIDE {
- mirror::Object* object_with_rdz = reinterpret_cast<mirror::Object*>(
- reinterpret_cast<uintptr_t>(obj) - kValgrindRedZoneBytes);
+ bool IsZygoteLargeObject(Thread* self, mirror::Object* obj) const OVERRIDE {
+ return LargeObjectMapSpace::IsZygoteLargeObject(self, ObjectWithRedzone(obj));
+ }
+
+ size_t Free(Thread* self, mirror::Object* obj) OVERRIDE {
+ mirror::Object* object_with_rdz = ObjectWithRedzone(obj);
VALGRIND_MAKE_MEM_UNDEFINED(object_with_rdz, AllocationSize(obj, nullptr));
return LargeObjectMapSpace::Free(self, object_with_rdz);
}
bool Contains(const mirror::Object* obj) const OVERRIDE {
- mirror::Object* object_with_rdz = reinterpret_cast<mirror::Object*>(
- reinterpret_cast<uintptr_t>(obj) - kValgrindRedZoneBytes);
- return LargeObjectMapSpace::Contains(object_with_rdz);
+ return LargeObjectMapSpace::Contains(ObjectWithRedzone(obj));
}
private:
+ static const mirror::Object* ObjectWithRedzone(const mirror::Object* obj) {
+ return reinterpret_cast<const mirror::Object*>(
+ reinterpret_cast<uintptr_t>(obj) - kValgrindRedZoneBytes);
+ }
+
+ static mirror::Object* ObjectWithRedzone(mirror::Object* obj) {
+ return reinterpret_cast<mirror::Object*>(
+ reinterpret_cast<uintptr_t>(obj) - kValgrindRedZoneBytes);
+ }
+
static constexpr size_t kValgrindRedZoneBytes = kPageSize;
};
@@ -139,8 +148,7 @@
CHECK(space_bitmap == nullptr) << obj_end << " overlaps with bitmap " << *space_bitmap;
}
MutexLock mu(self, lock_);
- large_objects_.push_back(obj);
- mem_maps_.Put(obj, mem_map);
+ large_objects_.Put(obj, LargeObject {mem_map, false /* not zygote */});
const size_t allocation_size = mem_map->BaseSize();
DCHECK(bytes_allocated != nullptr);
begin_ = std::min(begin_, reinterpret_cast<uint8_t*>(obj));
@@ -161,28 +169,43 @@
return obj;
}
+bool LargeObjectMapSpace::IsZygoteLargeObject(Thread* self, mirror::Object* obj) const {
+ MutexLock mu(self, lock_);
+ auto it = large_objects_.find(obj);
+ CHECK(it != large_objects_.end());
+ return it->second.is_zygote;
+}
+
+void LargeObjectMapSpace::SetAllLargeObjectsAsZygoteObjects(Thread* self) {
+ MutexLock mu(self, lock_);
+ for (auto& pair : large_objects_) {
+ pair.second.is_zygote = true;
+ }
+}
+
size_t LargeObjectMapSpace::Free(Thread* self, mirror::Object* ptr) {
MutexLock mu(self, lock_);
- MemMaps::iterator found = mem_maps_.find(ptr);
- if (UNLIKELY(found == mem_maps_.end())) {
- Runtime::Current()->GetHeap()->DumpSpaces(LOG(ERROR));
+ auto it = large_objects_.find(ptr);
+ if (UNLIKELY(it == large_objects_.end())) {
+ Runtime::Current()->GetHeap()->DumpSpaces(LOG(INTERNAL_FATAL));
LOG(FATAL) << "Attempted to free large object " << ptr << " which was not live";
}
- const size_t map_size = found->second->BaseSize();
+ MemMap* mem_map = it->second.mem_map;
+ const size_t map_size = mem_map->BaseSize();
DCHECK_GE(num_bytes_allocated_, map_size);
size_t allocation_size = map_size;
num_bytes_allocated_ -= allocation_size;
--num_objects_allocated_;
- delete found->second;
- mem_maps_.erase(found);
+ delete mem_map;
+ large_objects_.erase(it);
return allocation_size;
}
size_t LargeObjectMapSpace::AllocationSize(mirror::Object* obj, size_t* usable_size) {
MutexLock mu(Thread::Current(), lock_);
- auto found = mem_maps_.find(obj);
- CHECK(found != mem_maps_.end()) << "Attempted to get size of a large object which is not live";
- size_t alloc_size = found->second->BaseSize();
+ auto it = large_objects_.find(obj);
+ CHECK(it != large_objects_.end()) << "Attempted to get size of a large object which is not live";
+ size_t alloc_size = it->second.mem_map->BaseSize();
if (usable_size != nullptr) {
*usable_size = alloc_size;
}
@@ -202,8 +225,8 @@
void LargeObjectMapSpace::Walk(DlMallocSpace::WalkCallback callback, void* arg) {
MutexLock mu(Thread::Current(), lock_);
- for (auto it = mem_maps_.begin(); it != mem_maps_.end(); ++it) {
- MemMap* mem_map = it->second;
+ for (auto& pair : large_objects_) {
+ MemMap* mem_map = pair.second.mem_map;
callback(mem_map->Begin(), mem_map->End(), mem_map->Size(), arg);
callback(nullptr, nullptr, 0, arg);
}
@@ -213,22 +236,25 @@
Thread* self = Thread::Current();
if (lock_.IsExclusiveHeld(self)) {
// We hold lock_ so do the check.
- return mem_maps_.find(const_cast<mirror::Object*>(obj)) != mem_maps_.end();
+ return large_objects_.find(const_cast<mirror::Object*>(obj)) != large_objects_.end();
} else {
MutexLock mu(self, lock_);
- return mem_maps_.find(const_cast<mirror::Object*>(obj)) != mem_maps_.end();
+ return large_objects_.find(const_cast<mirror::Object*>(obj)) != large_objects_.end();
}
}
// Keeps track of allocation sizes + whether or not the previous allocation is free.
-// Used to coalesce free blocks and find the best fit block for an allocation.
+// Used to coalesce free blocks and find the best fit block for an allocation for best fit object
+// allocation. Each allocation has an AllocationInfo which contains the size of the previous free
+// block preceding it. Implemented in such a way that we can also find the iterator for any
+// allocation info pointer.
class AllocationInfo {
public:
AllocationInfo() : prev_free_(0), alloc_size_(0) {
}
// Return the number of pages that the allocation info covers.
size_t AlignSize() const {
- return alloc_size_ & ~kFlagFree;
+ return alloc_size_ & kFlagsMask;
}
// Returns the allocation size in bytes.
size_t ByteSize() const {
@@ -236,12 +262,23 @@
}
// Updates the allocation size and whether or not it is free.
void SetByteSize(size_t size, bool free) {
+ DCHECK_EQ(size & ~kFlagsMask, 0u);
DCHECK_ALIGNED(size, FreeListSpace::kAlignment);
- alloc_size_ = (size / FreeListSpace::kAlignment) | (free ? kFlagFree : 0U);
+ alloc_size_ = (size / FreeListSpace::kAlignment) | (free ? kFlagFree : 0u);
}
+ // Returns true if the block is free.
bool IsFree() const {
return (alloc_size_ & kFlagFree) != 0;
}
+ // Return true if the large object is a zygote object.
+ bool IsZygoteObject() const {
+ return (alloc_size_ & kFlagZygote) != 0;
+ }
+ // Change the object to be a zygote object.
+ void SetZygoteObject() {
+ alloc_size_ |= kFlagZygote;
+ }
+ // Return true if this is a zygote large object.
// Finds and returns the next non free allocation info after ourself.
AllocationInfo* GetNextInfo() {
return this + AlignSize();
@@ -275,10 +312,9 @@
}
private:
- // Used to implement best fit object allocation. Each allocation has an AllocationInfo which
- // contains the size of the previous free block preceding it. Implemented in such a way that we
- // can also find the iterator for any allocation info pointer.
- static constexpr uint32_t kFlagFree = 0x8000000;
+ static constexpr uint32_t kFlagFree = 0x80000000; // If block is free.
+ static constexpr uint32_t kFlagZygote = 0x40000000; // If the large object is a zygote object.
+ static constexpr uint32_t kFlagsMask = ~(kFlagFree | kFlagZygote); // Combined flags for masking.
// Contains the size of the previous free block with kAlignment as the unit. If 0 then the
// allocation before us is not free.
// These variables are undefined in the middle of allocations / free blocks.
@@ -493,7 +529,7 @@
}
void FreeListSpace::Dump(std::ostream& os) const {
- MutexLock mu(Thread::Current(), const_cast<Mutex&>(lock_));
+ MutexLock mu(Thread::Current(), lock_);
os << GetName() << " -"
<< " begin: " << reinterpret_cast<void*>(Begin())
<< " end: " << reinterpret_cast<void*>(End()) << "\n";
@@ -519,6 +555,24 @@
}
}
+bool FreeListSpace::IsZygoteLargeObject(Thread* self ATTRIBUTE_UNUSED, mirror::Object* obj) const {
+ const AllocationInfo* info = GetAllocationInfoForAddress(reinterpret_cast<uintptr_t>(obj));
+ DCHECK(info != nullptr);
+ return info->IsZygoteObject();
+}
+
+void FreeListSpace::SetAllLargeObjectsAsZygoteObjects(Thread* self) {
+ MutexLock mu(self, lock_);
+ uintptr_t free_end_start = reinterpret_cast<uintptr_t>(end_) - free_end_;
+ for (AllocationInfo* cur_info = GetAllocationInfoForAddress(reinterpret_cast<uintptr_t>(Begin())),
+ *end_info = GetAllocationInfoForAddress(free_end_start); cur_info < end_info;
+ cur_info = cur_info->GetNextInfo()) {
+ if (!cur_info->IsFree()) {
+ cur_info->SetZygoteObject();
+ }
+ }
+}
+
void LargeObjectSpace::SweepCallback(size_t num_ptrs, mirror::Object** ptrs, void* arg) {
SweepCallbackContext* context = static_cast<SweepCallbackContext*>(arg);
space::LargeObjectSpace* space = context->space->AsLargeObjectSpace();
diff --git a/runtime/gc/space/large_object_space.h b/runtime/gc/space/large_object_space.h
index d1f9386..45ed0cd 100644
--- a/runtime/gc/space/large_object_space.h
+++ b/runtime/gc/space/large_object_space.h
@@ -98,6 +98,12 @@
void LogFragmentationAllocFailure(std::ostream& os, size_t failed_alloc_bytes) OVERRIDE
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ // Return true if the large object is a zygote large object. Potentially slow.
+ virtual bool IsZygoteLargeObject(Thread* self, mirror::Object* obj) const = 0;
+ // Called when we create the zygote space, mark all existing large objects as zygote large
+ // objects.
+ virtual void SetAllLargeObjectsAsZygoteObjects(Thread* self) = 0;
+
protected:
explicit LargeObjectSpace(const std::string& name, uint8_t* begin, uint8_t* end);
static void SweepCallback(size_t num_ptrs, mirror::Object** ptrs, void* arg);
@@ -133,16 +139,20 @@
bool Contains(const mirror::Object* obj) const NO_THREAD_SAFETY_ANALYSIS;
protected:
+ struct LargeObject {
+ MemMap* mem_map;
+ bool is_zygote;
+ };
explicit LargeObjectMapSpace(const std::string& name);
virtual ~LargeObjectMapSpace() {}
+ bool IsZygoteLargeObject(Thread* self, mirror::Object* obj) const OVERRIDE LOCKS_EXCLUDED(lock_);
+ void SetAllLargeObjectsAsZygoteObjects(Thread* self) OVERRIDE LOCKS_EXCLUDED(lock_);
+
// Used to ensure mutual exclusion when the allocation spaces data structures are being modified.
mutable Mutex lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
- std::vector<mirror::Object*, TrackingAllocator<mirror::Object*, kAllocatorTagLOS>> large_objects_
+ AllocationTrackingSafeMap<mirror::Object*, LargeObject, kAllocatorTagLOSMaps> large_objects_
GUARDED_BY(lock_);
- typedef SafeMap<mirror::Object*, MemMap*, std::less<mirror::Object*>,
- TrackingAllocator<std::pair<mirror::Object*, MemMap*>, kAllocatorTagLOSMaps>> MemMaps;
- MemMaps mem_maps_ GUARDED_BY(lock_);
};
// A continuous large object space with a free-list to handle holes.
@@ -177,6 +187,8 @@
}
// Removes header from the free blocks set by finding the corresponding iterator and erasing it.
void RemoveFreePrev(AllocationInfo* info) EXCLUSIVE_LOCKS_REQUIRED(lock_);
+ bool IsZygoteLargeObject(Thread* self, mirror::Object* obj) const OVERRIDE;
+ void SetAllLargeObjectsAsZygoteObjects(Thread* self) OVERRIDE;
class SortByPrevFree {
public:
@@ -192,7 +204,7 @@
std::unique_ptr<MemMap> allocation_info_map_;
AllocationInfo* allocation_info_;
- Mutex lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
+ mutable Mutex lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
// Free bytes at the end of the space.
size_t free_end_ GUARDED_BY(lock_);
FreeBlocks free_blocks_ GUARDED_BY(lock_);
diff --git a/runtime/gc/space/large_object_space_test.cc b/runtime/gc/space/large_object_space_test.cc
index f04a7ca..05b484a 100644
--- a/runtime/gc/space/large_object_space_test.cc
+++ b/runtime/gc/space/large_object_space_test.cc
@@ -34,6 +34,7 @@
void LargeObjectSpaceTest::LargeObjectTest() {
size_t rand_seed = 0;
+ Thread* const self = Thread::Current();
for (size_t i = 0; i < 2; ++i) {
LargeObjectSpace* los = nullptr;
if (i == 0) {
@@ -51,8 +52,8 @@
size_t request_size = test_rand(&rand_seed) % max_allocation_size;
size_t allocation_size = 0;
size_t bytes_tl_bulk_allocated;
- mirror::Object* obj = los->Alloc(Thread::Current(), request_size, &allocation_size,
- nullptr, &bytes_tl_bulk_allocated);
+ mirror::Object* obj = los->Alloc(self, request_size, &allocation_size, nullptr,
+ &bytes_tl_bulk_allocated);
ASSERT_TRUE(obj != nullptr);
ASSERT_EQ(allocation_size, los->AllocationSize(obj, nullptr));
ASSERT_GE(allocation_size, request_size);
@@ -70,8 +71,21 @@
}
}
+ // Check the zygote flag for the first phase.
+ if (phase == 0) {
+ for (const auto& pair : requests) {
+ mirror::Object* obj = pair.first;
+ ASSERT_FALSE(los->IsZygoteLargeObject(self, obj));
+ }
+ los->SetAllLargeObjectsAsZygoteObjects(self);
+ for (const auto& pair : requests) {
+ mirror::Object* obj = pair.first;
+ ASSERT_TRUE(los->IsZygoteLargeObject(self, obj));
+ }
+ }
+
// Free 1 / 2 the allocations the first phase, and all the second phase.
- size_t limit = !phase ? requests.size() / 2 : 0;
+ size_t limit = phase == 0 ? requests.size() / 2 : 0;
while (requests.size() > limit) {
mirror::Object* obj = requests.back().first;
size_t request_size = requests.back().second;
@@ -88,7 +102,7 @@
size_t bytes_allocated = 0, bytes_tl_bulk_allocated;
// Checks that the coalescing works.
- mirror::Object* obj = los->Alloc(Thread::Current(), 100 * MB, &bytes_allocated, nullptr,
+ mirror::Object* obj = los->Alloc(self, 100 * MB, &bytes_allocated, nullptr,
&bytes_tl_bulk_allocated);
EXPECT_TRUE(obj != nullptr);
los->Free(Thread::Current(), obj);
diff --git a/runtime/hprof/hprof.cc b/runtime/hprof/hprof.cc
index 917fe43..6e0e56e 100644
--- a/runtime/hprof/hprof.cc
+++ b/runtime/hprof/hprof.cc
@@ -891,8 +891,8 @@
return;
}
- gc::space::ContinuousSpace* space =
- Runtime::Current()->GetHeap()->FindContinuousSpaceFromObject(obj, true);
+ gc::Heap* const heap = Runtime::Current()->GetHeap();
+ const gc::space::ContinuousSpace* const space = heap->FindContinuousSpaceFromObject(obj, true);
HprofHeapId heap_type = HPROF_HEAP_APP;
if (space != nullptr) {
if (space->IsZygoteSpace()) {
@@ -900,6 +900,11 @@
} else if (space->IsImageSpace()) {
heap_type = HPROF_HEAP_IMAGE;
}
+ } else {
+ const auto* los = heap->GetLargeObjectsSpace();
+ if (los->Contains(obj) && los->IsZygoteLargeObject(Thread::Current(), obj)) {
+ heap_type = HPROF_HEAP_ZYGOTE;
+ }
}
CheckHeapSegmentConstraints();
@@ -1040,7 +1045,7 @@
}
// Instance fields for this class (no superclass fields)
- int iFieldCount = klass->IsObjectClass() ? 0 : klass->NumInstanceFields();
+ int iFieldCount = klass->NumInstanceFields();
if (klass->IsStringClass()) {
__ AddU2((uint16_t)iFieldCount + 1);
} else {
@@ -1114,7 +1119,7 @@
// Write the instance data; fields for this class, followed by super class fields,
// and so on. Don't write the klass or monitor fields of Object.class.
mirror::Class* orig_klass = klass;
- while (!klass->IsObjectClass()) {
+ do {
int ifieldCount = klass->NumInstanceFields();
for (int i = 0; i < ifieldCount; ++i) {
ArtField* f = klass->GetInstanceField(i);
@@ -1146,7 +1151,7 @@
}
klass = klass->GetSuperClass();
- }
+ } while (klass != nullptr);
// Output native value character array for strings.
if (orig_klass->IsStringClass()) {
diff --git a/runtime/mem_map.cc b/runtime/mem_map.cc
index cf4233c..d8c1ec1 100644
--- a/runtime/mem_map.cc
+++ b/runtime/mem_map.cc
@@ -221,7 +221,7 @@
// We call this here so that we can try and generate a full error
// message with the overlapping mapping. There's no guarantee that
// that there will be an overlap though, since
- // - The kernel is not *required* to honour expected_ptr unless MAP_FIXED is
+ // - The kernel is not *required* to honor expected_ptr unless MAP_FIXED is
// true, even if there is no overlap
// - There might have been an overlap at the point of mmap, but the
// overlapping region has since been unmapped.
diff --git a/runtime/native/java_lang_VMClassLoader.cc b/runtime/native/java_lang_VMClassLoader.cc
index 0c39f2b..1515630 100644
--- a/runtime/native/java_lang_VMClassLoader.cc
+++ b/runtime/native/java_lang_VMClassLoader.cc
@@ -55,60 +55,29 @@
return nullptr;
}
-static jint VMClassLoader_getBootClassPathSize(JNIEnv*, jclass) {
- return Runtime::Current()->GetClassLinker()->GetBootClassPath().size();
-}
-
/*
- * Returns a string URL for a resource with the specified 'javaName' in
- * entry 'index' of the boot class path.
- *
- * We return a newly-allocated String in the following form:
- *
- * jar:file://path!/name
- *
- * Where "path" is the bootstrap class path entry and "name" is the string
- * passed into this method. "path" needs to be an absolute path (starting
- * with '/'); if it's not we'd need to make it absolute as part of forming
- * the URL string.
+ * Returns an array of entries from the boot classpath that could contain resources.
*/
-static jstring VMClassLoader_getBootClassPathResource(JNIEnv* env, jclass, jstring javaName,
- jint index) {
- ScopedUtfChars name(env, javaName);
- if (name.c_str() == nullptr) {
- return nullptr;
- }
-
+static jobjectArray VMClassLoader_getBootClassPathEntries(JNIEnv* env, jclass) {
const std::vector<const DexFile*>& path =
Runtime::Current()->GetClassLinker()->GetBootClassPath();
- if (index < 0 || size_t(index) >= path.size()) {
- return nullptr;
- }
- const DexFile* dex_file = path[index];
+ jclass stringClass = env->FindClass("java/lang/String");
+ jobjectArray array = env->NewObjectArray(path.size(), stringClass, nullptr);
+ for (size_t i = 0; i < path.size(); ++i) {
+ const DexFile* dex_file = path[i];
- // For multidex locations, e.g., x.jar:classes2.dex, we want to look into x.jar.
- const std::string& location(dex_file->GetBaseLocation());
+ // For multidex locations, e.g., x.jar:classes2.dex, we want to look into x.jar.
+ const std::string& location(dex_file->GetBaseLocation());
- std::string error_msg;
- std::unique_ptr<ZipArchive> zip_archive(ZipArchive::Open(location.c_str(), &error_msg));
- if (zip_archive.get() == nullptr) {
- LOG(WARNING) << "Failed to open zip archive '" << location << "': " << error_msg;
- return nullptr;
+ jstring javaPath = env->NewStringUTF(location.c_str());
+ env->SetObjectArrayElement(array, i, javaPath);
}
- std::unique_ptr<ZipEntry> zip_entry(zip_archive->Find(name.c_str(), &error_msg));
- if (zip_entry.get() == nullptr) {
- return nullptr;
- }
-
- std::string url;
- StringAppendF(&url, "jar:file://%s!/%s", location.c_str(), name.c_str());
- return env->NewStringUTF(url.c_str());
+ return array;
}
static JNINativeMethod gMethods[] = {
NATIVE_METHOD(VMClassLoader, findLoadedClass, "!(Ljava/lang/ClassLoader;Ljava/lang/String;)Ljava/lang/Class;"),
- NATIVE_METHOD(VMClassLoader, getBootClassPathResource, "(Ljava/lang/String;I)Ljava/lang/String;"),
- NATIVE_METHOD(VMClassLoader, getBootClassPathSize, "!()I"),
+ NATIVE_METHOD(VMClassLoader, getBootClassPathEntries, "()[Ljava/lang/String;"),
};
void register_java_lang_VMClassLoader(JNIEnv* env) {
diff --git a/runtime/thread.cc b/runtime/thread.cc
index 65999f7..67f611e 100644
--- a/runtime/thread.cc
+++ b/runtime/thread.cc
@@ -196,7 +196,12 @@
// Check that if we got here we cannot be shutting down (as shutdown should never have started
// while threads are being born).
CHECK(!runtime->IsShuttingDownLocked());
- CHECK(self->Init(runtime->GetThreadList(), runtime->GetJavaVM()));
+ // Note: given that the JNIEnv is created in the parent thread, the only failure point here is
+ // a mess in InitStackHwm. We do not have a reasonable way to recover from that, so abort
+ // the runtime in such a case. In case this ever changes, we need to make sure here to
+ // delete the tmp_jni_env, as we own it at this point.
+ CHECK(self->Init(runtime->GetThreadList(), runtime->GetJavaVM(), self->tlsPtr_.tmp_jni_env));
+ self->tlsPtr_.tmp_jni_env = nullptr;
Runtime::Current()->EndThreadBirth();
}
{
@@ -358,37 +363,59 @@
env->SetLongField(java_peer, WellKnownClasses::java_lang_Thread_nativePeer,
reinterpret_cast<jlong>(child_thread));
- pthread_t new_pthread;
- pthread_attr_t attr;
- CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "new thread");
- CHECK_PTHREAD_CALL(pthread_attr_setdetachstate, (&attr, PTHREAD_CREATE_DETACHED), "PTHREAD_CREATE_DETACHED");
- CHECK_PTHREAD_CALL(pthread_attr_setstacksize, (&attr, stack_size), stack_size);
- int pthread_create_result = pthread_create(&new_pthread, &attr, Thread::CreateCallback, child_thread);
- CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "new thread");
+ // Try to allocate a JNIEnvExt for the thread. We do this here as we might be out of memory and
+ // do not have a good way to report this on the child's side.
+ std::unique_ptr<JNIEnvExt> child_jni_env_ext(
+ JNIEnvExt::Create(child_thread, Runtime::Current()->GetJavaVM()));
- if (pthread_create_result != 0) {
- // pthread_create(3) failed, so clean up.
- {
- MutexLock mu(self, *Locks::runtime_shutdown_lock_);
- runtime->EndThreadBirth();
+ int pthread_create_result = 0;
+ if (child_jni_env_ext.get() != nullptr) {
+ pthread_t new_pthread;
+ pthread_attr_t attr;
+ child_thread->tlsPtr_.tmp_jni_env = child_jni_env_ext.get();
+ CHECK_PTHREAD_CALL(pthread_attr_init, (&attr), "new thread");
+ CHECK_PTHREAD_CALL(pthread_attr_setdetachstate, (&attr, PTHREAD_CREATE_DETACHED),
+ "PTHREAD_CREATE_DETACHED");
+ CHECK_PTHREAD_CALL(pthread_attr_setstacksize, (&attr, stack_size), stack_size);
+ pthread_create_result = pthread_create(&new_pthread,
+ &attr,
+ Thread::CreateCallback,
+ child_thread);
+ CHECK_PTHREAD_CALL(pthread_attr_destroy, (&attr), "new thread");
+
+ if (pthread_create_result == 0) {
+ // pthread_create started the new thread. The child is now responsible for managing the
+ // JNIEnvExt we created.
+ // Note: we can't check for tmp_jni_env == nullptr, as that would require synchronization
+ // between the threads.
+ child_jni_env_ext.release();
+ return;
}
- // Manually delete the global reference since Thread::Init will not have been run.
- env->DeleteGlobalRef(child_thread->tlsPtr_.jpeer);
- child_thread->tlsPtr_.jpeer = nullptr;
- delete child_thread;
- child_thread = nullptr;
- // TODO: remove from thread group?
- env->SetLongField(java_peer, WellKnownClasses::java_lang_Thread_nativePeer, 0);
- {
- std::string msg(StringPrintf("pthread_create (%s stack) failed: %s",
- PrettySize(stack_size).c_str(), strerror(pthread_create_result)));
- ScopedObjectAccess soa(env);
- soa.Self()->ThrowOutOfMemoryError(msg.c_str());
- }
+ }
+
+ // Either JNIEnvExt::Create or pthread_create(3) failed, so clean up.
+ {
+ MutexLock mu(self, *Locks::runtime_shutdown_lock_);
+ runtime->EndThreadBirth();
+ }
+ // Manually delete the global reference since Thread::Init will not have been run.
+ env->DeleteGlobalRef(child_thread->tlsPtr_.jpeer);
+ child_thread->tlsPtr_.jpeer = nullptr;
+ delete child_thread;
+ child_thread = nullptr;
+ // TODO: remove from thread group?
+ env->SetLongField(java_peer, WellKnownClasses::java_lang_Thread_nativePeer, 0);
+ {
+ std::string msg(child_jni_env_ext.get() == nullptr ?
+ "Could not allocate JNI Env" :
+ StringPrintf("pthread_create (%s stack) failed: %s",
+ PrettySize(stack_size).c_str(), strerror(pthread_create_result)));
+ ScopedObjectAccess soa(env);
+ soa.Self()->ThrowOutOfMemoryError(msg.c_str());
}
}
-bool Thread::Init(ThreadList* thread_list, JavaVMExt* java_vm) {
+bool Thread::Init(ThreadList* thread_list, JavaVMExt* java_vm, JNIEnvExt* jni_env_ext) {
// This function does all the initialization that must be run by the native thread it applies to.
// (When we create a new thread from managed code, we allocate the Thread* in Thread::Create so
// we can handshake with the corresponding native thread when it's ready.) Check this native
@@ -415,9 +442,15 @@
tls32_.thin_lock_thread_id = thread_list->AllocThreadId(this);
- tlsPtr_.jni_env = JNIEnvExt::Create(this, java_vm);
- if (tlsPtr_.jni_env == nullptr) {
- return false;
+ if (jni_env_ext != nullptr) {
+ DCHECK_EQ(jni_env_ext->vm, java_vm);
+ DCHECK_EQ(jni_env_ext->self, this);
+ tlsPtr_.jni_env = jni_env_ext;
+ } else {
+ tlsPtr_.jni_env = JNIEnvExt::Create(this, java_vm);
+ if (tlsPtr_.jni_env == nullptr) {
+ return false;
+ }
}
thread_list->Register(this);
diff --git a/runtime/thread.h b/runtime/thread.h
index 8c2e215..3f0d0a5 100644
--- a/runtime/thread.h
+++ b/runtime/thread.h
@@ -975,7 +975,15 @@
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void RemoveFromThreadGroup(ScopedObjectAccess& soa) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool Init(ThreadList*, JavaVMExt*) EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_);
+ // Initialize a thread.
+ //
+ // The third parameter is not mandatory. If given, the thread will use this JNIEnvExt. In case
+ // Init succeeds, this means the thread takes ownership of it. If Init fails, it is the caller's
+ // responsibility to destroy the given JNIEnvExt. If the parameter is null, Init will try to
+ // create a JNIEnvExt on its own (and potentially fail at that stage, indicated by a return value
+ // of false).
+ bool Init(ThreadList*, JavaVMExt*, JNIEnvExt* jni_env_ext = nullptr)
+ EXCLUSIVE_LOCKS_REQUIRED(Locks::runtime_shutdown_lock_);
void InitCardTable();
void InitCpu();
void CleanupCpu();
@@ -1111,8 +1119,8 @@
struct PACKED(4) tls_ptr_sized_values {
tls_ptr_sized_values() : card_table(nullptr), exception(nullptr), stack_end(nullptr),
- managed_stack(), suspend_trigger(nullptr), jni_env(nullptr), self(nullptr), opeer(nullptr),
- jpeer(nullptr), stack_begin(nullptr), stack_size(0),
+ managed_stack(), suspend_trigger(nullptr), jni_env(nullptr), tmp_jni_env(nullptr),
+ self(nullptr), opeer(nullptr), jpeer(nullptr), stack_begin(nullptr), stack_size(0),
stack_trace_sample(nullptr), wait_next(nullptr), monitor_enter_object(nullptr),
top_handle_scope(nullptr), class_loader_override(nullptr), long_jump_context(nullptr),
instrumentation_stack(nullptr), debug_invoke_req(nullptr), single_step_control(nullptr),
@@ -1144,6 +1152,10 @@
// Every thread may have an associated JNI environment
JNIEnvExt* jni_env;
+ // Temporary storage to transfer a pre-allocated JNIEnvExt from the creating thread to the
+ // created thread.
+ JNIEnvExt* tmp_jni_env;
+
// Initialized to "this". On certain architectures (such as x86) reading off of Thread::Current
// is easy but getting the address of Thread::Current is hard. This field can be read off of
// Thread::Current to give the address.
diff --git a/test/004-StackWalk/src/Main.java b/test/004-StackWalk/src/Main.java
index 782f51d..9a1d0ab 100644
--- a/test/004-StackWalk/src/Main.java
+++ b/test/004-StackWalk/src/Main.java
@@ -2,7 +2,7 @@
public Main() {
}
- int f() throws Exception {
+ int $noinline$f() throws Exception {
g(1);
g(2);
@@ -93,6 +93,6 @@
public static void main(String[] args) throws Exception {
Main st = new Main();
- st.f();
+ st.$noinline$f();
}
}
diff --git a/test/067-preemptive-unpark/src/Main.java b/test/067-preemptive-unpark/src/Main.java
index 2c099b9..beb3262 100644
--- a/test/067-preemptive-unpark/src/Main.java
+++ b/test/067-preemptive-unpark/src/Main.java
@@ -40,22 +40,24 @@
/**
* Set up {@link #UNSAFE}.
*/
- public static void setUp() {
+ public static void setUp() throws Exception{
/*
* Subvert the access check to get the unique Unsafe instance.
* We can do this because there's no security manager
* installed when running the test.
*/
+ Field field = null;
try {
- Field field = Unsafe.class.getDeclaredField("THE_ONE");
- field.setAccessible(true);
-
- UNSAFE = (Unsafe) field.get(null);
- } catch (NoSuchFieldException ex) {
- throw new RuntimeException(ex);
- } catch (IllegalAccessException ex) {
- throw new RuntimeException(ex);
+ field = Unsafe.class.getDeclaredField("THE_ONE");
+ } catch (NoSuchFieldException e1) {
+ try {
+ field = Unsafe.class.getDeclaredField("theUnsafe");
+ } catch (NoSuchFieldException e2) {
+ throw new RuntimeException("Failed to find THE_ONE or theUnsafe");
+ }
}
+ field.setAccessible(true);
+ UNSAFE = (Unsafe) field.get(null);
}
/**
diff --git a/test/133-static-invoke-super/src/Main.java b/test/133-static-invoke-super/src/Main.java
index 7cfd099..e694998 100644
--- a/test/133-static-invoke-super/src/Main.java
+++ b/test/133-static-invoke-super/src/Main.java
@@ -26,14 +26,14 @@
run(timing);
}
- static int testBasis(int interations) {
- (new SubClass()).testDirect(interations);
- return interations;
+ static int testBasis(int iterations) {
+ (new SubClass()).testDirect(iterations);
+ return iterations;
}
- static int testStatic(int interations) {
- (new SubClass()).testStatic(interations);
- return interations;
+ static int testStatic(int iterations) {
+ (new SubClass()).testStatic(iterations);
+ return iterations;
}
static public void run(boolean timing) {
diff --git a/test/422-type-conversion/src/Main.java b/test/422-type-conversion/src/Main.java
index 447b9b8..9f8f417 100644
--- a/test/422-type-conversion/src/Main.java
+++ b/test/422-type-conversion/src/Main.java
@@ -138,554 +138,554 @@
}
private static void byteToLong() {
- assertLongEquals(1L, $opt$ByteToLong((byte)1));
- assertLongEquals(0L, $opt$ByteToLong((byte)0));
- assertLongEquals(-1L, $opt$ByteToLong((byte)-1));
- assertLongEquals(51L, $opt$ByteToLong((byte)51));
- assertLongEquals(-51L, $opt$ByteToLong((byte)-51));
- assertLongEquals(127L, $opt$ByteToLong((byte)127)); // 2^7 - 1
- assertLongEquals(-127L, $opt$ByteToLong((byte)-127)); // -(2^7 - 1)
- assertLongEquals(-128L, $opt$ByteToLong((byte)-128)); // -(2^7)
+ assertLongEquals(1L, $opt$noinline$ByteToLong((byte)1));
+ assertLongEquals(0L, $opt$noinline$ByteToLong((byte)0));
+ assertLongEquals(-1L, $opt$noinline$ByteToLong((byte)-1));
+ assertLongEquals(51L, $opt$noinline$ByteToLong((byte)51));
+ assertLongEquals(-51L, $opt$noinline$ByteToLong((byte)-51));
+ assertLongEquals(127L, $opt$noinline$ByteToLong((byte)127)); // 2^7 - 1
+ assertLongEquals(-127L, $opt$noinline$ByteToLong((byte)-127)); // -(2^7 - 1)
+ assertLongEquals(-128L, $opt$noinline$ByteToLong((byte)-128)); // -(2^7)
}
private static void shortToLong() {
- assertLongEquals(1L, $opt$ShortToLong((short)1));
- assertLongEquals(0L, $opt$ShortToLong((short)0));
- assertLongEquals(-1L, $opt$ShortToLong((short)-1));
- assertLongEquals(51L, $opt$ShortToLong((short)51));
- assertLongEquals(-51L, $opt$ShortToLong((short)-51));
- assertLongEquals(32767L, $opt$ShortToLong((short)32767)); // 2^15 - 1
- assertLongEquals(-32767L, $opt$ShortToLong((short)-32767)); // -(2^15 - 1)
- assertLongEquals(-32768L, $opt$ShortToLong((short)-32768)); // -(2^15)
+ assertLongEquals(1L, $opt$noinline$ShortToLong((short)1));
+ assertLongEquals(0L, $opt$noinline$ShortToLong((short)0));
+ assertLongEquals(-1L, $opt$noinline$ShortToLong((short)-1));
+ assertLongEquals(51L, $opt$noinline$ShortToLong((short)51));
+ assertLongEquals(-51L, $opt$noinline$ShortToLong((short)-51));
+ assertLongEquals(32767L, $opt$noinline$ShortToLong((short)32767)); // 2^15 - 1
+ assertLongEquals(-32767L, $opt$noinline$ShortToLong((short)-32767)); // -(2^15 - 1)
+ assertLongEquals(-32768L, $opt$noinline$ShortToLong((short)-32768)); // -(2^15)
}
private static void intToLong() {
- assertLongEquals(1L, $opt$IntToLong(1));
- assertLongEquals(0L, $opt$IntToLong(0));
- assertLongEquals(-1L, $opt$IntToLong(-1));
- assertLongEquals(51L, $opt$IntToLong(51));
- assertLongEquals(-51L, $opt$IntToLong(-51));
- assertLongEquals(2147483647L, $opt$IntToLong(2147483647)); // 2^31 - 1
- assertLongEquals(-2147483647L, $opt$IntToLong(-2147483647)); // -(2^31 - 1)
- assertLongEquals(-2147483648L, $opt$IntToLong(-2147483648)); // -(2^31)
+ assertLongEquals(1L, $opt$noinline$IntToLong(1));
+ assertLongEquals(0L, $opt$noinline$IntToLong(0));
+ assertLongEquals(-1L, $opt$noinline$IntToLong(-1));
+ assertLongEquals(51L, $opt$noinline$IntToLong(51));
+ assertLongEquals(-51L, $opt$noinline$IntToLong(-51));
+ assertLongEquals(2147483647L, $opt$noinline$IntToLong(2147483647)); // 2^31 - 1
+ assertLongEquals(-2147483647L, $opt$noinline$IntToLong(-2147483647)); // -(2^31 - 1)
+ assertLongEquals(-2147483648L, $opt$noinline$IntToLong(-2147483648)); // -(2^31)
}
private static void charToLong() {
- assertLongEquals(1L, $opt$CharToLong((char)1));
- assertLongEquals(0L, $opt$CharToLong((char)0));
- assertLongEquals(51L, $opt$CharToLong((char)51));
- assertLongEquals(32767L, $opt$CharToLong((char)32767)); // 2^15 - 1
- assertLongEquals(65535L, $opt$CharToLong((char)65535)); // 2^16 - 1
- assertLongEquals(65535L, $opt$CharToLong((char)-1));
- assertLongEquals(65485L, $opt$CharToLong((char)-51));
- assertLongEquals(32769L, $opt$CharToLong((char)-32767)); // -(2^15 - 1)
- assertLongEquals(32768L, $opt$CharToLong((char)-32768)); // -(2^15)
+ assertLongEquals(1L, $opt$noinline$CharToLong((char)1));
+ assertLongEquals(0L, $opt$noinline$CharToLong((char)0));
+ assertLongEquals(51L, $opt$noinline$CharToLong((char)51));
+ assertLongEquals(32767L, $opt$noinline$CharToLong((char)32767)); // 2^15 - 1
+ assertLongEquals(65535L, $opt$noinline$CharToLong((char)65535)); // 2^16 - 1
+ assertLongEquals(65535L, $opt$noinline$CharToLong((char)-1));
+ assertLongEquals(65485L, $opt$noinline$CharToLong((char)-51));
+ assertLongEquals(32769L, $opt$noinline$CharToLong((char)-32767)); // -(2^15 - 1)
+ assertLongEquals(32768L, $opt$noinline$CharToLong((char)-32768)); // -(2^15)
}
private static void byteToFloat() {
- assertFloatEquals(1F, $opt$ByteToFloat((byte)1));
- assertFloatEquals(0F, $opt$ByteToFloat((byte)0));
- assertFloatEquals(-1F, $opt$ByteToFloat((byte)-1));
- assertFloatEquals(51F, $opt$ByteToFloat((byte)51));
- assertFloatEquals(-51F, $opt$ByteToFloat((byte)-51));
- assertFloatEquals(127F, $opt$ByteToFloat((byte)127)); // 2^7 - 1
- assertFloatEquals(-127F, $opt$ByteToFloat((byte)-127)); // -(2^7 - 1)
- assertFloatEquals(-128F, $opt$ByteToFloat((byte)-128)); // -(2^7)
+ assertFloatEquals(1F, $opt$noinline$ByteToFloat((byte)1));
+ assertFloatEquals(0F, $opt$noinline$ByteToFloat((byte)0));
+ assertFloatEquals(-1F, $opt$noinline$ByteToFloat((byte)-1));
+ assertFloatEquals(51F, $opt$noinline$ByteToFloat((byte)51));
+ assertFloatEquals(-51F, $opt$noinline$ByteToFloat((byte)-51));
+ assertFloatEquals(127F, $opt$noinline$ByteToFloat((byte)127)); // 2^7 - 1
+ assertFloatEquals(-127F, $opt$noinline$ByteToFloat((byte)-127)); // -(2^7 - 1)
+ assertFloatEquals(-128F, $opt$noinline$ByteToFloat((byte)-128)); // -(2^7)
}
private static void shortToFloat() {
- assertFloatEquals(1F, $opt$ShortToFloat((short)1));
- assertFloatEquals(0F, $opt$ShortToFloat((short)0));
- assertFloatEquals(-1F, $opt$ShortToFloat((short)-1));
- assertFloatEquals(51F, $opt$ShortToFloat((short)51));
- assertFloatEquals(-51F, $opt$ShortToFloat((short)-51));
- assertFloatEquals(32767F, $opt$ShortToFloat((short)32767)); // 2^15 - 1
- assertFloatEquals(-32767F, $opt$ShortToFloat((short)-32767)); // -(2^15 - 1)
- assertFloatEquals(-32768F, $opt$ShortToFloat((short)-32768)); // -(2^15)
+ assertFloatEquals(1F, $opt$noinline$ShortToFloat((short)1));
+ assertFloatEquals(0F, $opt$noinline$ShortToFloat((short)0));
+ assertFloatEquals(-1F, $opt$noinline$ShortToFloat((short)-1));
+ assertFloatEquals(51F, $opt$noinline$ShortToFloat((short)51));
+ assertFloatEquals(-51F, $opt$noinline$ShortToFloat((short)-51));
+ assertFloatEquals(32767F, $opt$noinline$ShortToFloat((short)32767)); // 2^15 - 1
+ assertFloatEquals(-32767F, $opt$noinline$ShortToFloat((short)-32767)); // -(2^15 - 1)
+ assertFloatEquals(-32768F, $opt$noinline$ShortToFloat((short)-32768)); // -(2^15)
}
private static void intToFloat() {
- assertFloatEquals(1F, $opt$IntToFloat(1));
- assertFloatEquals(0F, $opt$IntToFloat(0));
- assertFloatEquals(-1F, $opt$IntToFloat(-1));
- assertFloatEquals(51F, $opt$IntToFloat(51));
- assertFloatEquals(-51F, $opt$IntToFloat(-51));
- assertFloatEquals(16777215F, $opt$IntToFloat(16777215)); // 2^24 - 1
- assertFloatEquals(-16777215F, $opt$IntToFloat(-16777215)); // -(2^24 - 1)
- assertFloatEquals(16777216F, $opt$IntToFloat(16777216)); // 2^24
- assertFloatEquals(-16777216F, $opt$IntToFloat(-16777216)); // -(2^24)
- assertFloatEquals(2147483647F, $opt$IntToFloat(2147483647)); // 2^31 - 1
- assertFloatEquals(-2147483648F, $opt$IntToFloat(-2147483648)); // -(2^31)
+ assertFloatEquals(1F, $opt$noinline$IntToFloat(1));
+ assertFloatEquals(0F, $opt$noinline$IntToFloat(0));
+ assertFloatEquals(-1F, $opt$noinline$IntToFloat(-1));
+ assertFloatEquals(51F, $opt$noinline$IntToFloat(51));
+ assertFloatEquals(-51F, $opt$noinline$IntToFloat(-51));
+ assertFloatEquals(16777215F, $opt$noinline$IntToFloat(16777215)); // 2^24 - 1
+ assertFloatEquals(-16777215F, $opt$noinline$IntToFloat(-16777215)); // -(2^24 - 1)
+ assertFloatEquals(16777216F, $opt$noinline$IntToFloat(16777216)); // 2^24
+ assertFloatEquals(-16777216F, $opt$noinline$IntToFloat(-16777216)); // -(2^24)
+ assertFloatEquals(2147483647F, $opt$noinline$IntToFloat(2147483647)); // 2^31 - 1
+ assertFloatEquals(-2147483648F, $opt$noinline$IntToFloat(-2147483648)); // -(2^31)
}
private static void charToFloat() {
- assertFloatEquals(1F, $opt$CharToFloat((char)1));
- assertFloatEquals(0F, $opt$CharToFloat((char)0));
- assertFloatEquals(51F, $opt$CharToFloat((char)51));
- assertFloatEquals(32767F, $opt$CharToFloat((char)32767)); // 2^15 - 1
- assertFloatEquals(65535F, $opt$CharToFloat((char)65535)); // 2^16 - 1
- assertFloatEquals(65535F, $opt$CharToFloat((char)-1));
- assertFloatEquals(65485F, $opt$CharToFloat((char)-51));
- assertFloatEquals(32769F, $opt$CharToFloat((char)-32767)); // -(2^15 - 1)
- assertFloatEquals(32768F, $opt$CharToFloat((char)-32768)); // -(2^15)
+ assertFloatEquals(1F, $opt$noinline$CharToFloat((char)1));
+ assertFloatEquals(0F, $opt$noinline$CharToFloat((char)0));
+ assertFloatEquals(51F, $opt$noinline$CharToFloat((char)51));
+ assertFloatEquals(32767F, $opt$noinline$CharToFloat((char)32767)); // 2^15 - 1
+ assertFloatEquals(65535F, $opt$noinline$CharToFloat((char)65535)); // 2^16 - 1
+ assertFloatEquals(65535F, $opt$noinline$CharToFloat((char)-1));
+ assertFloatEquals(65485F, $opt$noinline$CharToFloat((char)-51));
+ assertFloatEquals(32769F, $opt$noinline$CharToFloat((char)-32767)); // -(2^15 - 1)
+ assertFloatEquals(32768F, $opt$noinline$CharToFloat((char)-32768)); // -(2^15)
}
private static void byteToDouble() {
- assertDoubleEquals(1D, $opt$ByteToDouble((byte)1));
- assertDoubleEquals(0D, $opt$ByteToDouble((byte)0));
- assertDoubleEquals(-1D, $opt$ByteToDouble((byte)-1));
- assertDoubleEquals(51D, $opt$ByteToDouble((byte)51));
- assertDoubleEquals(-51D, $opt$ByteToDouble((byte)-51));
- assertDoubleEquals(127D, $opt$ByteToDouble((byte)127)); // 2^7 - 1
- assertDoubleEquals(-127D, $opt$ByteToDouble((byte)-127)); // -(2^7 - 1)
- assertDoubleEquals(-128D, $opt$ByteToDouble((byte)-128)); // -(2^7)
+ assertDoubleEquals(1D, $opt$noinline$ByteToDouble((byte)1));
+ assertDoubleEquals(0D, $opt$noinline$ByteToDouble((byte)0));
+ assertDoubleEquals(-1D, $opt$noinline$ByteToDouble((byte)-1));
+ assertDoubleEquals(51D, $opt$noinline$ByteToDouble((byte)51));
+ assertDoubleEquals(-51D, $opt$noinline$ByteToDouble((byte)-51));
+ assertDoubleEquals(127D, $opt$noinline$ByteToDouble((byte)127)); // 2^7 - 1
+ assertDoubleEquals(-127D, $opt$noinline$ByteToDouble((byte)-127)); // -(2^7 - 1)
+ assertDoubleEquals(-128D, $opt$noinline$ByteToDouble((byte)-128)); // -(2^7)
}
private static void shortToDouble() {
- assertDoubleEquals(1D, $opt$ShortToDouble((short)1));
- assertDoubleEquals(0D, $opt$ShortToDouble((short)0));
- assertDoubleEquals(-1D, $opt$ShortToDouble((short)-1));
- assertDoubleEquals(51D, $opt$ShortToDouble((short)51));
- assertDoubleEquals(-51D, $opt$ShortToDouble((short)-51));
- assertDoubleEquals(32767D, $opt$ShortToDouble((short)32767)); // 2^15 - 1
- assertDoubleEquals(-32767D, $opt$ShortToDouble((short)-32767)); // -(2^15 - 1)
- assertDoubleEquals(-32768D, $opt$ShortToDouble((short)-32768)); // -(2^15)
+ assertDoubleEquals(1D, $opt$noinline$ShortToDouble((short)1));
+ assertDoubleEquals(0D, $opt$noinline$ShortToDouble((short)0));
+ assertDoubleEquals(-1D, $opt$noinline$ShortToDouble((short)-1));
+ assertDoubleEquals(51D, $opt$noinline$ShortToDouble((short)51));
+ assertDoubleEquals(-51D, $opt$noinline$ShortToDouble((short)-51));
+ assertDoubleEquals(32767D, $opt$noinline$ShortToDouble((short)32767)); // 2^15 - 1
+ assertDoubleEquals(-32767D, $opt$noinline$ShortToDouble((short)-32767)); // -(2^15 - 1)
+ assertDoubleEquals(-32768D, $opt$noinline$ShortToDouble((short)-32768)); // -(2^15)
}
private static void intToDouble() {
- assertDoubleEquals(1D, $opt$IntToDouble(1));
- assertDoubleEquals(0D, $opt$IntToDouble(0));
- assertDoubleEquals(-1D, $opt$IntToDouble(-1));
- assertDoubleEquals(51D, $opt$IntToDouble(51));
- assertDoubleEquals(-51D, $opt$IntToDouble(-51));
- assertDoubleEquals(16777216D, $opt$IntToDouble(16777216)); // 2^24
- assertDoubleEquals(-16777216D, $opt$IntToDouble(-16777216)); // -(2^24)
- assertDoubleEquals(2147483647D, $opt$IntToDouble(2147483647)); // 2^31 - 1
- assertDoubleEquals(-2147483648D, $opt$IntToDouble(-2147483648)); // -(2^31)
+ assertDoubleEquals(1D, $opt$noinline$IntToDouble(1));
+ assertDoubleEquals(0D, $opt$noinline$IntToDouble(0));
+ assertDoubleEquals(-1D, $opt$noinline$IntToDouble(-1));
+ assertDoubleEquals(51D, $opt$noinline$IntToDouble(51));
+ assertDoubleEquals(-51D, $opt$noinline$IntToDouble(-51));
+ assertDoubleEquals(16777216D, $opt$noinline$IntToDouble(16777216)); // 2^24
+ assertDoubleEquals(-16777216D, $opt$noinline$IntToDouble(-16777216)); // -(2^24)
+ assertDoubleEquals(2147483647D, $opt$noinline$IntToDouble(2147483647)); // 2^31 - 1
+ assertDoubleEquals(-2147483648D, $opt$noinline$IntToDouble(-2147483648)); // -(2^31)
}
private static void charToDouble() {
- assertDoubleEquals(1D, $opt$CharToDouble((char)1));
- assertDoubleEquals(0D, $opt$CharToDouble((char)0));
- assertDoubleEquals(51D, $opt$CharToDouble((char)51));
- assertDoubleEquals(32767D, $opt$CharToDouble((char)32767)); // 2^15 - 1
- assertDoubleEquals(65535D, $opt$CharToDouble((char)65535)); // 2^16 - 1
- assertDoubleEquals(65535D, $opt$CharToDouble((char)-1));
- assertDoubleEquals(65485D, $opt$CharToDouble((char)-51));
- assertDoubleEquals(32769D, $opt$CharToDouble((char)-32767)); // -(2^15 - 1)
- assertDoubleEquals(32768D, $opt$CharToDouble((char)-32768)); // -(2^15)
+ assertDoubleEquals(1D, $opt$noinline$CharToDouble((char)1));
+ assertDoubleEquals(0D, $opt$noinline$CharToDouble((char)0));
+ assertDoubleEquals(51D, $opt$noinline$CharToDouble((char)51));
+ assertDoubleEquals(32767D, $opt$noinline$CharToDouble((char)32767)); // 2^15 - 1
+ assertDoubleEquals(65535D, $opt$noinline$CharToDouble((char)65535)); // 2^16 - 1
+ assertDoubleEquals(65535D, $opt$noinline$CharToDouble((char)-1));
+ assertDoubleEquals(65485D, $opt$noinline$CharToDouble((char)-51));
+ assertDoubleEquals(32769D, $opt$noinline$CharToDouble((char)-32767)); // -(2^15 - 1)
+ assertDoubleEquals(32768D, $opt$noinline$CharToDouble((char)-32768)); // -(2^15)
}
private static void longToInt() {
- assertIntEquals(1, $opt$LongToInt(1L));
- assertIntEquals(0, $opt$LongToInt(0L));
- assertIntEquals(-1, $opt$LongToInt(-1L));
- assertIntEquals(51, $opt$LongToInt(51L));
- assertIntEquals(-51, $opt$LongToInt(-51L));
- assertIntEquals(2147483647, $opt$LongToInt(2147483647L)); // 2^31 - 1
- assertIntEquals(-2147483647, $opt$LongToInt(-2147483647L)); // -(2^31 - 1)
- assertIntEquals(-2147483648, $opt$LongToInt(-2147483648L)); // -(2^31)
- assertIntEquals(-2147483648, $opt$LongToInt(2147483648L)); // (2^31)
- assertIntEquals(2147483647, $opt$LongToInt(-2147483649L)); // -(2^31 + 1)
- assertIntEquals(-1, $opt$LongToInt(9223372036854775807L)); // 2^63 - 1
- assertIntEquals(1, $opt$LongToInt(-9223372036854775807L)); // -(2^63 - 1)
- assertIntEquals(0, $opt$LongToInt(-9223372036854775808L)); // -(2^63)
+ assertIntEquals(1, $opt$noinline$LongToInt(1L));
+ assertIntEquals(0, $opt$noinline$LongToInt(0L));
+ assertIntEquals(-1, $opt$noinline$LongToInt(-1L));
+ assertIntEquals(51, $opt$noinline$LongToInt(51L));
+ assertIntEquals(-51, $opt$noinline$LongToInt(-51L));
+ assertIntEquals(2147483647, $opt$noinline$LongToInt(2147483647L)); // 2^31 - 1
+ assertIntEquals(-2147483647, $opt$noinline$LongToInt(-2147483647L)); // -(2^31 - 1)
+ assertIntEquals(-2147483648, $opt$noinline$LongToInt(-2147483648L)); // -(2^31)
+ assertIntEquals(-2147483648, $opt$noinline$LongToInt(2147483648L)); // (2^31)
+ assertIntEquals(2147483647, $opt$noinline$LongToInt(-2147483649L)); // -(2^31 + 1)
+ assertIntEquals(-1, $opt$noinline$LongToInt(9223372036854775807L)); // 2^63 - 1
+ assertIntEquals(1, $opt$noinline$LongToInt(-9223372036854775807L)); // -(2^63 - 1)
+ assertIntEquals(0, $opt$noinline$LongToInt(-9223372036854775808L)); // -(2^63)
- assertIntEquals(42, $opt$LongLiteralToInt());
+ assertIntEquals(42, $opt$noinline$LongLiteralToInt());
// Ensure long-to-int conversions truncates values as expected.
- assertLongEquals(1L, $opt$IntToLong($opt$LongToInt(4294967297L))); // 2^32 + 1
- assertLongEquals(0L, $opt$IntToLong($opt$LongToInt(4294967296L))); // 2^32
- assertLongEquals(-1L, $opt$IntToLong($opt$LongToInt(4294967295L))); // 2^32 - 1
- assertLongEquals(0L, $opt$IntToLong($opt$LongToInt(0L)));
- assertLongEquals(1L, $opt$IntToLong($opt$LongToInt(-4294967295L))); // -(2^32 - 1)
- assertLongEquals(0L, $opt$IntToLong($opt$LongToInt(-4294967296L))); // -(2^32)
- assertLongEquals(-1, $opt$IntToLong($opt$LongToInt(-4294967297L))); // -(2^32 + 1)
+ assertLongEquals(1L, $opt$noinline$IntToLong($opt$noinline$LongToInt(4294967297L))); // 2^32 + 1
+ assertLongEquals(0L, $opt$noinline$IntToLong($opt$noinline$LongToInt(4294967296L))); // 2^32
+ assertLongEquals(-1L, $opt$noinline$IntToLong($opt$noinline$LongToInt(4294967295L))); // 2^32 - 1
+ assertLongEquals(0L, $opt$noinline$IntToLong($opt$noinline$LongToInt(0L)));
+ assertLongEquals(1L, $opt$noinline$IntToLong($opt$noinline$LongToInt(-4294967295L))); // -(2^32 - 1)
+ assertLongEquals(0L, $opt$noinline$IntToLong($opt$noinline$LongToInt(-4294967296L))); // -(2^32)
+ assertLongEquals(-1, $opt$noinline$IntToLong($opt$noinline$LongToInt(-4294967297L))); // -(2^32 + 1)
}
private static void longToFloat() {
- assertFloatEquals(1F, $opt$LongToFloat(1L));
- assertFloatEquals(0F, $opt$LongToFloat(0L));
- assertFloatEquals(-1F, $opt$LongToFloat(-1L));
- assertFloatEquals(51F, $opt$LongToFloat(51L));
- assertFloatEquals(-51F, $opt$LongToFloat(-51L));
- assertFloatEquals(2147483647F, $opt$LongToFloat(2147483647L)); // 2^31 - 1
- assertFloatEquals(-2147483647F, $opt$LongToFloat(-2147483647L)); // -(2^31 - 1)
- assertFloatEquals(-2147483648F, $opt$LongToFloat(-2147483648L)); // -(2^31)
- assertFloatEquals(2147483648F, $opt$LongToFloat(2147483648L)); // (2^31)
- assertFloatEquals(-2147483649F, $opt$LongToFloat(-2147483649L)); // -(2^31 + 1)
- assertFloatEquals(4294967296F, $opt$LongToFloat(4294967296L)); // (2^32)
- assertFloatEquals(-4294967296F, $opt$LongToFloat(-4294967296L)); // -(2^32)
- assertFloatEquals(140739635871745F, $opt$LongToFloat(140739635871745L)); // 1 + 2^15 + 2^31 + 2^47
- assertFloatEquals(-140739635871745F, $opt$LongToFloat(-140739635871745L)); // -(1 + 2^15 + 2^31 + 2^47)
- assertFloatEquals(9223372036854775807F, $opt$LongToFloat(9223372036854775807L)); // 2^63 - 1
- assertFloatEquals(-9223372036854775807F, $opt$LongToFloat(-9223372036854775807L)); // -(2^63 - 1)
- assertFloatEquals(-9223372036854775808F, $opt$LongToFloat(-9223372036854775808L)); // -(2^63)
+ assertFloatEquals(1F, $opt$noinline$LongToFloat(1L));
+ assertFloatEquals(0F, $opt$noinline$LongToFloat(0L));
+ assertFloatEquals(-1F, $opt$noinline$LongToFloat(-1L));
+ assertFloatEquals(51F, $opt$noinline$LongToFloat(51L));
+ assertFloatEquals(-51F, $opt$noinline$LongToFloat(-51L));
+ assertFloatEquals(2147483647F, $opt$noinline$LongToFloat(2147483647L)); // 2^31 - 1
+ assertFloatEquals(-2147483647F, $opt$noinline$LongToFloat(-2147483647L)); // -(2^31 - 1)
+ assertFloatEquals(-2147483648F, $opt$noinline$LongToFloat(-2147483648L)); // -(2^31)
+ assertFloatEquals(2147483648F, $opt$noinline$LongToFloat(2147483648L)); // (2^31)
+ assertFloatEquals(-2147483649F, $opt$noinline$LongToFloat(-2147483649L)); // -(2^31 + 1)
+ assertFloatEquals(4294967296F, $opt$noinline$LongToFloat(4294967296L)); // (2^32)
+ assertFloatEquals(-4294967296F, $opt$noinline$LongToFloat(-4294967296L)); // -(2^32)
+ assertFloatEquals(140739635871745F, $opt$noinline$LongToFloat(140739635871745L)); // 1 + 2^15 + 2^31 + 2^47
+ assertFloatEquals(-140739635871745F, $opt$noinline$LongToFloat(-140739635871745L)); // -(1 + 2^15 + 2^31 + 2^47)
+ assertFloatEquals(9223372036854775807F, $opt$noinline$LongToFloat(9223372036854775807L)); // 2^63 - 1
+ assertFloatEquals(-9223372036854775807F, $opt$noinline$LongToFloat(-9223372036854775807L)); // -(2^63 - 1)
+ assertFloatEquals(-9223372036854775808F, $opt$noinline$LongToFloat(-9223372036854775808L)); // -(2^63)
}
private static void longToDouble() {
- assertDoubleEquals(1D, $opt$LongToDouble(1L));
- assertDoubleEquals(0D, $opt$LongToDouble(0L));
- assertDoubleEquals(-1D, $opt$LongToDouble(-1L));
- assertDoubleEquals(51D, $opt$LongToDouble(51L));
- assertDoubleEquals(-51D, $opt$LongToDouble(-51L));
- assertDoubleEquals(2147483647D, $opt$LongToDouble(2147483647L)); // 2^31 - 1
- assertDoubleEquals(-2147483647D, $opt$LongToDouble(-2147483647L)); // -(2^31 - 1)
- assertDoubleEquals(-2147483648D, $opt$LongToDouble(-2147483648L)); // -(2^31)
- assertDoubleEquals(2147483648D, $opt$LongToDouble(2147483648L)); // (2^31)
- assertDoubleEquals(-2147483649D, $opt$LongToDouble(-2147483649L)); // -(2^31 + 1)
- assertDoubleEquals(4294967296D, $opt$LongToDouble(4294967296L)); // (2^32)
- assertDoubleEquals(-4294967296D, $opt$LongToDouble(-4294967296L)); // -(2^32)
- assertDoubleEquals(140739635871745D, $opt$LongToDouble(140739635871745L)); // 1 + 2^15 + 2^31 + 2^47
- assertDoubleEquals(-140739635871745D, $opt$LongToDouble(-140739635871745L)); // -(1 + 2^15 + 2^31 + 2^47)
- assertDoubleEquals(9223372036854775807D, $opt$LongToDouble(9223372036854775807L)); // 2^63 - 1
- assertDoubleEquals(-9223372036854775807D, $opt$LongToDouble(-9223372036854775807L)); // -(2^63 - 1)
- assertDoubleEquals(-9223372036854775808D, $opt$LongToDouble(-9223372036854775808L)); // -(2^63)
+ assertDoubleEquals(1D, $opt$noinline$LongToDouble(1L));
+ assertDoubleEquals(0D, $opt$noinline$LongToDouble(0L));
+ assertDoubleEquals(-1D, $opt$noinline$LongToDouble(-1L));
+ assertDoubleEquals(51D, $opt$noinline$LongToDouble(51L));
+ assertDoubleEquals(-51D, $opt$noinline$LongToDouble(-51L));
+ assertDoubleEquals(2147483647D, $opt$noinline$LongToDouble(2147483647L)); // 2^31 - 1
+ assertDoubleEquals(-2147483647D, $opt$noinline$LongToDouble(-2147483647L)); // -(2^31 - 1)
+ assertDoubleEquals(-2147483648D, $opt$noinline$LongToDouble(-2147483648L)); // -(2^31)
+ assertDoubleEquals(2147483648D, $opt$noinline$LongToDouble(2147483648L)); // (2^31)
+ assertDoubleEquals(-2147483649D, $opt$noinline$LongToDouble(-2147483649L)); // -(2^31 + 1)
+ assertDoubleEquals(4294967296D, $opt$noinline$LongToDouble(4294967296L)); // (2^32)
+ assertDoubleEquals(-4294967296D, $opt$noinline$LongToDouble(-4294967296L)); // -(2^32)
+ assertDoubleEquals(140739635871745D, $opt$noinline$LongToDouble(140739635871745L)); // 1 + 2^15 + 2^31 + 2^47
+ assertDoubleEquals(-140739635871745D, $opt$noinline$LongToDouble(-140739635871745L)); // -(1 + 2^15 + 2^31 + 2^47)
+ assertDoubleEquals(9223372036854775807D, $opt$noinline$LongToDouble(9223372036854775807L)); // 2^63 - 1
+ assertDoubleEquals(-9223372036854775807D, $opt$noinline$LongToDouble(-9223372036854775807L)); // -(2^63 - 1)
+ assertDoubleEquals(-9223372036854775808D, $opt$noinline$LongToDouble(-9223372036854775808L)); // -(2^63)
}
private static void floatToInt() {
- assertIntEquals(1, $opt$FloatToInt(1F));
- assertIntEquals(0, $opt$FloatToInt(0F));
- assertIntEquals(0, $opt$FloatToInt(-0F));
- assertIntEquals(-1, $opt$FloatToInt(-1F));
- assertIntEquals(51, $opt$FloatToInt(51F));
- assertIntEquals(-51, $opt$FloatToInt(-51F));
- assertIntEquals(0, $opt$FloatToInt(0.5F));
- assertIntEquals(0, $opt$FloatToInt(0.4999999F));
- assertIntEquals(0, $opt$FloatToInt(-0.4999999F));
- assertIntEquals(0, $opt$FloatToInt(-0.5F));
- assertIntEquals(42, $opt$FloatToInt(42.199F));
- assertIntEquals(-42, $opt$FloatToInt(-42.199F));
- assertIntEquals(2147483647, $opt$FloatToInt(2147483647F)); // 2^31 - 1
- assertIntEquals(-2147483648, $opt$FloatToInt(-2147483647F)); // -(2^31 - 1)
- assertIntEquals(-2147483648, $opt$FloatToInt(-2147483648F)); // -(2^31)
- assertIntEquals(2147483647, $opt$FloatToInt(2147483648F)); // (2^31)
- assertIntEquals(-2147483648, $opt$FloatToInt(-2147483649F)); // -(2^31 + 1)
- assertIntEquals(2147483647, $opt$FloatToInt(9223372036854775807F)); // 2^63 - 1
- assertIntEquals(-2147483648, $opt$FloatToInt(-9223372036854775807F)); // -(2^63 - 1)
- assertIntEquals(-2147483648, $opt$FloatToInt(-9223372036854775808F)); // -(2^63)
- assertIntEquals(0, $opt$FloatToInt(Float.NaN));
- assertIntEquals(2147483647, $opt$FloatToInt(Float.POSITIVE_INFINITY));
- assertIntEquals(-2147483648, $opt$FloatToInt(Float.NEGATIVE_INFINITY));
+ assertIntEquals(1, $opt$noinline$FloatToInt(1F));
+ assertIntEquals(0, $opt$noinline$FloatToInt(0F));
+ assertIntEquals(0, $opt$noinline$FloatToInt(-0F));
+ assertIntEquals(-1, $opt$noinline$FloatToInt(-1F));
+ assertIntEquals(51, $opt$noinline$FloatToInt(51F));
+ assertIntEquals(-51, $opt$noinline$FloatToInt(-51F));
+ assertIntEquals(0, $opt$noinline$FloatToInt(0.5F));
+ assertIntEquals(0, $opt$noinline$FloatToInt(0.4999999F));
+ assertIntEquals(0, $opt$noinline$FloatToInt(-0.4999999F));
+ assertIntEquals(0, $opt$noinline$FloatToInt(-0.5F));
+ assertIntEquals(42, $opt$noinline$FloatToInt(42.199F));
+ assertIntEquals(-42, $opt$noinline$FloatToInt(-42.199F));
+ assertIntEquals(2147483647, $opt$noinline$FloatToInt(2147483647F)); // 2^31 - 1
+ assertIntEquals(-2147483648, $opt$noinline$FloatToInt(-2147483647F)); // -(2^31 - 1)
+ assertIntEquals(-2147483648, $opt$noinline$FloatToInt(-2147483648F)); // -(2^31)
+ assertIntEquals(2147483647, $opt$noinline$FloatToInt(2147483648F)); // (2^31)
+ assertIntEquals(-2147483648, $opt$noinline$FloatToInt(-2147483649F)); // -(2^31 + 1)
+ assertIntEquals(2147483647, $opt$noinline$FloatToInt(9223372036854775807F)); // 2^63 - 1
+ assertIntEquals(-2147483648, $opt$noinline$FloatToInt(-9223372036854775807F)); // -(2^63 - 1)
+ assertIntEquals(-2147483648, $opt$noinline$FloatToInt(-9223372036854775808F)); // -(2^63)
+ assertIntEquals(0, $opt$noinline$FloatToInt(Float.NaN));
+ assertIntEquals(2147483647, $opt$noinline$FloatToInt(Float.POSITIVE_INFINITY));
+ assertIntEquals(-2147483648, $opt$noinline$FloatToInt(Float.NEGATIVE_INFINITY));
}
private static void floatToLong() {
- assertLongEquals(1L, $opt$FloatToLong(1F));
- assertLongEquals(0L, $opt$FloatToLong(0F));
- assertLongEquals(0L, $opt$FloatToLong(-0F));
- assertLongEquals(-1L, $opt$FloatToLong(-1F));
- assertLongEquals(51L, $opt$FloatToLong(51F));
- assertLongEquals(-51L, $opt$FloatToLong(-51F));
- assertLongEquals(0L, $opt$FloatToLong(0.5F));
- assertLongEquals(0L, $opt$FloatToLong(0.4999999F));
- assertLongEquals(0L, $opt$FloatToLong(-0.4999999F));
- assertLongEquals(0L, $opt$FloatToLong(-0.5F));
- assertLongEquals(42L, $opt$FloatToLong(42.199F));
- assertLongEquals(-42L, $opt$FloatToLong(-42.199F));
- assertLongEquals(2147483648L, $opt$FloatToLong(2147483647F)); // 2^31 - 1
- assertLongEquals(-2147483648L, $opt$FloatToLong(-2147483647F)); // -(2^31 - 1)
- assertLongEquals(-2147483648L, $opt$FloatToLong(-2147483648F)); // -(2^31)
- assertLongEquals(2147483648L, $opt$FloatToLong(2147483648F)); // (2^31)
- assertLongEquals(-2147483648L, $opt$FloatToLong(-2147483649F)); // -(2^31 + 1)
- assertLongEquals(9223372036854775807L, $opt$FloatToLong(9223372036854775807F)); // 2^63 - 1
- assertLongEquals(-9223372036854775808L, $opt$FloatToLong(-9223372036854775807F)); // -(2^63 - 1)
- assertLongEquals(-9223372036854775808L, $opt$FloatToLong(-9223372036854775808F)); // -(2^63)
- assertLongEquals(0L, $opt$FloatToLong(Float.NaN));
- assertLongEquals(9223372036854775807L, $opt$FloatToLong(Float.POSITIVE_INFINITY));
- assertLongEquals(-9223372036854775808L, $opt$FloatToLong(Float.NEGATIVE_INFINITY));
+ assertLongEquals(1L, $opt$noinline$FloatToLong(1F));
+ assertLongEquals(0L, $opt$noinline$FloatToLong(0F));
+ assertLongEquals(0L, $opt$noinline$FloatToLong(-0F));
+ assertLongEquals(-1L, $opt$noinline$FloatToLong(-1F));
+ assertLongEquals(51L, $opt$noinline$FloatToLong(51F));
+ assertLongEquals(-51L, $opt$noinline$FloatToLong(-51F));
+ assertLongEquals(0L, $opt$noinline$FloatToLong(0.5F));
+ assertLongEquals(0L, $opt$noinline$FloatToLong(0.4999999F));
+ assertLongEquals(0L, $opt$noinline$FloatToLong(-0.4999999F));
+ assertLongEquals(0L, $opt$noinline$FloatToLong(-0.5F));
+ assertLongEquals(42L, $opt$noinline$FloatToLong(42.199F));
+ assertLongEquals(-42L, $opt$noinline$FloatToLong(-42.199F));
+ assertLongEquals(2147483648L, $opt$noinline$FloatToLong(2147483647F)); // 2^31 - 1
+ assertLongEquals(-2147483648L, $opt$noinline$FloatToLong(-2147483647F)); // -(2^31 - 1)
+ assertLongEquals(-2147483648L, $opt$noinline$FloatToLong(-2147483648F)); // -(2^31)
+ assertLongEquals(2147483648L, $opt$noinline$FloatToLong(2147483648F)); // (2^31)
+ assertLongEquals(-2147483648L, $opt$noinline$FloatToLong(-2147483649F)); // -(2^31 + 1)
+ assertLongEquals(9223372036854775807L, $opt$noinline$FloatToLong(9223372036854775807F)); // 2^63 - 1
+ assertLongEquals(-9223372036854775808L, $opt$noinline$FloatToLong(-9223372036854775807F)); // -(2^63 - 1)
+ assertLongEquals(-9223372036854775808L, $opt$noinline$FloatToLong(-9223372036854775808F)); // -(2^63)
+ assertLongEquals(0L, $opt$noinline$FloatToLong(Float.NaN));
+ assertLongEquals(9223372036854775807L, $opt$noinline$FloatToLong(Float.POSITIVE_INFINITY));
+ assertLongEquals(-9223372036854775808L, $opt$noinline$FloatToLong(Float.NEGATIVE_INFINITY));
}
private static void floatToDouble() {
- assertDoubleEquals(1D, $opt$FloatToDouble(1F));
- assertDoubleEquals(0D, $opt$FloatToDouble(0F));
- assertDoubleEquals(0D, $opt$FloatToDouble(-0F));
- assertDoubleEquals(-1D, $opt$FloatToDouble(-1F));
- assertDoubleEquals(51D, $opt$FloatToDouble(51F));
- assertDoubleEquals(-51D, $opt$FloatToDouble(-51F));
- assertDoubleEquals(0.5D, $opt$FloatToDouble(0.5F));
- assertDoubleEquals(0.49999991059303284D, $opt$FloatToDouble(0.4999999F));
- assertDoubleEquals(-0.49999991059303284D, $opt$FloatToDouble(-0.4999999F));
- assertDoubleEquals(-0.5D, $opt$FloatToDouble(-0.5F));
- assertDoubleEquals(42.19900131225586D, $opt$FloatToDouble(42.199F));
- assertDoubleEquals(-42.19900131225586D, $opt$FloatToDouble(-42.199F));
- assertDoubleEquals(2147483648D, $opt$FloatToDouble(2147483647F)); // 2^31 - 1
- assertDoubleEquals(-2147483648D, $opt$FloatToDouble(-2147483647F)); // -(2^31 - 1)
- assertDoubleEquals(-2147483648D, $opt$FloatToDouble(-2147483648F)); // -(2^31)
- assertDoubleEquals(2147483648D, $opt$FloatToDouble(2147483648F)); // (2^31)
- assertDoubleEquals(-2147483648D, $opt$FloatToDouble(-2147483649F)); // -(2^31 + 1)
- assertDoubleEquals(9223372036854775807D, $opt$FloatToDouble(9223372036854775807F)); // 2^63 - 1
- assertDoubleEquals(-9223372036854775807D, $opt$FloatToDouble(-9223372036854775807F)); // -(2^63 - 1)
- assertDoubleEquals(-9223372036854775808D, $opt$FloatToDouble(-9223372036854775808F)); // -(2^63)
- assertDoubleIsNaN($opt$FloatToDouble(Float.NaN));
- assertDoubleEquals(Double.POSITIVE_INFINITY, $opt$FloatToDouble(Float.POSITIVE_INFINITY));
- assertDoubleEquals(Double.NEGATIVE_INFINITY, $opt$FloatToDouble(Float.NEGATIVE_INFINITY));
+ assertDoubleEquals(1D, $opt$noinline$FloatToDouble(1F));
+ assertDoubleEquals(0D, $opt$noinline$FloatToDouble(0F));
+ assertDoubleEquals(0D, $opt$noinline$FloatToDouble(-0F));
+ assertDoubleEquals(-1D, $opt$noinline$FloatToDouble(-1F));
+ assertDoubleEquals(51D, $opt$noinline$FloatToDouble(51F));
+ assertDoubleEquals(-51D, $opt$noinline$FloatToDouble(-51F));
+ assertDoubleEquals(0.5D, $opt$noinline$FloatToDouble(0.5F));
+ assertDoubleEquals(0.49999991059303284D, $opt$noinline$FloatToDouble(0.4999999F));
+ assertDoubleEquals(-0.49999991059303284D, $opt$noinline$FloatToDouble(-0.4999999F));
+ assertDoubleEquals(-0.5D, $opt$noinline$FloatToDouble(-0.5F));
+ assertDoubleEquals(42.19900131225586D, $opt$noinline$FloatToDouble(42.199F));
+ assertDoubleEquals(-42.19900131225586D, $opt$noinline$FloatToDouble(-42.199F));
+ assertDoubleEquals(2147483648D, $opt$noinline$FloatToDouble(2147483647F)); // 2^31 - 1
+ assertDoubleEquals(-2147483648D, $opt$noinline$FloatToDouble(-2147483647F)); // -(2^31 - 1)
+ assertDoubleEquals(-2147483648D, $opt$noinline$FloatToDouble(-2147483648F)); // -(2^31)
+ assertDoubleEquals(2147483648D, $opt$noinline$FloatToDouble(2147483648F)); // (2^31)
+ assertDoubleEquals(-2147483648D, $opt$noinline$FloatToDouble(-2147483649F)); // -(2^31 + 1)
+ assertDoubleEquals(9223372036854775807D, $opt$noinline$FloatToDouble(9223372036854775807F)); // 2^63 - 1
+ assertDoubleEquals(-9223372036854775807D, $opt$noinline$FloatToDouble(-9223372036854775807F)); // -(2^63 - 1)
+ assertDoubleEquals(-9223372036854775808D, $opt$noinline$FloatToDouble(-9223372036854775808F)); // -(2^63)
+ assertDoubleIsNaN($opt$noinline$FloatToDouble(Float.NaN));
+ assertDoubleEquals(Double.POSITIVE_INFINITY, $opt$noinline$FloatToDouble(Float.POSITIVE_INFINITY));
+ assertDoubleEquals(Double.NEGATIVE_INFINITY, $opt$noinline$FloatToDouble(Float.NEGATIVE_INFINITY));
}
private static void doubleToInt() {
- assertIntEquals(1, $opt$DoubleToInt(1D));
- assertIntEquals(0, $opt$DoubleToInt(0D));
- assertIntEquals(0, $opt$DoubleToInt(-0D));
- assertIntEquals(-1, $opt$DoubleToInt(-1D));
- assertIntEquals(51, $opt$DoubleToInt(51D));
- assertIntEquals(-51, $opt$DoubleToInt(-51D));
- assertIntEquals(0, $opt$DoubleToInt(0.5D));
- assertIntEquals(0, $opt$DoubleToInt(0.4999999D));
- assertIntEquals(0, $opt$DoubleToInt(-0.4999999D));
- assertIntEquals(0, $opt$DoubleToInt(-0.5D));
- assertIntEquals(42, $opt$DoubleToInt(42.199D));
- assertIntEquals(-42, $opt$DoubleToInt(-42.199D));
- assertIntEquals(2147483647, $opt$DoubleToInt(2147483647D)); // 2^31 - 1
- assertIntEquals(-2147483647, $opt$DoubleToInt(-2147483647D)); // -(2^31 - 1)
- assertIntEquals(-2147483648, $opt$DoubleToInt(-2147483648D)); // -(2^31)
- assertIntEquals(2147483647, $opt$DoubleToInt(2147483648D)); // (2^31)
- assertIntEquals(-2147483648, $opt$DoubleToInt(-2147483649D)); // -(2^31 + 1)
- assertIntEquals(2147483647, $opt$DoubleToInt(9223372036854775807D)); // 2^63 - 1
- assertIntEquals(-2147483648, $opt$DoubleToInt(-9223372036854775807D)); // -(2^63 - 1)
- assertIntEquals(-2147483648, $opt$DoubleToInt(-9223372036854775808D)); // -(2^63)
- assertIntEquals(0, $opt$DoubleToInt(Double.NaN));
- assertIntEquals(2147483647, $opt$DoubleToInt(Double.POSITIVE_INFINITY));
- assertIntEquals(-2147483648, $opt$DoubleToInt(Double.NEGATIVE_INFINITY));
+ assertIntEquals(1, $opt$noinline$DoubleToInt(1D));
+ assertIntEquals(0, $opt$noinline$DoubleToInt(0D));
+ assertIntEquals(0, $opt$noinline$DoubleToInt(-0D));
+ assertIntEquals(-1, $opt$noinline$DoubleToInt(-1D));
+ assertIntEquals(51, $opt$noinline$DoubleToInt(51D));
+ assertIntEquals(-51, $opt$noinline$DoubleToInt(-51D));
+ assertIntEquals(0, $opt$noinline$DoubleToInt(0.5D));
+ assertIntEquals(0, $opt$noinline$DoubleToInt(0.4999999D));
+ assertIntEquals(0, $opt$noinline$DoubleToInt(-0.4999999D));
+ assertIntEquals(0, $opt$noinline$DoubleToInt(-0.5D));
+ assertIntEquals(42, $opt$noinline$DoubleToInt(42.199D));
+ assertIntEquals(-42, $opt$noinline$DoubleToInt(-42.199D));
+ assertIntEquals(2147483647, $opt$noinline$DoubleToInt(2147483647D)); // 2^31 - 1
+ assertIntEquals(-2147483647, $opt$noinline$DoubleToInt(-2147483647D)); // -(2^31 - 1)
+ assertIntEquals(-2147483648, $opt$noinline$DoubleToInt(-2147483648D)); // -(2^31)
+ assertIntEquals(2147483647, $opt$noinline$DoubleToInt(2147483648D)); // (2^31)
+ assertIntEquals(-2147483648, $opt$noinline$DoubleToInt(-2147483649D)); // -(2^31 + 1)
+ assertIntEquals(2147483647, $opt$noinline$DoubleToInt(9223372036854775807D)); // 2^63 - 1
+ assertIntEquals(-2147483648, $opt$noinline$DoubleToInt(-9223372036854775807D)); // -(2^63 - 1)
+ assertIntEquals(-2147483648, $opt$noinline$DoubleToInt(-9223372036854775808D)); // -(2^63)
+ assertIntEquals(0, $opt$noinline$DoubleToInt(Double.NaN));
+ assertIntEquals(2147483647, $opt$noinline$DoubleToInt(Double.POSITIVE_INFINITY));
+ assertIntEquals(-2147483648, $opt$noinline$DoubleToInt(Double.NEGATIVE_INFINITY));
}
private static void doubleToLong() {
- assertLongEquals(1L, $opt$DoubleToLong(1D));
- assertLongEquals(0L, $opt$DoubleToLong(0D));
- assertLongEquals(0L, $opt$DoubleToLong(-0D));
- assertLongEquals(-1L, $opt$DoubleToLong(-1D));
- assertLongEquals(51L, $opt$DoubleToLong(51D));
- assertLongEquals(-51L, $opt$DoubleToLong(-51D));
- assertLongEquals(0L, $opt$DoubleToLong(0.5D));
- assertLongEquals(0L, $opt$DoubleToLong(0.4999999D));
- assertLongEquals(0L, $opt$DoubleToLong(-0.4999999D));
- assertLongEquals(0L, $opt$DoubleToLong(-0.5D));
- assertLongEquals(42L, $opt$DoubleToLong(42.199D));
- assertLongEquals(-42L, $opt$DoubleToLong(-42.199D));
- assertLongEquals(2147483647L, $opt$DoubleToLong(2147483647D)); // 2^31 - 1
- assertLongEquals(-2147483647L, $opt$DoubleToLong(-2147483647D)); // -(2^31 - 1)
- assertLongEquals(-2147483648L, $opt$DoubleToLong(-2147483648D)); // -(2^31)
- assertLongEquals(2147483648L, $opt$DoubleToLong(2147483648D)); // (2^31)
- assertLongEquals(-2147483649L, $opt$DoubleToLong(-2147483649D)); // -(2^31 + 1)
- assertLongEquals(9223372036854775807L, $opt$DoubleToLong(9223372036854775807D)); // 2^63 - 1
- assertLongEquals(-9223372036854775808L, $opt$DoubleToLong(-9223372036854775807D)); // -(2^63 - 1)
- assertLongEquals(-9223372036854775808L, $opt$DoubleToLong(-9223372036854775808D)); // -(2^63)
- assertLongEquals(0L, $opt$DoubleToLong(Double.NaN));
- assertLongEquals(9223372036854775807L, $opt$DoubleToLong(Double.POSITIVE_INFINITY));
- assertLongEquals(-9223372036854775808L, $opt$DoubleToLong(Double.NEGATIVE_INFINITY));
+ assertLongEquals(1L, $opt$noinline$DoubleToLong(1D));
+ assertLongEquals(0L, $opt$noinline$DoubleToLong(0D));
+ assertLongEquals(0L, $opt$noinline$DoubleToLong(-0D));
+ assertLongEquals(-1L, $opt$noinline$DoubleToLong(-1D));
+ assertLongEquals(51L, $opt$noinline$DoubleToLong(51D));
+ assertLongEquals(-51L, $opt$noinline$DoubleToLong(-51D));
+ assertLongEquals(0L, $opt$noinline$DoubleToLong(0.5D));
+ assertLongEquals(0L, $opt$noinline$DoubleToLong(0.4999999D));
+ assertLongEquals(0L, $opt$noinline$DoubleToLong(-0.4999999D));
+ assertLongEquals(0L, $opt$noinline$DoubleToLong(-0.5D));
+ assertLongEquals(42L, $opt$noinline$DoubleToLong(42.199D));
+ assertLongEquals(-42L, $opt$noinline$DoubleToLong(-42.199D));
+ assertLongEquals(2147483647L, $opt$noinline$DoubleToLong(2147483647D)); // 2^31 - 1
+ assertLongEquals(-2147483647L, $opt$noinline$DoubleToLong(-2147483647D)); // -(2^31 - 1)
+ assertLongEquals(-2147483648L, $opt$noinline$DoubleToLong(-2147483648D)); // -(2^31)
+ assertLongEquals(2147483648L, $opt$noinline$DoubleToLong(2147483648D)); // (2^31)
+ assertLongEquals(-2147483649L, $opt$noinline$DoubleToLong(-2147483649D)); // -(2^31 + 1)
+ assertLongEquals(9223372036854775807L, $opt$noinline$DoubleToLong(9223372036854775807D)); // 2^63 - 1
+ assertLongEquals(-9223372036854775808L, $opt$noinline$DoubleToLong(-9223372036854775807D)); // -(2^63 - 1)
+ assertLongEquals(-9223372036854775808L, $opt$noinline$DoubleToLong(-9223372036854775808D)); // -(2^63)
+ assertLongEquals(0L, $opt$noinline$DoubleToLong(Double.NaN));
+ assertLongEquals(9223372036854775807L, $opt$noinline$DoubleToLong(Double.POSITIVE_INFINITY));
+ assertLongEquals(-9223372036854775808L, $opt$noinline$DoubleToLong(Double.NEGATIVE_INFINITY));
}
private static void doubleToFloat() {
- assertFloatEquals(1F, $opt$DoubleToFloat(1D));
- assertFloatEquals(0F, $opt$DoubleToFloat(0D));
- assertFloatEquals(0F, $opt$DoubleToFloat(-0D));
- assertFloatEquals(-1F, $opt$DoubleToFloat(-1D));
- assertFloatEquals(51F, $opt$DoubleToFloat(51D));
- assertFloatEquals(-51F, $opt$DoubleToFloat(-51D));
- assertFloatEquals(0.5F, $opt$DoubleToFloat(0.5D));
- assertFloatEquals(0.4999999F, $opt$DoubleToFloat(0.4999999D));
- assertFloatEquals(-0.4999999F, $opt$DoubleToFloat(-0.4999999D));
- assertFloatEquals(-0.5F, $opt$DoubleToFloat(-0.5D));
- assertFloatEquals(42.199F, $opt$DoubleToFloat(42.199D));
- assertFloatEquals(-42.199F, $opt$DoubleToFloat(-42.199D));
- assertFloatEquals(2147483648F, $opt$DoubleToFloat(2147483647D)); // 2^31 - 1
- assertFloatEquals(-2147483648F, $opt$DoubleToFloat(-2147483647D)); // -(2^31 - 1)
- assertFloatEquals(-2147483648F, $opt$DoubleToFloat(-2147483648D)); // -(2^31)
- assertFloatEquals(2147483648F, $opt$DoubleToFloat(2147483648D)); // (2^31)
- assertFloatEquals(-2147483648F, $opt$DoubleToFloat(-2147483649D)); // -(2^31 + 1)
- assertFloatEquals(9223372036854775807F, $opt$DoubleToFloat(9223372036854775807D)); // 2^63 - 1
- assertFloatEquals(-9223372036854775807F, $opt$DoubleToFloat(-9223372036854775807D)); // -(2^63 - 1)
- assertFloatEquals(-9223372036854775808F, $opt$DoubleToFloat(-9223372036854775808D)); // -(2^63)
- assertFloatIsNaN($opt$DoubleToFloat(Float.NaN));
- assertFloatEquals(Float.POSITIVE_INFINITY, $opt$DoubleToFloat(Double.POSITIVE_INFINITY));
- assertFloatEquals(Float.NEGATIVE_INFINITY, $opt$DoubleToFloat(Double.NEGATIVE_INFINITY));
+ assertFloatEquals(1F, $opt$noinline$DoubleToFloat(1D));
+ assertFloatEquals(0F, $opt$noinline$DoubleToFloat(0D));
+ assertFloatEquals(0F, $opt$noinline$DoubleToFloat(-0D));
+ assertFloatEquals(-1F, $opt$noinline$DoubleToFloat(-1D));
+ assertFloatEquals(51F, $opt$noinline$DoubleToFloat(51D));
+ assertFloatEquals(-51F, $opt$noinline$DoubleToFloat(-51D));
+ assertFloatEquals(0.5F, $opt$noinline$DoubleToFloat(0.5D));
+ assertFloatEquals(0.4999999F, $opt$noinline$DoubleToFloat(0.4999999D));
+ assertFloatEquals(-0.4999999F, $opt$noinline$DoubleToFloat(-0.4999999D));
+ assertFloatEquals(-0.5F, $opt$noinline$DoubleToFloat(-0.5D));
+ assertFloatEquals(42.199F, $opt$noinline$DoubleToFloat(42.199D));
+ assertFloatEquals(-42.199F, $opt$noinline$DoubleToFloat(-42.199D));
+ assertFloatEquals(2147483648F, $opt$noinline$DoubleToFloat(2147483647D)); // 2^31 - 1
+ assertFloatEquals(-2147483648F, $opt$noinline$DoubleToFloat(-2147483647D)); // -(2^31 - 1)
+ assertFloatEquals(-2147483648F, $opt$noinline$DoubleToFloat(-2147483648D)); // -(2^31)
+ assertFloatEquals(2147483648F, $opt$noinline$DoubleToFloat(2147483648D)); // (2^31)
+ assertFloatEquals(-2147483648F, $opt$noinline$DoubleToFloat(-2147483649D)); // -(2^31 + 1)
+ assertFloatEquals(9223372036854775807F, $opt$noinline$DoubleToFloat(9223372036854775807D)); // 2^63 - 1
+ assertFloatEquals(-9223372036854775807F, $opt$noinline$DoubleToFloat(-9223372036854775807D)); // -(2^63 - 1)
+ assertFloatEquals(-9223372036854775808F, $opt$noinline$DoubleToFloat(-9223372036854775808D)); // -(2^63)
+ assertFloatIsNaN($opt$noinline$DoubleToFloat(Float.NaN));
+ assertFloatEquals(Float.POSITIVE_INFINITY, $opt$noinline$DoubleToFloat(Double.POSITIVE_INFINITY));
+ assertFloatEquals(Float.NEGATIVE_INFINITY, $opt$noinline$DoubleToFloat(Double.NEGATIVE_INFINITY));
}
private static void shortToByte() {
- assertByteEquals((byte)1, $opt$ShortToByte((short)1));
- assertByteEquals((byte)0, $opt$ShortToByte((short)0));
- assertByteEquals((byte)-1, $opt$ShortToByte((short)-1));
- assertByteEquals((byte)51, $opt$ShortToByte((short)51));
- assertByteEquals((byte)-51, $opt$ShortToByte((short)-51));
- assertByteEquals((byte)127, $opt$ShortToByte((short)127)); // 2^7 - 1
- assertByteEquals((byte)-127, $opt$ShortToByte((short)-127)); // -(2^7 - 1)
- assertByteEquals((byte)-128, $opt$ShortToByte((short)-128)); // -(2^7)
- assertByteEquals((byte)-128, $opt$ShortToByte((short)128)); // 2^7
- assertByteEquals((byte)127, $opt$ShortToByte((short)-129)); // -(2^7 + 1)
- assertByteEquals((byte)-1, $opt$ShortToByte((short)32767)); // 2^15 - 1
- assertByteEquals((byte)0, $opt$ShortToByte((short)-32768)); // -(2^15)
+ assertByteEquals((byte)1, $opt$noinline$ShortToByte((short)1));
+ assertByteEquals((byte)0, $opt$noinline$ShortToByte((short)0));
+ assertByteEquals((byte)-1, $opt$noinline$ShortToByte((short)-1));
+ assertByteEquals((byte)51, $opt$noinline$ShortToByte((short)51));
+ assertByteEquals((byte)-51, $opt$noinline$ShortToByte((short)-51));
+ assertByteEquals((byte)127, $opt$noinline$ShortToByte((short)127)); // 2^7 - 1
+ assertByteEquals((byte)-127, $opt$noinline$ShortToByte((short)-127)); // -(2^7 - 1)
+ assertByteEquals((byte)-128, $opt$noinline$ShortToByte((short)-128)); // -(2^7)
+ assertByteEquals((byte)-128, $opt$noinline$ShortToByte((short)128)); // 2^7
+ assertByteEquals((byte)127, $opt$noinline$ShortToByte((short)-129)); // -(2^7 + 1)
+ assertByteEquals((byte)-1, $opt$noinline$ShortToByte((short)32767)); // 2^15 - 1
+ assertByteEquals((byte)0, $opt$noinline$ShortToByte((short)-32768)); // -(2^15)
}
private static void intToByte() {
- assertByteEquals((byte)1, $opt$IntToByte(1));
- assertByteEquals((byte)0, $opt$IntToByte(0));
- assertByteEquals((byte)-1, $opt$IntToByte(-1));
- assertByteEquals((byte)51, $opt$IntToByte(51));
- assertByteEquals((byte)-51, $opt$IntToByte(-51));
- assertByteEquals((byte)127, $opt$IntToByte(127)); // 2^7 - 1
- assertByteEquals((byte)-127, $opt$IntToByte(-127)); // -(2^7 - 1)
- assertByteEquals((byte)-128, $opt$IntToByte(-128)); // -(2^7)
- assertByteEquals((byte)-128, $opt$IntToByte(128)); // 2^7
- assertByteEquals((byte)127, $opt$IntToByte(-129)); // -(2^7 + 1)
- assertByteEquals((byte)-1, $opt$IntToByte(2147483647)); // 2^31 - 1
- assertByteEquals((byte)0, $opt$IntToByte(-2147483648)); // -(2^31)
+ assertByteEquals((byte)1, $opt$noinline$IntToByte(1));
+ assertByteEquals((byte)0, $opt$noinline$IntToByte(0));
+ assertByteEquals((byte)-1, $opt$noinline$IntToByte(-1));
+ assertByteEquals((byte)51, $opt$noinline$IntToByte(51));
+ assertByteEquals((byte)-51, $opt$noinline$IntToByte(-51));
+ assertByteEquals((byte)127, $opt$noinline$IntToByte(127)); // 2^7 - 1
+ assertByteEquals((byte)-127, $opt$noinline$IntToByte(-127)); // -(2^7 - 1)
+ assertByteEquals((byte)-128, $opt$noinline$IntToByte(-128)); // -(2^7)
+ assertByteEquals((byte)-128, $opt$noinline$IntToByte(128)); // 2^7
+ assertByteEquals((byte)127, $opt$noinline$IntToByte(-129)); // -(2^7 + 1)
+ assertByteEquals((byte)-1, $opt$noinline$IntToByte(2147483647)); // 2^31 - 1
+ assertByteEquals((byte)0, $opt$noinline$IntToByte(-2147483648)); // -(2^31)
}
private static void charToByte() {
- assertByteEquals((byte)1, $opt$CharToByte((char)1));
- assertByteEquals((byte)0, $opt$CharToByte((char)0));
- assertByteEquals((byte)51, $opt$CharToByte((char)51));
- assertByteEquals((byte)127, $opt$CharToByte((char)127)); // 2^7 - 1
- assertByteEquals((byte)-128, $opt$CharToByte((char)128)); // 2^7
- assertByteEquals((byte)-1, $opt$CharToByte((char)32767)); // 2^15 - 1
- assertByteEquals((byte)-1, $opt$CharToByte((char)65535)); // 2^16 - 1
- assertByteEquals((byte)-1, $opt$CharToByte((char)-1));
- assertByteEquals((byte)-51, $opt$CharToByte((char)-51));
- assertByteEquals((byte)-127, $opt$CharToByte((char)-127)); // -(2^7 - 1)
- assertByteEquals((byte)-128, $opt$CharToByte((char)-128)); // -(2^7)
- assertByteEquals((byte)127, $opt$CharToByte((char)-129)); // -(2^7 + 1)
+ assertByteEquals((byte)1, $opt$noinline$CharToByte((char)1));
+ assertByteEquals((byte)0, $opt$noinline$CharToByte((char)0));
+ assertByteEquals((byte)51, $opt$noinline$CharToByte((char)51));
+ assertByteEquals((byte)127, $opt$noinline$CharToByte((char)127)); // 2^7 - 1
+ assertByteEquals((byte)-128, $opt$noinline$CharToByte((char)128)); // 2^7
+ assertByteEquals((byte)-1, $opt$noinline$CharToByte((char)32767)); // 2^15 - 1
+ assertByteEquals((byte)-1, $opt$noinline$CharToByte((char)65535)); // 2^16 - 1
+ assertByteEquals((byte)-1, $opt$noinline$CharToByte((char)-1));
+ assertByteEquals((byte)-51, $opt$noinline$CharToByte((char)-51));
+ assertByteEquals((byte)-127, $opt$noinline$CharToByte((char)-127)); // -(2^7 - 1)
+ assertByteEquals((byte)-128, $opt$noinline$CharToByte((char)-128)); // -(2^7)
+ assertByteEquals((byte)127, $opt$noinline$CharToByte((char)-129)); // -(2^7 + 1)
}
private static void byteToShort() {
- assertShortEquals((short)1, $opt$ByteToShort((byte)1));
- assertShortEquals((short)0, $opt$ByteToShort((byte)0));
- assertShortEquals((short)-1, $opt$ByteToShort((byte)-1));
- assertShortEquals((short)51, $opt$ByteToShort((byte)51));
- assertShortEquals((short)-51, $opt$ByteToShort((byte)-51));
- assertShortEquals((short)127, $opt$ByteToShort((byte)127)); // 2^7 - 1
- assertShortEquals((short)-127, $opt$ByteToShort((byte)-127)); // -(2^7 - 1)
- assertShortEquals((short)-128, $opt$ByteToShort((byte)-128)); // -(2^7)
+ assertShortEquals((short)1, $opt$noinline$ByteToShort((byte)1));
+ assertShortEquals((short)0, $opt$noinline$ByteToShort((byte)0));
+ assertShortEquals((short)-1, $opt$noinline$ByteToShort((byte)-1));
+ assertShortEquals((short)51, $opt$noinline$ByteToShort((byte)51));
+ assertShortEquals((short)-51, $opt$noinline$ByteToShort((byte)-51));
+ assertShortEquals((short)127, $opt$noinline$ByteToShort((byte)127)); // 2^7 - 1
+ assertShortEquals((short)-127, $opt$noinline$ByteToShort((byte)-127)); // -(2^7 - 1)
+ assertShortEquals((short)-128, $opt$noinline$ByteToShort((byte)-128)); // -(2^7)
}
private static void intToShort() {
- assertShortEquals((short)1, $opt$IntToShort(1));
- assertShortEquals((short)0, $opt$IntToShort(0));
- assertShortEquals((short)-1, $opt$IntToShort(-1));
- assertShortEquals((short)51, $opt$IntToShort(51));
- assertShortEquals((short)-51, $opt$IntToShort(-51));
- assertShortEquals((short)32767, $opt$IntToShort(32767)); // 2^15 - 1
- assertShortEquals((short)-32767, $opt$IntToShort(-32767)); // -(2^15 - 1)
- assertShortEquals((short)-32768, $opt$IntToShort(-32768)); // -(2^15)
- assertShortEquals((short)-32768, $opt$IntToShort(32768)); // 2^15
- assertShortEquals((short)32767, $opt$IntToShort(-32769)); // -(2^15 + 1)
- assertShortEquals((short)-1, $opt$IntToShort(2147483647)); // 2^31 - 1
- assertShortEquals((short)0, $opt$IntToShort(-2147483648)); // -(2^31)
+ assertShortEquals((short)1, $opt$noinline$IntToShort(1));
+ assertShortEquals((short)0, $opt$noinline$IntToShort(0));
+ assertShortEquals((short)-1, $opt$noinline$IntToShort(-1));
+ assertShortEquals((short)51, $opt$noinline$IntToShort(51));
+ assertShortEquals((short)-51, $opt$noinline$IntToShort(-51));
+ assertShortEquals((short)32767, $opt$noinline$IntToShort(32767)); // 2^15 - 1
+ assertShortEquals((short)-32767, $opt$noinline$IntToShort(-32767)); // -(2^15 - 1)
+ assertShortEquals((short)-32768, $opt$noinline$IntToShort(-32768)); // -(2^15)
+ assertShortEquals((short)-32768, $opt$noinline$IntToShort(32768)); // 2^15
+ assertShortEquals((short)32767, $opt$noinline$IntToShort(-32769)); // -(2^15 + 1)
+ assertShortEquals((short)-1, $opt$noinline$IntToShort(2147483647)); // 2^31 - 1
+ assertShortEquals((short)0, $opt$noinline$IntToShort(-2147483648)); // -(2^31)
}
private static void charToShort() {
- assertShortEquals((short)1, $opt$CharToShort((char)1));
- assertShortEquals((short)0, $opt$CharToShort((char)0));
- assertShortEquals((short)51, $opt$CharToShort((char)51));
- assertShortEquals((short)32767, $opt$CharToShort((char)32767)); // 2^15 - 1
- assertShortEquals((short)-32768, $opt$CharToShort((char)32768)); // 2^15
- assertShortEquals((short)-32767, $opt$CharToShort((char)32769)); // 2^15
- assertShortEquals((short)-1, $opt$CharToShort((char)65535)); // 2^16 - 1
- assertShortEquals((short)-1, $opt$CharToShort((char)-1));
- assertShortEquals((short)-51, $opt$CharToShort((char)-51));
- assertShortEquals((short)-32767, $opt$CharToShort((char)-32767)); // -(2^15 - 1)
- assertShortEquals((short)-32768, $opt$CharToShort((char)-32768)); // -(2^15)
- assertShortEquals((short)32767, $opt$CharToShort((char)-32769)); // -(2^15 + 1)
+ assertShortEquals((short)1, $opt$noinline$CharToShort((char)1));
+ assertShortEquals((short)0, $opt$noinline$CharToShort((char)0));
+ assertShortEquals((short)51, $opt$noinline$CharToShort((char)51));
+ assertShortEquals((short)32767, $opt$noinline$CharToShort((char)32767)); // 2^15 - 1
+ assertShortEquals((short)-32768, $opt$noinline$CharToShort((char)32768)); // 2^15
+ assertShortEquals((short)-32767, $opt$noinline$CharToShort((char)32769)); // 2^15
+ assertShortEquals((short)-1, $opt$noinline$CharToShort((char)65535)); // 2^16 - 1
+ assertShortEquals((short)-1, $opt$noinline$CharToShort((char)-1));
+ assertShortEquals((short)-51, $opt$noinline$CharToShort((char)-51));
+ assertShortEquals((short)-32767, $opt$noinline$CharToShort((char)-32767)); // -(2^15 - 1)
+ assertShortEquals((short)-32768, $opt$noinline$CharToShort((char)-32768)); // -(2^15)
+ assertShortEquals((short)32767, $opt$noinline$CharToShort((char)-32769)); // -(2^15 + 1)
}
private static void byteToChar() {
- assertCharEquals((char)1, $opt$ByteToChar((byte)1));
- assertCharEquals((char)0, $opt$ByteToChar((byte)0));
- assertCharEquals((char)65535, $opt$ByteToChar((byte)-1));
- assertCharEquals((char)51, $opt$ByteToChar((byte)51));
- assertCharEquals((char)65485, $opt$ByteToChar((byte)-51));
- assertCharEquals((char)127, $opt$ByteToChar((byte)127)); // 2^7 - 1
- assertCharEquals((char)65409, $opt$ByteToChar((byte)-127)); // -(2^7 - 1)
- assertCharEquals((char)65408, $opt$ByteToChar((byte)-128)); // -(2^7)
+ assertCharEquals((char)1, $opt$noinline$ByteToChar((byte)1));
+ assertCharEquals((char)0, $opt$noinline$ByteToChar((byte)0));
+ assertCharEquals((char)65535, $opt$noinline$ByteToChar((byte)-1));
+ assertCharEquals((char)51, $opt$noinline$ByteToChar((byte)51));
+ assertCharEquals((char)65485, $opt$noinline$ByteToChar((byte)-51));
+ assertCharEquals((char)127, $opt$noinline$ByteToChar((byte)127)); // 2^7 - 1
+ assertCharEquals((char)65409, $opt$noinline$ByteToChar((byte)-127)); // -(2^7 - 1)
+ assertCharEquals((char)65408, $opt$noinline$ByteToChar((byte)-128)); // -(2^7)
}
private static void shortToChar() {
- assertCharEquals((char)1, $opt$ShortToChar((short)1));
- assertCharEquals((char)0, $opt$ShortToChar((short)0));
- assertCharEquals((char)65535, $opt$ShortToChar((short)-1));
- assertCharEquals((char)51, $opt$ShortToChar((short)51));
- assertCharEquals((char)65485, $opt$ShortToChar((short)-51));
- assertCharEquals((char)32767, $opt$ShortToChar((short)32767)); // 2^15 - 1
- assertCharEquals((char)32769, $opt$ShortToChar((short)-32767)); // -(2^15 - 1)
- assertCharEquals((char)32768, $opt$ShortToChar((short)-32768)); // -(2^15)
+ assertCharEquals((char)1, $opt$noinline$ShortToChar((short)1));
+ assertCharEquals((char)0, $opt$noinline$ShortToChar((short)0));
+ assertCharEquals((char)65535, $opt$noinline$ShortToChar((short)-1));
+ assertCharEquals((char)51, $opt$noinline$ShortToChar((short)51));
+ assertCharEquals((char)65485, $opt$noinline$ShortToChar((short)-51));
+ assertCharEquals((char)32767, $opt$noinline$ShortToChar((short)32767)); // 2^15 - 1
+ assertCharEquals((char)32769, $opt$noinline$ShortToChar((short)-32767)); // -(2^15 - 1)
+ assertCharEquals((char)32768, $opt$noinline$ShortToChar((short)-32768)); // -(2^15)
}
private static void intToChar() {
- assertCharEquals((char)1, $opt$IntToChar(1));
- assertCharEquals((char)0, $opt$IntToChar(0));
- assertCharEquals((char)65535, $opt$IntToChar(-1));
- assertCharEquals((char)51, $opt$IntToChar(51));
- assertCharEquals((char)65485, $opt$IntToChar(-51));
- assertCharEquals((char)32767, $opt$IntToChar(32767)); // 2^15 - 1
- assertCharEquals((char)32769, $opt$IntToChar(-32767)); // -(2^15 - 1)
- assertCharEquals((char)32768, $opt$IntToChar(32768)); // 2^15
- assertCharEquals((char)32768, $opt$IntToChar(-32768)); // -(2^15)
- assertCharEquals((char)65535, $opt$IntToChar(65535)); // 2^16 - 1
- assertCharEquals((char)1, $opt$IntToChar(-65535)); // -(2^16 - 1)
- assertCharEquals((char)0, $opt$IntToChar(65536)); // 2^16
- assertCharEquals((char)0, $opt$IntToChar(-65536)); // -(2^16)
- assertCharEquals((char)65535, $opt$IntToChar(2147483647)); // 2^31 - 1
- assertCharEquals((char)0, $opt$IntToChar(-2147483648)); // -(2^31)
+ assertCharEquals((char)1, $opt$noinline$IntToChar(1));
+ assertCharEquals((char)0, $opt$noinline$IntToChar(0));
+ assertCharEquals((char)65535, $opt$noinline$IntToChar(-1));
+ assertCharEquals((char)51, $opt$noinline$IntToChar(51));
+ assertCharEquals((char)65485, $opt$noinline$IntToChar(-51));
+ assertCharEquals((char)32767, $opt$noinline$IntToChar(32767)); // 2^15 - 1
+ assertCharEquals((char)32769, $opt$noinline$IntToChar(-32767)); // -(2^15 - 1)
+ assertCharEquals((char)32768, $opt$noinline$IntToChar(32768)); // 2^15
+ assertCharEquals((char)32768, $opt$noinline$IntToChar(-32768)); // -(2^15)
+ assertCharEquals((char)65535, $opt$noinline$IntToChar(65535)); // 2^16 - 1
+ assertCharEquals((char)1, $opt$noinline$IntToChar(-65535)); // -(2^16 - 1)
+ assertCharEquals((char)0, $opt$noinline$IntToChar(65536)); // 2^16
+ assertCharEquals((char)0, $opt$noinline$IntToChar(-65536)); // -(2^16)
+ assertCharEquals((char)65535, $opt$noinline$IntToChar(2147483647)); // 2^31 - 1
+ assertCharEquals((char)0, $opt$noinline$IntToChar(-2147483648)); // -(2^31)
}
// A dummy value to defeat inlining of these routines.
static boolean doThrow = false;
// These methods produce int-to-long Dex instructions.
- static long $opt$ByteToLong(byte a) { if (doThrow) throw new Error(); return (long)a; }
- static long $opt$ShortToLong(short a) { if (doThrow) throw new Error(); return (long)a; }
- static long $opt$IntToLong(int a) { if (doThrow) throw new Error(); return (long)a; }
- static long $opt$CharToLong(int a) { if (doThrow) throw new Error(); return (long)a; }
+ static long $opt$noinline$ByteToLong(byte a) { if (doThrow) throw new Error(); return (long)a; }
+ static long $opt$noinline$ShortToLong(short a) { if (doThrow) throw new Error(); return (long)a; }
+ static long $opt$noinline$IntToLong(int a) { if (doThrow) throw new Error(); return (long)a; }
+ static long $opt$noinline$CharToLong(int a) { if (doThrow) throw new Error(); return (long)a; }
// These methods produce int-to-float Dex instructions.
- static float $opt$ByteToFloat(byte a) { if (doThrow) throw new Error(); return (float)a; }
- static float $opt$ShortToFloat(short a) { if (doThrow) throw new Error(); return (float)a; }
- static float $opt$IntToFloat(int a) { if (doThrow) throw new Error(); return (float)a; }
- static float $opt$CharToFloat(char a) { if (doThrow) throw new Error(); return (float)a; }
+ static float $opt$noinline$ByteToFloat(byte a) { if (doThrow) throw new Error(); return (float)a; }
+ static float $opt$noinline$ShortToFloat(short a) { if (doThrow) throw new Error(); return (float)a; }
+ static float $opt$noinline$IntToFloat(int a) { if (doThrow) throw new Error(); return (float)a; }
+ static float $opt$noinline$CharToFloat(char a) { if (doThrow) throw new Error(); return (float)a; }
// These methods produce int-to-double Dex instructions.
- static double $opt$ByteToDouble(byte a) { if (doThrow) throw new Error(); return (double)a; }
- static double $opt$ShortToDouble(short a) { if (doThrow) throw new Error(); return (double)a; }
- static double $opt$IntToDouble(int a) { if (doThrow) throw new Error(); return (double)a; }
- static double $opt$CharToDouble(int a) { if (doThrow) throw new Error(); return (double)a; }
+ static double $opt$noinline$ByteToDouble(byte a) { if (doThrow) throw new Error(); return (double)a; }
+ static double $opt$noinline$ShortToDouble(short a) { if (doThrow) throw new Error(); return (double)a; }
+ static double $opt$noinline$IntToDouble(int a) { if (doThrow) throw new Error(); return (double)a; }
+ static double $opt$noinline$CharToDouble(int a) { if (doThrow) throw new Error(); return (double)a; }
// These methods produce long-to-int Dex instructions.
- static int $opt$LongToInt(long a) { if (doThrow) throw new Error(); return (int)a; }
- static int $opt$LongLiteralToInt() { if (doThrow) throw new Error(); return (int)42L; }
+ static int $opt$noinline$LongToInt(long a) { if (doThrow) throw new Error(); return (int)a; }
+ static int $opt$noinline$LongLiteralToInt() { if (doThrow) throw new Error(); return (int)42L; }
// This method produces a long-to-float Dex instruction.
- static float $opt$LongToFloat(long a) { if (doThrow) throw new Error(); return (float)a; }
+ static float $opt$noinline$LongToFloat(long a) { if (doThrow) throw new Error(); return (float)a; }
// This method produces a long-to-double Dex instruction.
- static double $opt$LongToDouble(long a) { if (doThrow) throw new Error(); return (double)a; }
+ static double $opt$noinline$LongToDouble(long a) { if (doThrow) throw new Error(); return (double)a; }
// This method produces a float-to-int Dex instruction.
- static int $opt$FloatToInt(float a) { if (doThrow) throw new Error(); return (int)a; }
+ static int $opt$noinline$FloatToInt(float a) { if (doThrow) throw new Error(); return (int)a; }
// This method produces a float-to-long Dex instruction.
- static long $opt$FloatToLong(float a){ if (doThrow) throw new Error(); return (long)a; }
+ static long $opt$noinline$FloatToLong(float a){ if (doThrow) throw new Error(); return (long)a; }
// This method produces a float-to-double Dex instruction.
- static double $opt$FloatToDouble(float a) { if (doThrow) throw new Error(); return (double)a; }
+ static double $opt$noinline$FloatToDouble(float a) { if (doThrow) throw new Error(); return (double)a; }
// This method produces a double-to-int Dex instruction.
- static int $opt$DoubleToInt(double a){ if (doThrow) throw new Error(); return (int)a; }
+ static int $opt$noinline$DoubleToInt(double a){ if (doThrow) throw new Error(); return (int)a; }
// This method produces a double-to-long Dex instruction.
- static long $opt$DoubleToLong(double a){ if (doThrow) throw new Error(); return (long)a; }
+ static long $opt$noinline$DoubleToLong(double a){ if (doThrow) throw new Error(); return (long)a; }
// This method produces a double-to-float Dex instruction.
- static float $opt$DoubleToFloat(double a) { if (doThrow) throw new Error(); return (float)a; }
+ static float $opt$noinline$DoubleToFloat(double a) { if (doThrow) throw new Error(); return (float)a; }
// These methods produce int-to-byte Dex instructions.
- static byte $opt$ShortToByte(short a) { if (doThrow) throw new Error(); return (byte)a; }
- static byte $opt$IntToByte(int a) { if (doThrow) throw new Error(); return (byte)a; }
- static byte $opt$CharToByte(char a) { if (doThrow) throw new Error(); return (byte)a; }
+ static byte $opt$noinline$ShortToByte(short a) { if (doThrow) throw new Error(); return (byte)a; }
+ static byte $opt$noinline$IntToByte(int a) { if (doThrow) throw new Error(); return (byte)a; }
+ static byte $opt$noinline$CharToByte(char a) { if (doThrow) throw new Error(); return (byte)a; }
// These methods produce int-to-short Dex instructions.
- static short $opt$ByteToShort(byte a) { if (doThrow) throw new Error(); return (short)a; }
- static short $opt$IntToShort(int a) { if (doThrow) throw new Error(); return (short)a; }
- static short $opt$CharToShort(char a) { if (doThrow) throw new Error(); return (short)a; }
+ static short $opt$noinline$ByteToShort(byte a) { if (doThrow) throw new Error(); return (short)a; }
+ static short $opt$noinline$IntToShort(int a) { if (doThrow) throw new Error(); return (short)a; }
+ static short $opt$noinline$CharToShort(char a) { if (doThrow) throw new Error(); return (short)a; }
// These methods produce int-to-char Dex instructions.
- static char $opt$ByteToChar(byte a) { if (doThrow) throw new Error(); return (char)a; }
- static char $opt$ShortToChar(short a) { if (doThrow) throw new Error(); return (char)a; }
- static char $opt$IntToChar(int a) { if (doThrow) throw new Error(); return (char)a; }
+ static char $opt$noinline$ByteToChar(byte a) { if (doThrow) throw new Error(); return (char)a; }
+ static char $opt$noinline$ShortToChar(short a) { if (doThrow) throw new Error(); return (char)a; }
+ static char $opt$noinline$IntToChar(int a) { if (doThrow) throw new Error(); return (char)a; }
}
diff --git a/test/441-checker-inliner/src/Main.java b/test/441-checker-inliner/src/Main.java
index df969a4..3899d7f 100644
--- a/test/441-checker-inliner/src/Main.java
+++ b/test/441-checker-inliner/src/Main.java
@@ -19,7 +19,7 @@
/// CHECK-START: void Main.InlineVoid() inliner (before)
/// CHECK-DAG: <<Const42:i\d+>> IntConstant 42
/// CHECK-DAG: InvokeStaticOrDirect
- /// CHECK-DAG: InvokeStaticOrDirect [<<Const42>>]
+ /// CHECK-DAG: InvokeStaticOrDirect [<<Const42>>,{{[ij]\d+}}]
/// CHECK-START: void Main.InlineVoid() inliner (after)
/// CHECK-NOT: InvokeStaticOrDirect
@@ -31,7 +31,7 @@
/// CHECK-START: int Main.InlineParameter(int) inliner (before)
/// CHECK-DAG: <<Param:i\d+>> ParameterValue
- /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<Param>>]
+ /// CHECK-DAG: <<Result:i\d+>> InvokeStaticOrDirect [<<Param>>,{{[ij]\d+}}]
/// CHECK-DAG: Return [<<Result>>]
/// CHECK-START: int Main.InlineParameter(int) inliner (after)
@@ -44,7 +44,7 @@
/// CHECK-START: long Main.InlineWideParameter(long) inliner (before)
/// CHECK-DAG: <<Param:j\d+>> ParameterValue
- /// CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect [<<Param>>]
+ /// CHECK-DAG: <<Result:j\d+>> InvokeStaticOrDirect [<<Param>>,{{[ij]\d+}}]
/// CHECK-DAG: Return [<<Result>>]
/// CHECK-START: long Main.InlineWideParameter(long) inliner (after)
@@ -57,7 +57,7 @@
/// CHECK-START: java.lang.Object Main.InlineReferenceParameter(java.lang.Object) inliner (before)
/// CHECK-DAG: <<Param:l\d+>> ParameterValue
- /// CHECK-DAG: <<Result:l\d+>> InvokeStaticOrDirect [<<Param>>]
+ /// CHECK-DAG: <<Result:l\d+>> InvokeStaticOrDirect [<<Param>>,{{[ij]\d+}}]
/// CHECK-DAG: Return [<<Result>>]
/// CHECK-START: java.lang.Object Main.InlineReferenceParameter(java.lang.Object) inliner (after)
@@ -130,8 +130,8 @@
/// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
/// CHECK-DAG: <<Const3:i\d+>> IntConstant 3
/// CHECK-DAG: <<Const5:i\d+>> IntConstant 5
- /// CHECK-DAG: <<Add:i\d+>> InvokeStaticOrDirect [<<Const1>>,<<Const3>>]
- /// CHECK-DAG: <<Sub:i\d+>> InvokeStaticOrDirect [<<Const5>>,<<Const3>>]
+ /// CHECK-DAG: <<Add:i\d+>> InvokeStaticOrDirect [<<Const1>>,<<Const3>>,{{[ij]\d+}}]
+ /// CHECK-DAG: <<Sub:i\d+>> InvokeStaticOrDirect [<<Const5>>,<<Const3>>,{{[ij]\d+}}]
/// CHECK-DAG: <<Phi:i\d+>> Phi [<<Add>>,<<Sub>>]
/// CHECK-DAG: Return [<<Phi>>]
diff --git a/test/450-checker-types/src/Main.java b/test/450-checker-types/src/Main.java
index 9bf7cdf..4056275 100644
--- a/test/450-checker-types/src/Main.java
+++ b/test/450-checker-types/src/Main.java
@@ -16,25 +16,25 @@
interface Interface {
- void f();
+ void $noinline$f();
}
class Super implements Interface {
- public void f() {
+ public void $noinline$f() {
throw new RuntimeException();
}
}
class SubclassA extends Super {
- public void f() {
+ public void $noinline$f() {
throw new RuntimeException();
}
- public String h() {
+ public String $noinline$h() {
throw new RuntimeException();
}
- void g() {
+ void $noinline$g() {
throw new RuntimeException();
}
}
@@ -43,11 +43,11 @@
}
class SubclassB extends Super {
- public void f() {
+ public void $noinline$f() {
throw new RuntimeException();
}
- void g() {
+ void $noinline$g() {
throw new RuntimeException();
}
}
@@ -61,7 +61,7 @@
/// CHECK-NOT: CheckCast
public void testSimpleRemove() {
Super s = new SubclassA();
- ((SubclassA)s).g();
+ ((SubclassA)s).$noinline$g();
}
/// CHECK-START: void Main.testSimpleKeep(Super) instruction_simplifier_after_types (before)
@@ -70,7 +70,7 @@
/// CHECK-START: void Main.testSimpleKeep(Super) instruction_simplifier_after_types (after)
/// CHECK: CheckCast
public void testSimpleKeep(Super s) {
- ((SubclassA)s).f();
+ ((SubclassA)s).$noinline$f();
}
/// CHECK-START: java.lang.String Main.testClassRemove() instruction_simplifier_after_types (before)
@@ -90,7 +90,7 @@
/// CHECK: CheckCast
public String testClassKeep() {
Object s = SubclassA.class;
- return ((SubclassA)s).h();
+ return ((SubclassA)s).$noinline$h();
}
/// CHECK-START: void Main.testIfRemove(int) instruction_simplifier_after_types (before)
@@ -105,7 +105,7 @@
} else {
s = new SubclassC();
}
- ((SubclassA)s).g();
+ ((SubclassA)s).$noinline$g();
}
/// CHECK-START: void Main.testIfKeep(int) instruction_simplifier_after_types (before)
@@ -120,7 +120,7 @@
} else {
s = new SubclassB();
}
- ((SubclassA)s).g();
+ ((SubclassA)s).$noinline$g();
}
/// CHECK-START: void Main.testForRemove(int) instruction_simplifier_after_types (before)
@@ -135,7 +135,7 @@
s = new SubclassC();
}
}
- ((SubclassA)s).g();
+ ((SubclassA)s).$noinline$g();
}
/// CHECK-START: void Main.testForKeep(int) instruction_simplifier_after_types (before)
@@ -150,7 +150,7 @@
s = new SubclassC();
}
}
- ((SubclassC)s).g();
+ ((SubclassC)s).$noinline$g();
}
/// CHECK-START: void Main.testPhiFromCall(int) instruction_simplifier_after_types (before)
@@ -165,7 +165,7 @@
} else {
x = newObject(); // this one will have an unknown type.
}
- ((SubclassC)x).g();
+ ((SubclassC)x).$noinline$g();
}
/// CHECK-START: void Main.testInstanceOf(java.lang.Object) instruction_simplifier_after_types (before)
@@ -176,10 +176,10 @@
/// CHECK-NOT: CheckCast
public void testInstanceOf(Object o) {
if (o instanceof SubclassC) {
- ((SubclassC)o).g();
+ ((SubclassC)o).$noinline$g();
}
if (o instanceof SubclassB) {
- ((SubclassB)o).g();
+ ((SubclassB)o).$noinline$g();
}
}
@@ -192,10 +192,10 @@
/// CHECK: CheckCast
public void testInstanceOfKeep(Object o) {
if (o instanceof SubclassC) {
- ((SubclassB)o).g();
+ ((SubclassB)o).$noinline$g();
}
if (o instanceof SubclassB) {
- ((SubclassA)o).g();
+ ((SubclassA)o).$noinline$g();
}
}
@@ -208,9 +208,9 @@
public void testInstanceOfNested(Object o) {
if (o instanceof SubclassC) {
if (o instanceof SubclassB) {
- ((SubclassB)o).g();
+ ((SubclassB)o).$noinline$g();
} else {
- ((SubclassC)o).g();
+ ((SubclassC)o).$noinline$g();
}
}
}
@@ -229,7 +229,7 @@
}
if (o instanceof SubclassB) {
- ((SubclassB)o).g();
+ ((SubclassB)o).$noinline$g();
}
}
@@ -245,7 +245,7 @@
o = new SubclassB();
}
if (o instanceof SubclassB) {
- ((SubclassB)o).g();
+ ((SubclassB)o).$noinline$g();
}
}
}
@@ -258,7 +258,7 @@
public void testInstanceOfSubclass() {
Object o = new SubclassA();
if (o instanceof Super) {
- ((SubclassA)o).g();
+ ((SubclassA)o).$noinline$g();
}
}
@@ -276,7 +276,7 @@
}
if (o instanceof Super) {
- ((SubclassA)o).g();
+ ((SubclassA)o).$noinline$g();
}
}
@@ -294,7 +294,7 @@
}
if (o instanceof Super) {
- ((Super)o).f();
+ ((Super)o).$noinline$f();
}
}
@@ -307,7 +307,7 @@
Object o = new SubclassA();
for (int i = 0; i < n; i++) {
if (o instanceof Super) {
- ((SubclassA)o).g();
+ ((SubclassA)o).$noinline$g();
}
if (i / 2 == 0) {
o = new SubclassC();
@@ -324,7 +324,7 @@
Object o = new SubclassA();
for (int i = 0; i < n; i++) {
if (o instanceof Super) {
- ((Super)o).f();
+ ((Super)o).$noinline$f();
}
if (i / 2 == 0) {
o = new Object();
@@ -351,7 +351,7 @@
public void testInstanceFieldGetSimpleRemove() {
Main m = new Main();
Super a = m.a;
- ((SubclassA)a).g();
+ ((SubclassA)a).$noinline$g();
}
/// CHECK-START: void Main.testStaticFieldGetSimpleRemove() instruction_simplifier_after_types (before)
@@ -361,7 +361,7 @@
/// CHECK-NOT: CheckCast
public void testStaticFieldGetSimpleRemove() {
Super b = Main.b;
- ((SubclassA)b).g();
+ ((SubclassA)b).$noinline$g();
}
public static void main(String[] args) {
diff --git a/test/451-spill-splot/src/Main.java b/test/451-spill-splot/src/Main.java
index f631ebd..b2f39f3 100644
--- a/test/451-spill-splot/src/Main.java
+++ b/test/451-spill-splot/src/Main.java
@@ -48,37 +48,37 @@
for (int count = 0; count < 2; count++) {
System.out.println(aa + bb + cc + dd + ee + ff + gg + hh + ii + jj + kk + ll + mm + nn);
System.out.println(a + b + c + d + e + f + g + h + i + j);
- a = computeDouble();
- b = computeDouble();
- c = computeDouble();
- d = computeDouble();
- e = computeDouble();
- f = computeDouble();
- g = computeDouble();
- h = computeDouble();
- i = computeDouble();
- j = computeDouble();
+ a = $noinline$computeDouble();
+ b = $noinline$computeDouble();
+ c = $noinline$computeDouble();
+ d = $noinline$computeDouble();
+ e = $noinline$computeDouble();
+ f = $noinline$computeDouble();
+ g = $noinline$computeDouble();
+ h = $noinline$computeDouble();
+ i = $noinline$computeDouble();
+ j = $noinline$computeDouble();
System.out.println(a + b + c + d + e + f + g + h + i + j);
- aa = computeFloat();
- bb = computeFloat();
- cc = computeFloat();
- dd = computeFloat();
- ee = computeFloat();
- ff = computeFloat();
- gg = computeFloat();
- hh = computeFloat();
- ii = computeFloat();
- jj = computeFloat();
- kk = computeFloat();
- ll = computeFloat();
- mm = computeFloat();
- nn = computeFloat();
+ aa = $noinline$computeFloat();
+ bb = $noinline$computeFloat();
+ cc = $noinline$computeFloat();
+ dd = $noinline$computeFloat();
+ ee = $noinline$computeFloat();
+ ff = $noinline$computeFloat();
+ gg = $noinline$computeFloat();
+ hh = $noinline$computeFloat();
+ ii = $noinline$computeFloat();
+ jj = $noinline$computeFloat();
+ kk = $noinline$computeFloat();
+ ll = $noinline$computeFloat();
+ mm = $noinline$computeFloat();
+ nn = $noinline$computeFloat();
}
}
static boolean doThrow = false;
- public static double computeDouble() {
+ public static double $noinline$computeDouble() {
if (doThrow) {
// Try defeating inlining.
throw new Error();
@@ -86,7 +86,7 @@
return 2.0;
}
- public static float computeFloat() {
+ public static float $noinline$computeFloat() {
if (doThrow) {
// Try defeating inlining.
throw new Error();
diff --git a/test/478-checker-clinit-check-pruning/src/Main.java b/test/478-checker-clinit-check-pruning/src/Main.java
index 51be912..e6aab63 100644
--- a/test/478-checker-clinit-check-pruning/src/Main.java
+++ b/test/478-checker-clinit-check-pruning/src/Main.java
@@ -26,7 +26,7 @@
/// CHECK-START: void Main.invokeStaticInlined() builder (after)
/// CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
/// CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
- /// CHECK-DAG: InvokeStaticOrDirect [<<ClinitCheck>>]
+ /// CHECK-DAG: InvokeStaticOrDirect [{{[ij]\d+}},<<ClinitCheck>>]
/// CHECK-START: void Main.invokeStaticInlined() inliner (after)
/// CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
@@ -69,12 +69,12 @@
/// CHECK-START: void Main.invokeStaticNotInlined() builder (after)
/// CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
/// CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
- /// CHECK-DAG: InvokeStaticOrDirect [<<ClinitCheck>>]
+ /// CHECK-DAG: InvokeStaticOrDirect [{{[ij]\d+}},<<ClinitCheck>>]
/// CHECK-START: void Main.invokeStaticNotInlined() inliner (after)
/// CHECK-DAG: <<LoadClass:l\d+>> LoadClass gen_clinit_check:false
/// CHECK-DAG: <<ClinitCheck:l\d+>> ClinitCheck [<<LoadClass>>]
- /// CHECK-DAG: InvokeStaticOrDirect [<<ClinitCheck>>]
+ /// CHECK-DAG: InvokeStaticOrDirect [{{[ij]\d+}},<<ClinitCheck>>]
// The following checks ensure the clinit check and load class
// instructions added by the builder are pruned by the
@@ -90,7 +90,7 @@
/// CHECK-NOT: ClinitCheck
static void invokeStaticNotInlined() {
- ClassWithClinit2.staticMethod();
+ ClassWithClinit2.$noinline$staticMethod();
}
static class ClassWithClinit2 {
@@ -100,7 +100,7 @@
static boolean doThrow = false;
- static void staticMethod() {
+ static void $noinline$staticMethod() {
if (doThrow) {
// Try defeating inlining.
throw new Error();
@@ -169,7 +169,7 @@
// initialization of ClassWithClinit4, meaning that the
// call to staticMethod below does not need a clinit
// check.
- staticMethod();
+ $noinline$staticMethod();
}
static {
@@ -178,7 +178,7 @@
static boolean doThrow = false;
- static void staticMethod() {
+ static void $noinline$staticMethod() {
if (doThrow) {
// Try defeating inlining.
throw new Error();
@@ -242,7 +242,7 @@
static class ClassWithClinit6 {
static boolean doThrow = false;
- static void staticMethod() {
+ static void $noinline$staticMethod() {
if (doThrow) {
// Try defeating inlining.
throw new Error();
@@ -256,7 +256,7 @@
static class SubClassOfClassWithClinit6 extends ClassWithClinit6 {
static void invokeStaticNotInlined() {
- ClassWithClinit6.staticMethod();
+ ClassWithClinit6.$noinline$staticMethod();
}
}
@@ -276,7 +276,7 @@
/// CHECK-NOT: ClinitCheck
static void noClinitBecauseOfInvokeStatic() {
- ClassWithClinit2.staticMethod();
+ ClassWithClinit2.$noinline$staticMethod();
ClassWithClinit2.doThrow = false;
}
@@ -295,7 +295,7 @@
/// CHECK-NOT: ClinitCheck
static void clinitBecauseOfFieldAccess() {
ClassWithClinit2.doThrow = false;
- ClassWithClinit2.staticMethod();
+ ClassWithClinit2.$noinline$staticMethod();
}
// TODO: Add a test for the case of a static method whose declaring
diff --git a/test/486-checker-must-do-null-check/src/Main.java b/test/486-checker-must-do-null-check/src/Main.java
index ea72718..e8ff6a4 100644
--- a/test/486-checker-must-do-null-check/src/Main.java
+++ b/test/486-checker-must-do-null-check/src/Main.java
@@ -36,16 +36,16 @@
/// CHECK: CheckCast must_do_null_check:false
public void CheckCastPreChecked(Object o) {
o.toString();
- ((Main)o).Bar();
+ ((Main)o).$noinline$Bar();
}
/// CHECK-START: void Main.CheckCast(java.lang.Object) instruction_simplifier (after)
/// CHECK: CheckCast must_do_null_check:true
public void CheckCast(Object o) {
- ((Main)o).Bar();
+ ((Main)o).$noinline$Bar();
}
- void Bar() {throw new RuntimeException();}
+ void $noinline$Bar() {throw new RuntimeException();}
public static void main(String[] sa) {
Main t = new Main();
