From 3a98aae1b9b20bc78dc5e05d2e60cb1d0072db02 Mon Sep 17 00:00:00 2001 From: Tamas Berghammer Date: Mon, 8 Feb 2016 20:21:54 +0000 Subject: [PATCH] Revert "Make it possible to enable native debugging through debug flags" The change causes issues in test-art-target-gtest-jni_internal_test32 This reverts commit c94a61f06ffc13288c67891048128c987b29bf33. Change-Id: Iecfe3c6874d7b0dd59f10156fe2eb743ab7221dc --- runtime/class_linker.cc | 46 ++++++++++------------------- runtime/class_linker.h | 3 -- runtime/interpreter/interpreter.cc | 8 ++--- runtime/interpreter/interpreter_common.cc | 25 ++++++++++++---- runtime/native/dalvik_system_ZygoteHooks.cc | 6 ---- 5 files changed, 38 insertions(+), 50 deletions(-) diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc index 7f7f2dbad..04fe79aeb 100644 --- a/runtime/class_linker.cc +++ b/runtime/class_linker.cc @@ -2593,37 +2593,19 @@ const void* ClassLinker::GetQuickOatCodeFor(const DexFile& dex_file, return oat_class.GetOatMethod(oat_method_idx).GetQuickCode(); } -bool ClassLinker::CanUseAOTCode(ArtMethod* method, const void* quick_code) { +// Returns true if the method must run with interpreter, false otherwise. +static bool NeedsInterpreter(ArtMethod* method, const void* quick_code) + SHARED_REQUIRES(Locks::mutator_lock_) { if (quick_code == nullptr) { // No code: need interpreter. - return false; - } - - if (UNLIKELY(method->IsNative() || method->IsProxyMethod())) { + // May return true for native code, in the case of generic JNI + // DCHECK(!method->IsNative()); return true; } - - Runtime* runtime = Runtime::Current(); - instrumentation::Instrumentation* instr = runtime->GetInstrumentation(); - if (instr->InterpretOnly()) { - return false; - } - - if (runtime->GetClassLinker()->IsQuickToInterpreterBridge(quick_code)) { - // Doing this check avoids doing compiled/interpreter transitions. - return false; - } - - if (Dbg::IsForcedInterpreterNeededForCalling(Thread::Current(), method)) { - // Force the use of interpreter when it is required by the debugger. - return false; - } - - if (runtime->UseJit() && runtime->GetJit()->JitAtFirstUse()) { - // Don't use AOT code in force JIT mode. - return false; - } - return true; + // If interpreter mode is enabled, every method (except native and proxy) must + // be run with interpreter. + return Runtime::Current()->GetInstrumentation()->InterpretOnly() && + !method->IsNative() && !method->IsProxyMethod(); } void ClassLinker::FixupStaticTrampolines(mirror::Class* klass) { @@ -2668,7 +2650,8 @@ void ClassLinker::FixupStaticTrampolines(mirror::Class* klass) { OatFile::OatMethod oat_method = oat_class.GetOatMethod(method_index); quick_code = oat_method.GetQuickCode(); } - if (!CanUseAOTCode(method, quick_code)) { + const bool enter_interpreter = NeedsInterpreter(method, quick_code); + if (enter_interpreter) { // Use interpreter entry point. // Check whether the method is native, in which case it's generic JNI. if (quick_code == nullptr && method->IsNative()) { @@ -2705,7 +2688,8 @@ void ClassLinker::LinkCode(ArtMethod* method, const OatFile::OatClass* oat_class oat_method.LinkMethod(method); } - bool has_usable_oat_code = CanUseAOTCode(method, method->GetEntryPointFromQuickCompiledCode()); + // Install entry point from interpreter. + bool enter_interpreter = NeedsInterpreter(method, method->GetEntryPointFromQuickCompiledCode()); if (!method->IsInvokable()) { EnsureThrowsInvocationError(method); @@ -2717,7 +2701,7 @@ void ClassLinker::LinkCode(ArtMethod* method, const OatFile::OatClass* oat_class // It will be replaced by the proper entry point by ClassLinker::FixupStaticTrampolines // after initializing class (see ClassLinker::InitializeClass method). method->SetEntryPointFromQuickCompiledCode(GetQuickResolutionStub()); - } else if (!has_usable_oat_code) { + } else if (enter_interpreter) { if (!method->IsNative()) { // Set entry point from compiled code if there's no code or in interpreter only mode. method->SetEntryPointFromQuickCompiledCode(GetQuickToInterpreterBridge()); @@ -2730,7 +2714,7 @@ void ClassLinker::LinkCode(ArtMethod* method, const OatFile::OatClass* oat_class // Unregistering restores the dlsym lookup stub. method->UnregisterNative(); - if (!has_usable_oat_code) { + if (enter_interpreter) { // We have a native method here without code. Then it should have either the generic JNI // trampoline as entrypoint (non-static), or the resolution trampoline (static). // TODO: this doesn't handle all the cases where trampolines may be installed. diff --git a/runtime/class_linker.h b/runtime/class_linker.h index 8e1e2a07f..71fcf296b 100644 --- a/runtime/class_linker.h +++ b/runtime/class_linker.h @@ -592,9 +592,6 @@ class ClassLinker { REQUIRES(!Locks::classlinker_classes_lock_) SHARED_REQUIRES(Locks::mutator_lock_); - static bool CanUseAOTCode(ArtMethod* method, const void* quick_code) - SHARED_REQUIRES(Locks::mutator_lock_); - struct DexCacheData { // Weak root to the DexCache. Note: Do not decode this unnecessarily or else class unloading may // not work properly. diff --git a/runtime/interpreter/interpreter.cc b/runtime/interpreter/interpreter.cc index 4fd3c78f4..0b2471b4c 100644 --- a/runtime/interpreter/interpreter.cc +++ b/runtime/interpreter/interpreter.cc @@ -27,7 +27,6 @@ #include "unstarted_runtime.h" #include "mterp/mterp.h" #include "jit/jit.h" -#include "jit/jit_code_cache.h" namespace art { namespace interpreter { @@ -294,10 +293,9 @@ static inline JValue Execute(Thread* self, const DexFile::CodeItem* code_item, method, 0); } - jit::Jit* jit = Runtime::Current()->GetJit(); - if (UNLIKELY(jit != nullptr && - jit->JitAtFirstUse() && - jit->GetCodeCache()->ContainsMethod(method))) { + if (UNLIKELY(Runtime::Current()->GetJit() != nullptr && + Runtime::Current()->GetJit()->JitAtFirstUse() && + method->HasAnyCompiledCode())) { JValue result; // Pop the shadow frame before calling into compiled code. diff --git a/runtime/interpreter/interpreter_common.cc b/runtime/interpreter/interpreter_common.cc index 2c7f1fddc..09d860140 100644 --- a/runtime/interpreter/interpreter_common.cc +++ b/runtime/interpreter/interpreter_common.cc @@ -20,7 +20,6 @@ #include "debugger.h" #include "entrypoints/runtime_asm_entrypoints.h" -#include "jit/jit.h" #include "mirror/array-inl.h" #include "stack.h" #include "unstarted_runtime.h" @@ -502,6 +501,23 @@ static inline bool DoCallCommon(ArtMethod* called_method, uint32_t (&arg)[kVarArgMax], uint32_t vregC) ALWAYS_INLINE; +SHARED_REQUIRES(Locks::mutator_lock_) +static inline bool NeedsInterpreter(Thread* self, ShadowFrame* new_shadow_frame) ALWAYS_INLINE; + +static inline bool NeedsInterpreter(Thread* self, ShadowFrame* new_shadow_frame) { + ArtMethod* target = new_shadow_frame->GetMethod(); + if (UNLIKELY(target->IsNative() || target->IsProxyMethod())) { + return false; + } + Runtime* runtime = Runtime::Current(); + ClassLinker* class_linker = runtime->GetClassLinker(); + return runtime->GetInstrumentation()->IsForcedInterpretOnly() || + // Doing this check avoids doing compiled/interpreter transitions. + class_linker->IsQuickToInterpreterBridge(target->GetEntryPointFromQuickCompiledCode()) || + // Force the use of interpreter when it is required by the debugger. + Dbg::IsForcedInterpreterNeededForCalling(self, target); +} + void ArtInterpreterToCompiledCodeBridge(Thread* self, const DexFile::CodeItem* code_item, ShadowFrame* shadow_frame, @@ -720,11 +736,10 @@ static inline bool DoCallCommon(ArtMethod* called_method, // Do the call now. if (LIKELY(Runtime::Current()->IsStarted())) { - ArtMethod* target = new_shadow_frame->GetMethod(); - if (ClassLinker::CanUseAOTCode(target, target->GetEntryPointFromQuickCompiledCode())) { - ArtInterpreterToCompiledCodeBridge(self, code_item, new_shadow_frame, result); - } else { + if (NeedsInterpreter(self, new_shadow_frame)) { ArtInterpreterToInterpreterBridge(self, code_item, new_shadow_frame, result); + } else { + ArtInterpreterToCompiledCodeBridge(self, code_item, new_shadow_frame, result); } } else { UnstartedRuntime::Invoke(self, code_item, new_shadow_frame, result, first_dest_reg); diff --git a/runtime/native/dalvik_system_ZygoteHooks.cc b/runtime/native/dalvik_system_ZygoteHooks.cc index a092b9f24..a7881ac52 100644 --- a/runtime/native/dalvik_system_ZygoteHooks.cc +++ b/runtime/native/dalvik_system_ZygoteHooks.cc @@ -66,7 +66,6 @@ static void EnableDebugFeatures(uint32_t debug_flags) { DEBUG_ENABLE_JNI_LOGGING = 1 << 4, DEBUG_GENERATE_DEBUG_INFO = 1 << 5, DEBUG_ALWAYS_JIT = 1 << 6, - DEBUG_NATIVE_DEBUGGABLE = 1 << 7, }; Runtime* const runtime = Runtime::Current(); @@ -118,11 +117,6 @@ static void EnableDebugFeatures(uint32_t debug_flags) { debug_flags &= ~DEBUG_ALWAYS_JIT; } - if ((debug_flags & DEBUG_NATIVE_DEBUGGABLE) != 0) { - runtime->AddCompilerOption("--native-debuggable"); - debug_flags &= ~DEBUG_NATIVE_DEBUGGABLE; - } - if (debug_flags != 0) { LOG(ERROR) << StringPrintf("Unknown bits set in debug_flags: %#x", debug_flags); } -- 2.11.0