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
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 7f7f2db..04fe79a 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -2593,37 +2593,19 @@
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 @@
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 @@
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 @@
// 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 @@
// 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 8e1e2a0..71fcf29 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -592,9 +592,6 @@
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 4fd3c78..0b2471b 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 @@
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 2c7f1fd..09d8601 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 @@
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 @@
// 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 a092b9f..a7881ac 100644
--- a/runtime/native/dalvik_system_ZygoteHooks.cc
+++ b/runtime/native/dalvik_system_ZygoteHooks.cc
@@ -66,7 +66,6 @@
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 @@
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);
}
