Directory restructuring of object.h
Break object.h into constituent files.
Reduce number of #includes in other GC header files.
Introduce -inl.h files to avoid mirror files #include-ing each other.
Check invariants of verifier RegTypes for all constructors.
Change-Id: Iecf1171c02910ac152d52947330ef456df4043bc
diff --git a/src/native/dalvik_system_DexFile.cc b/src/native/dalvik_system_DexFile.cc
index 7485600..e549a8b 100644
--- a/src/native/dalvik_system_DexFile.cc
+++ b/src/native/dalvik_system_DexFile.cc
@@ -18,11 +18,12 @@
#include "base/logging.h"
#include "class_linker.h"
-#include "class_loader.h"
#include "dex_file.h"
#include "gc/space.h"
#include "image.h"
#include "jni_internal.h"
+#include "mirror/class_loader.h"
+#include "mirror/string.h"
#include "oat.h"
#include "os.h"
#include "runtime.h"
@@ -150,9 +151,8 @@
}
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
class_linker->RegisterDexFile(*dex_file);
- Object* class_loader_object = soa.Decode<Object*>(javaLoader);
- ClassLoader* class_loader = down_cast<ClassLoader*>(class_loader_object);
- Class* result = class_linker->DefineClass(descriptor, class_loader, *dex_file, *dex_class_def);
+ mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(javaLoader);
+ mirror::Class* result = class_linker->DefineClass(descriptor, class_loader, *dex_file, *dex_class_def);
return soa.AddLocalReference<jclass>(result);
}
diff --git a/src/native/dalvik_system_VMDebug.cc b/src/native/dalvik_system_VMDebug.cc
index e5a398a..dc07a31 100644
--- a/src/native/dalvik_system_VMDebug.cc
+++ b/src/native/dalvik_system_VMDebug.cc
@@ -21,6 +21,7 @@
#include "debugger.h"
#include "hprof/hprof.h"
#include "jni_internal.h"
+#include "mirror/class.h"
#include "ScopedUtfChars.h"
#include "scoped_thread_state_change.h"
#include "toStringArray.h"
@@ -220,11 +221,11 @@
static jlong VMDebug_countInstancesOfClass(JNIEnv* env, jclass, jclass javaClass,
jboolean countAssignable) {
ScopedObjectAccess soa(env);
- Class* c = soa.Decode<Class*>(javaClass);
+ mirror::Class* c = soa.Decode<mirror::Class*>(javaClass);
if (c == NULL) {
return 0;
}
- std::vector<Class*> classes;
+ std::vector<mirror::Class*> classes;
classes.push_back(c);
uint64_t count = 0;
Runtime::Current()->GetHeap()->CountInstances(classes, countAssignable, &count);
diff --git a/src/native/dalvik_system_VMRuntime.cc b/src/native/dalvik_system_VMRuntime.cc
index bf518dc..5ce27fb 100644
--- a/src/native/dalvik_system_VMRuntime.cc
+++ b/src/native/dalvik_system_VMRuntime.cc
@@ -19,7 +19,8 @@
#include "class_linker.h"
#include "debugger.h"
#include "jni_internal.h"
-#include "object.h"
+#include "mirror/object.h"
+#include "mirror/object-inl.h"
#include "object_utils.h"
#include "scoped_thread_state_change.h"
#include "gc/space.h"
@@ -52,7 +53,7 @@
UNIMPLEMENTED(FATAL);
#endif
- Class* element_class = soa.Decode<Class*>(javaElementClass);
+ mirror::Class* element_class = soa.Decode<mirror::Class*>(javaElementClass);
if (element_class == NULL) {
soa.Self()->ThrowNewException("Ljava/lang/NullPointerException;", "element class == null");
return NULL;
@@ -66,8 +67,8 @@
std::string descriptor;
descriptor += "[";
descriptor += ClassHelper(element_class).GetDescriptor();
- Class* array_class = class_linker->FindClass(descriptor.c_str(), NULL);
- Array* result = Array::Alloc(soa.Self(), array_class, length);
+ mirror::Class* array_class = class_linker->FindClass(descriptor.c_str(), NULL);
+ mirror::Array* result = mirror::Array::Alloc(soa.Self(), array_class, length);
if (result == NULL) {
return NULL;
}
@@ -79,7 +80,7 @@
return 0;
}
ScopedObjectAccess soa(env);
- Array* array = soa.Decode<Array*>(javaArray);
+ mirror::Array* array = soa.Decode<mirror::Array*>(javaArray);
if (!array->IsArrayInstance()) {
soa.Self()->ThrowNewException("Ljava/lang/IllegalArgumentException;", "not an array");
return 0;
diff --git a/src/native/dalvik_system_VMStack.cc b/src/native/dalvik_system_VMStack.cc
index 494f38d..bb2ed88 100644
--- a/src/native/dalvik_system_VMStack.cc
+++ b/src/native/dalvik_system_VMStack.cc
@@ -14,10 +14,11 @@
* limitations under the License.
*/
-#include "class_loader.h"
#include "jni_internal.h"
#include "nth_caller_visitor.h"
-#include "object.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/class.h"
+#include "mirror/class_loader.h"
#include "scoped_thread_state_change.h"
#include "thread_list.h"
@@ -26,7 +27,7 @@
static jobject GetThreadStack(JNIEnv* env, jobject peer) {
{
ScopedObjectAccess soa(env);
- if (soa.Decode<Object*>(peer) == soa.Self()->GetPeer()) {
+ if (soa.Decode<mirror::Object*>(peer) == soa.Self()->GetPeer()) {
return soa.Self()->CreateInternalStackTrace(soa);
}
}
@@ -73,13 +74,13 @@
static jobject VMStack_getClosestUserClassLoader(JNIEnv* env, jclass, jobject javaBootstrap,
jobject javaSystem) {
struct ClosestUserClassLoaderVisitor : public StackVisitor {
- ClosestUserClassLoaderVisitor(Thread* thread, Object* bootstrap, Object* system)
+ ClosestUserClassLoaderVisitor(Thread* thread, mirror::Object* bootstrap, mirror::Object* system)
: StackVisitor(thread, NULL), bootstrap(bootstrap), system(system), class_loader(NULL) {}
bool VisitFrame() {
DCHECK(class_loader == NULL);
- Class* c = GetMethod()->GetDeclaringClass();
- Object* cl = c->GetClassLoader();
+ mirror::Class* c = GetMethod()->GetDeclaringClass();
+ mirror::Object* cl = c->GetClassLoader();
if (cl != NULL && cl != bootstrap && cl != system) {
class_loader = cl;
return false;
@@ -87,13 +88,13 @@
return true;
}
- Object* bootstrap;
- Object* system;
- Object* class_loader;
+ mirror::Object* bootstrap;
+ mirror::Object* system;
+ mirror::Object* class_loader;
};
ScopedObjectAccess soa(env);
- Object* bootstrap = soa.Decode<Object*>(javaBootstrap);
- Object* system = soa.Decode<Object*>(javaSystem);
+ mirror::Object* bootstrap = soa.Decode<mirror::Object*>(javaBootstrap);
+ mirror::Object* system = soa.Decode<mirror::Object*>(javaSystem);
ClosestUserClassLoaderVisitor visitor(soa.Self(), bootstrap, system);
visitor.WalkStack();
return soa.AddLocalReference<jobject>(visitor.class_loader);
diff --git a/src/native/java_lang_Class.cc b/src/native/java_lang_Class.cc
index 59c9bef..dded787 100644
--- a/src/native/java_lang_Class.cc
+++ b/src/native/java_lang_Class.cc
@@ -15,10 +15,12 @@
*/
#include "class_linker.h"
-#include "class_loader.h"
#include "jni_internal.h"
#include "nth_caller_visitor.h"
-#include "object.h"
+#include "mirror/class.h"
+#include "mirror/class_loader.h"
+#include "mirror/object-inl.h"
+#include "mirror/proxy.h"
#include "object_utils.h"
#include "scoped_thread_state_change.h"
#include "ScopedLocalRef.h"
@@ -27,9 +29,9 @@
namespace art {
-static Class* DecodeClass(const ScopedObjectAccess& soa, jobject java_class)
+static mirror::Class* DecodeClass(const ScopedObjectAccess& soa, jobject java_class)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Class* c = soa.Decode<Class*>(java_class);
+ mirror::Class* c = soa.Decode<mirror::Class*>(java_class);
DCHECK(c != NULL);
DCHECK(c->IsClass());
// TODO: we could EnsureInitialized here, rather than on every reflective get/set or invoke .
@@ -56,9 +58,9 @@
}
std::string descriptor(DotToDescriptor(name.c_str()));
- ClassLoader* class_loader = soa.Decode<ClassLoader*>(javaLoader);
+ mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(javaLoader);
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- Class* c = class_linker->FindClass(descriptor.c_str(), class_loader);
+ mirror::Class* c = class_linker->FindClass(descriptor.c_str(), class_loader);
if (c == NULL) {
ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred());
env->ExceptionClear();
@@ -76,7 +78,7 @@
static jint Class_getAnnotationDirectoryOffset(JNIEnv* env, jclass javaClass) {
ScopedObjectAccess soa(env);
- Class* c = DecodeClass(soa, javaClass);
+ mirror::Class* c = DecodeClass(soa, javaClass);
if (c->IsPrimitive() || c->IsArrayClass() || c->IsProxyClass()) {
return 0; // primitive, array and proxy classes don't have class definitions
}
@@ -90,9 +92,9 @@
static jobject Class_getDex(JNIEnv* env, jobject javaClass) {
ScopedObjectAccess soa(env);
- Class* c = DecodeClass(soa, javaClass);
+ mirror::Class* c = DecodeClass(soa, javaClass);
- DexCache* dex_cache = c->GetDexCache();
+ mirror::DexCache* dex_cache = c->GetDexCache();
if (dex_cache == NULL) {
return NULL;
}
@@ -105,13 +107,14 @@
static jstring Class_getNameNative(JNIEnv* env, jobject javaThis) {
ScopedObjectAccess soa(env);
- Class* c = DecodeClass(soa, javaThis);
+ mirror::Class* c = DecodeClass(soa, javaThis);
return soa.AddLocalReference<jstring>(c->ComputeName());
}
static jobjectArray Class_getProxyInterfaces(JNIEnv* env, jobject javaThis) {
ScopedObjectAccess soa(env);
- SynthesizedProxyClass* c = down_cast<SynthesizedProxyClass*>(DecodeClass(soa, javaThis));
+ mirror::SynthesizedProxyClass* c =
+ down_cast<mirror::SynthesizedProxyClass*>(DecodeClass(soa, javaThis));
return soa.AddLocalReference<jobjectArray>(c->GetInterfaces()->Clone(soa.Self()));
}
diff --git a/src/native/java_lang_Object.cc b/src/native/java_lang_Object.cc
index f3c295e..75d5f70 100644
--- a/src/native/java_lang_Object.cc
+++ b/src/native/java_lang_Object.cc
@@ -15,7 +15,7 @@
*/
#include "jni_internal.h"
-#include "object.h"
+#include "mirror/object.h"
#include "scoped_thread_state_change.h"
// TODO: better support for overloading.
@@ -27,31 +27,31 @@
static jobject Object_internalClone(JNIEnv* env, jobject java_this) {
ScopedObjectAccess soa(env);
- Object* o = soa.Decode<Object*>(java_this);
+ mirror::Object* o = soa.Decode<mirror::Object*>(java_this);
return soa.AddLocalReference<jobject>(o->Clone(soa.Self()));
}
static void Object_notify(JNIEnv* env, jobject java_this) {
ScopedObjectAccess soa(env);
- Object* o = soa.Decode<Object*>(java_this);
+ mirror::Object* o = soa.Decode<mirror::Object*>(java_this);
o->Notify();
}
static void Object_notifyAll(JNIEnv* env, jobject java_this) {
ScopedObjectAccess soa(env);
- Object* o = soa.Decode<Object*>(java_this);
+ mirror::Object* o = soa.Decode<mirror::Object*>(java_this);
o->NotifyAll();
}
static void Object_wait(JNIEnv* env, jobject java_this) {
ScopedObjectAccess soa(env);
- Object* o = soa.Decode<Object*>(java_this);
+ mirror::Object* o = soa.Decode<mirror::Object*>(java_this);
o->Wait();
}
static void Object_waitJI(JNIEnv* env, jobject java_this, jlong ms, jint ns) {
ScopedObjectAccess soa(env);
- Object* o = soa.Decode<Object*>(java_this);
+ mirror::Object* o = soa.Decode<mirror::Object*>(java_this);
o->Wait(ms, ns);
}
diff --git a/src/native/java_lang_Runtime.cc b/src/native/java_lang_Runtime.cc
index d197b73..54ccddc 100644
--- a/src/native/java_lang_Runtime.cc
+++ b/src/native/java_lang_Runtime.cc
@@ -18,10 +18,9 @@
#include <limits.h>
#include <unistd.h>
-#include "class_loader.h"
#include "heap.h"
#include "jni_internal.h"
-#include "object.h"
+#include "mirror/class_loader.h"
#include "runtime.h"
#include "scoped_thread_state_change.h"
#include "ScopedUtfChars.h"
@@ -59,7 +58,7 @@
}
}
- ClassLoader* classLoader = soa.Decode<ClassLoader*>(javaLoader);
+ mirror::ClassLoader* classLoader = soa.Decode<mirror::ClassLoader*>(javaLoader);
std::string detail;
JavaVMExt* vm = Runtime::Current()->GetJavaVM();
bool success = vm->LoadNativeLibrary(filename.c_str(), classLoader, detail);
diff --git a/src/native/java_lang_String.cc b/src/native/java_lang_String.cc
index 8b7a691..44ab1ca 100644
--- a/src/native/java_lang_String.cc
+++ b/src/native/java_lang_String.cc
@@ -15,7 +15,7 @@
*/
#include "jni_internal.h"
-#include "object.h"
+#include "mirror/string.h"
#include "scoped_thread_state_change.h"
#include "ScopedLocalRef.h"
@@ -28,7 +28,7 @@
return -1;
} else {
ScopedObjectAccess soa(env);
- return soa.Decode<String*>(javaThis)->CompareTo(soa.Decode<String*>(javaRhs));
+ return soa.Decode<mirror::String*>(javaThis)->CompareTo(soa.Decode<mirror::String*>(javaRhs));
}
}
@@ -37,14 +37,14 @@
// This method does not handle supplementary characters. They're dealt with in managed code.
DCHECK_LE(ch, 0xffff);
- String* s = soa.Decode<String*>(java_this);
+ mirror::String* s = soa.Decode<mirror::String*>(java_this);
return s->FastIndexOf(ch, start);
}
static jstring String_intern(JNIEnv* env, jobject javaThis) {
ScopedObjectAccess soa(env);
- String* s = soa.Decode<String*>(javaThis);
- String* result = s->Intern();
+ mirror::String* s = soa.Decode<mirror::String*>(javaThis);
+ mirror::String* result = s->Intern();
return soa.AddLocalReference<jstring>(result);
}
diff --git a/src/native/java_lang_System.cc b/src/native/java_lang_System.cc
index d74c9db..54ee2e9 100644
--- a/src/native/java_lang_System.cc
+++ b/src/native/java_lang_System.cc
@@ -14,8 +14,12 @@
* limitations under the License.
*/
+#include "gc/card_table-inl.h"
#include "jni_internal.h"
-#include "object.h"
+#include "mirror/array.h"
+#include "mirror/class.h"
+#include "mirror/class-inl.h"
+#include "mirror/object-inl.h"
#include "scoped_thread_state_change.h"
/*
@@ -101,7 +105,7 @@
namespace art {
-static void ThrowArrayStoreException_NotAnArray(const char* identifier, Object* array)
+static void ThrowArrayStoreException_NotAnArray(const char* identifier, mirror::Object* array)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
std::string actualType(PrettyTypeOf(array));
Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;",
@@ -122,8 +126,8 @@
}
// Make sure source and destination are both arrays.
- Object* srcObject = soa.Decode<Object*>(javaSrc);
- Object* dstObject = soa.Decode<Object*>(javaDst);
+ mirror::Object* srcObject = soa.Decode<mirror::Object*>(javaSrc);
+ mirror::Object* dstObject = soa.Decode<mirror::Object*>(javaDst);
if (!srcObject->IsArrayInstance()) {
ThrowArrayStoreException_NotAnArray("source", srcObject);
return;
@@ -132,10 +136,10 @@
ThrowArrayStoreException_NotAnArray("destination", dstObject);
return;
}
- Array* srcArray = srcObject->AsArray();
- Array* dstArray = dstObject->AsArray();
- Class* srcComponentType = srcArray->GetClass()->GetComponentType();
- Class* dstComponentType = dstArray->GetClass()->GetComponentType();
+ mirror::Array* srcArray = srcObject->AsArray();
+ mirror::Array* dstArray = dstObject->AsArray();
+ mirror::Class* srcComponentType = srcArray->GetClass()->GetComponentType();
+ mirror::Class* dstComponentType = dstArray->GetClass()->GetComponentType();
// Bounds checking.
if (srcPos < 0 || dstPos < 0 || length < 0 || srcPos > srcArray->GetLength() - length || dstPos > dstArray->GetLength() - length) {
@@ -182,7 +186,7 @@
}
// Neither class is primitive. Are the types trivially compatible?
- const size_t width = sizeof(Object*);
+ const size_t width = sizeof(mirror::Object*);
uint8_t* dstBytes = reinterpret_cast<uint8_t*>(dstArray->GetRawData(width));
const uint8_t* srcBytes = reinterpret_cast<const uint8_t*>(srcArray->GetRawData(width));
if (dstArray == srcArray || dstComponentType->IsAssignableFrom(srcComponentType)) {
@@ -202,20 +206,21 @@
// We already dealt with overlapping copies, so we don't need to cope with that case below.
CHECK_NE(dstArray, srcArray);
- Object* const * srcObjects = reinterpret_cast<Object* const *>(srcBytes + srcPos * width);
- Object** dstObjects = reinterpret_cast<Object**>(dstBytes + dstPos * width);
- Class* dstClass = dstArray->GetClass()->GetComponentType();
+ mirror::Object* const * srcObjects =
+ reinterpret_cast<mirror::Object* const *>(srcBytes + srcPos * width);
+ mirror::Object** dstObjects = reinterpret_cast<mirror::Object**>(dstBytes + dstPos * width);
+ mirror::Class* dstClass = dstArray->GetClass()->GetComponentType();
// We want to avoid redundant IsAssignableFrom checks where possible, so we cache a class that
// we know is assignable to the destination array's component type.
- Class* lastAssignableElementClass = dstClass;
+ mirror::Class* lastAssignableElementClass = dstClass;
- Object* o = NULL;
+ mirror::Object* o = NULL;
int i = 0;
for (; i < length; ++i) {
o = srcObjects[i];
if (o != NULL) {
- Class* oClass = o->GetClass();
+ mirror::Class* oClass = o->GetClass();
if (lastAssignableElementClass == oClass) {
dstObjects[i] = o;
} else if (dstClass->IsAssignableFrom(oClass)) {
@@ -243,7 +248,7 @@
static jint System_identityHashCode(JNIEnv* env, jclass, jobject javaObject) {
ScopedObjectAccess soa(env);
- Object* o = soa.Decode<Object*>(javaObject);
+ mirror::Object* o = soa.Decode<mirror::Object*>(javaObject);
return static_cast<jint>(o->IdentityHashCode());
}
diff --git a/src/native/java_lang_Thread.cc b/src/native/java_lang_Thread.cc
index 473369e..ca4be9d 100644
--- a/src/native/java_lang_Thread.cc
+++ b/src/native/java_lang_Thread.cc
@@ -17,7 +17,7 @@
#include "debugger.h"
#include "jni_internal.h"
#include "monitor.h"
-#include "object.h"
+#include "mirror/object.h"
#include "scoped_thread_state_change.h"
#include "ScopedUtfChars.h"
#include "thread.h"
@@ -88,7 +88,7 @@
static jboolean Thread_nativeHoldsLock(JNIEnv* env, jobject java_thread, jobject java_object) {
ScopedObjectAccess soa(env);
- Object* object = soa.Decode<Object*>(java_object);
+ mirror::Object* object = soa.Decode<mirror::Object*>(java_object);
if (object == NULL) {
Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;", "object == null");
return JNI_FALSE;
@@ -111,7 +111,7 @@
ScopedUtfChars name(env, java_name);
{
ScopedObjectAccess soa(env);
- if (soa.Decode<Object*>(peer) == soa.Self()->GetPeer()) {
+ if (soa.Decode<mirror::Object*>(peer) == soa.Self()->GetPeer()) {
soa.Self()->SetThreadName(name.c_str());
return;
}
@@ -149,7 +149,7 @@
static void Thread_sleep(JNIEnv* env, jclass, jobject java_lock, jlong ms, jint ns) {
ScopedObjectAccess soa(env);
- Object* lock = soa.Decode<Object*>(java_lock);
+ mirror::Object* lock = soa.Decode<mirror::Object*>(java_lock);
Monitor::Wait(Thread::Current(), lock, ms, ns, true, kSleeping);
}
diff --git a/src/native/java_lang_VMClassLoader.cc b/src/native/java_lang_VMClassLoader.cc
index 4b5c31c..02b7c25 100644
--- a/src/native/java_lang_VMClassLoader.cc
+++ b/src/native/java_lang_VMClassLoader.cc
@@ -15,8 +15,8 @@
*/
#include "class_linker.h"
-#include "class_loader.h"
#include "jni_internal.h"
+#include "mirror/class_loader.h"
#include "scoped_thread_state_change.h"
#include "ScopedUtfChars.h"
#include "zip_archive.h"
@@ -25,14 +25,14 @@
static jclass VMClassLoader_findLoadedClass(JNIEnv* env, jclass, jobject javaLoader, jstring javaName) {
ScopedObjectAccess soa(env);
- ClassLoader* loader = soa.Decode<ClassLoader*>(javaLoader);
+ mirror::ClassLoader* loader = soa.Decode<mirror::ClassLoader*>(javaLoader);
ScopedUtfChars name(env, javaName);
if (name.c_str() == NULL) {
return NULL;
}
std::string descriptor(DotToDescriptor(name.c_str()));
- Class* c = Runtime::Current()->GetClassLinker()->LookupClass(descriptor.c_str(), loader);
+ mirror::Class* c = Runtime::Current()->GetClassLinker()->LookupClass(descriptor.c_str(), loader);
if (c != NULL && c->IsResolved()) {
return soa.AddLocalReference<jclass>(c);
} else {
diff --git a/src/native/java_lang_reflect_Array.cc b/src/native/java_lang_reflect_Array.cc
index 15aeed2..2833cb0 100644
--- a/src/native/java_lang_reflect_Array.cc
+++ b/src/native/java_lang_reflect_Array.cc
@@ -16,7 +16,8 @@
#include "class_linker.h"
#include "jni_internal.h"
-#include "object.h"
+#include "mirror/class.h"
+#include "mirror/object-inl.h"
#include "object_utils.h"
#include "scoped_thread_state_change.h"
#include "sirt_ref.h"
@@ -26,21 +27,21 @@
static jobject Array_createMultiArray(JNIEnv* env, jclass, jclass javaElementClass, jobject javaDimArray) {
ScopedObjectAccess soa(env);
DCHECK(javaElementClass != NULL);
- Class* element_class = soa.Decode<Class*>(javaElementClass);
+ mirror::Class* element_class = soa.Decode<mirror::Class*>(javaElementClass);
DCHECK(element_class->IsClass());
DCHECK(javaDimArray != NULL);
- Object* dimensions_obj = soa.Decode<Object*>(javaDimArray);
+ mirror::Object* dimensions_obj = soa.Decode<mirror::Object*>(javaDimArray);
DCHECK(dimensions_obj->IsArrayInstance());
DCHECK_STREQ(ClassHelper(dimensions_obj->GetClass()).GetDescriptor(), "[I");
- IntArray* dimensions_array = down_cast<IntArray*>(dimensions_obj);
- Array* new_array = Array::CreateMultiArray(soa.Self(), element_class, dimensions_array);
+ mirror::IntArray* dimensions_array = down_cast<mirror::IntArray*>(dimensions_obj);
+ mirror::Array* new_array = mirror::Array::CreateMultiArray(soa.Self(), element_class, dimensions_array);
return soa.AddLocalReference<jobject>(new_array);
}
static jobject Array_createObjectArray(JNIEnv* env, jclass, jclass javaElementClass, jint length) {
ScopedObjectAccess soa(env);
DCHECK(javaElementClass != NULL);
- Class* element_class = soa.Decode<Class*>(javaElementClass);
+ mirror::Class* element_class = soa.Decode<mirror::Class*>(javaElementClass);
if (UNLIKELY(length < 0)) {
soa.Self()->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d", length);
return NULL;
@@ -49,13 +50,13 @@
descriptor += ClassHelper(element_class).GetDescriptor();
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- Class* array_class = class_linker->FindClass(descriptor.c_str(), element_class->GetClassLoader());
+ mirror::Class* array_class = class_linker->FindClass(descriptor.c_str(), element_class->GetClassLoader());
if (UNLIKELY(array_class == NULL)) {
CHECK(soa.Self()->IsExceptionPending());
return NULL;
}
DCHECK(array_class->IsArrayClass());
- Array* new_array = Array::Alloc(soa.Self(), array_class, length);
+ mirror::Array* new_array = mirror::Array::Alloc(soa.Self(), array_class, length);
return soa.AddLocalReference<jobject>(new_array);
}
diff --git a/src/native/java_lang_reflect_Constructor.cc b/src/native/java_lang_reflect_Constructor.cc
index ed0d1f1..fb84dfd 100644
--- a/src/native/java_lang_reflect_Constructor.cc
+++ b/src/native/java_lang_reflect_Constructor.cc
@@ -16,7 +16,10 @@
#include "class_linker.h"
#include "jni_internal.h"
-#include "object.h"
+#include "mirror/class-inl.h"
+#include "mirror/abstract_method.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object-inl.h"
#include "object_utils.h"
#include "reflection.h"
#include "scoped_thread_state_change.h"
@@ -32,8 +35,8 @@
*/
static jobject Constructor_newInstance(JNIEnv* env, jobject javaMethod, jobjectArray javaArgs) {
ScopedObjectAccess soa(env);
- AbstractMethod* m = soa.Decode<Object*>(javaMethod)->AsMethod();
- Class* c = m->GetDeclaringClass();
+ mirror::AbstractMethod* m = soa.Decode<mirror::Object*>(javaMethod)->AsMethod();
+ mirror::Class* c = m->GetDeclaringClass();
if (c->IsAbstract()) {
soa.Self()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
"Can't instantiate abstract class %s", PrettyDescriptor(c).c_str());
@@ -45,7 +48,7 @@
return NULL;
}
- Object* receiver = c->AllocObject(soa.Self());
+ mirror::Object* receiver = c->AllocObject(soa.Self());
if (receiver == NULL) {
return NULL;
}
diff --git a/src/native/java_lang_reflect_Field.cc b/src/native/java_lang_reflect_Field.cc
index fde8f94..9a2671c 100644
--- a/src/native/java_lang_reflect_Field.cc
+++ b/src/native/java_lang_reflect_Field.cc
@@ -15,15 +15,17 @@
*/
#include "class_linker.h"
+#include "class_linker-inl.h"
#include "jni_internal.h"
-#include "object.h"
+#include "mirror/field.h"
+#include "mirror/field-inl.h"
#include "object_utils.h"
#include "reflection.h"
#include "scoped_thread_state_change.h"
namespace art {
-static bool GetFieldValue(const ScopedObjectAccess& soa, Object* o, Field* f,
+static bool GetFieldValue(const ScopedObjectAccess& soa, mirror::Object* o, mirror::Field* f,
JValue& value, bool allow_references)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK_EQ(value.GetJ(), 0LL);
@@ -72,16 +74,16 @@
return false;
}
-static bool CheckReceiver(const ScopedObjectAccess& soa, jobject javaObj, Field* f,
- Object*& o)
+static bool CheckReceiver(const ScopedObjectAccess& soa, jobject javaObj, mirror::Field* f,
+ mirror::Object*& o)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (f->IsStatic()) {
o = f->GetDeclaringClass();
return true;
}
- o = soa.Decode<Object*>(javaObj);
- Class* declaringClass = f->GetDeclaringClass();
+ o = soa.Decode<mirror::Object*>(javaObj);
+ mirror::Class* declaringClass = f->GetDeclaringClass();
if (!VerifyObjectInClass(o, declaringClass)) {
return false;
}
@@ -90,8 +92,8 @@
static jobject Field_get(JNIEnv* env, jobject javaField, jobject javaObj) {
ScopedObjectAccess soa(env);
- Field* f = soa.DecodeField(env->FromReflectedField(javaField));
- Object* o = NULL;
+ mirror::Field* f = soa.DecodeField(env->FromReflectedField(javaField));
+ mirror::Object* o = NULL;
if (!CheckReceiver(soa, javaObj, f, o)) {
return NULL;
}
@@ -107,8 +109,8 @@
static JValue GetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, char dst_descriptor) {
ScopedObjectAccess soa(env);
- Field* f = soa.DecodeField(env->FromReflectedField(javaField));
- Object* o = NULL;
+ mirror::Field* f = soa.DecodeField(env->FromReflectedField(javaField));
+ mirror::Object* o = NULL;
if (!CheckReceiver(soa, javaObj, f, o)) {
return JValue();
}
@@ -121,7 +123,7 @@
// Widen it if necessary (and possible).
JValue wide_value;
- Class* dst_type = Runtime::Current()->GetClassLinker()->FindPrimitiveClass(dst_descriptor);
+ mirror::Class* dst_type = Runtime::Current()->GetClassLinker()->FindPrimitiveClass(dst_descriptor);
if (!ConvertPrimitiveValue(FieldHelper(f).GetTypeAsPrimitiveType(), dst_type->GetPrimitiveType(),
field_value, wide_value)) {
return JValue();
@@ -161,7 +163,8 @@
return GetPrimitiveField(env, javaField, javaObj, 'S').GetS();
}
-static void SetFieldValue(Object* o, Field* f, const JValue& new_value, bool allow_references)
+static void SetFieldValue(mirror::Object* o, mirror::Field* f, const JValue& new_value,
+ bool allow_references)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(f->GetDeclaringClass(),
true, true)) {
@@ -214,17 +217,17 @@
static void Field_set(JNIEnv* env, jobject javaField, jobject javaObj, jobject javaValue) {
ScopedObjectAccess soa(env);
- Field* f = soa.DecodeField(env->FromReflectedField(javaField));
+ mirror::Field* f = soa.DecodeField(env->FromReflectedField(javaField));
// Unbox the value, if necessary.
- Object* boxed_value = soa.Decode<Object*>(javaValue);
+ mirror::Object* boxed_value = soa.Decode<mirror::Object*>(javaValue);
JValue unboxed_value;
if (!UnboxPrimitiveForField(boxed_value, FieldHelper(f).GetType(), unboxed_value, f)) {
return;
}
// Check that the receiver is non-null and an instance of the field's declaring class.
- Object* o = NULL;
+ mirror::Object* o = NULL;
if (!CheckReceiver(soa, javaObj, f, o)) {
return;
}
@@ -235,8 +238,8 @@
static void SetPrimitiveField(JNIEnv* env, jobject javaField, jobject javaObj, char src_descriptor,
const JValue& new_value) {
ScopedObjectAccess soa(env);
- Field* f = soa.DecodeField(env->FromReflectedField(javaField));
- Object* o = NULL;
+ mirror::Field* f = soa.DecodeField(env->FromReflectedField(javaField));
+ mirror::Object* o = NULL;
if (!CheckReceiver(soa, javaObj, f, o)) {
return;
}
@@ -249,7 +252,7 @@
// Widen the value if necessary (and possible).
JValue wide_value;
- Class* src_type = Runtime::Current()->GetClassLinker()->FindPrimitiveClass(src_descriptor);
+ mirror::Class* src_type = Runtime::Current()->GetClassLinker()->FindPrimitiveClass(src_descriptor);
if (!ConvertPrimitiveValue(src_type->GetPrimitiveType(), fh.GetTypeAsPrimitiveType(),
new_value, wide_value)) {
return;
diff --git a/src/native/java_lang_reflect_Method.cc b/src/native/java_lang_reflect_Method.cc
index b1eb6e0..14dc6a4 100644
--- a/src/native/java_lang_reflect_Method.cc
+++ b/src/native/java_lang_reflect_Method.cc
@@ -16,7 +16,12 @@
#include "class_linker.h"
#include "jni_internal.h"
-#include "object.h"
+#include "mirror/class-inl.h"
+#include "mirror/abstract_method.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
+#include "mirror/proxy.h"
#include "object_utils.h"
#include "reflection.h"
#include "scoped_thread_state_change.h"
@@ -30,10 +35,10 @@
static jobject Method_getExceptionTypesNative(JNIEnv* env, jobject javaMethod) {
ScopedObjectAccess soa(env);
- AbstractMethod* proxy_method = soa.Decode<Object*>(javaMethod)->AsMethod();
+ mirror::AbstractMethod* proxy_method = soa.Decode<mirror::Object*>(javaMethod)->AsMethod();
CHECK(proxy_method->GetDeclaringClass()->IsProxyClass());
- SynthesizedProxyClass* proxy_class =
- down_cast<SynthesizedProxyClass*>(proxy_method->GetDeclaringClass());
+ mirror::SynthesizedProxyClass* proxy_class =
+ down_cast<mirror::SynthesizedProxyClass*>(proxy_method->GetDeclaringClass());
int throws_index = -1;
size_t num_virt_methods = proxy_class->NumVirtualMethods();
for (size_t i = 0; i < num_virt_methods; i++) {
@@ -43,13 +48,13 @@
}
}
CHECK_NE(throws_index, -1);
- ObjectArray<Class>* declared_exceptions = proxy_class->GetThrows()->Get(throws_index);
+ mirror::ObjectArray<mirror::Class>* declared_exceptions = proxy_class->GetThrows()->Get(throws_index);
return soa.AddLocalReference<jobject>(declared_exceptions->Clone(soa.Self()));
}
static jobject Method_findOverriddenMethodNative(JNIEnv* env, jobject javaMethod) {
ScopedObjectAccess soa(env);
- AbstractMethod* method = soa.Decode<Object*>(javaMethod)->AsMethod();
+ mirror::AbstractMethod* method = soa.Decode<mirror::Object*>(javaMethod)->AsMethod();
return soa.AddLocalReference<jobject>(method->FindOverriddenMethod());
}
diff --git a/src/native/java_lang_reflect_Proxy.cc b/src/native/java_lang_reflect_Proxy.cc
index a567268..547ce7b 100644
--- a/src/native/java_lang_reflect_Proxy.cc
+++ b/src/native/java_lang_reflect_Proxy.cc
@@ -15,22 +15,28 @@
*/
#include "class_linker.h"
-#include "class_loader.h"
#include "jni_internal.h"
-#include "object.h"
+#include "mirror/class_loader.h"
+#include "mirror/object_array.h"
+#include "mirror/string.h"
#include "scoped_thread_state_change.h"
namespace art {
-static jclass Proxy_generateProxy(JNIEnv* env, jclass, jstring javaName, jobjectArray javaInterfaces, jobject javaLoader, jobjectArray javaMethods, jobjectArray javaThrows) {
+static jclass Proxy_generateProxy(JNIEnv* env, jclass, jstring javaName,
+ jobjectArray javaInterfaces, jobject javaLoader,
+ jobjectArray javaMethods, jobjectArray javaThrows) {
ScopedObjectAccess soa(env);
- String* name = soa.Decode<String*>(javaName);
- ObjectArray<Class>* interfaces = soa.Decode<ObjectArray<Class>*>(javaInterfaces);
- ClassLoader* loader = soa.Decode<ClassLoader*>(javaLoader);
- ObjectArray<AbstractMethod>* methods = soa.Decode<ObjectArray<AbstractMethod>*>(javaMethods);
- ObjectArray<ObjectArray<Class> >* throws = soa.Decode<ObjectArray<ObjectArray<Class> >*>(javaThrows);
+ mirror::String* name = soa.Decode<mirror::String*>(javaName);
+ mirror::ObjectArray<mirror::Class>* interfaces =
+ soa.Decode<mirror::ObjectArray<mirror::Class>*>(javaInterfaces);
+ mirror::ClassLoader* loader = soa.Decode<mirror::ClassLoader*>(javaLoader);
+ mirror::ObjectArray<mirror::AbstractMethod>* methods =
+ soa.Decode<mirror::ObjectArray<mirror::AbstractMethod>*>(javaMethods);
+ mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >* throws =
+ soa.Decode<mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >*>(javaThrows);
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- Class* result = class_linker->CreateProxyClass(name, interfaces, loader, methods, throws);
+ mirror::Class* result = class_linker->CreateProxyClass(name, interfaces, loader, methods, throws);
return soa.AddLocalReference<jclass>(result);
}
diff --git a/src/native/sun_misc_Unsafe.cc b/src/native/sun_misc_Unsafe.cc
index cb06a0b..abb0d5c 100644
--- a/src/native/sun_misc_Unsafe.cc
+++ b/src/native/sun_misc_Unsafe.cc
@@ -14,15 +14,18 @@
* limitations under the License.
*/
+#include "atomic.h"
+#include "gc/card_table-inl.h"
#include "jni_internal.h"
-#include "object.h"
+#include "mirror/object.h"
+#include "mirror/object-inl.h"
#include "scoped_thread_state_change.h"
namespace art {
static jboolean Unsafe_compareAndSwapInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint expectedValue, jint newValue) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
volatile int32_t* address = reinterpret_cast<volatile int32_t*>(raw_addr);
// Note: android_atomic_release_cas() returns 0 on success, not failure.
@@ -32,7 +35,7 @@
static jboolean Unsafe_compareAndSwapLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong expectedValue, jlong newValue) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
volatile int64_t* address = reinterpret_cast<volatile int64_t*>(raw_addr);
// Note: android_atomic_cmpxchg() returns 0 on success, not failure.
@@ -42,9 +45,9 @@
static jboolean Unsafe_compareAndSwapObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaExpectedValue, jobject javaNewValue) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
- Object* expectedValue = soa.Decode<Object*>(javaExpectedValue);
- Object* newValue = soa.Decode<Object*>(javaNewValue);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
+ mirror::Object* expectedValue = soa.Decode<mirror::Object*>(javaExpectedValue);
+ mirror::Object* newValue = soa.Decode<mirror::Object*>(javaNewValue);
byte* raw_addr = reinterpret_cast<byte*>(obj) + offset;
int32_t* address = reinterpret_cast<int32_t*>(raw_addr);
// Note: android_atomic_cmpxchg() returns 0 on success, not failure.
@@ -58,98 +61,98 @@
static jint Unsafe_getInt(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
return obj->GetField32(MemberOffset(offset), false);
}
static jint Unsafe_getIntVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
return obj->GetField32(MemberOffset(offset), true);
}
static void Unsafe_putInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint newValue) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
obj->SetField32(MemberOffset(offset), newValue, false);
}
static void Unsafe_putIntVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint newValue) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
obj->SetField32(MemberOffset(offset), newValue, true);
}
static void Unsafe_putOrderedInt(JNIEnv* env, jobject, jobject javaObj, jlong offset, jint newValue) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
ANDROID_MEMBAR_STORE();
obj->SetField32(MemberOffset(offset), newValue, false);
}
static jlong Unsafe_getLong(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
return obj->GetField64(MemberOffset(offset), false);
}
static jlong Unsafe_getLongVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
return obj->GetField64(MemberOffset(offset), true);
}
static void Unsafe_putLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong newValue) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
obj->SetField64(MemberOffset(offset), newValue, false);
}
static void Unsafe_putLongVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong newValue) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
obj->SetField64(MemberOffset(offset), newValue, true);
}
static void Unsafe_putOrderedLong(JNIEnv* env, jobject, jobject javaObj, jlong offset, jlong newValue) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
ANDROID_MEMBAR_STORE();
obj->SetField64(MemberOffset(offset), newValue, false);
}
static jobject Unsafe_getObjectVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
- Object* value = obj->GetFieldObject<Object*>(MemberOffset(offset), true);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
+ mirror::Object* value = obj->GetFieldObject<mirror::Object*>(MemberOffset(offset), true);
return soa.AddLocalReference<jobject>(value);
}
static jobject Unsafe_getObject(JNIEnv* env, jobject, jobject javaObj, jlong offset) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
- Object* value = obj->GetFieldObject<Object*>(MemberOffset(offset), false);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
+ mirror::Object* value = obj->GetFieldObject<mirror::Object*>(MemberOffset(offset), false);
return soa.AddLocalReference<jobject>(value);
}
static void Unsafe_putObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaNewValue) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
- Object* newValue = soa.Decode<Object*>(javaNewValue);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
+ mirror::Object* newValue = soa.Decode<mirror::Object*>(javaNewValue);
obj->SetFieldObject(MemberOffset(offset), newValue, false);
}
static void Unsafe_putObjectVolatile(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaNewValue) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
- Object* newValue = soa.Decode<Object*>(javaNewValue);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
+ mirror::Object* newValue = soa.Decode<mirror::Object*>(javaNewValue);
obj->SetFieldObject(MemberOffset(offset), newValue, true);
}
static void Unsafe_putOrderedObject(JNIEnv* env, jobject, jobject javaObj, jlong offset, jobject javaNewValue) {
ScopedObjectAccess soa(env);
- Object* obj = soa.Decode<Object*>(javaObj);
- Object* newValue = soa.Decode<Object*>(javaNewValue);
+ mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
+ mirror::Object* newValue = soa.Decode<mirror::Object*>(javaNewValue);
ANDROID_MEMBAR_STORE();
obj->SetFieldObject(MemberOffset(offset), newValue, false);
}