From 1e3dfff2b73e142c568625a0310c1764658218c4 Mon Sep 17 00:00:00 2001 From: Jeff Hao Date: Tue, 27 Jan 2015 11:22:04 -0800 Subject: [PATCH] Allow preopted apps to have sharpened calls for non-x86 architectures. Bug: 19100762 Change-Id: Idce391a06a85b881ce138756155b36e3ed7319c1 --- compiler/dex/quick/arm64/call_arm64.cc | 5 ++--- compiler/driver/compiler_driver.cc | 26 +++++++++++++++++--------- compiler/oat_writer.cc | 23 +++++++++++++++-------- 3 files changed, 34 insertions(+), 20 deletions(-) diff --git a/compiler/dex/quick/arm64/call_arm64.cc b/compiler/dex/quick/arm64/call_arm64.cc index 6492442b9..d2204f558 100644 --- a/compiler/dex/quick/arm64/call_arm64.cc +++ b/compiler/dex/quick/arm64/call_arm64.cc @@ -400,9 +400,8 @@ void Arm64Mir2Lir::GenSpecialExitSequence() { } static bool Arm64UseRelativeCall(CompilationUnit* cu, const MethodReference& target_method) { - UNUSED(cu, target_method); - // Always emit relative calls. - return true; + // Emit relative calls anywhere in the image or within a dex file otherwise. + return cu->compiler_driver->IsImage() || cu->dex_file == target_method.dex_file; } /* diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc index 7451bd58c..cc59a2fe7 100644 --- a/compiler/driver/compiler_driver.cc +++ b/compiler/driver/compiler_driver.cc @@ -1267,14 +1267,14 @@ void CompilerDriver::GetCodeAndMethodForDirectCall(InvokeType* type, InvokeType } // TODO: support patching on all architectures. use_dex_cache = use_dex_cache || (force_relocations && !support_boot_image_fixup_); - bool method_code_in_boot = (method->GetDeclaringClass()->GetClassLoader() == nullptr); + mirror::Class* declaring_class = method->GetDeclaringClass(); + bool method_code_in_boot = (declaring_class->GetClassLoader() == nullptr); if (!use_dex_cache) { if (!method_code_in_boot) { use_dex_cache = true; } else { - bool has_clinit_trampoline = - method->IsStatic() && !method->GetDeclaringClass()->IsInitialized(); - if (has_clinit_trampoline && (method->GetDeclaringClass() != referrer_class)) { + bool has_clinit_trampoline = method->IsStatic() && !declaring_class->IsInitialized(); + if (has_clinit_trampoline && (declaring_class != referrer_class)) { // Ensure we run the clinit trampoline unless we are invoking a static method in the same // class. use_dex_cache = true; @@ -1285,7 +1285,15 @@ void CompilerDriver::GetCodeAndMethodForDirectCall(InvokeType* type, InvokeType *stats_flags |= kFlagDirectCallToBoot | kFlagDirectMethodToBoot; } if (!use_dex_cache && force_relocations) { - if (!IsImage() || !IsImageClass(method->GetDeclaringClassDescriptor())) { + bool is_in_image; + if (IsImage()) { + is_in_image = IsImageClass(method->GetDeclaringClassDescriptor()); + } else { + is_in_image = instruction_set_ != kX86 && instruction_set_ != kX86_64 && + Runtime::Current()->GetHeap()->FindSpaceFromObject(declaring_class, + false)->IsImageSpace(); + } + if (!is_in_image) { // We can only branch directly to Methods that are resolved in the DexCache. // Otherwise we won't invoke the resolution trampoline. use_dex_cache = true; @@ -1294,7 +1302,7 @@ void CompilerDriver::GetCodeAndMethodForDirectCall(InvokeType* type, InvokeType // The method is defined not within this dex file. We need a dex cache slot within the current // dex file or direct pointers. bool must_use_direct_pointers = false; - if (target_method->dex_file == method->GetDeclaringClass()->GetDexCache()->GetDexFile()) { + if (target_method->dex_file == declaring_class->GetDexCache()->GetDexFile()) { target_method->dex_method_index = method->GetDexMethodIndex(); } else { if (no_guarantee_of_dex_cache_entry) { @@ -1307,7 +1315,7 @@ void CompilerDriver::GetCodeAndMethodForDirectCall(InvokeType* type, InvokeType } else { if (force_relocations && !use_dex_cache) { target_method->dex_method_index = method->GetDexMethodIndex(); - target_method->dex_file = method->GetDeclaringClass()->GetDexCache()->GetDexFile(); + target_method->dex_file = declaring_class->GetDexCache()->GetDexFile(); } must_use_direct_pointers = true; } @@ -1330,14 +1338,14 @@ void CompilerDriver::GetCodeAndMethodForDirectCall(InvokeType* type, InvokeType *type = sharp_type; *direct_method = force_relocations ? -1 : reinterpret_cast(method); *direct_code = force_relocations ? -1 : compiler_->GetEntryPointOf(method); - target_method->dex_file = method->GetDeclaringClass()->GetDexCache()->GetDexFile(); + target_method->dex_file = declaring_class->GetDexCache()->GetDexFile(); target_method->dex_method_index = method->GetDexMethodIndex(); } else if (!must_use_direct_pointers) { // Set the code and rely on the dex cache for the method. *type = sharp_type; if (force_relocations) { *direct_code = -1; - target_method->dex_file = method->GetDeclaringClass()->GetDexCache()->GetDexFile(); + target_method->dex_file = declaring_class->GetDexCache()->GetDexFile(); target_method->dex_method_index = method->GetDexMethodIndex(); } else { *direct_code = compiler_->GetEntryPointOf(method); diff --git a/compiler/oat_writer.cc b/compiler/oat_writer.cc index 3c36ffa4e..751681196 100644 --- a/compiler/oat_writer.cc +++ b/compiler/oat_writer.cc @@ -1103,10 +1103,18 @@ class OatWriter::WriteCodeMethodVisitor : public OatDexMethodVisitor { if (UNLIKELY(target_offset == 0)) { mirror::ArtMethod* target = GetTargetMethod(patch); DCHECK(target != nullptr); - DCHECK_EQ(target->GetQuickOatCodeOffset(), 0u); - target_offset = target->IsNative() - ? writer_->oat_header_->GetQuickGenericJniTrampolineOffset() - : writer_->oat_header_->GetQuickToInterpreterBridgeOffset(); + size_t size = GetInstructionSetPointerSize(writer_->compiler_driver_->GetInstructionSet()); + const void* oat_code_offset = target->GetEntryPointFromQuickCompiledCodePtrSize(size); + if (oat_code_offset != 0) { + DCHECK(!Runtime::Current()->GetClassLinker()->IsQuickResolutionStub(oat_code_offset)); + DCHECK(!Runtime::Current()->GetClassLinker()->IsQuickToInterpreterBridge(oat_code_offset)); + DCHECK(!Runtime::Current()->GetClassLinker()->IsQuickGenericJniStub(oat_code_offset)); + target_offset = PointerToLowMemUInt32(oat_code_offset); + } else { + target_offset = target->IsNative() + ? writer_->oat_header_->GetQuickGenericJniTrampolineOffset() + : writer_->oat_header_->GetQuickToInterpreterBridgeOffset(); + } } return target_offset; } @@ -1138,10 +1146,9 @@ class OatWriter::WriteCodeMethodVisitor : public OatDexMethodVisitor { void PatchCodeAddress(std::vector* code, uint32_t offset, uint32_t target_offset) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { - // NOTE: Direct calls across oat files don't use linker patches. - DCHECK(writer_->image_writer_ != nullptr); - uint32_t address = PointerToLowMemUInt32(writer_->image_writer_->GetOatFileBegin() + - writer_->oat_data_offset_ + target_offset); + uint32_t address = writer_->image_writer_ == nullptr ? target_offset : + PointerToLowMemUInt32(writer_->image_writer_->GetOatFileBegin() + + writer_->oat_data_offset_ + target_offset); DCHECK_LE(offset + 4, code->size()); uint8_t* data = &(*code)[offset]; data[0] = address & 0xffu; -- 2.11.0