Remove Frame, merge shadow and quick representations.
Change-Id: I5ae03a5e52111792d2df7e83cbd89ab25777844b
diff --git a/src/asm_support.h b/src/asm_support.h
index e776e53..415747e 100644
--- a/src/asm_support.h
+++ b/src/asm_support.h
@@ -29,15 +29,15 @@
#define rSELF r9
#define rLR r14
// Offset of field Thread::suspend_count_ verified in InitCpu
-#define THREAD_SUSPEND_COUNT_OFFSET 124
+#define THREAD_SUSPEND_COUNT_OFFSET 0
// Offset of field Thread::exception_ verified in InitCpu
-#define THREAD_EXCEPTION_OFFSET 120
+#define THREAD_EXCEPTION_OFFSET 8
#elif defined(__i386__)
// Offset of field Thread::self_ verified in InitCpu
-#define THREAD_SELF_OFFSET 112
+#define THREAD_SELF_OFFSET 36
// Offset of field Thread::exception_ verified in InitCpu
-#define THREAD_EXCEPTION_OFFSET 120
+#define THREAD_EXCEPTION_OFFSET 8
#endif
#endif // ART_SRC_ASM_SUPPORT_H_
diff --git a/src/check_jni.cc b/src/check_jni.cc
index 4da4b37..0fd5f6e 100644
--- a/src/check_jni.cc
+++ b/src/check_jni.cc
@@ -80,7 +80,7 @@
static bool IsSirtLocalRef(JNIEnv* env, jobject localRef) {
return GetIndirectRefKind(localRef) == kSirtOrInvalid &&
- reinterpret_cast<JNIEnvExt*>(env)->self->StackReferencesContain(localRef);
+ reinterpret_cast<JNIEnvExt*>(env)->self->SirtContains(localRef);
}
template<typename T>
diff --git a/src/compiler.cc b/src/compiler.cc
index 8e24fc2..2633b78 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -923,9 +923,9 @@
return true;
}
-class Context {
+class CompilationContext {
public:
- Context(ClassLinker* class_linker,
+ CompilationContext(ClassLinker* class_linker,
const ClassLoader* class_loader,
Compiler* compiler,
DexCache* dex_cache,
@@ -964,11 +964,11 @@
const DexFile* dex_file_;
};
-typedef void Callback(Context* context, size_t index);
+typedef void Callback(CompilationContext* context, size_t index);
class WorkerThread {
public:
- WorkerThread(Context* context, size_t begin, size_t end, Callback callback, size_t stripe, bool spawn)
+ WorkerThread(CompilationContext* context, size_t begin, size_t end, Callback callback, size_t stripe, bool spawn)
: spawn_(spawn), context_(context), begin_(begin), end_(end), callback_(callback), stripe_(stripe) {
if (spawn_) {
// Mac OS stacks are only 512KiB. Make sure we have the same stack size on all platforms.
@@ -1017,16 +1017,16 @@
pthread_t pthread_;
bool spawn_;
- Context* context_;
+ CompilationContext* context_;
size_t begin_;
size_t end_;
Callback* callback_;
size_t stripe_;
- friend void ForAll(Context*, size_t, size_t, Callback, size_t);
+ friend void ForAll(CompilationContext*, size_t, size_t, Callback, size_t);
};
-void ForAll(Context* context, size_t begin, size_t end, Callback callback, size_t thread_count) {
+void ForAll(CompilationContext* context, size_t begin, size_t end, Callback callback, size_t thread_count) {
Thread* self = Thread::Current();
CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
CHECK_GT(thread_count, 0U);
@@ -1042,7 +1042,7 @@
STLDeleteElements(&threads);
}
-static void ResolveClassFieldsAndMethods(Context* context, size_t class_def_index) {
+static void ResolveClassFieldsAndMethods(CompilationContext* context, size_t class_def_index) {
const DexFile& dex_file = *context->GetDexFile();
// Method and Field are the worst. We can't resolve without either
@@ -1108,7 +1108,7 @@
DCHECK(!it.HasNext());
}
-static void ResolveType(Context* context, size_t type_idx) {
+static void ResolveType(CompilationContext* context, size_t type_idx) {
// Class derived values are more complicated, they require the linker and loader.
Thread* self = Thread::Current();
Class* klass = context->GetClassLinker()->ResolveType(*context->GetDexFile(),
@@ -1135,7 +1135,7 @@
timings.AddSplit("Resolve " + dex_file.GetLocation() + " Strings");
}
- Context context(class_linker, class_loader, this, dex_cache, &dex_file);
+ CompilationContext context(class_linker, class_loader, this, dex_cache, &dex_file);
ForAll(&context, 0, dex_cache->NumResolvedTypes(), ResolveType, thread_count_);
timings.AddSplit("Resolve " + dex_file.GetLocation() + " Types");
@@ -1152,7 +1152,7 @@
}
}
-static void VerifyClass(Context* context, size_t class_def_index) {
+static void VerifyClass(CompilationContext* context, size_t class_def_index) {
const DexFile::ClassDef& class_def = context->GetDexFile()->GetClassDef(class_def_index);
const char* descriptor = context->GetDexFile()->GetClassDescriptor(class_def);
Class* klass = context->GetClassLinker()->FindClass(descriptor, context->GetClassLoader());
@@ -1194,7 +1194,7 @@
dex_file.ChangePermissions(PROT_READ | PROT_WRITE);
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- Context context(class_linker, class_loader, this, class_linker->FindDexCache(dex_file), &dex_file);
+ CompilationContext context(class_linker, class_loader, this, class_linker->FindDexCache(dex_file), &dex_file);
ForAll(&context, 0, dex_file.NumClassDefs(), VerifyClass, thread_count_);
dex_file.ChangePermissions(PROT_READ);
@@ -1255,7 +1255,7 @@
// the future.
class DexFilesWorkerThread {
public:
- DexFilesWorkerThread(Context *worker_context, Callback class_callback,
+ DexFilesWorkerThread(CompilationContext *worker_context, Callback class_callback,
const std::vector<const DexFile*>& dex_files,
volatile int32_t* shared_class_index, bool spawn)
: spawn_(spawn), worker_context_(worker_context),
@@ -1308,10 +1308,10 @@
// TODO: Add a callback to let the client specify the class_linker and
// dex_cache in the context for the current working dex file.
- context_ = new Context(/* class_linker */NULL,
- worker_context_->GetClassLoader(),
- worker_context_->GetCompiler(),
- /* dex_cache */NULL, dex_file);
+ context_ = new CompilationContext(/* class_linker */NULL,
+ worker_context_->GetClassLoader(),
+ worker_context_->GetCompiler(),
+ /* dex_cache */NULL, dex_file);
CHECK(context_ != NULL);
}
@@ -1356,19 +1356,19 @@
pthread_t pthread_;
bool spawn_;
- Context* worker_context_;
+ CompilationContext* worker_context_;
Callback* class_callback_;
const std::vector<const DexFile*>& dex_files_;
- Context* context_;
+ CompilationContext* context_;
volatile int32_t* shared_class_index_;
- friend void ForClassesInAllDexFiles(Context*,
+ friend void ForClassesInAllDexFiles(CompilationContext*,
const std::vector<const DexFile*>&,
Callback, size_t);
};
-void ForClassesInAllDexFiles(Context* worker_context,
+void ForClassesInAllDexFiles(CompilationContext* worker_context,
const std::vector<const DexFile*>& dex_files,
Callback class_callback, size_t thread_count) {
Thread* self = Thread::Current();
@@ -1396,7 +1396,7 @@
if (dex_files.size() <= 0) {
return; // No dex file
}
- Context context(NULL, class_loader, this, NULL, NULL);
+ CompilationContext context(NULL, class_loader, this, NULL, NULL);
ForClassesInAllDexFiles(&context, dex_files, Compiler::CompileClass, thread_count_);
#else
for (size_t i = 0; i != dex_files.size(); ++i) {
@@ -1407,7 +1407,7 @@
#endif
}
-void Compiler::CompileClass(Context* context, size_t class_def_index) {
+void Compiler::CompileClass(CompilationContext* context, size_t class_def_index) {
const ClassLoader* class_loader = context->GetClassLoader();
const DexFile& dex_file = *context->GetDexFile();
const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
@@ -1466,7 +1466,7 @@
}
void Compiler::CompileDexFile(const ClassLoader* class_loader, const DexFile& dex_file) {
- Context context(NULL, class_loader, this, NULL, &dex_file);
+ CompilationContext context(NULL, class_loader, this, NULL, &dex_file);
ForAll(&context, 0, dex_file.NumClassDefs(), Compiler::CompileClass, thread_count_);
}
diff --git a/src/compiler.h b/src/compiler.h
index b36d807..8f5d5b4 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -36,7 +36,7 @@
namespace art {
class AOTCompilationStats;
-class Context;
+class CompilationContext;
class OatCompilationUnit;
class TimingLogger;
@@ -278,7 +278,7 @@
void CompileMethod(const DexFile::CodeItem* code_item, uint32_t access_flags, uint32_t method_idx,
const ClassLoader* class_loader, const DexFile& dex_file);
- static void CompileClass(Context* context, size_t class_def_index);
+ static void CompileClass(CompilationContext* context, size_t class_def_index);
void SetGcMaps(const ClassLoader* class_loader, const std::vector<const DexFile*>& dex_files);
void SetGcMapsDexFile(const ClassLoader* class_loader, const DexFile& dex_file);
diff --git a/src/compiler/codegen/RallocUtil.cc b/src/compiler/codegen/RallocUtil.cc
index affb545..2088cdc 100644
--- a/src/compiler/codegen/RallocUtil.cc
+++ b/src/compiler/codegen/RallocUtil.cc
@@ -1244,8 +1244,8 @@
/* Returns sp-relative offset in bytes for a VReg */
extern int oatVRegOffset(CompilationUnit* cUnit, int vReg)
{
- return Frame::GetVRegOffset(cUnit->code_item, cUnit->coreSpillMask,
- cUnit->fpSpillMask, cUnit->frameSize, vReg);
+ return StackVisitor::GetVRegOffset(cUnit->code_item, cUnit->coreSpillMask,
+ cUnit->fpSpillMask, cUnit->frameSize, vReg);
}
/* Returns sp-relative offset in bytes for a SReg */
diff --git a/src/compiler_llvm/jni_compiler.cc b/src/compiler_llvm/jni_compiler.cc
index bb45fac..37ca82f 100644
--- a/src/compiler_llvm/jni_compiler.cc
+++ b/src/compiler_llvm/jni_compiler.cc
@@ -27,7 +27,6 @@
#include "object.h"
#include "runtime.h"
#include "runtime_support_func.h"
-#include "shadow_frame.h"
#include "utils_llvm.h"
#include <llvm/BasicBlock.h>
@@ -115,7 +114,7 @@
// Store the dex pc
irb_.StoreToObjectOffset(shadow_frame_,
ShadowFrame::DexPCOffset(),
- irb_.getInt32(0),
+ irb_.getInt32(DexFile::kDexNoIndex),
kTBAAShadowFrame);
// Push the shadow frame
diff --git a/src/compiler_llvm/method_compiler.cc b/src/compiler_llvm/method_compiler.cc
index 754f3ba..eef71db 100644
--- a/src/compiler_llvm/method_compiler.cc
+++ b/src/compiler_llvm/method_compiler.cc
@@ -28,7 +28,6 @@
#include "object_utils.h"
#include "runtime_support_func.h"
#include "runtime_support_llvm.h"
-#include "shadow_frame.h"
#include "stl_util.h"
#include "stringprintf.h"
#include "utils_llvm.h"
diff --git a/src/compiler_llvm/runtime_support_builder.cc b/src/compiler_llvm/runtime_support_builder.cc
index 00a8efa..8bbac94 100644
--- a/src/compiler_llvm/runtime_support_builder.cc
+++ b/src/compiler_llvm/runtime_support_builder.cc
@@ -20,7 +20,6 @@
#include "ir_builder.h"
#include "monitor.h"
#include "object.h"
-#include "shadow_frame.h"
#include "thread.h"
#include "utils_llvm.h"
diff --git a/src/compiler_llvm/runtime_support_llvm.cc b/src/compiler_llvm/runtime_support_llvm.cc
index 155d824..04073e0 100644
--- a/src/compiler_llvm/runtime_support_llvm.cc
+++ b/src/compiler_llvm/runtime_support_llvm.cc
@@ -26,7 +26,6 @@
#include "runtime_support_func_list.h"
#include "runtime_support_llvm.h"
#include "ScopedLocalRef.h"
-#include "shadow_frame.h"
#include "thread.h"
#include "thread_list.h"
#include "utils_llvm.h"
@@ -124,9 +123,7 @@
void art_throw_no_such_method_from_code(int32_t method_idx) {
Thread* thread = art_get_current_thread_from_code();
// We need the calling method as context for the method_idx
- Frame frame = thread->GetTopOfStack();
- frame.Next();
- Method* method = frame.GetMethod();
+ Method* method = thread->GetCurrentMethod();
thread->ThrowNewException("Ljava/lang/NoSuchMethodError;",
MethodNameFromIndex(method,
method_idx,
@@ -136,8 +133,8 @@
void art_throw_null_pointer_exception_from_code(uint32_t dex_pc) {
Thread* thread = art_get_current_thread_from_code();
- NthCallerVisitor visitor(0);
- thread->WalkStack(&visitor);
+ NthCallerVisitor visitor(thread->GetManagedStack(), 0);
+ visitor.WalkStack();
Method* throw_method = visitor.caller;
ThrowNullPointerExceptionFromDexPC(thread, throw_method, dex_pc);
}
diff --git a/src/debugger.cc b/src/debugger.cc
index 604560e..e3c30f8 100644
--- a/src/debugger.cc
+++ b/src/debugger.cc
@@ -96,10 +96,10 @@
struct AllocRecordStackTraceElement {
Method* method;
- uintptr_t raw_pc;
+ uint32_t dex_pc;
int32_t LineNumber() const {
- return MethodHelper(method).GetLineNumFromNativePC(raw_pc);
+ return MethodHelper(method).GetLineNumFromDexPC(dex_pc);
}
};
@@ -947,7 +947,7 @@
#endif
}
-static void SetLocation(JDWP::JdwpLocation& location, Method* m, uintptr_t native_pc) {
+static void SetLocation(JDWP::JdwpLocation& location, Method* m, uint32_t dex_pc) {
if (m == NULL) {
memset(&location, 0, sizeof(location));
} else {
@@ -955,7 +955,7 @@
location.type_tag = c->IsInterface() ? JDWP::TT_INTERFACE : JDWP::TT_CLASS;
location.class_id = gRegistry->Add(c);
location.method_id = ToMethodId(m);
- location.dex_pc = m->IsNative() ? -1 : m->ToDexPC(native_pc);
+ location.dex_pc = dex_pc;
}
}
@@ -1467,18 +1467,21 @@
}
static int GetStackDepth(Thread* thread) {
- struct CountStackDepthVisitor : public Thread::StackVisitor {
- CountStackDepthVisitor() : depth(0) {}
- bool VisitFrame(const Frame& f, uintptr_t) {
- if (f.HasMethod()) {
+ struct CountStackDepthVisitor : public StackVisitor {
+ CountStackDepthVisitor(const ManagedStack* stack,
+ const std::vector<TraceStackFrame>* trace_stack) :
+ StackVisitor(stack, trace_stack), depth(0) {}
+
+ bool VisitFrame() {
+ if (!GetMethod()->IsRuntimeMethod()) {
++depth;
}
return true;
}
size_t depth;
};
- CountStackDepthVisitor visitor;
- thread->WalkStack(&visitor);
+ CountStackDepthVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack());
+ visitor.WalkStack();
return visitor.depth;
}
@@ -1487,32 +1490,37 @@
return GetStackDepth(DecodeThread(threadId));
}
-void Dbg::GetThreadFrame(JDWP::ObjectId threadId, int desired_frame_number, JDWP::FrameId* pFrameId, JDWP::JdwpLocation* pLoc) {
+void Dbg::GetThreadFrame(JDWP::ObjectId threadId, int desired_frame_number, JDWP::FrameId* pFrameId,
+ JDWP::JdwpLocation* pLoc) {
ScopedThreadListLock thread_list_lock;
- struct GetFrameVisitor : public Thread::StackVisitor {
- GetFrameVisitor(int desired_frame_number, JDWP::FrameId* pFrameId, JDWP::JdwpLocation* pLoc)
- : depth(0), desired_frame_number(desired_frame_number), pFrameId(pFrameId), pLoc(pLoc) {
+ struct GetFrameVisitor : public StackVisitor {
+ GetFrameVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
+ int desired_frame_number, JDWP::FrameId* pFrameId, JDWP::JdwpLocation* pLoc) :
+ StackVisitor(stack, trace_stack), depth(0),
+ desired_frame_number(desired_frame_number), pFrameId(pFrameId), pLoc(pLoc) {
}
- bool VisitFrame(const Frame& f, uintptr_t pc) {
- if (!f.HasMethod()) {
+
+ bool VisitFrame() {
+ if (GetMethod()->IsRuntimeMethod()) {
return true; // The debugger can't do anything useful with a frame that has no Method*.
}
if (depth == desired_frame_number) {
- *pFrameId = reinterpret_cast<JDWP::FrameId>(f.GetSP());
- SetLocation(*pLoc, f.GetMethod(), pc);
+ *pFrameId = GetFrameId();
+ SetLocation(*pLoc, GetMethod(), GetDexPc());
return false;
}
++depth;
return true;
}
int depth;
- int desired_frame_number;
- JDWP::FrameId* pFrameId;
- JDWP::JdwpLocation* pLoc;
+ const int desired_frame_number;
+ JDWP::FrameId* const pFrameId;
+ JDWP::JdwpLocation* const pLoc;
};
- GetFrameVisitor visitor(desired_frame_number, pFrameId, pLoc);
- visitor.desired_frame_number = desired_frame_number;
- DecodeThread(threadId)->WalkStack(&visitor);
+ Thread* thread = DecodeThread(threadId);
+ GetFrameVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), desired_frame_number,
+ pFrameId, pLoc);
+ visitor.WalkStack();
}
JDWP::ObjectId Dbg::GetThreadSelfId() {
@@ -1556,180 +1564,252 @@
Runtime::Current()->GetThreadList()->SuspendSelfForDebugger();
}
-static Object* GetThis(Frame& f) {
- Method* m = f.GetMethod();
- Object* o = NULL;
- if (!m->IsNative() && !m->IsStatic()) {
- uint16_t reg = DemangleSlot(0, m);
- o = reinterpret_cast<Object*>(f.GetVReg(m, reg));
+struct GetThisVisitor : public StackVisitor {
+ GetThisVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
+ Context* context, JDWP::FrameId frameId) :
+ StackVisitor(stack, trace_stack, context), thisObject_(NULL), frameId_(frameId) {}
+
+
+ virtual bool VisitFrame() {
+ if (frameId_ != GetFrameId()) {
+ return true; // continue
+ }
+ Method* m = GetMethod();
+ if (m->IsNative() || m->IsStatic()) {
+ thisObject_ = NULL;
+ } else {
+ uint16_t reg = DemangleSlot(0, m);
+ thisObject_ = reinterpret_cast<Object*>(GetVReg(m, reg));
+ }
+ return false;
}
- return o;
+
+ Object* thisObject_;
+ JDWP::FrameId frameId_;
+};
+
+static Object* GetThis(Method** quickFrame) {
+ struct FrameIdVisitor : public StackVisitor {
+ FrameIdVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
+ Method** m) : StackVisitor(stack, trace_stack),
+ quick_frame_to_find_(m) , frame_id_(0) {}
+
+ virtual bool VisitFrame() {
+ if (quick_frame_to_find_ != GetCurrentQuickFrame()) {
+ return true; // Continue.
+ }
+ frame_id_ = GetFrameId();
+ return false; // Stop.
+ }
+
+ Method** const quick_frame_to_find_;
+ JDWP::FrameId frame_id_;
+ };
+
+ Method* m = *quickFrame;
+ if (m->IsNative() || m->IsStatic()) {
+ return NULL;
+ }
+ Thread* self = Thread::Current();
+ const ManagedStack* stack = self->GetManagedStack();
+ const std::vector<TraceStackFrame>* trace_stack = self->GetTraceStack();
+ FrameIdVisitor frameIdVisitor(stack, trace_stack, quickFrame);
+ frameIdVisitor.WalkStack();
+ UniquePtr<Context> context(Context::Create());
+ GetThisVisitor getThisVisitor(stack, trace_stack, context.get(), frameIdVisitor.frame_id_);
+ getThisVisitor.WalkStack();
+ return getThisVisitor.thisObject_;
}
void Dbg::GetThisObject(JDWP::FrameId frameId, JDWP::ObjectId* pThisId) {
- Method** sp = reinterpret_cast<Method**>(frameId);
- Frame f(sp);
- Object* o = GetThis(f);
- *pThisId = gRegistry->Add(o);
+ UniquePtr<Context> context(Context::Create());
+ Thread* self = Thread::Current();
+ GetThisVisitor visitor(self->GetManagedStack(), self->GetTraceStack(), context.get(), frameId);
+ visitor.WalkStack();
+ *pThisId = gRegistry->Add(visitor.thisObject_);
}
-void Dbg::GetLocalValue(JDWP::ObjectId /*threadId*/, JDWP::FrameId frameId, int slot, JDWP::JdwpTag tag, uint8_t* buf, size_t width) {
- Method** sp = reinterpret_cast<Method**>(frameId);
- Frame f(sp);
- Method* m = f.GetMethod();
- uint16_t reg = DemangleSlot(slot, m);
-
-#if defined(ART_USE_LLVM_COMPILER)
- UNIMPLEMENTED(FATAL);
-#else
- const VmapTable vmap_table(m->GetVmapTableRaw());
- uint32_t vmap_offset;
- if (vmap_table.IsInContext(reg, vmap_offset)) {
- UNIMPLEMENTED(FATAL) << "Don't know how to pull locals from callee save frames: " << vmap_offset;
- }
-#endif
-
- // TODO: check that the tag is compatible with the actual type of the slot!
-
- switch (tag) {
- case JDWP::JT_BOOLEAN:
- {
- CHECK_EQ(width, 1U);
- uint32_t intVal = f.GetVReg(m, reg);
- VLOG(jdwp) << "get boolean local " << reg << " = " << intVal;
- JDWP::Set1(buf+1, intVal != 0);
+void Dbg::GetLocalValue(JDWP::ObjectId threadId, JDWP::FrameId frameId, int slot, JDWP::JdwpTag tag, uint8_t* buf, size_t width) {
+ struct GetLocalVisitor : public StackVisitor {
+ GetLocalVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
+ Context* context, JDWP::FrameId frameId, int slot, JDWP::JdwpTag tag,
+ uint8_t* buf, size_t width) :
+ StackVisitor(stack, trace_stack, context), frame_id_(frameId), slot_(slot), tag_(tag),
+ buf_(buf), width_(width) {
}
- break;
- case JDWP::JT_BYTE:
- {
- CHECK_EQ(width, 1U);
- uint32_t intVal = f.GetVReg(m, reg);
- VLOG(jdwp) << "get byte local " << reg << " = " << intVal;
- JDWP::Set1(buf+1, intVal);
- }
- break;
- case JDWP::JT_SHORT:
- case JDWP::JT_CHAR:
- {
- CHECK_EQ(width, 2U);
- uint32_t intVal = f.GetVReg(m, reg);
- VLOG(jdwp) << "get short/char local " << reg << " = " << intVal;
- JDWP::Set2BE(buf+1, intVal);
- }
- break;
- case JDWP::JT_INT:
- case JDWP::JT_FLOAT:
- {
- CHECK_EQ(width, 4U);
- uint32_t intVal = f.GetVReg(m, reg);
- VLOG(jdwp) << "get int/float local " << reg << " = " << intVal;
- JDWP::Set4BE(buf+1, intVal);
- }
- break;
- case JDWP::JT_ARRAY:
- {
- CHECK_EQ(width, sizeof(JDWP::ObjectId));
- Object* o = reinterpret_cast<Object*>(f.GetVReg(m, reg));
- VLOG(jdwp) << "get array local " << reg << " = " << o;
- if (!Runtime::Current()->GetHeap()->IsHeapAddress(o)) {
- LOG(FATAL) << "Register " << reg << " expected to hold array: " << o;
+ bool VisitFrame() {
+ if (GetFrameId() != frame_id_) {
+ return true; // Not our frame, carry on.
}
- JDWP::SetObjectId(buf+1, gRegistry->Add(o));
- }
- break;
- case JDWP::JT_CLASS_LOADER:
- case JDWP::JT_CLASS_OBJECT:
- case JDWP::JT_OBJECT:
- case JDWP::JT_STRING:
- case JDWP::JT_THREAD:
- case JDWP::JT_THREAD_GROUP:
- {
- CHECK_EQ(width, sizeof(JDWP::ObjectId));
- Object* o = reinterpret_cast<Object*>(f.GetVReg(m, reg));
- VLOG(jdwp) << "get object local " << reg << " = " << o;
- if (!Runtime::Current()->GetHeap()->IsHeapAddress(o)) {
- LOG(FATAL) << "Register " << reg << " expected to hold object: " << o;
- }
- tag = TagFromObject(o);
- JDWP::SetObjectId(buf+1, gRegistry->Add(o));
- }
- break;
- case JDWP::JT_DOUBLE:
- case JDWP::JT_LONG:
- {
- CHECK_EQ(width, 8U);
- uint32_t lo = f.GetVReg(m, reg);
- uint64_t hi = f.GetVReg(m, reg + 1);
- uint64_t longVal = (hi << 32) | lo;
- VLOG(jdwp) << "get double/long local " << hi << ":" << lo << " = " << longVal;
- JDWP::Set8BE(buf+1, longVal);
- }
- break;
- default:
- LOG(FATAL) << "Unknown tag " << tag;
- break;
- }
+ // TODO: check that the tag is compatible with the actual type of the slot!
+ Method* m = GetMethod();
+ uint16_t reg = DemangleSlot(slot_, m);
- // Prepend tag, which may have been updated.
- JDWP::Set1(buf, tag);
+ switch (tag_) {
+ case JDWP::JT_BOOLEAN:
+ {
+ CHECK_EQ(width_, 1U);
+ uint32_t intVal = GetVReg(m, reg);
+ VLOG(jdwp) << "get boolean local " << reg << " = " << intVal;
+ JDWP::Set1(buf_+1, intVal != 0);
+ }
+ break;
+ case JDWP::JT_BYTE:
+ {
+ CHECK_EQ(width_, 1U);
+ uint32_t intVal = GetVReg(m, reg);
+ VLOG(jdwp) << "get byte local " << reg << " = " << intVal;
+ JDWP::Set1(buf_+1, intVal);
+ }
+ break;
+ case JDWP::JT_SHORT:
+ case JDWP::JT_CHAR:
+ {
+ CHECK_EQ(width_, 2U);
+ uint32_t intVal = GetVReg(m, reg);
+ VLOG(jdwp) << "get short/char local " << reg << " = " << intVal;
+ JDWP::Set2BE(buf_+1, intVal);
+ }
+ break;
+ case JDWP::JT_INT:
+ case JDWP::JT_FLOAT:
+ {
+ CHECK_EQ(width_, 4U);
+ uint32_t intVal = GetVReg(m, reg);
+ VLOG(jdwp) << "get int/float local " << reg << " = " << intVal;
+ JDWP::Set4BE(buf_+1, intVal);
+ }
+ break;
+ case JDWP::JT_ARRAY:
+ {
+ CHECK_EQ(width_, sizeof(JDWP::ObjectId));
+ Object* o = reinterpret_cast<Object*>(GetVReg(m, reg));
+ VLOG(jdwp) << "get array local " << reg << " = " << o;
+ if (!Runtime::Current()->GetHeap()->IsHeapAddress(o)) {
+ LOG(FATAL) << "Register " << reg << " expected to hold array: " << o;
+ }
+ JDWP::SetObjectId(buf_+1, gRegistry->Add(o));
+ }
+ break;
+ case JDWP::JT_CLASS_LOADER:
+ case JDWP::JT_CLASS_OBJECT:
+ case JDWP::JT_OBJECT:
+ case JDWP::JT_STRING:
+ case JDWP::JT_THREAD:
+ case JDWP::JT_THREAD_GROUP:
+ {
+ CHECK_EQ(width_, sizeof(JDWP::ObjectId));
+ Object* o = reinterpret_cast<Object*>(GetVReg(m, reg));
+ VLOG(jdwp) << "get object local " << reg << " = " << o;
+ if (!Runtime::Current()->GetHeap()->IsHeapAddress(o)) {
+ LOG(FATAL) << "Register " << reg << " expected to hold object: " << o;
+ }
+ tag_ = TagFromObject(o);
+ JDWP::SetObjectId(buf_+1, gRegistry->Add(o));
+ }
+ break;
+ case JDWP::JT_DOUBLE:
+ case JDWP::JT_LONG:
+ {
+ CHECK_EQ(width_, 8U);
+ uint32_t lo = GetVReg(m, reg);
+ uint64_t hi = GetVReg(m, reg + 1);
+ uint64_t longVal = (hi << 32) | lo;
+ VLOG(jdwp) << "get double/long local " << hi << ":" << lo << " = " << longVal;
+ JDWP::Set8BE(buf_+1, longVal);
+ }
+ break;
+ default:
+ LOG(FATAL) << "Unknown tag " << tag_;
+ break;
+ }
+
+ // Prepend tag, which may have been updated.
+ JDWP::Set1(buf_, tag_);
+ return false;
+ }
+
+ const JDWP::FrameId frame_id_;
+ const int slot_;
+ JDWP::JdwpTag tag_;
+ uint8_t* const buf_;
+ const size_t width_;
+ };
+ Thread* thread = DecodeThread(threadId);
+ UniquePtr<Context> context(Context::Create());
+ GetLocalVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), context.get(),
+ frameId, slot, tag, buf, width);
+ visitor.WalkStack();
}
-void Dbg::SetLocalValue(JDWP::ObjectId /*threadId*/, JDWP::FrameId frameId, int slot, JDWP::JdwpTag tag, uint64_t value, size_t width) {
- Method** sp = reinterpret_cast<Method**>(frameId);
- Frame f(sp);
- Method* m = f.GetMethod();
- uint16_t reg = DemangleSlot(slot, m);
-
-#if defined(ART_USE_LLVM_COMPILER)
- UNIMPLEMENTED(FATAL);
-#else
- const VmapTable vmap_table(m->GetVmapTableRaw());
- uint32_t vmap_offset;
- if (vmap_table.IsInContext(reg, vmap_offset)) {
- UNIMPLEMENTED(FATAL) << "Don't know how to pull locals from callee save frames: " << vmap_offset;
- }
-#endif
-
- // TODO: check that the tag is compatible with the actual type of the slot!
-
- switch (tag) {
- case JDWP::JT_BOOLEAN:
- case JDWP::JT_BYTE:
- CHECK_EQ(width, 1U);
- f.SetVReg(m, reg, static_cast<uint32_t>(value));
- break;
- case JDWP::JT_SHORT:
- case JDWP::JT_CHAR:
- CHECK_EQ(width, 2U);
- f.SetVReg(m, reg, static_cast<uint32_t>(value));
- break;
- case JDWP::JT_INT:
- case JDWP::JT_FLOAT:
- CHECK_EQ(width, 4U);
- f.SetVReg(m, reg, static_cast<uint32_t>(value));
- break;
- case JDWP::JT_ARRAY:
- case JDWP::JT_OBJECT:
- case JDWP::JT_STRING:
- {
- CHECK_EQ(width, sizeof(JDWP::ObjectId));
- Object* o = gRegistry->Get<Object*>(static_cast<JDWP::ObjectId>(value));
- if (o == kInvalidObject) {
- UNIMPLEMENTED(FATAL) << "return an error code when given an invalid object to store";
- }
- f.SetVReg(m, reg, static_cast<uint32_t>(reinterpret_cast<uintptr_t>(o)));
+void Dbg::SetLocalValue(JDWP::ObjectId threadId, JDWP::FrameId frameId, int slot, JDWP::JdwpTag tag,
+ uint64_t value, size_t width) {
+ struct SetLocalVisitor : public StackVisitor {
+ SetLocalVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
+ JDWP::FrameId frame_id, int slot, JDWP::JdwpTag tag, uint64_t value,
+ size_t width) :
+ StackVisitor(stack, trace_stack), frame_id_(frame_id), slot_(slot), tag_(tag),
+ value_(value), width_(width) {
}
- break;
- case JDWP::JT_DOUBLE:
- case JDWP::JT_LONG:
- CHECK_EQ(width, 8U);
- f.SetVReg(m, reg, static_cast<uint32_t>(value));
- f.SetVReg(m, reg + 1, static_cast<uint32_t>(value >> 32));
- break;
- default:
- LOG(FATAL) << "Unknown tag " << tag;
- break;
- }
+ bool VisitFrame() {
+ if (GetFrameId() != frame_id_) {
+ return true; // Not our frame, carry on.
+ }
+ // TODO: check that the tag is compatible with the actual type of the slot!
+ Method* m = GetMethod();
+ uint16_t reg = DemangleSlot(slot_, m);
+
+ switch (tag_) {
+ case JDWP::JT_BOOLEAN:
+ case JDWP::JT_BYTE:
+ CHECK_EQ(width_, 1U);
+ SetVReg(m, reg, static_cast<uint32_t>(value_));
+ break;
+ case JDWP::JT_SHORT:
+ case JDWP::JT_CHAR:
+ CHECK_EQ(width_, 2U);
+ SetVReg(m, reg, static_cast<uint32_t>(value_));
+ break;
+ case JDWP::JT_INT:
+ case JDWP::JT_FLOAT:
+ CHECK_EQ(width_, 4U);
+ SetVReg(m, reg, static_cast<uint32_t>(value_));
+ break;
+ case JDWP::JT_ARRAY:
+ case JDWP::JT_OBJECT:
+ case JDWP::JT_STRING:
+ {
+ CHECK_EQ(width_, sizeof(JDWP::ObjectId));
+ Object* o = gRegistry->Get<Object*>(static_cast<JDWP::ObjectId>(value_));
+ if (o == kInvalidObject) {
+ UNIMPLEMENTED(FATAL) << "return an error code when given an invalid object to store";
+ }
+ SetVReg(m, reg, static_cast<uint32_t>(reinterpret_cast<uintptr_t>(o)));
+ }
+ break;
+ case JDWP::JT_DOUBLE:
+ case JDWP::JT_LONG:
+ CHECK_EQ(width_, 8U);
+ SetVReg(m, reg, static_cast<uint32_t>(value_));
+ SetVReg(m, reg + 1, static_cast<uint32_t>(value_ >> 32));
+ break;
+ default:
+ LOG(FATAL) << "Unknown tag " << tag_;
+ break;
+ }
+ return false;
+ }
+
+ const JDWP::FrameId frame_id_;
+ const int slot_;
+ const JDWP::JdwpTag tag_;
+ const uint64_t value_;
+ const size_t width_;
+ };
+ Thread* thread = DecodeThread(threadId);
+ SetLocalVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), frameId, slot, tag,
+ value, width);
+ visitor.WalkStack();
}
void Dbg::PostLocationEvent(const Method* m, int dex_pc, Object* this_object, int event_flags) {
@@ -1753,19 +1833,20 @@
}
}
-void Dbg::PostException(Method** sp, Method* throwMethod, uintptr_t throwNativePc, Method* catchMethod, uintptr_t catchNativePc, Object* exception) {
+void Dbg::PostException(JDWP::FrameId throwFrameId, Method* throwMethod, uint32_t throwDexPc,
+ Method* catchMethod, uint32_t catchDexPc, Throwable* exception) {
if (!IsDebuggerActive()) {
return;
}
JDWP::JdwpLocation throw_location;
- SetLocation(throw_location, throwMethod, throwNativePc);
+ SetLocation(throw_location, throwMethod, throwDexPc);
JDWP::JdwpLocation catch_location;
- SetLocation(catch_location, catchMethod, catchNativePc);
+ SetLocation(catch_location, catchMethod, catchDexPc);
// We need 'this' for InstanceOnly filters.
JDWP::ObjectId this_id;
- GetThisObject(reinterpret_cast<JDWP::FrameId>(sp), &this_id);
+ GetThisObject(throwFrameId, &this_id);
/*
* Hand the event to the JDWP exception handler. Note we're using the
@@ -1800,15 +1881,13 @@
return;
}
- Frame f(sp);
- f.Next(); // Skip callee save frame.
- Method* m = f.GetMethod();
+ Method* m = self->GetCurrentMethod();
if (dex_pc == -1) {
// We use a pc of -1 to represent method entry, since we might branch back to pc 0 later.
// This means that for this special notification, there can't be anything else interesting
// going on, so we're done already.
- Dbg::PostLocationEvent(m, 0, GetThis(f), kMethodEntry);
+ Dbg::PostLocationEvent(m, 0, GetThis(sp), kMethodEntry);
return;
}
@@ -1899,7 +1978,7 @@
// If there's something interesting going on, see if it matches one
// of the debugger filters.
if (event_flags != 0) {
- Dbg::PostLocationEvent(m, dex_pc, GetThis(f), event_flags);
+ Dbg::PostLocationEvent(m, dex_pc, GetThis(sp), event_flags);
}
}
@@ -1942,32 +2021,34 @@
// is for step-out.
//
- struct SingleStepStackVisitor : public Thread::StackVisitor {
- SingleStepStackVisitor() {
+ struct SingleStepStackVisitor : public StackVisitor {
+ SingleStepStackVisitor(const ManagedStack* stack,
+ const std::vector<TraceStackFrame>* trace_stack) :
+ StackVisitor(stack, trace_stack) {
MutexLock mu(gBreakpointsLock); // Keep GCC happy.
gSingleStepControl.method = NULL;
gSingleStepControl.stack_depth = 0;
}
- bool VisitFrame(const Frame& f, uintptr_t pc) {
+ bool VisitFrame() {
MutexLock mu(gBreakpointsLock); // Keep GCC happy.
- if (f.HasMethod()) {
+ const Method* m = GetMethod();
+ if (!m->IsRuntimeMethod()) {
++gSingleStepControl.stack_depth;
if (gSingleStepControl.method == NULL) {
- const Method* m = f.GetMethod();
const DexCache* dex_cache = m->GetDeclaringClass()->GetDexCache();
gSingleStepControl.method = m;
gSingleStepControl.line_number = -1;
if (dex_cache != NULL) {
const DexFile& dex_file = Runtime::Current()->GetClassLinker()->FindDexFile(dex_cache);
- gSingleStepControl.line_number = dex_file.GetLineNumFromPC(m, m->ToDexPC(pc));
+ gSingleStepControl.line_number = dex_file.GetLineNumFromPC(m, GetDexPc());
}
}
}
return true;
}
};
- SingleStepStackVisitor visitor;
- thread->WalkStack(&visitor);
+ SingleStepStackVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack());
+ visitor.WalkStack();
//
// Find the dex_pc values that correspond to the current line, for line-based single-stepping.
@@ -2835,17 +2916,20 @@
}
}
-struct AllocRecordStackVisitor : public Thread::StackVisitor {
- explicit AllocRecordStackVisitor(AllocRecord* record) : record(record), depth(0) {
+struct AllocRecordStackVisitor : public StackVisitor {
+ AllocRecordStackVisitor(const ManagedStack* stack,
+ const std::vector<TraceStackFrame>* trace_stack, AllocRecord* record) :
+ StackVisitor(stack, trace_stack), record(record), depth(0) {
}
- bool VisitFrame(const Frame& f, uintptr_t pc) {
+ bool VisitFrame() {
if (depth >= kMaxAllocRecordStackDepth) {
return false;
}
- if (f.HasMethod()) {
- record->stack[depth].method = f.GetMethod();
- record->stack[depth].raw_pc = pc;
+ Method* m = GetMethod();
+ if (!m->IsRuntimeMethod()) {
+ record->stack[depth].method = m;
+ record->stack[depth].dex_pc = GetDexPc();
++depth;
}
return true;
@@ -2855,7 +2939,7 @@
// Clear out any unused stack trace elements.
for (; depth < kMaxAllocRecordStackDepth; ++depth) {
record->stack[depth].method = NULL;
- record->stack[depth].raw_pc = 0;
+ record->stack[depth].dex_pc = 0;
}
}
@@ -2884,8 +2968,8 @@
record->thin_lock_id = self->GetThinLockId();
// Fill in the stack trace.
- AllocRecordStackVisitor visitor(record);
- self->WalkStack(&visitor);
+ AllocRecordStackVisitor visitor(self->GetManagedStack(), self->GetTraceStack(), record);
+ visitor.WalkStack();
if (gAllocRecordCount < kNumAllocRecords) {
++gAllocRecordCount;
diff --git a/src/debugger.h b/src/debugger.h
index 9dffa7c..c6880f7 100644
--- a/src/debugger.h
+++ b/src/debugger.h
@@ -214,7 +214,7 @@
kMethodExit = 0x08,
};
static void PostLocationEvent(const Method* method, int pcOffset, Object* thisPtr, int eventFlags);
- static void PostException(Method** sp, Method* throwMethod, uintptr_t throwNativePc, Method* catchMethod, uintptr_t catchNativePc, Object* exception);
+ static void PostException(JDWP::FrameId frameId, Method* throwMethod, uint32_t throwDexPc, Method* catchMethod, uint32_t catchDexPc, Throwable* exception);
static void PostThreadStart(Thread* t);
static void PostThreadDeath(Thread* t);
static void PostClassPrepare(Class* c);
diff --git a/src/exception_test.cc b/src/exception_test.cc
index 2730954..90bcb7c 100644
--- a/src/exception_test.cc
+++ b/src/exception_test.cc
@@ -184,6 +184,9 @@
#if !defined(ART_USE_LLVM_COMPILER)
thread->SetTopOfStack(NULL, 0); // Disarm the assertion that no code is running when we detach.
+#else
+ thread->PopShadowFrame();
+ thread->PopShadowFrame();
#endif
}
diff --git a/src/heap.cc b/src/heap.cc
index 55a8afe..55d9c03 100644
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -471,9 +471,10 @@
Object* Heap::AllocateLocked(AllocSpace* space, size_t alloc_size) {
lock_->AssertHeld();
- // Since allocation can cause a GC which will need to SuspendAll,
- // make sure all allocators are in the kRunnable state.
- CHECK_EQ(Thread::Current()->GetState(), kRunnable);
+ // Since allocation can cause a GC which will need to SuspendAll, make sure all allocations are
+ // done in the runnable state where suspension is expected.
+ DCHECK_EQ(Thread::Current()->GetState(), kRunnable);
+ Thread::Current()->AssertThreadSuspensionIsAllowable();
// Fail impossible allocations
if (alloc_size > space->Capacity()) {
diff --git a/src/indirect_reference_table.cc b/src/indirect_reference_table.cc
index 69f171c..81b87ef 100644
--- a/src/indirect_reference_table.cc
+++ b/src/indirect_reference_table.cc
@@ -226,7 +226,7 @@
JavaVMExt* vm = Runtime::Current()->GetJavaVM();
if (GetIndirectRefKind(iref) == kSirtOrInvalid &&
- Thread::Current()->StackReferencesContain(reinterpret_cast<jobject>(iref))) {
+ Thread::Current()->SirtContains(reinterpret_cast<jobject>(iref))) {
LOG(WARNING) << "Attempt to remove local SIRT entry from IRT, ignoring";
return true;
}
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 716bb85..fa79a01 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -2376,7 +2376,7 @@
return JNIWeakGlobalRefType;
case kSirtOrInvalid:
// Is it in a stack IRT?
- if (ts.Self()->StackReferencesContain(java_object)) {
+ if (ts.Self()->SirtContains(java_object)) {
return JNILocalRefType;
}
diff --git a/src/monitor.cc b/src/monitor.cc
index 30e0172..8bb7e45 100644
--- a/src/monitor.cc
+++ b/src/monitor.cc
@@ -118,7 +118,7 @@
wait_set_(NULL),
lock_("a monitor lock"),
locking_method_(NULL),
- locking_pc_(0) {
+ locking_dex_pc_(0) {
}
Monitor::~Monitor() {
@@ -188,14 +188,14 @@
if (!lock_.TryLock()) {
uint32_t wait_threshold = lock_profiling_threshold_;
const Method* current_locking_method = NULL;
- uintptr_t current_locking_pc = 0;
+ uint32_t current_locking_dex_pc = 0;
{
ScopedThreadStateChange tsc(self, kBlocked);
if (wait_threshold != 0) {
waitStart = NanoTime() / 1000;
}
current_locking_method = locking_method_;
- current_locking_pc = locking_pc_;
+ current_locking_dex_pc = locking_dex_pc_;
lock_.Lock();
if (wait_threshold != 0) {
@@ -214,7 +214,7 @@
if (sample_percent != 0 && (static_cast<uint32_t>(rand() % 100) < sample_percent)) {
const char* current_locking_filename;
uint32_t current_locking_line_number;
- TranslateLocation(current_locking_method, current_locking_pc,
+ TranslateLocation(current_locking_method, current_locking_dex_pc,
current_locking_filename, current_locking_line_number);
LogContentionEvent(self, wait_ms, sample_percent, current_locking_filename, current_locking_line_number);
}
@@ -226,7 +226,7 @@
// When debugging, save the current monitor holder for future
// acquisition failures to use in sampled logging.
if (lock_profiling_threshold_ != 0) {
- locking_method_ = self->GetCurrentMethod(&locking_pc_);
+ locking_method_ = self->GetCurrentMethod(&locking_dex_pc_);
}
}
@@ -323,7 +323,7 @@
if (lock_count_ == 0) {
owner_ = NULL;
locking_method_ = NULL;
- locking_pc_ = 0;
+ locking_dex_pc_ = 0;
lock_.Unlock();
} else {
--lock_count_;
@@ -427,13 +427,13 @@
* not order sensitive as we hold the pthread mutex.
*/
AppendToWaitSet(self);
- int prevLockCount = lock_count_;
+ int prev_lock_count = lock_count_;
lock_count_ = 0;
owner_ = NULL;
- const Method* savedMethod = locking_method_;
+ const Method* saved_method = locking_method_;
locking_method_ = NULL;
- uintptr_t savedPc = locking_pc_;
- locking_pc_ = 0;
+ uintptr_t saved_dex_pc = locking_dex_pc_;
+ locking_dex_pc_ = 0;
/*
* Update thread status. If the GC wakes up, it'll ignore us, knowing
@@ -498,9 +498,9 @@
* updates is not order sensitive as we hold the pthread mutex.
*/
owner_ = self;
- lock_count_ = prevLockCount;
- locking_method_ = savedMethod;
- locking_pc_ = savedPc;
+ lock_count_ = prev_lock_count;
+ locking_method_ = saved_method;
+ locking_dex_pc_ = saved_dex_pc;
RemoveFromWaitSet(self);
/* set self->status back to kRunnable, and self-suspend if needed */
@@ -857,7 +857,7 @@
os << "\n";
}
-void Monitor::TranslateLocation(const Method* method, uint32_t pc,
+void Monitor::TranslateLocation(const Method* method, uint32_t dex_pc,
const char*& source_file, uint32_t& line_number) const {
// If method is null, location is unknown
if (method == NULL) {
@@ -870,7 +870,7 @@
if (source_file == NULL) {
source_file = "";
}
- line_number = mh.GetLineNumFromNativePC(pc);
+ line_number = mh.GetLineNumFromDexPC(dex_pc);
}
MonitorList::MonitorList() : lock_("MonitorList lock") {
diff --git a/src/monitor.h b/src/monitor.h
index e5aa01e..300e5a5 100644
--- a/src/monitor.h
+++ b/src/monitor.h
@@ -120,11 +120,11 @@
Mutex lock_;
- // Method and pc where the lock owner acquired the lock, used when lock
+ // Method and dex pc where the lock owner acquired the lock, used when lock
// sampling is enabled. locking_method_ may be null if the lock is currently
// unlocked, or if the lock is acquired by the system when the stack is empty.
const Method* locking_method_;
- uintptr_t locking_pc_;
+ uint32_t locking_dex_pc_;
friend class MonitorList;
friend class Object;
diff --git a/src/native/dalvik_system_DexFile.cc b/src/native/dalvik_system_DexFile.cc
index afa09b3..89d7130 100644
--- a/src/native/dalvik_system_DexFile.cc
+++ b/src/native/dalvik_system_DexFile.cc
@@ -24,6 +24,7 @@
#include "logging.h"
#include "os.h"
#include "runtime.h"
+#include "scoped_jni_thread_state.h"
#include "ScopedLocalRef.h"
#include "ScopedUtfChars.h"
#include "space.h"
@@ -125,7 +126,7 @@
static jclass DexFile_defineClassNative(JNIEnv* env, jclass, jstring javaName, jobject javaLoader,
jint cookie) {
- ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
+ ScopedJniThreadState tsc(env);
const DexFile* dex_file = toDexFile(cookie);
if (dex_file == NULL) {
return NULL;
@@ -139,11 +140,10 @@
if (dex_class_def == NULL) {
return NULL;
}
-
- Object* class_loader_object = Decode<Object*>(env, javaLoader);
- ClassLoader* class_loader = down_cast<ClassLoader*>(class_loader_object);
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
class_linker->RegisterDexFile(*dex_file);
+ Object* class_loader_object = Decode<Object*>(env, javaLoader);
+ ClassLoader* class_loader = down_cast<ClassLoader*>(class_loader_object);
Class* result = class_linker->DefineClass(descriptor, class_loader, *dex_file, *dex_class_def);
return AddLocalReference<jclass>(env, result);
}
diff --git a/src/native/dalvik_system_VMStack.cc b/src/native/dalvik_system_VMStack.cc
index ab82694..e3ecbd9 100644
--- a/src/native/dalvik_system_VMStack.cc
+++ b/src/native/dalvik_system_VMStack.cc
@@ -19,6 +19,7 @@
#include "nth_caller_visitor.h"
#include "object.h"
#include "scoped_heap_lock.h"
+#include "scoped_jni_thread_state.h"
#include "scoped_thread_list_lock.h"
#include "thread_list.h"
@@ -43,18 +44,22 @@
// Returns the defining class loader of the caller's caller.
static jobject VMStack_getCallingClassLoader(JNIEnv* env, jclass) {
- NthCallerVisitor visitor(2);
- Thread::Current()->WalkStack(&visitor);
+ ScopedJniThreadState ts(env, kNative); // Not a state change out of native.
+ NthCallerVisitor visitor(ts.Self()->GetManagedStack(), ts.Self()->GetTraceStack(), 2);
+ visitor.WalkStack();
return AddLocalReference<jobject>(env, visitor.caller->GetDeclaringClass()->GetClassLoader());
}
static jobject VMStack_getClosestUserClassLoader(JNIEnv* env, jclass, jobject javaBootstrap, jobject javaSystem) {
- struct ClosestUserClassLoaderVisitor : public Thread::StackVisitor {
- ClosestUserClassLoaderVisitor(Object* bootstrap, Object* system)
- : bootstrap(bootstrap), system(system), class_loader(NULL) {}
- bool VisitFrame(const Frame& f, uintptr_t) {
+ struct ClosestUserClassLoaderVisitor : public StackVisitor {
+ ClosestUserClassLoaderVisitor(const ManagedStack* stack,
+ const std::vector<TraceStackFrame>* trace_stack,
+ Object* bootstrap, Object* system)
+ : StackVisitor(stack, trace_stack), bootstrap(bootstrap), system(system),
+ class_loader(NULL) {}
+ bool VisitFrame() {
DCHECK(class_loader == NULL);
- Class* c = f.GetMethod()->GetDeclaringClass();
+ Class* c = GetMethod()->GetDeclaringClass();
Object* cl = c->GetClassLoader();
if (cl != NULL && cl != bootstrap && cl != system) {
class_loader = cl;
@@ -66,17 +71,20 @@
Object* system;
Object* class_loader;
};
+ ScopedJniThreadState ts(env);
Object* bootstrap = Decode<Object*>(env, javaBootstrap);
Object* system = Decode<Object*>(env, javaSystem);
- ClosestUserClassLoaderVisitor visitor(bootstrap, system);
- Thread::Current()->WalkStack(&visitor);
+ ClosestUserClassLoaderVisitor visitor(ts.Self()->GetManagedStack(), ts.Self()->GetTraceStack(),
+ bootstrap, system);
+ visitor.WalkStack();
return AddLocalReference<jobject>(env, visitor.class_loader);
}
// Returns the class of the caller's caller's caller.
static jclass VMStack_getStackClass2(JNIEnv* env, jclass) {
- NthCallerVisitor visitor(3);
- Thread::Current()->WalkStack(&visitor);
+ ScopedJniThreadState ts(env, kNative); // Not a state change out of native.
+ NthCallerVisitor visitor(ts.Self()->GetManagedStack(), ts.Self()->GetTraceStack(), 3);
+ visitor.WalkStack();
return AddLocalReference<jclass>(env, visitor.caller->GetDeclaringClass());
}
diff --git a/src/native/java_lang_Class.cc b/src/native/java_lang_Class.cc
index 66c83c7..99e3a26 100644
--- a/src/native/java_lang_Class.cc
+++ b/src/native/java_lang_Class.cc
@@ -20,6 +20,7 @@
#include "nth_caller_visitor.h"
#include "object.h"
#include "object_utils.h"
+#include "scoped_jni_thread_state.h"
#include "ScopedLocalRef.h"
#include "ScopedUtfChars.h"
#include "well_known_classes.h"
@@ -307,7 +308,7 @@
}
static jobject Class_getDeclaredFieldNative(JNIEnv* env, jclass java_class, jobject jname) {
- ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
+ ScopedJniThreadState ts(env);
Class* c = DecodeClass(env, java_class);
if (c == NULL) {
return NULL;
@@ -343,23 +344,23 @@
}
static jstring Class_getNameNative(JNIEnv* env, jobject javaThis) {
- ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
+ ScopedJniThreadState ts(env);
Class* c = DecodeClass(env, javaThis);
return AddLocalReference<jstring>(env, c->ComputeName());
}
static jobjectArray Class_getProxyInterfaces(JNIEnv* env, jobject javaThis) {
- ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
+ ScopedJniThreadState ts(env);
SynthesizedProxyClass* c = down_cast<SynthesizedProxyClass*>(DecodeClass(env, javaThis));
return AddLocalReference<jobjectArray>(env, c->GetInterfaces()->Clone());
}
static jboolean Class_isAssignableFrom(JNIEnv* env, jobject javaLhs, jclass javaRhs) {
- ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
+ ScopedJniThreadState ts(env);
Class* lhs = DecodeClass(env, javaLhs);
Class* rhs = Decode<Class*>(env, javaRhs); // Can be null.
if (rhs == NULL) {
- Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;", "class == null");
+ ts.Self()->ThrowNewException("Ljava/lang/NullPointerException;", "class == null");
return JNI_FALSE;
}
return lhs->IsAssignableFrom(rhs) ? JNI_TRUE : JNI_FALSE;
@@ -395,10 +396,10 @@
}
static jobject Class_newInstanceImpl(JNIEnv* env, jobject javaThis) {
- ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
+ ScopedJniThreadState ts(env);
Class* c = DecodeClass(env, javaThis);
if (c->IsPrimitive() || c->IsInterface() || c->IsArrayClass() || c->IsAbstract()) {
- Thread::Current()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
+ ts.Self()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
"Class %s can not be instantiated", PrettyDescriptor(ClassHelper(c).GetDescriptor()).c_str());
return NULL;
}
@@ -409,7 +410,7 @@
Method* init = c->FindDeclaredDirectMethod("<init>", "()V");
if (init == NULL) {
- Thread::Current()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
+ ts.Self()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
"Class %s has no default <init>()V constructor", PrettyDescriptor(ClassHelper(c).GetDescriptor()).c_str());
return NULL;
}
@@ -423,20 +424,20 @@
// constructor must be public or, if the caller is in the same package,
// have package scope.
- NthCallerVisitor visitor(2);
- Thread::Current()->WalkStack(&visitor);
+ NthCallerVisitor visitor(ts.Self()->GetManagedStack(), ts.Self()->GetTraceStack(), 2);
+ visitor.WalkStack();
Class* caller_class = visitor.caller->GetDeclaringClass();
ClassHelper caller_ch(caller_class);
if (!caller_class->CanAccess(c)) {
- Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessException;",
+ ts.Self()->ThrowNewExceptionF("Ljava/lang/IllegalAccessException;",
"Class %s is not accessible from class %s",
PrettyDescriptor(ClassHelper(c).GetDescriptor()).c_str(),
PrettyDescriptor(caller_ch.GetDescriptor()).c_str());
return NULL;
}
if (!CheckMemberAccess(caller_class, init->GetDeclaringClass(), init->GetAccessFlags())) {
- Thread::Current()->ThrowNewExceptionF("Ljava/lang/IllegalAccessException;",
+ ts.Self()->ThrowNewExceptionF("Ljava/lang/IllegalAccessException;",
"%s is not accessible from class %s",
PrettyMethod(init).c_str(),
PrettyDescriptor(caller_ch.GetDescriptor()).c_str());
@@ -445,7 +446,7 @@
Object* new_obj = c->AllocObject();
if (new_obj == NULL) {
- DCHECK(Thread::Current()->IsExceptionPending());
+ DCHECK(ts.Self()->IsExceptionPending());
return NULL;
}
diff --git a/src/nth_caller_visitor.h b/src/nth_caller_visitor.h
index 84d2b3b..db4d28c 100644
--- a/src/nth_caller_visitor.h
+++ b/src/nth_caller_visitor.h
@@ -23,20 +23,19 @@
namespace art {
// Walks up the stack 'n' callers, when used with Thread::WalkStack.
-struct NthCallerVisitor : public Thread::StackVisitor {
- NthCallerVisitor(size_t n) : n(n), count(0), pc(0), caller(NULL) {}
- bool VisitFrame(const Frame& f, uintptr_t fpc) {
+struct NthCallerVisitor : public StackVisitor {
+ NthCallerVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
+ size_t n) : StackVisitor(stack, trace_stack), n(n), count(0), caller(NULL) {}
+ bool VisitFrame() {
DCHECK(caller == NULL);
if (count++ == n) {
- caller = f.GetMethod();
- pc = fpc;
+ caller = GetMethod();
return false;
}
return true;
}
size_t n;
size_t count;
- uintptr_t pc;
Method* caller;
};
diff --git a/src/oat/runtime/arm/context_arm.cc b/src/oat/runtime/arm/context_arm.cc
index 50c386f..2959ef6 100644
--- a/src/oat/runtime/arm/context_arm.cc
+++ b/src/oat/runtime/arm/context_arm.cc
@@ -33,18 +33,19 @@
#endif
}
-void ArmContext::FillCalleeSaves(const Frame& fr) {
+void ArmContext::FillCalleeSaves(const StackVisitor& fr) {
Method* method = fr.GetMethod();
uint32_t core_spills = method->GetCoreSpillMask();
uint32_t fp_core_spills = method->GetFpSpillMask();
size_t spill_count = __builtin_popcount(core_spills);
size_t fp_spill_count = __builtin_popcount(fp_core_spills);
+ size_t frame_size = method->GetFrameSizeInBytes();
if (spill_count > 0) {
// Lowest number spill is furthest away, walk registers and fill into context
int j = 1;
for (int i = 0; i < 16; i++) {
if (((core_spills >> i) & 1) != 0) {
- gprs_[i] = fr.LoadCalleeSave(spill_count - j);
+ gprs_[i] = fr.LoadCalleeSave(spill_count - j, frame_size);
j++;
}
}
@@ -54,7 +55,7 @@
int j = 1;
for (int i = 0; i < 32; i++) {
if (((fp_core_spills >> i) & 1) != 0) {
- fprs_[i] = fr.LoadCalleeSave(spill_count + fp_spill_count - j);
+ fprs_[i] = fr.LoadCalleeSave(spill_count + fp_spill_count - j, frame_size);
j++;
}
}
diff --git a/src/oat/runtime/arm/context_arm.h b/src/oat/runtime/arm/context_arm.h
index 73cb50f..6f42cc3 100644
--- a/src/oat/runtime/arm/context_arm.h
+++ b/src/oat/runtime/arm/context_arm.h
@@ -28,7 +28,7 @@
ArmContext();
virtual ~ArmContext() {}
- virtual void FillCalleeSaves(const Frame& fr);
+ virtual void FillCalleeSaves(const StackVisitor& fr);
virtual void SetSP(uintptr_t new_sp) {
gprs_[SP] = new_sp;
diff --git a/src/oat/runtime/context.h b/src/oat/runtime/context.h
index 6c7359b..7002f6a 100644
--- a/src/oat/runtime/context.h
+++ b/src/oat/runtime/context.h
@@ -22,7 +22,7 @@
namespace art {
-class Frame;
+class StackVisitor;
// Representation of a thread's context on the executing machine
class Context {
@@ -34,7 +34,7 @@
// Read values from callee saves in the given frame. The frame also holds
// the method that holds the layout.
- virtual void FillCalleeSaves(const Frame& fr) = 0;
+ virtual void FillCalleeSaves(const StackVisitor& fr) = 0;
// Set the stack pointer value
virtual void SetSP(uintptr_t new_sp) = 0;
diff --git a/src/oat/runtime/support_jni.cc b/src/oat/runtime/support_jni.cc
index ff19a4c..cfa1a11 100644
--- a/src/oat/runtime/support_jni.cc
+++ b/src/oat/runtime/support_jni.cc
@@ -90,7 +90,7 @@
// | unused |
// | unused |
// | unused | <- sp
- Method* jni_method = self->GetTopOfStack().GetMethod();
+ Method* jni_method = self->GetCurrentMethod();
DCHECK(jni_method->IsNative()) << PrettyMethod(jni_method);
intptr_t* arg_ptr = sp + 4; // pointer to r1 on stack
// Fix up this/jclass argument
diff --git a/src/oat/runtime/support_stubs.cc b/src/oat/runtime/support_stubs.cc
index 2a46c8b..522ccf2 100644
--- a/src/oat/runtime/support_stubs.cc
+++ b/src/oat/runtime/support_stubs.cc
@@ -221,9 +221,8 @@
#else // ART_USE_LLVM_COMPILER
const void* UnresolvedDirectMethodTrampolineFromCode(Method* called, Method** called_addr,
Thread* thread, Runtime::TrampolineType type) {
- NthCallerVisitor visitor(0);
- thread->WalkStack(&visitor);
- Method* caller = visitor.caller;
+ uint32_t dex_pc;
+ Method* caller = thread->GetCurrentMethod(&dex_pc);
ClassLinker* linker = Runtime::Current()->GetClassLinker();
bool is_static;
@@ -231,8 +230,6 @@
uint32_t dex_method_idx;
if (type == Runtime::kUnknownMethod) {
DCHECK(called->IsRuntimeMethod());
- // less two as return address may span into next dex instruction
- uint32_t dex_pc = static_cast<uint32_t>(visitor.pc);
const DexFile::CodeItem* code = MethodHelper(caller).GetCodeItem();
CHECK_LT(dex_pc, code->insns_size_in_code_units_);
const Instruction* instr = Instruction::At(&code->insns_[dex_pc]);
diff --git a/src/oat/runtime/support_throw.cc b/src/oat/runtime/support_throw.cc
index 4293228..31cf7d9 100644
--- a/src/oat/runtime/support_throw.cc
+++ b/src/oat/runtime/support_throw.cc
@@ -49,11 +49,8 @@
// Called by generated call to throw a NPE exception.
extern "C" void artThrowNullPointerExceptionFromCode(Thread* self, Method** sp) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
- Frame frame = self->GetTopOfStack();
- uintptr_t throw_native_pc = frame.GetReturnPC();
- frame.Next();
- Method* throw_method = frame.GetMethod();
- uint32_t dex_pc = throw_method->ToDexPC(throw_native_pc - 2);
+ uint32_t dex_pc;
+ Method* throw_method = self->GetCurrentMethod(&dex_pc);
ThrowNullPointerExceptionFromDexPC(self, throw_method, dex_pc);
self->DeliverException();
}
@@ -88,9 +85,7 @@
extern "C" void artThrowNoSuchMethodFromCode(int32_t method_idx, Thread* self, Method** sp) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
- Frame frame = self->GetTopOfStack(); // We need the calling method as context for the method_idx
- frame.Next();
- Method* method = frame.GetMethod();
+ Method* method = self->GetCurrentMethod();
self->ThrowNewException("Ljava/lang/NoSuchMethodError;",
MethodNameFromIndex(method, method_idx, verifier::VERIFY_ERROR_REF_METHOD, false).c_str());
self->DeliverException();
@@ -98,9 +93,7 @@
extern "C" void artThrowVerificationErrorFromCode(int32_t kind, int32_t ref, Thread* self, Method** sp) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
- Frame frame = self->GetTopOfStack(); // We need the calling method as context to interpret 'ref'
- frame.Next();
- Method* method = frame.GetMethod();
+ Method* method = self->GetCurrentMethod();
ThrowVerificationError(self, method, kind, ref);
self->DeliverException();
}
diff --git a/src/oat/runtime/x86/context_x86.cc b/src/oat/runtime/x86/context_x86.cc
index 412b655..4d84f2b 100644
--- a/src/oat/runtime/x86/context_x86.cc
+++ b/src/oat/runtime/x86/context_x86.cc
@@ -31,17 +31,18 @@
#endif
}
-void X86Context::FillCalleeSaves(const Frame& fr) {
+void X86Context::FillCalleeSaves(const StackVisitor& fr) {
Method* method = fr.GetMethod();
uint32_t core_spills = method->GetCoreSpillMask();
size_t spill_count = __builtin_popcount(core_spills);
- CHECK_EQ(method->GetFpSpillMask(), 0u);
+ DCHECK_EQ(method->GetFpSpillMask(), 0u);
+ size_t frame_size = method->GetFrameSizeInBytes();
if (spill_count > 0) {
// Lowest number spill is furthest away, walk registers and fill into context.
int j = 2; // Offset j to skip return address spill.
for (int i = 0; i < 8; i++) {
if (((core_spills >> i) & 1) != 0) {
- gprs_[i] = fr.LoadCalleeSave(spill_count - j);
+ gprs_[i] = fr.LoadCalleeSave(spill_count - j, frame_size);
j++;
}
}
diff --git a/src/oat/runtime/x86/context_x86.h b/src/oat/runtime/x86/context_x86.h
index 845f6c3..3d6b1d9 100644
--- a/src/oat/runtime/x86/context_x86.h
+++ b/src/oat/runtime/x86/context_x86.h
@@ -29,7 +29,7 @@
virtual ~X86Context() {}
// No callee saves on X86
- virtual void FillCalleeSaves(const Frame& fr);
+ virtual void FillCalleeSaves(const StackVisitor& fr);
virtual void SetSP(uintptr_t new_sp) {
gprs_[ESP] = new_sp;
diff --git a/src/object.cc b/src/object.cc
index 9724e42..b728e28 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -544,11 +544,10 @@
void Method::Invoke(Thread* self, Object* receiver, JValue* args, JValue* result) const {
// Push a transition back into managed code onto the linked list in thread.
CHECK_EQ(kRunnable, self->GetState());
+ self->AssertThreadSuspensionIsAllowable();
-#if !defined(ART_USE_LLVM_COMPILER)
- NativeToManagedRecord record;
- self->PushNativeToManagedRecord(&record);
-#endif
+ ManagedStack fragment;
+ self->PushManagedStackFragment(&fragment);
// Call the invoke stub associated with the method.
// Pass everything as arguments.
@@ -584,10 +583,8 @@
}
}
-#if !defined(ART_USE_LLVM_COMPILER)
// Pop transition.
- self->PopNativeToManagedRecord(record);
-#endif
+ self->PopManagedStackFragment(fragment);
}
bool Method::IsRegistered() const {
@@ -1510,8 +1507,8 @@
for (int32_t i = 0; i < depth; ++i) {
Method* method = down_cast<Method*>(method_trace->Get(i));
mh.ChangeMethod(method);
- uint32_t native_pc = pc_trace->Get(i);
- int32_t line_number = mh.GetLineNumFromNativePC(native_pc);
+ uint32_t dex_pc = pc_trace->Get(i);
+ int32_t line_number = mh.GetLineNumFromDexPC(dex_pc);
const char* source_file = mh.GetDeclaringClassSourceFile();
result += StringPrintf(" at %s (%s:%d)\n", PrettyMethod(method, true).c_str(),
source_file, line_number);
diff --git a/src/object_utils.h b/src/object_utils.h
index ca666bf..c8d50a1 100644
--- a/src/object_utils.h
+++ b/src/object_utils.h
@@ -505,9 +505,13 @@
return dex_file.GetTypeDescriptor(dex_file.GetTypeId(return_type_idx));
}
- int32_t GetLineNumFromNativePC(uintptr_t raw_pc) {
- const DexFile& dex_file = GetDexFile();
- return dex_file.GetLineNumFromPC(method_, method_->ToDexPC(raw_pc));
+ int32_t GetLineNumFromDexPC(uint32_t dex_pc) {
+ if (dex_pc == DexFile::kDexNoIndex) {
+ return method_->IsNative() ? -2 : -1;
+ } else {
+ const DexFile& dex_file = GetDexFile();
+ return dex_file.GetLineNumFromPC(method_, dex_pc);
+ }
}
const char* GetDeclaringClassDescriptor() {
diff --git a/src/runtime.cc b/src/runtime.cc
index d7bef1e..b071ef4 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -862,7 +862,7 @@
if (self == NULL) {
LOG(FATAL) << "attempting to detach thread that is not attached";
}
- if (self->GetTopOfStack().GetSP() != NULL) {
+ if (self->HasManagedStack()) {
LOG(FATAL) << *Thread::Current() << " attempting to detach while still running code";
}
thread_list_->Unregister();
diff --git a/src/scoped_jni_thread_state.h b/src/scoped_jni_thread_state.h
index 7ef92d4..9b3e63c 100644
--- a/src/scoped_jni_thread_state.h
+++ b/src/scoped_jni_thread_state.h
@@ -25,10 +25,10 @@
// that are using a JNIEnv on the wrong thread.
class ScopedJniThreadState {
public:
- explicit ScopedJniThreadState(JNIEnv* env)
+ explicit ScopedJniThreadState(JNIEnv* env, ThreadState new_state = kRunnable)
: env_(reinterpret_cast<JNIEnvExt*>(env)) {
self_ = ThreadForEnv(env);
- old_thread_state_ = self_->SetState(kRunnable);
+ old_thread_state_ = self_->SetState(new_state);
self_->VerifyStack();
}
diff --git a/src/shadow_frame.h b/src/shadow_frame.h
deleted file mode 100644
index c4a633f..0000000
--- a/src/shadow_frame.h
+++ /dev/null
@@ -1,129 +0,0 @@
-/*
- * Copyright (C) 2012 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ART_SRC_SHADOW_FRAME_H_
-#define ART_SRC_SHADOW_FRAME_H_
-
-#include "logging.h"
-#include "macros.h"
-
-namespace art {
-
-class Object;
-class Method;
-
-class ShadowFrame {
- public:
- // Number of references contained within this shadow frame
- uint32_t NumberOfReferences() const {
- return number_of_references_;
- }
-
- void SetNumberOfReferences(uint32_t number_of_references) {
- number_of_references_ = number_of_references;
- }
-
- // Caller dex pc
- uint32_t GetDexPC() const {
- return dex_pc_;
- }
-
- void SetDexPC(uint32_t dex_pc) {
- dex_pc_ = dex_pc;
- }
-
- // Link to previous shadow frame or NULL
- ShadowFrame* GetLink() const {
- return link_;
- }
-
- void SetLink(ShadowFrame* frame) {
- DCHECK_NE(this, frame);
- link_ = frame;
- }
-
- Object* GetReference(size_t i) const {
- DCHECK_LT(i, number_of_references_);
- return references_[i];
- }
-
- void SetReference(size_t i, Object* object) {
- DCHECK_LT(i, number_of_references_);
- references_[i] = object;
- }
-
- Method* GetMethod() const {
- DCHECK_NE(method_, static_cast<void*>(NULL));
- return method_;
- }
-
- void SetMethod(Method* method) {
- DCHECK_NE(method, static_cast<void*>(NULL));
- method_ = method;
- }
-
- bool Contains(Object** shadow_frame_entry) const {
- // A ShadowFrame should at least contain a reference. Even if a
- // native method has no argument, we put jobject or jclass as a
- // reference. The former is "this", while the latter is for static
- // method.
- DCHECK_GT(number_of_references_, 0U);
- return ((&references_[0] <= shadow_frame_entry)
- && (shadow_frame_entry <= (&references_[number_of_references_ - 1])));
- }
-
- // Offset of link within shadow frame
- static size_t LinkOffset() {
- return OFFSETOF_MEMBER(ShadowFrame, link_);
- }
-
- // Offset of method within shadow frame
- static size_t MethodOffset() {
- return OFFSETOF_MEMBER(ShadowFrame, method_);
- }
-
- // Offset of dex pc within shadow frame
- static size_t DexPCOffset() {
- return OFFSETOF_MEMBER(ShadowFrame, dex_pc_);
- }
-
- // Offset of length within shadow frame
- static size_t NumberOfReferencesOffset() {
- return OFFSETOF_MEMBER(ShadowFrame, number_of_references_);
- }
-
- // Offset of references within shadow frame
- static size_t ReferencesOffset() {
- return OFFSETOF_MEMBER(ShadowFrame, references_);
- }
-
- private:
- // ShadowFrame should be allocated by the generated code directly.
- // We should not create new shadow stack in the runtime support function.
- ~ShadowFrame() {}
-
- uint32_t number_of_references_;
- ShadowFrame* link_;
- Method* method_;
- uint32_t dex_pc_;
- Object* references_[];
-
- DISALLOW_IMPLICIT_CONSTRUCTORS(ShadowFrame);
-};
-
-} // namespace art
-
-#endif // ART_SRC_SHADOW_FRAME_H_
diff --git a/src/stack.cc b/src/stack.cc
index d724a72..336f8ad 100644
--- a/src/stack.cc
+++ b/src/stack.cc
@@ -17,178 +17,13 @@
#include "stack.h"
#include "compiler.h"
+#include "oat/runtime/context.h"
#include "object.h"
#include "object_utils.h"
#include "thread_list.h"
namespace art {
-bool Frame::HasMethod() const {
- return GetMethod() != NULL && (!GetMethod()->IsCalleeSaveMethod());
-}
-
-void Frame::Next() {
-#if defined(ART_USE_LLVM_COMPILER)
- LOG(FATAL) << "LLVM compiler don't support this function";
-#else
- size_t frame_size = GetMethod()->GetFrameSizeInBytes();
- DCHECK_NE(frame_size, 0u);
- DCHECK_LT(frame_size, 1024u);
- byte* next_sp = reinterpret_cast<byte*>(sp_) + frame_size;
- sp_ = reinterpret_cast<Method**>(next_sp);
- if (*sp_ != NULL) {
- DCHECK((*sp_)->GetClass() == Method::GetMethodClass() ||
- (*sp_)->GetClass() == Method::GetConstructorClass());
- }
-#endif
-}
-
-uintptr_t Frame::GetReturnPC() const {
-#if defined(ART_USE_LLVM_COMPILER)
- LOG(FATAL) << "LLVM compiler don't support this function";
- return 0;
-#else
- byte* pc_addr = reinterpret_cast<byte*>(sp_) + GetMethod()->GetReturnPcOffsetInBytes();
- return *reinterpret_cast<uintptr_t*>(pc_addr);
-#endif
-}
-
-void Frame::SetReturnPC(uintptr_t pc) {
-#if defined(ART_USE_LLVM_COMPILER)
- LOG(FATAL) << "LLVM compiler don't support this function";
-#else
- byte* pc_addr = reinterpret_cast<byte*>(sp_) + GetMethod()->GetReturnPcOffsetInBytes();
- *reinterpret_cast<uintptr_t*>(pc_addr) = pc;
-#endif
-}
-
-/*
- * Return sp-relative offset for a Dalvik virtual register, compiler
- * spill or Method* in bytes using Method*.
- * Note that (reg >= 0) refers to a Dalvik register, (reg == -2)
- * denotes Method* and (reg <= -3) denotes a compiler temp.
- *
- * +------------------------+
- * | IN[ins-1] | {Note: resides in caller's frame}
- * | . |
- * | IN[0] |
- * | caller's Method* |
- * +========================+ {Note: start of callee's frame}
- * | core callee-save spill | {variable sized}
- * +------------------------+
- * | fp callee-save spill |
- * +------------------------+
- * | filler word | {For compatibility, if V[locals-1] used as wide
- * +------------------------+
- * | V[locals-1] |
- * | V[locals-2] |
- * | . |
- * | . | ... (reg == 2)
- * | V[1] | ... (reg == 1)
- * | V[0] | ... (reg == 0) <---- "locals_start"
- * +------------------------+
- * | Compiler temps | ... (reg == -2)
- * | | ... (reg == -3)
- * | | ... (reg == -4)
- * +------------------------+
- * | stack alignment padding| {0 to (kStackAlignWords-1) of padding}
- * +------------------------+
- * | OUT[outs-1] |
- * | OUT[outs-2] |
- * | . |
- * | OUT[0] |
- * | curMethod* | ... (reg == -1) <<== sp, 16-byte aligned
- * +========================+
- */
-int Frame::GetVRegOffset(const DexFile::CodeItem* code_item,
- uint32_t core_spills, uint32_t fp_spills,
- size_t frame_size, int reg) {
- DCHECK_EQ(frame_size & (kStackAlignment - 1), 0U);
- int num_spills = __builtin_popcount(core_spills) + __builtin_popcount(fp_spills) + 1 /* filler */;
- int num_ins = code_item->ins_size_;
- int num_regs = code_item->registers_size_ - num_ins;
- int locals_start = frame_size - ((num_spills + num_regs) * sizeof(uint32_t));
- if (reg == -2) {
- return 0; // Method*
- } else if (reg <= -3) {
- return locals_start - ((reg + 1) * sizeof(uint32_t)); // Compiler temp
- } else if (reg < num_regs) {
- return locals_start + (reg * sizeof(uint32_t)); // Dalvik local reg
- } else {
- return frame_size + ((reg - num_regs) * sizeof(uint32_t)) + sizeof(uint32_t); // Dalvik in
- }
-}
-
-uint32_t Frame::GetVReg(const DexFile::CodeItem* code_item, uint32_t core_spills,
- uint32_t fp_spills, size_t frame_size, int vreg) const {
-#if defined(ART_USE_LLVM_COMPILER)
- LOG(FATAL) << "LLVM compiler don't support this function";
- return 0;
-#else
- int offset = GetVRegOffset(code_item, core_spills, fp_spills, frame_size, vreg);
- byte* vreg_addr = reinterpret_cast<byte*>(sp_) + offset;
- return *reinterpret_cast<uint32_t*>(vreg_addr);
-#endif
-}
-
-uint32_t Frame::GetVReg(Method* m, int vreg) const {
-#if defined(ART_USE_LLVM_COMPILER)
- LOG(FATAL) << "LLVM compiler don't support this function";
- return 0;
-#else
- DCHECK(m == GetMethod());
- const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
- DCHECK(code_item != NULL); // can't be NULL or how would we compile its instructions?
- uint32_t core_spills = m->GetCoreSpillMask();
- uint32_t fp_spills = m->GetFpSpillMask();
- size_t frame_size = m->GetFrameSizeInBytes();
- return GetVReg(code_item, core_spills, fp_spills, frame_size, vreg);
-#endif
-}
-
-void Frame::SetVReg(Method* m, int vreg, uint32_t new_value) {
-#if defined(ART_USE_LLVM_COMPILER)
- LOG(FATAL) << "LLVM compiler don't support this function";
-#else
- DCHECK(m == GetMethod());
- const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
- DCHECK(code_item != NULL); // can't be NULL or how would we compile its instructions?
- uint32_t core_spills = m->GetCoreSpillMask();
- uint32_t fp_spills = m->GetFpSpillMask();
- size_t frame_size = m->GetFrameSizeInBytes();
- int offset = GetVRegOffset(code_item, core_spills, fp_spills, frame_size, vreg);
- byte* vreg_addr = reinterpret_cast<byte*>(sp_) + offset;
- *reinterpret_cast<uint32_t*>(vreg_addr) = new_value;
-#endif
-}
-
-uintptr_t Frame::LoadCalleeSave(int num) const {
-#if defined(ART_USE_LLVM_COMPILER)
- LOG(FATAL) << "LLVM compiler don't support this function";
- return 0;
-#else
- // Callee saves are held at the top of the frame
- Method* method = GetMethod();
- DCHECK(method != NULL);
- size_t frame_size = method->GetFrameSizeInBytes();
- byte* save_addr = reinterpret_cast<byte*>(sp_) + frame_size - ((num + 1) * kPointerSize);
-#if defined(__i386__)
- save_addr -= kPointerSize; // account for return address
-#endif
- return *reinterpret_cast<uintptr_t*>(save_addr);
-#endif
-}
-
-Method* Frame::NextMethod() const {
-#if defined(ART_USE_LLVM_COMPILER)
- LOG(FATAL) << "LLVM compiler don't support this function";
- return NULL;
-#else
- byte* next_sp = reinterpret_cast<byte*>(sp_) + GetMethod()->GetFrameSizeInBytes();
- return *reinterpret_cast<Method**>(next_sp);
-#endif
-}
-
class StackGetter {
public:
StackGetter(JNIEnv* env, Thread* thread) : env_(env), thread_(thread), trace_(NULL) {
@@ -219,4 +54,220 @@
return stack_getter.GetTrace();
}
+void ManagedStack::PushManagedStackFragment(ManagedStack* fragment) {
+ // Copy this top fragment into given fragment.
+ memcpy(fragment, this, sizeof(ManagedStack));
+ // Clear this fragment, which has become the top.
+ memset(this, 0, sizeof(ManagedStack));
+ // Link our top fragment onto the given fragment.
+ link_ = fragment;
+}
+
+void ManagedStack::PopManagedStackFragment(const ManagedStack& fragment) {
+ DCHECK(&fragment == link_);
+ // Copy this given fragment back to the top.
+ memcpy(this, &fragment, sizeof(ManagedStack));
+}
+
+size_t ManagedStack::NumShadowFrameReferences() const {
+ size_t count = 0;
+ for (const ManagedStack* current_fragment = this; current_fragment != NULL;
+ current_fragment = current_fragment->GetLink()) {
+ for (ShadowFrame* current_frame = current_fragment->top_shadow_frame_; current_frame != NULL;
+ current_frame = current_frame->GetLink()) {
+ count += current_frame->NumberOfReferences();
+ }
+ }
+ return count;
+}
+
+bool ManagedStack::ShadowFramesContain(Object** shadow_frame_entry) const {
+ for (const ManagedStack* current_fragment = this; current_fragment != NULL;
+ current_fragment = current_fragment->GetLink()) {
+ for (ShadowFrame* current_frame = current_fragment->top_shadow_frame_; current_frame != NULL;
+ current_frame = current_frame->GetLink()) {
+ if (current_frame->Contains(shadow_frame_entry)) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+uint32_t StackVisitor::GetDexPc() const {
+ if (cur_shadow_frame_ != NULL) {
+ return cur_shadow_frame_->GetDexPC();
+ } else if (cur_quick_frame_ != NULL) {
+ return GetMethod()->ToDexPC(AdjustQuickFramePcForDexPcComputation(cur_quick_frame_pc_));
+ } else {
+ return 0;
+ }
+}
+
+uint32_t StackVisitor::GetVReg(Method* m, int vreg) const {
+ DCHECK(m == GetMethod());
+ uint32_t core_spills = m->GetCoreSpillMask();
+ const VmapTable vmap_table(m->GetVmapTableRaw());
+ uint32_t vmap_offset;
+ // TODO: IsInContext stops before spotting floating point registers.
+ if (vmap_table.IsInContext(vreg, vmap_offset)) {
+ // Compute the register we need to load from the context.
+ uint32_t spill_mask = core_spills;
+ CHECK_LT(vmap_offset, static_cast<uint32_t>(__builtin_popcount(spill_mask)));
+ uint32_t matches = 0;
+ uint32_t spill_shifts = 0;
+ while (matches != (vmap_offset + 1)) {
+ DCHECK_NE(spill_mask, 0u);
+ matches += spill_mask & 1; // Add 1 if the low bit is set.
+ spill_mask >>= 1;
+ spill_shifts++;
+ }
+ spill_shifts--; // Wind back one as we want the last match.
+ return GetGPR(spill_shifts);
+ } else {
+ const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
+ DCHECK(code_item != NULL); // can't be NULL or how would we compile its instructions?
+ uint32_t fp_spills = m->GetFpSpillMask();
+ size_t frame_size = m->GetFrameSizeInBytes();
+ return GetVReg(code_item, core_spills, fp_spills, frame_size, vreg);
+ }
+}
+
+void StackVisitor::SetVReg(Method* m, int vreg, uint32_t new_value) {
+ DCHECK(m == GetMethod());
+ const VmapTable vmap_table(m->GetVmapTableRaw());
+ uint32_t vmap_offset;
+ // TODO: IsInContext stops before spotting floating point registers.
+ if (vmap_table.IsInContext(vreg, vmap_offset)) {
+ UNIMPLEMENTED(FATAL);
+ }
+ const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
+ DCHECK(code_item != NULL); // can't be NULL or how would we compile its instructions?
+ uint32_t core_spills = m->GetCoreSpillMask();
+ uint32_t fp_spills = m->GetFpSpillMask();
+ size_t frame_size = m->GetFrameSizeInBytes();
+ int offset = GetVRegOffset(code_item, core_spills, fp_spills, frame_size, vreg);
+ byte* vreg_addr = reinterpret_cast<byte*>(GetCurrentQuickFrame()) + offset;
+ *reinterpret_cast<uint32_t*>(vreg_addr) = new_value;
+}
+
+uintptr_t StackVisitor::GetGPR(uint32_t reg) const {
+ return context_->GetGPR(reg);
+}
+
+uintptr_t StackVisitor::GetReturnPc() const {
+ Method** sp = GetCurrentQuickFrame();
+ CHECK(sp != NULL);
+ byte* pc_addr = reinterpret_cast<byte*>(sp) + GetMethod()->GetReturnPcOffsetInBytes();
+ return *reinterpret_cast<uintptr_t*>(pc_addr);
+}
+
+void StackVisitor::SetReturnPc(uintptr_t new_ret_pc) {
+ Method** sp = GetCurrentQuickFrame();
+ CHECK(sp != NULL);
+ byte* pc_addr = reinterpret_cast<byte*>(sp) + GetMethod()->GetReturnPcOffsetInBytes();
+ *reinterpret_cast<uintptr_t*>(pc_addr) = new_ret_pc;
+}
+
+size_t StackVisitor::ComputeNumFrames() const {
+ struct NumFramesVisitor : public StackVisitor {
+ explicit NumFramesVisitor(const ManagedStack* stack,
+ const std::vector<TraceStackFrame>* trace_stack) :
+ StackVisitor(stack, trace_stack), frames(0) {}
+
+ virtual bool VisitFrame() {
+ frames++;
+ return true;
+ }
+ size_t frames;
+ };
+
+ NumFramesVisitor visitor(stack_start_, trace_stack_);
+ visitor.WalkStack(true);
+ return visitor.frames;
+}
+
+void StackVisitor::SanityCheckFrame() {
+#ifndef NDEBUG
+ Method* method = GetMethod();
+ CHECK(method->GetClass() == Method::GetMethodClass() ||
+ method->GetClass() == Method::GetConstructorClass());
+ if (cur_quick_frame_ != NULL) {
+ method->AssertPcIsWithinCode(AdjustQuickFramePcForDexPcComputation(cur_quick_frame_pc_));
+ // Frame sanity.
+ size_t frame_size = method->GetFrameSizeInBytes();
+ CHECK_NE(frame_size, 0u);
+ CHECK_LT(frame_size, 1024u);
+ size_t return_pc_offset = method->GetReturnPcOffsetInBytes();
+ CHECK_LT(return_pc_offset, frame_size);
+ }
+#endif
+}
+
+void StackVisitor::WalkStack(bool include_transitions) {
+ bool method_tracing_active = Runtime::Current()->IsMethodTracingActive();
+ uint32_t trace_stack_depth = 0;
+ for (const ManagedStack* current_fragment = stack_start_; current_fragment != NULL;
+ current_fragment = current_fragment->GetLink()) {
+ cur_shadow_frame_ = current_fragment->GetTopShadowFrame();
+ cur_quick_frame_ = current_fragment->GetTopQuickFrame();
+ cur_quick_frame_pc_ = current_fragment->GetTopQuickFramePc();
+ if (cur_quick_frame_ != NULL) { // Handle quick stack frames.
+ // Can't be both a shadow and a quick fragment.
+ DCHECK(current_fragment->GetTopShadowFrame() == NULL);
+ Method* method = *cur_quick_frame_;
+ do {
+ SanityCheckFrame();
+ bool should_continue = VisitFrame();
+ if (UNLIKELY(!should_continue)) {
+ return;
+ }
+ if (context_ != NULL) {
+ context_->FillCalleeSaves(*this);
+ }
+ size_t frame_size = method->GetFrameSizeInBytes();
+ // Compute PC for next stack frame from return PC.
+ size_t return_pc_offset = method->GetReturnPcOffsetInBytes();
+ byte* return_pc_addr = reinterpret_cast<byte*>(cur_quick_frame_) + return_pc_offset;
+ uintptr_t return_pc = *reinterpret_cast<uintptr_t*>(return_pc_addr);
+ if (UNLIKELY(method_tracing_active)) {
+ // While profiling, the return pc is restored from the side stack, except when walking
+ // the stack for an exception where the side stack will be unwound in VisitFrame.
+ // TODO: stop using include_transitions as a proxy for is this the catch block visitor.
+ if (IsTraceExitPc(return_pc) && !include_transitions) {
+ // TODO: unify trace and managed stack.
+ TraceStackFrame trace_frame = GetTraceStackFrame(trace_stack_depth);
+ trace_stack_depth++;
+ CHECK(trace_frame.method_ == GetMethod()) << "Excepted: " << PrettyMethod(method)
+ << " Found: " << PrettyMethod(GetMethod());
+ return_pc = trace_frame.return_pc_;
+ }
+ }
+ cur_quick_frame_pc_ = return_pc;
+ byte* next_frame = reinterpret_cast<byte*>(cur_quick_frame_) + frame_size;
+ cur_quick_frame_ = reinterpret_cast<Method**>(next_frame);
+ cur_depth_++;
+ method = *cur_quick_frame_;
+ } while (method != NULL);
+ } else if (cur_shadow_frame_ != NULL) {
+ do {
+ SanityCheckFrame();
+ bool should_continue = VisitFrame();
+ if (UNLIKELY(!should_continue)) {
+ return;
+ }
+ cur_depth_++;
+ cur_shadow_frame_ = cur_shadow_frame_->GetLink();
+ } while(cur_shadow_frame_ != NULL);
+ }
+ cur_depth_++;
+ if (include_transitions) {
+ bool should_continue = VisitFrame();
+ if (!should_continue) {
+ return;
+ }
+ }
+ }
+}
+
} // namespace art
diff --git a/src/stack.h b/src/stack.h
index a26b632..26afc0a 100644
--- a/src/stack.h
+++ b/src/stack.h
@@ -18,75 +18,377 @@
#define ART_SRC_STACK_H_
#include "dex_file.h"
+#include "heap.h"
+#include "jdwp/jdwp.h"
#include "jni.h"
#include "macros.h"
+#include "oat/runtime/context.h"
+#include "trace.h"
#include <stdint.h>
namespace art {
class Method;
+class Object;
+class ShadowFrame;
class Thread;
jobject GetThreadStack(JNIEnv*, Thread*);
-struct NativeToManagedRecord {
- NativeToManagedRecord* link_;
- void* last_top_of_managed_stack_;
- uintptr_t last_top_of_managed_stack_pc_;
-};
-
-// Iterator over managed frames up to the first native-to-managed transition.
-class PACKED Frame {
+class ShadowFrame {
public:
- Frame() : sp_(NULL) {}
+ // Number of references contained within this shadow frame
+ uint32_t NumberOfReferences() const {
+ return number_of_references_;
+ }
- explicit Frame(Method** sp) : sp_(sp) {}
+ void SetNumberOfReferences(uint32_t number_of_references) {
+ number_of_references_ = number_of_references;
+ }
+
+ // Caller dex pc
+ uint32_t GetDexPC() const {
+ return dex_pc_;
+ }
+
+ void SetDexPC(uint32_t dex_pc) {
+ dex_pc_ = dex_pc;
+ }
+
+ // Link to previous shadow frame or NULL
+ ShadowFrame* GetLink() const {
+ return link_;
+ }
+
+ void SetLink(ShadowFrame* frame) {
+ DCHECK_NE(this, frame);
+ link_ = frame;
+ }
+
+ Object* GetReference(size_t i) const {
+ DCHECK_LT(i, number_of_references_);
+ return references_[i];
+ }
+
+ void SetReference(size_t i, Object* object) {
+ DCHECK_LT(i, number_of_references_);
+ references_[i] = object;
+ }
Method* GetMethod() const {
- return (sp_ != NULL) ? *sp_ : NULL;
+ DCHECK_NE(method_, static_cast<void*>(NULL));
+ return method_;
}
- bool HasNext() const {
- return NextMethod() != NULL;
+ void SetMethod(Method* method) {
+ DCHECK_NE(method, static_cast<void*>(NULL));
+ method_ = method;
}
- void Next();
-
- uintptr_t GetReturnPC() const;
-
- void SetReturnPC(uintptr_t pc);
-
- uintptr_t LoadCalleeSave(int num) const;
-
- static int GetVRegOffset(const DexFile::CodeItem* code_item, uint32_t core_spills,
- uint32_t fp_spills, size_t frame_size, int reg);
-
- uint32_t GetVReg(const DexFile::CodeItem* code_item, uint32_t core_spills, uint32_t fp_spills,
- size_t frame_size, int vreg) const;
-
- uint32_t GetVReg(Method* m, int vreg) const;
- void SetVReg(Method* method, int vreg, uint32_t new_value);
-
- Method** GetSP() const {
- return sp_;
+ bool Contains(Object** shadow_frame_entry) const {
+ return ((&references_[0] <= shadow_frame_entry) &&
+ (shadow_frame_entry <= (&references_[number_of_references_ - 1])));
}
- void SetSP(Method** sp) {
- sp_ = sp;
+ void VisitRoots(Heap::RootVisitor* visitor, void* arg) {
+ size_t num_refs = NumberOfReferences();
+ for (size_t j = 0; j < num_refs; j++) {
+ Object* object = GetReference(j);
+ if (object != NULL) {
+ visitor(object, arg);
+ }
+ }
}
- // Is this a frame for a real method (native or with dex code)
- bool HasMethod() const;
+ // Offset of link within shadow frame
+ static size_t LinkOffset() {
+ return OFFSETOF_MEMBER(ShadowFrame, link_);
+ }
+
+ // Offset of method within shadow frame
+ static size_t MethodOffset() {
+ return OFFSETOF_MEMBER(ShadowFrame, method_);
+ }
+
+ // Offset of dex pc within shadow frame
+ static size_t DexPCOffset() {
+ return OFFSETOF_MEMBER(ShadowFrame, dex_pc_);
+ }
+
+ // Offset of length within shadow frame
+ static size_t NumberOfReferencesOffset() {
+ return OFFSETOF_MEMBER(ShadowFrame, number_of_references_);
+ }
+
+ // Offset of references within shadow frame
+ static size_t ReferencesOffset() {
+ return OFFSETOF_MEMBER(ShadowFrame, references_);
+ }
private:
- Method* NextMethod() const;
+ // ShadowFrame should be allocated by the generated code directly.
+ // We should not create new shadow stack in the runtime support function.
+ ~ShadowFrame() {}
- friend class Thread;
+ uint32_t number_of_references_;
+ ShadowFrame* link_;
+ Method* method_;
+ uint32_t dex_pc_;
+ Object* references_[];
- Method** sp_;
+ DISALLOW_IMPLICIT_CONSTRUCTORS(ShadowFrame);
};
+// The managed stack is used to record fragments of managed code stacks. Managed code stacks
+// may either be shadow frames or lists of frames using fixed frame sizes. Transition records are
+// necessary for transitions between code using different frame layouts and transitions into native
+// code.
+class PACKED ManagedStack {
+ public:
+ ManagedStack() : link_(NULL), top_shadow_frame_(NULL),
+ top_quick_frame_(NULL), top_quick_frame_pc_(0) {}
+ void PushManagedStackFragment(ManagedStack* fragment);
+ void PopManagedStackFragment(const ManagedStack& record);
+
+ ManagedStack* GetLink() const {
+ return link_;
+ }
+
+ Method** GetTopQuickFrame() const {
+ return top_quick_frame_;
+ }
+
+ void SetTopQuickFrame(Method** top) {
+ top_quick_frame_ = top;
+ }
+
+ uintptr_t GetTopQuickFramePc() const {
+ return top_quick_frame_pc_;
+ }
+
+ void SetTopQuickFramePc(uintptr_t pc) {
+ top_quick_frame_pc_ = pc;
+ }
+
+ static size_t TopQuickFrameOffset() {
+ return OFFSETOF_MEMBER(ManagedStack, top_quick_frame_);
+ }
+
+ static size_t TopQuickFramePcOffset() {
+ return OFFSETOF_MEMBER(ManagedStack, top_quick_frame_pc_);
+ }
+
+ ShadowFrame* PushShadowFrame(ShadowFrame* new_top_frame) {
+ ShadowFrame* old_frame = top_shadow_frame_;
+ top_shadow_frame_ = new_top_frame;
+ new_top_frame->SetLink(old_frame);
+ return old_frame;
+ }
+
+ ShadowFrame* PopShadowFrame() {
+ CHECK(top_shadow_frame_ != NULL);
+ ShadowFrame* frame = top_shadow_frame_;
+ top_shadow_frame_ = frame->GetLink();
+ return frame;
+ }
+
+ ShadowFrame* GetTopShadowFrame() const {
+ return top_shadow_frame_;
+ }
+
+ static size_t TopShadowFrameOffset() {
+ return OFFSETOF_MEMBER(ManagedStack, top_shadow_frame_);
+ }
+
+ size_t NumShadowFrameReferences() const;
+
+ bool ShadowFramesContain(Object** shadow_frame_entry) const;
+
+ private:
+ ManagedStack* link_;
+ ShadowFrame* top_shadow_frame_;
+ Method** top_quick_frame_;
+ uintptr_t top_quick_frame_pc_;
+};
+
+class StackVisitor {
+ protected:
+ StackVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
+ Context* context = NULL) :
+ stack_start_(stack), trace_stack_(trace_stack), cur_shadow_frame_(NULL), cur_quick_frame_(NULL),
+ cur_quick_frame_pc_(0), num_frames_(0), cur_depth_(0), context_(context) {}
+
+ public:
+ virtual ~StackVisitor() {}
+
+ // Return 'true' if we should continue to visit more frames, 'false' to stop.
+ virtual bool VisitFrame() = 0;
+
+ void WalkStack(bool include_transitions = false);
+
+ Method* GetMethod() const {
+ if (cur_shadow_frame_ != NULL) {
+ return cur_shadow_frame_->GetMethod();
+ } else if (cur_quick_frame_ != NULL) {
+ return *cur_quick_frame_;
+ } else {
+ return NULL;
+ }
+ }
+
+ bool IsShadowFrame() const {
+ return cur_shadow_frame_ != NULL;
+ }
+
+ uintptr_t LoadCalleeSave(int num, size_t frame_size) const {
+ // Callee saves are held at the top of the frame
+ Method* method = GetMethod();
+ DCHECK(method != NULL);
+ byte* save_addr =
+ reinterpret_cast<byte*>(cur_quick_frame_) + frame_size - ((num + 1) * kPointerSize);
+#if defined(__i386__)
+ save_addr -= kPointerSize; // account for return address
+#endif
+ return *reinterpret_cast<uintptr_t*>(save_addr);
+ }
+
+ uint32_t GetDexPc() const;
+
+ // Gets the height of the stack in the managed stack frames, including transitions.
+ size_t GetFrameHeight() {
+ return GetNumFrames() - cur_depth_;
+ }
+
+ // Get a frame ID where 0 is a special value.
+ size_t GetFrameId() {
+ return GetFrameHeight() + 1;
+ }
+
+ size_t GetNumFrames() {
+ if (num_frames_ == 0) {
+ num_frames_ = ComputeNumFrames();
+ }
+ return num_frames_;
+ }
+
+ uint32_t GetVReg(Method* m, int vreg) const;
+
+ void SetVReg(Method* m, int vreg, uint32_t new_value);
+
+ uintptr_t GetGPR(uint32_t reg) const;
+
+ uint32_t GetVReg(const DexFile::CodeItem* code_item, uint32_t core_spills,
+ uint32_t fp_spills, size_t frame_size, int vreg) const {
+ int offset = GetVRegOffset(code_item, core_spills, fp_spills, frame_size, vreg);
+ byte* vreg_addr = reinterpret_cast<byte*>(GetCurrentQuickFrame()) + offset;
+ return *reinterpret_cast<uint32_t*>(vreg_addr);
+ }
+
+ uintptr_t GetReturnPc() const;
+
+ void SetReturnPc(uintptr_t new_ret_pc);
+
+ /*
+ * Return sp-relative offset for a Dalvik virtual register, compiler
+ * spill or Method* in bytes using Method*.
+ * Note that (reg >= 0) refers to a Dalvik register, (reg == -2)
+ * denotes Method* and (reg <= -3) denotes a compiler temp.
+ *
+ * +------------------------+
+ * | IN[ins-1] | {Note: resides in caller's frame}
+ * | . |
+ * | IN[0] |
+ * | caller's Method* |
+ * +========================+ {Note: start of callee's frame}
+ * | core callee-save spill | {variable sized}
+ * +------------------------+
+ * | fp callee-save spill |
+ * +------------------------+
+ * | filler word | {For compatibility, if V[locals-1] used as wide
+ * +------------------------+
+ * | V[locals-1] |
+ * | V[locals-2] |
+ * | . |
+ * | . | ... (reg == 2)
+ * | V[1] | ... (reg == 1)
+ * | V[0] | ... (reg == 0) <---- "locals_start"
+ * +------------------------+
+ * | Compiler temps | ... (reg == -2)
+ * | | ... (reg == -3)
+ * | | ... (reg == -4)
+ * +------------------------+
+ * | stack alignment padding| {0 to (kStackAlignWords-1) of padding}
+ * +------------------------+
+ * | OUT[outs-1] |
+ * | OUT[outs-2] |
+ * | . |
+ * | OUT[0] |
+ * | curMethod* | ... (reg == -1) <<== sp, 16-byte aligned
+ * +========================+
+ */
+ static int GetVRegOffset(const DexFile::CodeItem* code_item,
+ uint32_t core_spills, uint32_t fp_spills,
+ size_t frame_size, int reg) {
+ DCHECK_EQ(frame_size & (kStackAlignment - 1), 0U);
+ int num_spills = __builtin_popcount(core_spills) + __builtin_popcount(fp_spills) + 1; // Filler.
+ int num_ins = code_item->ins_size_;
+ int num_regs = code_item->registers_size_ - num_ins;
+ int locals_start = frame_size - ((num_spills + num_regs) * sizeof(uint32_t));
+ if (reg == -2) {
+ return 0; // Method*
+ } else if (reg <= -3) {
+ return locals_start - ((reg + 1) * sizeof(uint32_t)); // Compiler temp.
+ } else if (reg < num_regs) {
+ return locals_start + (reg * sizeof(uint32_t)); // Dalvik local reg.
+ } else {
+ return frame_size + ((reg - num_regs) * sizeof(uint32_t)) + sizeof(uint32_t); // Dalvik in.
+ }
+ }
+
+ uintptr_t GetCurrentQuickFramePc() const {
+ return cur_quick_frame_pc_;
+ }
+
+ Method** GetCurrentQuickFrame() const {
+ return cur_quick_frame_;
+ }
+
+ ShadowFrame* GetCurrentShadowFrame() const {
+ return cur_shadow_frame_;
+ }
+
+ private:
+ size_t ComputeNumFrames() const;
+
+ TraceStackFrame GetTraceStackFrame(uint32_t depth) const {
+ return trace_stack_->at(trace_stack_->size() - depth - 1);
+ }
+
+ void SanityCheckFrame();
+
+ const ManagedStack* const stack_start_;
+ const std::vector<TraceStackFrame>* const trace_stack_;
+ ShadowFrame* cur_shadow_frame_;
+ Method** cur_quick_frame_;
+ uintptr_t cur_quick_frame_pc_;
+ // Lazily computed, number of frames in the stack.
+ size_t num_frames_;
+ // Depth of the frame we're currently at.
+ size_t cur_depth_;
+ protected:
+ Context* const context_;
+};
+
+static inline uintptr_t AdjustQuickFramePcForDexPcComputation(uintptr_t pc) {
+ // Quick methods record a mapping from quick PCs to Dex PCs at the beginning of the code for
+ // each dex instruction. When walking the stack, the return PC will be set to the instruction
+ // following call which will likely be the start of the next dex instruction. Adjust the PC
+ // for these cases by 2 bytes in case the return PC also has the thumb bit set.
+ if (pc > 0) { pc -= 2; }
+ return pc;
+}
+
} // namespace art
#endif // ART_SRC_STACK_H_
diff --git a/src/thread.cc b/src/thread.cc
index 457de6a..0192313 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -42,7 +42,6 @@
#include "runtime_support.h"
#include "scoped_jni_thread_state.h"
#include "ScopedLocalRef.h"
-#include "shadow_frame.h"
#include "space.h"
#include "stack.h"
#include "stack_indirect_reference_table.h"
@@ -528,44 +527,10 @@
Thread::DumpState(os, this, GetTid());
}
-#if !defined(ART_USE_LLVM_COMPILER)
-void Thread::PushNativeToManagedRecord(NativeToManagedRecord* record) {
- Method **sp = top_of_managed_stack_.GetSP();
-#ifndef NDEBUG
- if (sp != NULL) {
- Method* m = *sp;
- Runtime::Current()->GetHeap()->VerifyObject(m);
- DCHECK((m == NULL) || m->IsMethod());
- }
-#endif
- record->last_top_of_managed_stack_ = reinterpret_cast<void*>(sp);
- record->last_top_of_managed_stack_pc_ = top_of_managed_stack_pc_;
- record->link_ = native_to_managed_record_;
- native_to_managed_record_ = record;
- top_of_managed_stack_.SetSP(NULL);
-}
-#else
-void Thread::PushNativeToManagedRecord(NativeToManagedRecord*) {
- LOG(FATAL) << "Called non-LLVM method with LLVM";
-}
-#endif
-
-#if !defined(ART_USE_LLVM_COMPILER)
-void Thread::PopNativeToManagedRecord(const NativeToManagedRecord& record) {
- native_to_managed_record_ = record.link_;
- top_of_managed_stack_.SetSP(reinterpret_cast<Method**>(record.last_top_of_managed_stack_));
- top_of_managed_stack_pc_ = record.last_top_of_managed_stack_pc_;
-}
-#else
-void Thread::PopNativeToManagedRecord(const NativeToManagedRecord&) {
- LOG(FATAL) << "Called non-LLVM method with LLVM";
-}
-#endif
-
-struct StackDumpVisitor : public Thread::StackVisitor {
- StackDumpVisitor(std::ostream& os, const Thread* thread)
- : last_method(NULL), last_line_number(0), repetition_count(0), os(os), thread(thread),
- frame_count(0) {
+struct StackDumpVisitor : public StackVisitor {
+ StackDumpVisitor(std::ostream& os, const Thread* thread) :
+ StackVisitor(thread->GetManagedStack(), thread->GetTraceStack()), last_method(NULL),
+ last_line_number(0), repetition_count(0), os(os), thread(thread), frame_count(0) {
}
virtual ~StackDumpVisitor() {
@@ -574,19 +539,19 @@
}
}
- bool VisitFrame(const Frame& frame, uintptr_t pc) {
- if (!frame.HasMethod()) {
+ bool VisitFrame() {
+ Method* m = GetMethod();
+ if (m->IsRuntimeMethod()) {
return true;
}
const int kMaxRepetition = 3;
- Method* m = frame.GetMethod();
Class* c = m->GetDeclaringClass();
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
const DexCache* dex_cache = c->GetDexCache();
int line_number = -1;
if (dex_cache != NULL) { // be tolerant of bad input
const DexFile& dex_file = class_linker->FindDexFile(dex_cache);
- line_number = dex_file.GetLineNumFromPC(m, m->ToDexPC(pc));
+ line_number = dex_file.GetLineNumFromPC(m, GetDexPc());
}
if (line_number == last_line_number && last_method == m) {
repetition_count++;
@@ -632,7 +597,7 @@
DumpNativeStack(os, GetTid(), " native: ", false);
}
StackDumpVisitor dumper(os, this);
- WalkStack(&dumper);
+ dumper.WalkStack();
}
void Thread::SetStateWithoutSuspendCheck(ThreadState new_state) {
@@ -643,6 +608,11 @@
ThreadState Thread::SetState(ThreadState new_state) {
ThreadState old_state = state_;
+ if (old_state == kRunnable) {
+ // Non-runnable states are points where we expect thread suspension can occur.
+ AssertThreadSuspensionIsAllowable();
+ }
+
if (old_state == new_state) {
return old_state;
}
@@ -701,6 +671,7 @@
* the thread is supposed to be suspended. This is possibly faster
* on SMP and slightly more correct, but less convenient.
*/
+ AssertThreadSuspensionIsAllowable();
android_atomic_acquire_store(new_state, addr);
ANNOTATE_IGNORE_READS_BEGIN();
int suspend_count = suspend_count_;
@@ -813,35 +784,35 @@
}
Thread::Thread()
- : thin_lock_id_(0),
- tid_(0),
+ : suspend_count_(0),
+ card_table_(NULL),
+ exception_(NULL),
+ stack_end_(NULL),
+ managed_stack_(),
+ jni_env_(NULL),
+ self_(NULL),
+ state_(kNative),
peer_(NULL),
- top_of_managed_stack_(),
- top_of_managed_stack_pc_(0),
+ stack_begin_(NULL),
+ stack_size_(0),
+ thin_lock_id_(0),
+ tid_(0),
wait_mutex_(new Mutex("a thread wait mutex")),
wait_cond_(new ConditionVariable("a thread wait condition variable")),
wait_monitor_(NULL),
interrupted_(false),
wait_next_(NULL),
monitor_enter_object_(NULL),
- card_table_(0),
- stack_end_(NULL),
- native_to_managed_record_(NULL),
top_sirt_(NULL),
- top_shadow_frame_(NULL),
- jni_env_(NULL),
- state_(kNative),
- self_(NULL),
runtime_(NULL),
- exception_(NULL),
- suspend_count_(0),
- debug_suspend_count_(0),
class_loader_override_(NULL),
long_jump_context_(NULL),
throwing_OutOfMemoryError_(false),
+ debug_suspend_count_(0),
debug_invoke_req_(new DebugInvokeReq),
trace_stack_(new std::vector<TraceStackFrame>),
- name_(new std::string(kThreadNameDuringStartup)) {
+ name_(new std::string(kThreadNameDuringStartup)),
+ no_thread_suspension_(0) {
CHECK_EQ((sizeof(Thread) % 4), 0U) << sizeof(Thread);
memset(&held_mutexes_[0], 0, sizeof(held_mutexes_));
}
@@ -968,14 +939,6 @@
return count;
}
-size_t Thread::NumShadowFrameReferences() {
- size_t count = 0;
- for (ShadowFrame* cur = top_shadow_frame_; cur; cur = cur->GetLink()) {
- count += cur->NumberOfReferences();
- }
- return count;
-}
-
bool Thread::SirtContains(jobject obj) {
Object** sirt_entry = reinterpret_cast<Object**>(obj);
for (StackIndirectReferenceTable* cur = top_sirt_; cur; cur = cur->GetLink()) {
@@ -983,21 +946,8 @@
return true;
}
}
- return false;
-}
-
-bool Thread::ShadowFrameContains(jobject obj) {
- Object** shadow_frame_entry = reinterpret_cast<Object**>(obj);
- for (ShadowFrame* cur = top_shadow_frame_; cur; cur = cur->GetLink()) {
- if (cur->Contains(shadow_frame_entry)) {
- return true;
- }
- }
- return false;
-}
-
-bool Thread::StackReferencesContain(jobject obj) {
- return SirtContains(obj) || ShadowFrameContains(obj);
+ // JNI code invoked from portable code uses shadow frames rather than the SIRT.
+ return managed_stack_.ShadowFramesContain(sirt_entry);
}
void Thread::SirtVisitRoots(Heap::RootVisitor* visitor, void* arg) {
@@ -1012,18 +962,6 @@
}
}
-void Thread::ShadowFrameVisitRoots(Heap::RootVisitor* visitor, void* arg) {
- for (ShadowFrame* cur = top_shadow_frame_; cur; cur = cur->GetLink()) {
- size_t num_refs = cur->NumberOfReferences();
- for (size_t j = 0; j < num_refs; j++) {
- Object* object = cur->GetReference(j);
- if (object != NULL) {
- visitor(object, arg);
- }
- }
- }
-}
-
Object* Thread::DecodeJObject(jobject obj) {
DCHECK(CanAccessDirectReferences());
if (obj == NULL) {
@@ -1063,7 +1001,7 @@
default:
// TODO: make stack indirect reference table lookup more efficient
// Check if this is a local reference in the SIRT
- if (StackReferencesContain(obj)) {
+ if (SirtContains(obj)) {
result = *reinterpret_cast<Object**>(obj); // Read from SIRT
} else if (Runtime::Current()->GetJavaVM()->work_around_app_jni_bugs) {
// Assume an invalid local reference is actually a direct pointer.
@@ -1083,20 +1021,24 @@
return result;
}
-class CountStackDepthVisitor : public Thread::StackVisitor {
+class CountStackDepthVisitor : public StackVisitor {
public:
- CountStackDepthVisitor() : depth_(0), skip_depth_(0), skipping_(true) {}
+ CountStackDepthVisitor(const ManagedStack* stack,
+ const std::vector<TraceStackFrame>* trace_stack) :
+ StackVisitor(stack, trace_stack), depth_(0), skip_depth_(0),
+ skipping_(true) {}
- bool VisitFrame(const Frame& frame, uintptr_t /*pc*/) {
+ bool VisitFrame() {
// We want to skip frames up to and including the exception's constructor.
// Note we also skip the frame if it doesn't have a method (namely the callee
// save frame)
- if (skipping_ && frame.HasMethod() &&
- !Throwable::GetJavaLangThrowable()->IsAssignableFrom(frame.GetMethod()->GetDeclaringClass())) {
+ Method* m = GetMethod();
+ if (skipping_ && !m->IsRuntimeMethod() &&
+ !Throwable::GetJavaLangThrowable()->IsAssignableFrom(m->GetDeclaringClass())) {
skipping_ = false;
}
if (!skipping_) {
- if (frame.HasMethod()) { // ignore callee save frames
+ if (!m->IsRuntimeMethod()) { // Ignore runtime frames (in particular callee save).
++depth_;
}
} else {
@@ -1119,90 +1061,72 @@
bool skipping_;
};
-class BuildInternalStackTraceVisitor : public Thread::StackVisitor {
+class BuildInternalStackTraceVisitor : public StackVisitor {
public:
- explicit BuildInternalStackTraceVisitor(int skip_depth)
- : skip_depth_(skip_depth), count_(0), pc_trace_(NULL), method_trace_(NULL), local_ref_(NULL) {
- }
+ explicit BuildInternalStackTraceVisitor(const ManagedStack* stack,
+ const std::vector<TraceStackFrame>* trace_stack,
+ int skip_depth) :
+ StackVisitor(stack, trace_stack), skip_depth_(skip_depth), count_(0), dex_pc_trace_(NULL),
+ method_trace_(NULL) {}
bool Init(int depth, ScopedJniThreadState& ts) {
// Allocate method trace with an extra slot that will hold the PC trace
- method_trace_ = Runtime::Current()->GetClassLinker()->AllocObjectArray<Object>(depth + 1);
- if (method_trace_ == NULL) {
+ SirtRef<ObjectArray<Object> >
+ method_trace(Runtime::Current()->GetClassLinker()->AllocObjectArray<Object>(depth + 1));
+ if (method_trace.get() == NULL) {
return false;
}
- // Register a local reference as IntArray::Alloc may trigger GC
- local_ref_ = AddLocalReference<jobject>(ts.Env(), method_trace_);
- pc_trace_ = IntArray::Alloc(depth);
- if (pc_trace_ == NULL) {
+ IntArray* dex_pc_trace = IntArray::Alloc(depth);
+ if (dex_pc_trace == NULL) {
return false;
}
-#ifdef MOVING_GARBAGE_COLLECTOR
- // Re-read after potential GC
- method_trace_ = Decode<ObjectArray<Object>*>(ts.Env(), local_ref_);
-#endif
// Save PC trace in last element of method trace, also places it into the
// object graph.
- method_trace_->Set(depth, pc_trace_);
+ method_trace->Set(depth, dex_pc_trace);
+ // Set the Object*s and assert that no thread suspension is now possible.
+ ts.Self()->StartAssertNoThreadSuspension();
+ method_trace_ = method_trace.get();
+ dex_pc_trace_ = dex_pc_trace;
return true;
}
- virtual ~BuildInternalStackTraceVisitor() {}
+ virtual ~BuildInternalStackTraceVisitor() {
+ Thread::Current()->EndAssertNoThreadSuspension();
+ }
- bool VisitFrame(const Frame& frame, uintptr_t pc) {
- if (method_trace_ == NULL || pc_trace_ == NULL) {
+ bool VisitFrame() {
+ if (method_trace_ == NULL || dex_pc_trace_ == NULL) {
return true; // We're probably trying to fillInStackTrace for an OutOfMemoryError.
}
if (skip_depth_ > 0) {
skip_depth_--;
return true;
}
- if (!frame.HasMethod()) {
- return true; // ignore callee save frames
+ Method* m = GetMethod();
+ if (m->IsRuntimeMethod()) {
+ return true; // Ignore runtime frames (in particular callee save).
}
- method_trace_->Set(count_, frame.GetMethod());
- pc_trace_->Set(count_, pc);
+ method_trace_->Set(count_, m);
+ dex_pc_trace_->Set(count_, GetDexPc());
++count_;
return true;
}
- jobject GetInternalStackTrace() const {
- return local_ref_;
+ ObjectArray<Object>* GetInternalStackTrace() const {
+ return method_trace_;
}
private:
// How many more frames to skip.
int32_t skip_depth_;
- // Current position down stack trace
+ // Current position down stack trace.
uint32_t count_;
- // Array of return PC values
- IntArray* pc_trace_;
- // An array of the methods on the stack, the last entry is a reference to the
- // PC trace
+ // Array of dex PC values.
+ IntArray* dex_pc_trace_;
+ // An array of the methods on the stack, the last entry is a reference to the PC trace.
ObjectArray<Object>* method_trace_;
- // Local indirect reference table entry for method trace
- jobject local_ref_;
};
-#if !defined(ART_USE_LLVM_COMPILER)
-// TODO: remove this.
-static uintptr_t ManglePc(uintptr_t pc) {
- // Move the PC back 2 bytes as a call will frequently terminate the
- // decoding of a particular instruction and we want to make sure we
- // get the Dex PC of the instruction with the call and not the
- // instruction following.
- if (pc > 0) { pc -= 2; }
- return pc;
-}
-#endif
-
-// TODO: remove this.
-static uintptr_t DemanglePc(uintptr_t pc) {
- // Revert mangling for the case where we need the PC to return to the upcall
- if (pc > 0) { pc += 2; }
- return pc;
-}
-
void Thread::PushSirt(StackIndirectReferenceTable* sirt) {
sirt->SetLink(top_sirt_);
top_sirt_ = sirt;
@@ -1215,112 +1139,10 @@
return sirt;
}
-#if !defined(ART_USE_LLVM_COMPILER) // LLVM use ShadowFrame
-
-void Thread::WalkStack(StackVisitor* visitor, bool include_upcalls) const {
- Frame frame = GetTopOfStack();
- uintptr_t pc = ManglePc(top_of_managed_stack_pc_);
- uint32_t trace_stack_depth = 0;
- // TODO: enable this CHECK after native_to_managed_record_ is initialized during startup.
- // CHECK(native_to_managed_record_ != NULL);
- NativeToManagedRecord* record = native_to_managed_record_;
- bool method_tracing_active = Runtime::Current()->IsMethodTracingActive();
- while (frame.GetSP() != NULL) {
- for ( ; frame.GetMethod() != NULL; frame.Next()) {
- frame.GetMethod()->AssertPcIsWithinCode(pc);
- bool should_continue = visitor->VisitFrame(frame, pc);
- if (UNLIKELY(!should_continue)) {
- return;
- }
- uintptr_t return_pc = frame.GetReturnPC();
- if (LIKELY(!method_tracing_active)) {
- pc = ManglePc(return_pc);
- } else {
- // While profiling, the return pc is restored from the side stack, except when walking
- // the stack for an exception where the side stack will be unwound in VisitFrame.
- if (IsTraceExitPc(return_pc) && !include_upcalls) {
- TraceStackFrame trace_frame = GetTraceStackFrame(trace_stack_depth++);
- CHECK(trace_frame.method_ == frame.GetMethod());
- pc = ManglePc(trace_frame.return_pc_);
- } else {
- pc = ManglePc(return_pc);
- }
- }
- }
- if (include_upcalls) {
- bool should_continue = visitor->VisitFrame(frame, pc);
- if (!should_continue) {
- return;
- }
- }
- if (record == NULL) {
- return;
- }
- // last_tos should return Frame instead of sp?
- frame.SetSP(reinterpret_cast<Method**>(record->last_top_of_managed_stack_));
- pc = ManglePc(record->last_top_of_managed_stack_pc_);
- record = record->link_;
- }
-}
-
-#else // defined(ART_USE_LLVM_COMPILER) // LLVM uses ShadowFrame
-
-void Thread::WalkStack(StackVisitor* visitor, bool /*include_upcalls*/) const {
- for (ShadowFrame* cur = top_shadow_frame_; cur; cur = cur->GetLink()) {
- Frame frame;
- frame.SetSP(reinterpret_cast<Method**>(reinterpret_cast<byte*>(cur) +
- ShadowFrame::MethodOffset()));
- bool should_continue = visitor->VisitFrame(frame, cur->GetDexPC());
- if (!should_continue) {
- return;
- }
- }
-}
-
-/*
- * | |
- * | |
- * | |
- * | . |
- * | . |
- * | . |
- * | . |
- * | Method* |
- * | . |
- * | . | <-- top_shadow_frame_ (ShadowFrame*)
- * / +------------------------+
- * ->| . |
- * . | . |
- * . | . |
- * /+------------------------+
- * / | . |
- * / | . |
- * --- | | . |
- * | | | . |
- * | | Method* | <-- frame.GetSP() (Method**)
- * ShadowFrame \ | . |
- * | ->| . | <-- cur (ShadowFrame*)
- * --- /+------------------------+
- * / | . |
- * / | . |
- * --- | | . |
- * | cur->GetLink() | | . |
- * | | Method* |
- * ShadowFrame \ | . |
- * | ->| . |
- * --- +------------------------+
- * | . |
- * | . |
- * | . |
- * +========================+
- */
-
-#endif
-
jobject Thread::CreateInternalStackTrace(JNIEnv* env) const {
// Compute depth of stack
- CountStackDepthVisitor count_visitor;
- WalkStack(&count_visitor);
+ CountStackDepthVisitor count_visitor(GetManagedStack(), GetTraceStack());
+ count_visitor.WalkStack();
int32_t depth = count_visitor.GetDepth();
int32_t skip_depth = count_visitor.GetSkipDepth();
@@ -1328,12 +1150,13 @@
ScopedJniThreadState ts(env);
// Build internal stack trace
- BuildInternalStackTraceVisitor build_trace_visitor(skip_depth);
+ BuildInternalStackTraceVisitor build_trace_visitor(GetManagedStack(), GetTraceStack(),
+ skip_depth);
if (!build_trace_visitor.Init(depth, ts)) {
return NULL; // Allocation failed
}
- WalkStack(&build_trace_visitor);
- return build_trace_visitor.GetInternalStackTrace();
+ build_trace_visitor.WalkStack();
+ return AddLocalReference<jobjectArray>(ts.Env(), build_trace_visitor.GetInternalStackTrace());
}
jobjectArray Thread::InternalStackTraceToStackTraceElementArray(JNIEnv* env, jobject internal,
@@ -1375,8 +1198,8 @@
// Prepare parameters for StackTraceElement(String cls, String method, String file, int line)
Method* method = down_cast<Method*>(method_trace->Get(i));
mh.ChangeMethod(method);
- uint32_t native_pc = pc_trace->Get(i);
- int32_t line_number = mh.GetLineNumFromNativePC(native_pc);
+ uint32_t dex_pc = pc_trace->Get(i);
+ int32_t line_number = mh.GetLineNumFromDexPC(dex_pc);
// Allocate element, potentially triggering GC
// TODO: reuse class_name_object via Class::name_?
const char* descriptor = mh.GetDeclaringClassDescriptor();
@@ -1609,8 +1432,8 @@
DO_THREAD_OFFSET(state_);
DO_THREAD_OFFSET(suspend_count_);
DO_THREAD_OFFSET(thin_lock_id_);
- DO_THREAD_OFFSET(top_of_managed_stack_);
- DO_THREAD_OFFSET(top_of_managed_stack_pc_);
+ //DO_THREAD_OFFSET(top_of_managed_stack_);
+ //DO_THREAD_OFFSET(top_of_managed_stack_pc_);
DO_THREAD_OFFSET(top_sirt_);
#undef DO_THREAD_OFFSET
@@ -1628,68 +1451,100 @@
os << offset;
}
-class CatchBlockStackVisitor : public Thread::StackVisitor {
+static const bool kDebugExceptionDelivery = false;
+class CatchBlockStackVisitor : public StackVisitor {
public:
- CatchBlockStackVisitor(Class* to_find, Context* ljc)
- : to_find_(to_find), long_jump_context_(ljc), native_method_count_(0),
+ CatchBlockStackVisitor(Thread* self, Throwable* exception)
+ : StackVisitor(self->GetManagedStack(), self->GetTraceStack(), self->GetLongJumpContext()),
+ self_(self), exception_(exception), to_find_(exception->GetClass()), throw_method_(NULL),
+ throw_frame_id_(0), throw_dex_pc_(0), handler_quick_frame_(NULL),
+ handler_quick_frame_pc_(0), handler_dex_pc_(0), native_method_count_(0),
method_tracing_active_(Runtime::Current()->IsMethodTracingActive()) {
-#ifndef NDEBUG
- handler_pc_ = 0xEBADC0DE;
- handler_frame_.SetSP(reinterpret_cast<Method**>(0xEBADF00D));
-#endif
+ self->StartAssertNoThreadSuspension(); // Exception not in root sets, can't allow GC.
}
- bool VisitFrame(const Frame& fr, uintptr_t pc) {
- Method* method = fr.GetMethod();
+ bool VisitFrame() {
+ Method* method = GetMethod();
if (method == NULL) {
- // This is the upcall, we remember the frame and last_pc so that we may
- // long jump to them
- handler_pc_ = DemanglePc(pc);
- handler_frame_ = fr;
+ // This is the upcall, we remember the frame and last pc so that we may long jump to them.
+ handler_quick_frame_pc_ = GetCurrentQuickFramePc();
+ handler_quick_frame_ = GetCurrentQuickFrame();
return false; // End stack walk.
}
uint32_t dex_pc = DexFile::kDexNoIndex;
if (method->IsRuntimeMethod()) {
// ignore callee save method
DCHECK(method->IsCalleeSaveMethod());
- } else if (method->IsNative()) {
- native_method_count_++;
} else {
- // Unwind stack when an exception occurs during method tracing
- if (UNLIKELY(method_tracing_active_)) {
-#if !defined(ART_USE_LLVM_COMPILER)
- if (IsTraceExitPc(DemanglePc(pc))) {
- pc = ManglePc(TraceMethodUnwindFromCode(Thread::Current()));
- }
-#else
- UNIMPLEMENTED(FATAL);
-#endif
+ if (throw_method_ == NULL) {
+ throw_method_ = method;
+ throw_frame_id_ = GetFrameId();
+ throw_dex_pc_ = GetDexPc();
}
- dex_pc = method->ToDexPC(pc);
+ if (method->IsNative()) {
+ native_method_count_++;
+ } else {
+ // Unwind stack when an exception occurs during method tracing
+ if (UNLIKELY(method_tracing_active_ && IsTraceExitPc(GetCurrentQuickFramePc()))) {
+ uintptr_t pc = AdjustQuickFramePcForDexPcComputation(TraceMethodUnwindFromCode(Thread::Current()));
+ dex_pc = method->ToDexPC(pc);
+ } else {
+ dex_pc = GetDexPc();
+ }
+ }
}
if (dex_pc != DexFile::kDexNoIndex) {
uint32_t found_dex_pc = method->FindCatchBlock(to_find_, dex_pc);
if (found_dex_pc != DexFile::kDexNoIndex) {
- handler_pc_ = method->ToNativePC(found_dex_pc);
- handler_frame_ = fr;
+ handler_dex_pc_ = found_dex_pc;
+ handler_quick_frame_pc_ = method->ToNativePC(found_dex_pc);
+ handler_quick_frame_ = GetCurrentQuickFrame();
return false; // End stack walk.
}
}
-#if !defined(ART_USE_LLVM_COMPILER)
- // Caller may be handler, fill in callee saves in context
- long_jump_context_->FillCalleeSaves(fr);
-#endif
return true; // Continue stack walk.
}
- // The type of the exception catch block to find
+ void DoLongJump() {
+ Method* catch_method = *handler_quick_frame_;
+ Dbg::PostException(throw_frame_id_, throw_method_, throw_dex_pc_,
+ catch_method, handler_dex_pc_, exception_);
+ if (kDebugExceptionDelivery) {
+ if (catch_method == NULL) {
+ LOG(INFO) << "Handler is upcall";
+ } else {
+ ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+ const DexFile& dex_file =
+ class_linker->FindDexFile(catch_method->GetDeclaringClass()->GetDexCache());
+ int line_number = dex_file.GetLineNumFromPC(catch_method, handler_dex_pc_);
+ LOG(INFO) << "Handler: " << PrettyMethod(catch_method) << " (line: " << line_number << ")";
+ }
+ }
+ self_->SetException(exception_);
+ self_->EndAssertNoThreadSuspension(); // Exception back in root set.
+ // Place context back on thread so it will be available when we continue.
+ self_->ReleaseLongJumpContext(context_);
+ context_->SetSP(reinterpret_cast<uintptr_t>(handler_quick_frame_));
+ CHECK_NE(handler_quick_frame_pc_, 0u);
+ context_->SetPC(handler_quick_frame_pc_);
+ context_->SmashCallerSaves();
+ context_->DoLongJump();
+ }
+
+ private:
+ Thread* self_;
+ Throwable* exception_;
+ // The type of the exception catch block to find.
Class* to_find_;
- // Frame with found handler or last frame if no handler found
- Frame handler_frame_;
- // PC to branch to for the handler
- uintptr_t handler_pc_;
- // Context that will be the target of the long jump
- Context* long_jump_context_;
+ Method* throw_method_;
+ JDWP::FrameId throw_frame_id_;
+ uint32_t throw_dex_pc_;
+ // Quick frame with found handler or last frame if no handler found.
+ Method** handler_quick_frame_;
+ // PC to branch to for the handler.
+ uintptr_t handler_quick_frame_pc_;
+ // Associated dex PC.
+ uint32_t handler_dex_pc_;
// Number of native methods passed in crawl (equates to number of SIRTs to pop)
uint32_t native_method_count_;
// Is method tracing active?
@@ -1697,8 +1552,6 @@
};
void Thread::DeliverException() {
-#if !defined(ART_USE_LLVM_COMPILER)
- const bool kDebugExceptionDelivery = false;
Throwable* exception = GetException(); // Get exception from thread
CHECK(exception != NULL);
// Don't leave exception visible while we try to find the handler, which may cause class
@@ -1710,83 +1563,54 @@
DumpStack(LOG(INFO) << "Delivering exception: " << PrettyTypeOf(exception)
<< ": " << str_msg << "\n");
}
-
- Context* long_jump_context = GetLongJumpContext();
- CatchBlockStackVisitor catch_finder(exception->GetClass(), long_jump_context);
- WalkStack(&catch_finder, true);
-
- Method** sp;
- uintptr_t throw_native_pc;
- Method* throw_method = GetCurrentMethod(&throw_native_pc, &sp);
- uintptr_t catch_native_pc = catch_finder.handler_pc_;
- Method* catch_method = catch_finder.handler_frame_.GetMethod();
- Dbg::PostException(sp, throw_method, throw_native_pc, catch_method, catch_native_pc, exception);
-
- if (kDebugExceptionDelivery) {
- if (catch_method == NULL) {
- LOG(INFO) << "Handler is upcall";
- } else {
- ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- const DexFile& dex_file =
- class_linker->FindDexFile(catch_method->GetDeclaringClass()->GetDexCache());
- int line_number = dex_file.GetLineNumFromPC(catch_method,
- catch_method->ToDexPC(catch_finder.handler_pc_));
- LOG(INFO) << "Handler: " << PrettyMethod(catch_method) << " (line: " << line_number << ")";
- }
- }
- SetException(exception);
- CHECK_NE(catch_native_pc, 0u);
- long_jump_context->SetSP(reinterpret_cast<uintptr_t>(catch_finder.handler_frame_.GetSP()));
- long_jump_context->SetPC(catch_native_pc);
- long_jump_context->SmashCallerSaves();
- long_jump_context->DoLongJump();
-#endif
+ CatchBlockStackVisitor catch_finder(this, exception);
+ catch_finder.WalkStack(true);
+ catch_finder.DoLongJump();
LOG(FATAL) << "UNREACHABLE";
}
Context* Thread::GetLongJumpContext() {
Context* result = long_jump_context_;
-#if !defined(ART_USE_LLVM_COMPILER)
if (result == NULL) {
result = Context::Create();
- long_jump_context_ = result;
+ } else {
+ long_jump_context_ = NULL; // Avoid context being shared.
}
-#endif
return result;
}
-#if !defined(ART_USE_LLVM_COMPILER)
-Method* Thread::GetCurrentMethod(uintptr_t* pc, Method*** sp) const {
- Frame f = top_of_managed_stack_;
- Method* m = f.GetMethod();
- uintptr_t native_pc = top_of_managed_stack_pc_;
+Method* Thread::GetCurrentMethod(uint32_t* dex_pc, size_t* frame_id) const {
+ struct CurrentMethodVisitor : public StackVisitor {
+ CurrentMethodVisitor(const ManagedStack* stack,
+ const std::vector<TraceStackFrame>* trace_stack) :
+ StackVisitor(stack, trace_stack), method_(NULL), dex_pc_(0), frame_id_(0) {}
- // We use JNI internally for exception throwing, so it's possible to arrive
- // here via a "FromCode" function, in which case there's a synthetic
- // callee-save method at the top of the stack. These shouldn't be user-visible,
- // so if we find one, skip it and return the compiled method underneath.
- if (m != NULL && m->IsCalleeSaveMethod()) {
- native_pc = f.GetReturnPC();
- f.Next();
- m = f.GetMethod();
+ virtual bool VisitFrame() {
+ Method* m = GetMethod();
+ if (m->IsRuntimeMethod()) {
+ // Continue if this is a runtime method.
+ return true;
+ }
+ method_ = m;
+ dex_pc_ = GetDexPc();
+ frame_id_ = GetFrameId();
+ return false;
+ }
+ Method* method_;
+ uint32_t dex_pc_;
+ size_t frame_id_;
+ };
+
+ CurrentMethodVisitor visitor(GetManagedStack(), GetTraceStack());
+ visitor.WalkStack(false);
+ if (dex_pc != NULL) {
+ *dex_pc = visitor.dex_pc_;
}
- if (pc != NULL) {
- *pc = (m != NULL) ? ManglePc(native_pc) : 0;
+ if (frame_id != NULL) {
+ *frame_id = visitor.frame_id_;
}
- if (sp != NULL) {
- *sp = f.GetSP();
- }
- return m;
+ return visitor.method_;
}
-#else
-Method* Thread::GetCurrentMethod(uintptr_t*, Method***) const {
- ShadowFrame* frame = top_shadow_frame_;
- if (frame == NULL) {
- return NULL;
- }
- return frame->GetMethod();
-}
-#endif
bool Thread::HoldsLock(Object* object) {
if (object == NULL) {
@@ -1799,65 +1623,72 @@
return DecodeField(WellKnownClasses::java_lang_Thread_daemon)->GetBoolean(peer_);
}
-#if !defined(ART_USE_LLVM_COMPILER)
-class ReferenceMapVisitor : public Thread::StackVisitor {
+class ReferenceMapVisitor : public StackVisitor {
public:
- ReferenceMapVisitor(Context* context, Heap::RootVisitor* root_visitor, void* arg) :
- context_(context), root_visitor_(root_visitor), arg_(arg) {
+ ReferenceMapVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
+ Context* context, Heap::RootVisitor* root_visitor,
+ void* arg) : StackVisitor(stack, trace_stack, context),
+ root_visitor_(root_visitor), arg_(arg) {
}
- bool VisitFrame(const Frame& frame, uintptr_t pc) {
- Method* m = frame.GetMethod();
+ bool VisitFrame() {
if (false) {
- LOG(INFO) << "Visiting stack roots in " << PrettyMethod(m)
- << StringPrintf("@ PC:%04x", m->ToDexPC(pc));
+ LOG(INFO) << "Visiting stack roots in " << PrettyMethod(GetMethod())
+ << StringPrintf("@ PC:%04x", GetDexPc());
}
- // Process register map (which native and callee save methods don't have)
- if (!m->IsNative() && !m->IsCalleeSaveMethod() && !m->IsProxyMethod()) {
- CHECK(m->GetGcMap() != NULL) << PrettyMethod(m);
- CHECK_NE(0U, m->GetGcMapLength()) << PrettyMethod(m);
- verifier::PcToReferenceMap map(m->GetGcMap(), m->GetGcMapLength());
- const uint8_t* reg_bitmap = map.FindBitMap(m->ToDexPC(pc));
- CHECK(reg_bitmap != NULL);
- const VmapTable vmap_table(m->GetVmapTableRaw());
- const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
- DCHECK(code_item != NULL); // can't be NULL or how would we compile its instructions?
- uint32_t core_spills = m->GetCoreSpillMask();
- uint32_t fp_spills = m->GetFpSpillMask();
- size_t frame_size = m->GetFrameSizeInBytes();
- // For all dex registers in the bitmap
- size_t num_regs = std::min(map.RegWidth() * 8,
- static_cast<size_t>(code_item->registers_size_));
- for (size_t reg = 0; reg < num_regs; ++reg) {
- // Does this register hold a reference?
- if (TestBitmap(reg, reg_bitmap)) {
- uint32_t vmap_offset;
- Object* ref;
- if (vmap_table.IsInContext(reg, vmap_offset)) {
- // Compute the register we need to load from the context
- uint32_t spill_mask = m->GetCoreSpillMask();
- CHECK_LT(vmap_offset, static_cast<uint32_t>(__builtin_popcount(spill_mask)));
- uint32_t matches = 0;
- uint32_t spill_shifts = 0;
- while (matches != (vmap_offset + 1)) {
- DCHECK_NE(spill_mask, 0u);
- matches += spill_mask & 1; // Add 1 if the low bit is set
- spill_mask >>= 1;
- spill_shifts++;
+ ShadowFrame* shadow_frame = GetCurrentShadowFrame();
+ if (shadow_frame != NULL) {
+ shadow_frame->VisitRoots(root_visitor_, arg_);
+ } else {
+ Method* m = GetMethod();
+ // Process register map (which native and runtime methods don't have)
+ if (!m->IsNative() && !m->IsRuntimeMethod()) {
+ const uint8_t* gc_map = m->GetGcMap();
+ CHECK(gc_map != NULL) << PrettyMethod(m);
+ uint32_t gc_map_length = m->GetGcMapLength();
+ CHECK_NE(0U, gc_map_length) << PrettyMethod(m);
+ verifier::PcToReferenceMap map(gc_map, gc_map_length);
+ const uint8_t* reg_bitmap = map.FindBitMap(GetDexPc());
+ CHECK(reg_bitmap != NULL);
+ const VmapTable vmap_table(m->GetVmapTableRaw());
+ const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
+ DCHECK(code_item != NULL); // can't be NULL or how would we compile its instructions?
+ uint32_t core_spills = m->GetCoreSpillMask();
+ uint32_t fp_spills = m->GetFpSpillMask();
+ size_t frame_size = m->GetFrameSizeInBytes();
+ // For all dex registers in the bitmap
+ size_t num_regs = std::min(map.RegWidth() * 8,
+ static_cast<size_t>(code_item->registers_size_));
+ for (size_t reg = 0; reg < num_regs; ++reg) {
+ // Does this register hold a reference?
+ if (TestBitmap(reg, reg_bitmap)) {
+ uint32_t vmap_offset;
+ Object* ref;
+ if (vmap_table.IsInContext(reg, vmap_offset)) {
+ // Compute the register we need to load from the context
+ uint32_t spill_mask = core_spills;
+ CHECK_LT(vmap_offset, static_cast<uint32_t>(__builtin_popcount(spill_mask)));
+ uint32_t matches = 0;
+ uint32_t spill_shifts = 0;
+ while (matches != (vmap_offset + 1)) {
+ DCHECK_NE(spill_mask, 0u);
+ matches += spill_mask & 1; // Add 1 if the low bit is set
+ spill_mask >>= 1;
+ spill_shifts++;
+ }
+ spill_shifts--; // wind back one as we want the last match
+ ref = reinterpret_cast<Object*>(GetGPR(spill_shifts));
+ } else {
+ ref = reinterpret_cast<Object*>(GetVReg(code_item, core_spills, fp_spills,
+ frame_size, reg));
}
- spill_shifts--; // wind back one as we want the last match
- ref = reinterpret_cast<Object*>(context_->GetGPR(spill_shifts));
- } else {
- ref = reinterpret_cast<Object*>(frame.GetVReg(code_item, core_spills, fp_spills,
- frame_size, reg));
- }
- if (ref != NULL) {
- root_visitor_(ref, arg_);
+ if (ref != NULL) {
+ root_visitor_(ref, arg_);
+ }
}
}
}
}
- context_->FillCalleeSaves(frame);
return true;
}
@@ -1866,14 +1697,11 @@
return ((reg_vector[reg / 8] >> (reg % 8)) & 0x01) != 0;
}
- // Context used to build up picture of callee saves
- Context* context_;
// Call-back when we visit a root
Heap::RootVisitor* root_visitor_;
// Argument to call-back
void* arg_;
};
-#endif
void Thread::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
if (exception_ != NULL) {
@@ -1889,29 +1717,25 @@
jni_env_->monitors.VisitRoots(visitor, arg);
SirtVisitRoots(visitor, arg);
- ShadowFrameVisitRoots(visitor, arg);
-#if !defined(ART_USE_LLVM_COMPILER)
- // Cheat and steal the long jump context. Assume that we are not doing a GC during exception
- // delivery.
- Context* context = GetLongJumpContext();
// Visit roots on this thread's stack
- ReferenceMapVisitor mapper(context, visitor, arg);
- WalkStack(&mapper);
-#endif
+ Context* context = GetLongJumpContext();
+ ReferenceMapVisitor mapper(GetManagedStack(), GetTraceStack(), context, visitor, arg);
+ mapper.WalkStack();
+ ReleaseLongJumpContext(context);
}
#if VERIFY_OBJECT_ENABLED
-static void VerifyObject(const Object* obj, void*) {
- Runtime::Current()->GetHeap()->VerifyObject(obj);
+static void VerifyObject(const Object* obj, void* arg) {
+ Heap* heap = reinterpret_cast<Heap*>(arg);
+ heap->VerifyObject(obj);
}
void Thread::VerifyStack() {
-#if !defined(ART_USE_LLVM_COMPILER)
UniquePtr<Context> context(Context::Create());
- ReferenceMapVisitor mapper(context.get(), VerifyObject, NULL);
- WalkStack(&mapper);
-#endif
+ ReferenceMapVisitor mapper(GetManagedStack(), context.get(), VerifyObject,
+ Runtime::Current()->GetHeap());
+ mapper.WalkStack();
}
#endif
diff --git a/src/thread.h b/src/thread.h
index ad07498..e48f444 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -35,7 +35,6 @@
#include "oat/runtime/oat_support_entrypoints.h"
#include "offsets.h"
#include "runtime_stats.h"
-#include "shadow_frame.h"
#include "stack.h"
#include "trace.h"
#include "UniquePtr.h"
@@ -93,13 +92,6 @@
static const size_t kStackOverflowReservedBytes = 8 * KB;
#endif
- class StackVisitor {
- public:
- virtual ~StackVisitor() {}
- // Return 'true' if we should continue to visit more frames, 'false' to stop.
- virtual bool VisitFrame(const Frame& frame, uintptr_t pc) = 0;
- };
-
// Creates a new native thread corresponding to the given managed peer.
// Used to implement Thread.start.
static void CreateNativeThread(Object* peer, size_t stack_size);
@@ -111,7 +103,7 @@
// Reset internal state of child thread after fork.
void InitAfterFork();
- static Thread* Current() {
+ static Thread* Current() __attribute__ ((pure)) {
// We rely on Thread::Current returning NULL for a detached thread, so it's not obvious
// that we can replace this with a direct %fs access on x86.
void* thread = pthread_getspecific(Thread::pthread_key_self_);
@@ -145,6 +137,31 @@
void WaitUntilSuspended();
+ // Once called thread suspension will cause an assertion failure.
+ void StartAssertNoThreadSuspension() {
+#ifndef NDEBUG
+ no_thread_suspension_++;
+#endif
+ }
+ // End region where no thread suspension is expected.
+ void EndAssertNoThreadSuspension() {
+#ifndef NDEBUG
+ DCHECK_GT(no_thread_suspension_, 0U);
+ no_thread_suspension_--;
+#endif
+ }
+
+ void AssertThreadSuspensionIsAllowable() const {
+ DCHECK_EQ(0u, no_thread_suspension_);
+ }
+
+ bool CanAccessDirectReferences() const {
+#ifdef MOVING_GARBAGE_COLLECTOR
+ // TODO: when we have a moving collector, we'll need: return state_ == kRunnable;
+#endif
+ return true;
+ }
+
bool HoldsLock(Object*);
/*
@@ -168,13 +185,6 @@
// Returns the "system" ThreadGroup, used when attaching our internal threads.
static Object* GetSystemThreadGroup();
- bool CanAccessDirectReferences() const {
-#ifdef MOVING_GARBAGE_COLLECTOR
- // TODO: when we have a moving collector, we'll need: return state_ == kRunnable;
-#endif
- return true;
- }
-
uint32_t GetThinLockId() const {
return thin_lock_id_;
}
@@ -209,9 +219,6 @@
bool IsStillStarting() const;
- // Returns the current Method* and native PC (not dex PC) for this thread.
- Method* GetCurrentMethod(uintptr_t* pc = NULL, Method*** sp = NULL) const;
-
bool IsExceptionPending() const {
return exception_ != NULL;
}
@@ -236,20 +243,21 @@
void DeliverException();
Context* GetLongJumpContext();
-
- Frame GetTopOfStack() const {
- return top_of_managed_stack_;
+ void ReleaseLongJumpContext(Context* context) {
+ DCHECK(long_jump_context_ == NULL);
+ long_jump_context_ = context;
}
- // TODO: this is here for testing, remove when we have exception unit tests
- // that use the real stack
+ Method* GetCurrentMethod(uint32_t* dex_pc = NULL, size_t* frame_id = NULL) const;
+
void SetTopOfStack(void* stack, uintptr_t pc) {
- top_of_managed_stack_.SetSP(reinterpret_cast<Method**>(stack));
- top_of_managed_stack_pc_ = pc;
+ Method** top_method = reinterpret_cast<Method**>(stack);
+ managed_stack_.SetTopQuickFrame(top_method);
+ managed_stack_.SetTopQuickFramePc(pc);
}
- void SetTopOfStackPC(uintptr_t pc) {
- top_of_managed_stack_pc_ = pc;
+ bool HasManagedStack() const {
+ return managed_stack_.GetTopQuickFrame() != NULL || managed_stack_.GetTopShadowFrame() != NULL;
}
// If 'msg' is NULL, no detail message is set.
@@ -268,7 +276,7 @@
// Only the GC should call this.
void ThrowOutOfMemoryError(const char* msg);
- Frame FindExceptionHandler(void* throw_pc, void** handler_pc);
+ //QuickFrameIterator FindExceptionHandler(void* throw_pc, void** handler_pc);
void* FindExceptionHandlerInMethod(const Method* method,
void* throw_pc,
@@ -284,30 +292,6 @@
return jni_env_;
}
- // Number of references in SIRTs on this thread
- size_t NumSirtReferences();
-
- // Number of references allocated in ShadowFrames on this thread
- size_t NumShadowFrameReferences();
-
- // Number of references allocated in SIRTs & shadow frames on this thread
- size_t NumStackReferences() {
- return NumSirtReferences() + NumShadowFrameReferences();
- };
-
- // Is the given obj in this thread's stack indirect reference table?
- bool SirtContains(jobject obj);
-
- // Is the given obj in this thread's ShadowFrame?
- bool ShadowFrameContains(jobject obj);
-
- // Is the given obj in this thread's Sirts & ShadowFrames?
- bool StackReferencesContain(jobject obj);
-
- void SirtVisitRoots(Heap::RootVisitor* visitor, void* arg);
-
- void ShadowFrameVisitRoots(Heap::RootVisitor* visitor, void* arg);
-
// Convert a jobject into a Object*
Object* DecodeJObject(jobject obj);
@@ -339,10 +323,6 @@
NotifyLocked();
}
- // Linked list recording transitions from native to managed code
- void PushNativeToManagedRecord(NativeToManagedRecord* record);
- void PopNativeToManagedRecord(const NativeToManagedRecord& record);
-
const ClassLoader* GetClassLoaderOverride() {
// TODO: need to place the class_loader_override_ in a handle
// DCHECK(CanAccessDirectReferences());
@@ -433,32 +413,58 @@
}
static ThreadOffset TopOfManagedStackOffset() {
- return ThreadOffset(OFFSETOF_MEMBER(Thread, top_of_managed_stack_) +
- OFFSETOF_MEMBER(Frame, sp_));
+ return ThreadOffset(OFFSETOF_MEMBER(Thread, managed_stack_) +
+ ManagedStack::TopQuickFrameOffset());
}
static ThreadOffset TopOfManagedStackPcOffset() {
- return ThreadOffset(OFFSETOF_MEMBER(Thread, top_of_managed_stack_pc_));
+ return ThreadOffset(OFFSETOF_MEMBER(Thread, managed_stack_) +
+ ManagedStack::TopQuickFramePcOffset());
}
- ShadowFrame* PushShadowFrame(ShadowFrame* frame) {
- ShadowFrame* old_frame = top_shadow_frame_;
- top_shadow_frame_ = frame;
- frame->SetLink(old_frame);
- return old_frame;
+ const ManagedStack* GetManagedStack() const {
+ return &managed_stack_;
+ }
+
+ // Linked list recording fragments of managed stack.
+ void PushManagedStackFragment(ManagedStack* fragment) {
+ managed_stack_.PushManagedStackFragment(fragment);
+ }
+ void PopManagedStackFragment(const ManagedStack& fragment) {
+ managed_stack_.PopManagedStackFragment(fragment);
+ }
+
+ ShadowFrame* PushShadowFrame(ShadowFrame* new_top_frame) {
+ return managed_stack_.PushShadowFrame(new_top_frame);
}
ShadowFrame* PopShadowFrame() {
- CHECK(top_shadow_frame_ != NULL);
- ShadowFrame* frame = top_shadow_frame_;
- top_shadow_frame_ = frame->GetLink();
- return frame;
+ return managed_stack_.PopShadowFrame();
}
static ThreadOffset TopShadowFrameOffset() {
- return ThreadOffset(OFFSETOF_MEMBER(Thread, top_shadow_frame_));
+ return ThreadOffset(OFFSETOF_MEMBER(Thread, managed_stack_) +
+ ManagedStack::TopShadowFrameOffset());
}
+ // Number of references allocated in ShadowFrames on this thread
+ size_t NumShadowFrameReferences() const {
+ return managed_stack_.NumShadowFrameReferences();
+ }
+
+ // Number of references in SIRTs on this thread
+ size_t NumSirtReferences();
+
+ // Number of references allocated in SIRTs & shadow frames on this thread
+ size_t NumStackReferences() {
+ return NumSirtReferences() + NumShadowFrameReferences();
+ };
+
+ // Is the given obj in this thread's stack indirect reference table?
+ bool SirtContains(jobject obj);
+
+ void SirtVisitRoots(Heap::RootVisitor* visitor, void* arg);
+
void PushSirt(StackIndirectReferenceTable* sirt);
StackIndirectReferenceTable* PopSirt();
@@ -466,20 +472,18 @@
return ThreadOffset(OFFSETOF_MEMBER(Thread, top_sirt_));
}
- void WalkStack(StackVisitor* visitor, bool include_upcalls = false) const;
-
DebugInvokeReq* GetInvokeReq() {
return debug_invoke_req_;
}
void SetDebuggerUpdatesEnabled(bool enabled);
- bool IsTraceStackEmpty() const {
- return trace_stack_->empty();
+ const std::vector<TraceStackFrame>* GetTraceStack() const {
+ return trace_stack_;
}
- TraceStackFrame GetTraceStackFrame(uint32_t depth) const {
- return trace_stack_->at(trace_stack_->size() - depth - 1);
+ bool IsTraceStackEmpty() const {
+ return trace_stack_->empty();
}
void PushTraceStackFrame(const TraceStackFrame& frame) {
@@ -532,6 +536,47 @@
static void ThreadExitCallback(void* arg);
+ // TLS key used to retrieve the Thread*.
+ static pthread_key_t pthread_key_self_;
+
+ // --- Frequently accessed fields first for short offsets ---
+
+ // A non-zero value is used to tell the current thread to enter a safe point
+ // at the next poll.
+ int suspend_count_;
+
+ // The biased card table, see CardTable for details
+ byte* card_table_;
+
+ // The pending exception or NULL.
+ Throwable* exception_;
+
+ // The end of this thread's stack. This is the lowest safely-addressable address on the stack.
+ // We leave extra space so there's room for the code that throws StackOverflowError.
+ byte* stack_end_;
+
+ // The top of the managed stack often manipulated directly by compiler generated code.
+ ManagedStack managed_stack_;
+
+ // Every thread may have an associated JNI environment
+ JNIEnvExt* 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.
+ Thread* self_;
+
+ volatile ThreadState state_;
+
+ // Our managed peer (an instance of java.lang.Thread).
+ Object* peer_;
+
+ // The "lowest addressable byte" of the stack
+ byte* stack_begin_;
+
+ // Size of the stack
+ size_t stack_size_;
+
// Thin lock thread id. This is a small integer used by the thin lock implementation.
// This is not to be confused with the native thread's tid, nor is it the value returned
// by java.lang.Thread.getId --- this is a distinct value, used only for locking. One
@@ -542,20 +587,6 @@
// System thread id.
pid_t tid_;
- // Our managed peer (an instance of java.lang.Thread).
- Object* peer_;
-
- // The top_of_managed_stack_ and top_of_managed_stack_pc_ fields are accessed from
- // compiled code, so we keep them early in the structure to (a) avoid having to keep
- // fixing the assembler offsets and (b) improve the chances that these will still be aligned.
-
- // Top of the managed stack, written out prior to the state transition from
- // kRunnable to kNative. Uses include giving the starting point for scanning
- // a managed stack when a thread is in native code.
- Frame top_of_managed_stack_;
- // PC corresponding to the call out of the top_of_managed_stack_ frame
- uintptr_t top_of_managed_stack_pc_;
-
// Guards the 'interrupted_' and 'wait_monitor_' members.
mutable Mutex* wait_mutex_;
ConditionVariable* wait_cond_;
@@ -570,53 +601,12 @@
friend class Monitor;
- RuntimeStats stats_;
-
- // The biased card table, see CardTable for details
- byte* card_table_;
-
- // The end of this thread's stack. This is the lowest safely-addressable address on the stack.
- // We leave extra space so there's room for the code that throws StackOverflowError.
- byte* stack_end_;
-
- // Size of the stack
- size_t stack_size_;
-
- // The "lowest addressable byte" of the stack
- byte* stack_begin_;
-
- // A linked list (of stack allocated records) recording transitions from
- // native to managed code.
- NativeToManagedRecord* native_to_managed_record_;
-
// Top of linked list of stack indirect reference tables or NULL for none
StackIndirectReferenceTable* top_sirt_;
- // Top of linked list of shadow stack or NULL for none
- // Some backend may require shadow frame to ease the GC work.
- ShadowFrame* top_shadow_frame_;
-
- // Every thread may have an associated JNI environment
- JNIEnvExt* jni_env_;
-
- volatile ThreadState state_;
-
- // 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.
- Thread* self_;
-
Runtime* runtime_;
- // The pending exception or NULL.
- Throwable* exception_;
-
- // A non-zero value is used to tell the current thread to enter a safe point
- // at the next poll.
- int suspend_count_;
- // How much of 'suspend_count_' is by request of the debugger, used to set things right
- // when the debugger detaches. Must be <= suspend_count_.
- int debug_suspend_count_;
+ RuntimeStats stats_;
// Needed to get the right ClassLoader in JNI_OnLoad, but also
// useful for testing.
@@ -628,12 +618,13 @@
// A boolean telling us whether we're recursively throwing OOME.
uint32_t throwing_OutOfMemoryError_;
+ // How much of 'suspend_count_' is by request of the debugger, used to set things right
+ // when the debugger detaches. Must be <= suspend_count_.
+ int debug_suspend_count_;
+
// JDWP invoke-during-breakpoint support.
DebugInvokeReq* debug_invoke_req_;
- // TLS key used to retrieve the Thread*.
- static pthread_key_t pthread_key_self_;
-
// Additional stack used by method tracer to store method and return pc values.
// Stored as a pointer since std::vector is not PACKED.
std::vector<TraceStackFrame>* trace_stack_;
@@ -644,8 +635,11 @@
// A cached pthread_t for the pthread underlying this Thread*.
pthread_t pthread_self_;
+ // Mutexes held by this thread, see CheckSafeToLockOrUnlock.
uint32_t held_mutexes_[kMaxMutexRank + 1];
+ // A positive value implies we're in a region where thread suspension isn't expected.
+ uint32_t no_thread_suspension_;
public:
// Runtime support function pointers
EntryPoints entrypoints_;
diff --git a/src/thread_x86.cc b/src/thread_x86.cc
index acc38f4..6a72286 100644
--- a/src/thread_x86.cc
+++ b/src/thread_x86.cc
@@ -130,6 +130,9 @@
: "r"(THREAD_SELF_OFFSET) // input
:); // clobber
CHECK_EQ(self_check, this);
+
+ // Sanity check other offsets.
+ CHECK_EQ(THREAD_EXCEPTION_OFFSET, OFFSETOF_MEMBER(Thread, exception_));
}
} // namespace art
diff --git a/src/trace.cc b/src/trace.cc
index a453e37..7b7c3eb 100644
--- a/src/trace.cc
+++ b/src/trace.cc
@@ -194,26 +194,28 @@
return true;
}
-static void TraceRestoreStack(Thread* t, void*) {
- Frame frame = t->GetTopOfStack();
- if (frame.GetSP() != 0) {
- for ( ; frame.GetMethod() != 0; frame.Next()) {
- if (t->IsTraceStackEmpty()) {
- break;
+static void TraceRestoreStack(Thread* self, void*) {
+ struct RestoreStackVisitor : public StackVisitor {
+ RestoreStackVisitor(Thread* self) : StackVisitor(self->GetManagedStack(),
+ self->GetTraceStack()), self_(self) {}
+
+ virtual bool VisitFrame() {
+ if (self_->IsTraceStackEmpty()) {
+ return false; // Stop.
}
-#if defined(ART_USE_LLVM_COMPILER)
- UNIMPLEMENTED(FATAL);
-#else
- uintptr_t pc = frame.GetReturnPC();
- Method* method = frame.GetMethod();
+ uintptr_t pc = GetReturnPc();
if (IsTraceExitPc(pc)) {
- TraceStackFrame trace_frame = t->PopTraceStackFrame();
- frame.SetReturnPC(trace_frame.return_pc_);
- CHECK(method == trace_frame.method_);
+ TraceStackFrame trace_frame = self_->PopTraceStackFrame();
+ SetReturnPc(trace_frame.return_pc_);
+ CHECK(GetMethod() == trace_frame.method_);
}
-#endif
+ return true; // Continue.
}
- }
+
+ Thread* self_;
+ };
+ RestoreStackVisitor visitor(self);
+ visitor.WalkStack();
}
void Trace::AddSavedCodeToMap(const Method* method, const void* code) {
@@ -470,10 +472,9 @@
for (It it = visited_methods_.begin(); it != visited_methods_.end(); ++it) {
const Method* method = *it;
MethodHelper mh(method);
- os << StringPrintf("%p\t%s\t%s\t%s\t%s\t%d\n", method,
+ os << StringPrintf("%p\t%s\t%s\t%s\t%s\n", method,
PrettyDescriptor(mh.GetDeclaringClassDescriptor()).c_str(), mh.GetName(),
- mh.GetSignature().c_str(), mh.GetDeclaringClassSourceFile(),
- mh.GetLineNumFromNativePC(0));
+ mh.GetSignature().c_str(), mh.GetDeclaringClassSourceFile());
}
}
diff --git a/test/ReferenceMap/stack_walk_refmap_jni.cc b/test/ReferenceMap/stack_walk_refmap_jni.cc
index 20be7a1..d7910af 100644
--- a/test/ReferenceMap/stack_walk_refmap_jni.cc
+++ b/test/ReferenceMap/stack_walk_refmap_jni.cc
@@ -40,23 +40,21 @@
<< "Error: Reg @ " << i << "-th argument is not in GC map"; \
} while (false)
-struct ReferenceMap2Visitor : public Thread::StackVisitor {
- ReferenceMap2Visitor() {
+struct ReferenceMap2Visitor : public StackVisitor {
+ explicit ReferenceMap2Visitor(const ManagedStack* stack,
+ const std::vector<TraceStackFrame>* trace_stack) :
+ StackVisitor(stack, trace_stack) {
}
- bool VisitFrame(const Frame& frame, uintptr_t pc) {
- Method* m = frame.GetMethod();
- if (!m || m->IsNative()) {
+ bool VisitFrame() {
+ Method* m = GetMethod();
+ if (!m || m->IsNative() || m->IsRuntimeMethod() || IsShadowFrame()) {
return true;
}
LOG(INFO) << "At " << PrettyMethod(m, false);
verifier::PcToReferenceMap map(m->GetGcMap(), m->GetGcMapLength());
- if (!pc) {
- // pc == NULL: m is either a native method or a phony method
- return true;
- }
if (m->IsCalleeSaveMethod()) {
LOG(WARNING) << "no PC for " << PrettyMethod(m);
return true;
@@ -283,8 +281,9 @@
extern "C" JNIEXPORT jint JNICALL Java_ReferenceMap_refmap(JNIEnv*, jobject, jint count) {
// Visitor
- ReferenceMap2Visitor mapper;
- Thread::Current()->WalkStack(&mapper);
+ ReferenceMap2Visitor mapper(Thread::Current()->GetManagedStack(),
+ Thread::Current()->GetTraceStack());
+ mapper.WalkStack();
return count + 1;
}
diff --git a/test/StackWalk/stack_walk_jni.cc b/test/StackWalk/stack_walk_jni.cc
index 15d866f..3773198 100644
--- a/test/StackWalk/stack_walk_jni.cc
+++ b/test/StackWalk/stack_walk_jni.cc
@@ -29,31 +29,36 @@
( ((reg) < mh.GetCodeItem()->registers_size_) && \
(( *((reg_bitmap) + (reg)/8) >> ((reg) % 8) ) & 0x01) )
-#define CHECK_REGS(...) do { \
- int t[] = {__VA_ARGS__}; \
- int t_size = sizeof(t) / sizeof(*t); \
- for (int i = 0; i < t_size; ++i) \
- CHECK(REG(mh, reg_bitmap, t[i])) << "Error: Reg " << i << " is not in RegisterMap"; \
- } while (false)
+#define CHECK_REGS(...) if (!IsShadowFrame()) { \
+ int t[] = {__VA_ARGS__}; \
+ int t_size = sizeof(t) / sizeof(*t); \
+ for (int i = 0; i < t_size; ++i) \
+ CHECK(REG(mh, reg_bitmap, t[i])) << "Error: Reg " << i << " is not in RegisterMap"; \
+ }
static int gJava_StackWalk_refmap_calls = 0;
-struct TestReferenceMapVisitor : public Thread::StackVisitor {
- TestReferenceMapVisitor() {
+struct TestReferenceMapVisitor : public StackVisitor {
+ explicit TestReferenceMapVisitor(const ManagedStack* stack,
+ const std::vector<TraceStackFrame>* trace_stack) :
+ StackVisitor(stack, trace_stack) {
}
- bool VisitFrame(const Frame& frame, uintptr_t pc) {
- Method* m = frame.GetMethod();
+ bool VisitFrame() {
+ Method* m = GetMethod();
CHECK(m != NULL);
LOG(INFO) << "At " << PrettyMethod(m, false);
if (m->IsCalleeSaveMethod() || m->IsNative()) {
LOG(WARNING) << "no PC for " << PrettyMethod(m);
- CHECK_EQ(pc, 0u);
+ CHECK_EQ(GetDexPc(), DexFile::kDexNoIndex);
return true;
}
- verifier::PcToReferenceMap map(m->GetGcMap(), m->GetGcMapLength());
- const uint8_t* reg_bitmap = map.FindBitMap(m->ToDexPC(pc));
+ const uint8_t* reg_bitmap = NULL;
+ if (!IsShadowFrame()) {
+ verifier::PcToReferenceMap map(m->GetGcMap(), m->GetGcMapLength());
+ reg_bitmap = map.FindBitMap(GetDexPc());
+ }
MethodHelper mh(m);
StringPiece m_name(mh.GetName());
@@ -62,29 +67,29 @@
// find is what is expected.
if (m_name == "f") {
if (gJava_StackWalk_refmap_calls == 1) {
- CHECK_EQ(1U, m->ToDexPC(pc));
+ CHECK_EQ(1U, GetDexPc());
CHECK_REGS(1);
} else {
CHECK_EQ(gJava_StackWalk_refmap_calls, 2);
- CHECK_EQ(5U, m->ToDexPC(pc));
+ CHECK_EQ(5U, GetDexPc());
CHECK_REGS(1);
}
} else if (m_name == "g") {
if (gJava_StackWalk_refmap_calls == 1) {
- CHECK_EQ(0xcU, m->ToDexPC(pc));
+ CHECK_EQ(0xcU, GetDexPc());
CHECK_REGS(0, 2); // Note that v1 is not in the minimal root set
} else {
CHECK_EQ(gJava_StackWalk_refmap_calls, 2);
- CHECK_EQ(0xcU, m->ToDexPC(pc));
+ CHECK_EQ(0xcU, GetDexPc());
CHECK_REGS(0, 2);
}
} else if (m_name == "shlemiel") {
if (gJava_StackWalk_refmap_calls == 1) {
- CHECK_EQ(0x380U, m->ToDexPC(pc));
+ CHECK_EQ(0x380U, GetDexPc());
CHECK_REGS(2, 4, 5, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 21, 25);
} else {
CHECK_EQ(gJava_StackWalk_refmap_calls, 2);
- CHECK_EQ(0x380U, m->ToDexPC(pc));
+ CHECK_EQ(0x380U, GetDexPc());
CHECK_REGS(2, 4, 5, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 21, 25);
}
}
@@ -99,8 +104,9 @@
gJava_StackWalk_refmap_calls++;
// Visitor
- TestReferenceMapVisitor mapper;
- Thread::Current()->WalkStack(&mapper);
+ TestReferenceMapVisitor mapper(Thread::Current()->GetManagedStack(),
+ Thread::Current()->GetTraceStack());
+ mapper.WalkStack();
return count + 1;
}
@@ -109,8 +115,9 @@
gJava_StackWalk_refmap_calls++;
// Visitor
- TestReferenceMapVisitor mapper;
- Thread::Current()->WalkStack(&mapper);
+ TestReferenceMapVisitor mapper(Thread::Current()->GetManagedStack(),
+ Thread::Current()->GetTraceStack());
+ mapper.WalkStack();
return count + 1;
}
