Remove Frame, merge shadow and quick representations.
Change-Id: I5ae03a5e52111792d2df7e83cbd89ab25777844b
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;
}