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/build/Android.common.mk b/build/Android.common.mk
index 1646264..21e829c 100644
--- a/build/Android.common.mk
+++ b/build/Android.common.mk
@@ -154,7 +154,6 @@
src/compiled_method.cc \
src/compiler.cc \
src/debugger.cc \
- src/dex_cache.cc \
src/dex_file.cc \
src/dex_file_verifier.cc \
src/dex_instruction.cc \
@@ -193,6 +192,15 @@
src/locks.cc \
src/mem_map.cc \
src/memory_region.cc \
+ src/mirror/abstract_method.cc \
+ src/mirror/array.cc \
+ src/mirror/class.cc \
+ src/mirror/dex_cache.cc \
+ src/mirror/field.cc \
+ src/mirror/object.cc \
+ src/mirror/stack_trace_element.cc \
+ src/mirror/string.cc \
+ src/mirror/throwable.cc \
src/monitor.cc \
src/native/dalvik_system_DexFile.cc \
src/native/dalvik_system_VMDebug.cc \
@@ -229,7 +237,6 @@
src/oat/utils/x86/managed_register_x86.cc \
src/oat_file.cc \
src/oat_writer.cc \
- src/object.cc \
src/offsets.cc \
src/os_linux.cc \
src/primitive.cc \
@@ -242,6 +249,7 @@
src/thread.cc \
src/thread_list.cc \
src/thread_pool.cc \
+ src/timing_logger.cc \
src/trace.cc \
src/utf.cc \
src/utils.cc \
@@ -354,6 +362,7 @@
src/compiler/compiler_enums.h \
src/dex_file.h \
src/dex_instruction.h \
+ src/gc/gc_type.h \
src/gc/space.h \
src/heap.h \
src/indirect_reference_table.h \
@@ -362,8 +371,9 @@
src/jdwp/jdwp.h \
src/jdwp/jdwp_constants.h \
src/locks.h \
- src/object.h \
+ src/mirror/class.h \
src/thread.h \
+ src/thread_state.h \
src/verifier/method_verifier.h
LIBARTTEST_COMMON_SRC_FILES := \
@@ -380,7 +390,6 @@
src/base/unix_file/string_file_test.cc \
src/class_linker_test.cc \
src/compiler_test.cc \
- src/dex_cache_test.cc \
src/dex_file_test.cc \
src/dex_instruction_visitor_test.cc \
src/elf_writer_test.cc \
@@ -395,10 +404,11 @@
src/intern_table_test.cc \
src/jni_compiler_test.cc \
src/jni_internal_test.cc \
+ src/mirror/dex_cache_test.cc \
+ src/mirror/object_test.cc \
src/oat/utils/arm/managed_register_arm_test.cc \
src/oat/utils/x86/managed_register_x86_test.cc \
src/oat_test.cc \
- src/object_test.cc \
src/output_stream_test.cc \
src/reference_table_test.cc \
src/runtime_support_test.cc \
diff --git a/src/barrier_test.cc b/src/barrier_test.cc
index 284be57..bb7bcb3 100644
--- a/src/barrier_test.cc
+++ b/src/barrier_test.cc
@@ -20,6 +20,7 @@
#include "atomic_integer.h"
#include "common_test.h"
+#include "mirror/object_array-inl.h"
#include "thread_pool.h"
#include "UniquePtr.h"
diff --git a/src/base/mutex.cc b/src/base/mutex.cc
index e2ab51f..d09a6a2 100644
--- a/src/base/mutex.cc
+++ b/src/base/mutex.cc
@@ -21,7 +21,6 @@
#include "base/logging.h"
#include "cutils/atomic.h"
-#include "cutils/atomic-inline.h"
#include "runtime.h"
#include "scoped_thread_state_change.h"
#include "thread.h"
diff --git a/src/check_jni.cc b/src/check_jni.cc
index 8f4e921..e53e1c4 100644
--- a/src/check_jni.cc
+++ b/src/check_jni.cc
@@ -21,9 +21,16 @@
#include "base/logging.h"
#include "class_linker.h"
+#include "class_linker-inl.h"
+#include "gc/space.h"
+#include "mirror/class-inl.h"
+#include "mirror/field-inl.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
+#include "mirror/throwable.h"
#include "object_utils.h"
#include "scoped_thread_state_change.h"
-#include "gc/space.h"
#include "thread.h"
#include "runtime.h"
@@ -36,7 +43,7 @@
static void JniAbort(const char* jni_function_name, const char* msg) {
Thread* self = Thread::Current();
ScopedObjectAccess soa(self);
- AbstractMethod* current_method = self->GetCurrentMethod();
+ mirror::AbstractMethod* current_method = self->GetCurrentMethod();
std::ostringstream os;
os << "JNI DETECTED ERROR IN APPLICATION: " << msg;
@@ -123,7 +130,7 @@
NULL
};
-static bool ShouldTrace(JavaVMExt* vm, const AbstractMethod* method)
+static bool ShouldTrace(JavaVMExt* vm, const mirror::AbstractMethod* method)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// If both "-Xcheck:jni" and "-Xjnitrace:" are enabled, we print trace messages
// when a native method that matches the -Xjnitrace argument calls a JNI function
@@ -196,14 +203,14 @@
*/
void CheckFieldType(jobject java_object, jfieldID fid, char prim, bool isStatic)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* f = CheckFieldID(fid);
+ mirror::Field* f = CheckFieldID(fid);
if (f == NULL) {
return;
}
- Class* field_type = FieldHelper(f).GetType();
+ mirror::Class* field_type = FieldHelper(f).GetType();
if (!field_type->IsPrimitive()) {
if (java_object != NULL) {
- Object* obj = soa_.Decode<Object*>(java_object);
+ mirror::Object* obj = soa_.Decode<mirror::Object*>(java_object);
// If java_object is a weak global ref whose referent has been cleared,
// obj will be NULL. Otherwise, obj should always be non-NULL
// and valid.
@@ -243,7 +250,7 @@
*/
void CheckInstanceFieldID(jobject java_object, jfieldID fid)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Object* o = soa_.Decode<Object*>(java_object);
+ mirror::Object* o = soa_.Decode<mirror::Object*>(java_object);
if (o == NULL || !Runtime::Current()->GetHeap()->IsHeapAddress(o)) {
Runtime::Current()->GetHeap()->DumpSpaces();
JniAbortF(function_name_, "field operation on invalid %s: %p",
@@ -251,11 +258,11 @@
return;
}
- Field* f = CheckFieldID(fid);
+ mirror::Field* f = CheckFieldID(fid);
if (f == NULL) {
return;
}
- Class* c = o->GetClass();
+ mirror::Class* c = o->GetClass();
FieldHelper fh(f);
if (c->FindInstanceField(fh.GetName(), fh.GetTypeDescriptor()) == NULL) {
JniAbortF(function_name_, "jfieldID %s not valid for an object of class %s",
@@ -278,7 +285,7 @@
*/
void CheckSig(jmethodID mid, const char* expectedType, bool isStatic)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* m = CheckMethodID(mid);
+ mirror::AbstractMethod* m = CheckMethodID(mid);
if (m == NULL) {
return;
}
@@ -304,8 +311,8 @@
*/
void CheckStaticFieldID(jclass java_class, jfieldID fid)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Class* c = soa_.Decode<Class*>(java_class);
- const Field* f = CheckFieldID(fid);
+ mirror::Class* c = soa_.Decode<mirror::Class*>(java_class);
+ const mirror::Field* f = CheckFieldID(fid);
if (f == NULL) {
return;
}
@@ -326,11 +333,11 @@
*/
void CheckStaticMethod(jclass java_class, jmethodID mid)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- const AbstractMethod* m = CheckMethodID(mid);
+ const mirror::AbstractMethod* m = CheckMethodID(mid);
if (m == NULL) {
return;
}
- Class* c = soa_.Decode<Class*>(java_class);
+ mirror::Class* c = soa_.Decode<mirror::Class*>(java_class);
if (!c->IsAssignableFrom(m->GetDeclaringClass())) {
JniAbortF(function_name_, "can't call static %s on class %s",
PrettyMethod(m).c_str(), PrettyClass(c).c_str());
@@ -346,11 +353,11 @@
*/
void CheckVirtualMethod(jobject java_object, jmethodID mid)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- const AbstractMethod* m = CheckMethodID(mid);
+ const mirror::AbstractMethod* m = CheckMethodID(mid);
if (m == NULL) {
return;
}
- Object* o = soa_.Decode<Object*>(java_object);
+ mirror::Object* o = soa_.Decode<mirror::Object*>(java_object);
if (!o->InstanceOf(m->GetDeclaringClass())) {
JniAbortF(function_name_, "can't call %s on instance of %s",
PrettyMethod(m).c_str(), PrettyTypeOf(o).c_str());
@@ -397,7 +404,7 @@
SHARED_LOCKS_REQUIRED (Locks::mutator_lock_) {
va_list ap;
- const AbstractMethod* traceMethod = NULL;
+ const mirror::AbstractMethod* traceMethod = NULL;
if ((!soa_.Vm()->trace.empty() || VLOG_IS_ON(third_party_jni)) && has_method_) {
// We need to guard some of the invocation interface's calls: a bad caller might
// use DetachCurrentThread or GetEnv on a thread that's not yet attached.
@@ -455,7 +462,7 @@
msg += (b ? "JNI_TRUE" : "JNI_FALSE");
} else if (ch == 'c') { // jclass
jclass jc = va_arg(ap, jclass);
- Class* c = reinterpret_cast<Class*>(Thread::Current()->DecodeJObject(jc));
+ mirror::Class* c = reinterpret_cast<mirror::Class*>(Thread::Current()->DecodeJObject(jc));
if (c == NULL) {
msg += "NULL";
} else if (c == kInvalidIndirectRefObject || !Runtime::Current()->GetHeap()->IsHeapAddress(c)) {
@@ -470,7 +477,7 @@
}
} else if (ch == 'f') { // jfieldID
jfieldID fid = va_arg(ap, jfieldID);
- Field* f = reinterpret_cast<Field*>(fid);
+ mirror::Field* f = reinterpret_cast<mirror::Field*>(fid);
msg += PrettyField(f);
if (!entry) {
StringAppendF(&msg, " (%p)", fid);
@@ -483,7 +490,7 @@
StringAppendF(&msg, "%d", i);
} else if (ch == 'm') { // jmethodID
jmethodID mid = va_arg(ap, jmethodID);
- AbstractMethod* m = reinterpret_cast<AbstractMethod*>(mid);
+ mirror::AbstractMethod* m = reinterpret_cast<mirror::AbstractMethod*>(mid);
msg += PrettyMethod(m);
if (!entry) {
StringAppendF(&msg, " (%p)", mid);
@@ -623,7 +630,7 @@
return false;
}
- Object* obj = soa_.Decode<Object*>(java_object);
+ mirror::Object* obj = soa_.Decode<mirror::Object*>(java_object);
if (!Runtime::Current()->GetHeap()->IsHeapAddress(obj)) {
Runtime::Current()->GetHeap()->DumpSpaces();
JniAbortF(function_name_, "%s is an invalid %s: %p (%p)",
@@ -677,7 +684,7 @@
return;
}
- Array* a = soa_.Decode<Array*>(java_array);
+ mirror::Array* a = soa_.Decode<mirror::Array*>(java_array);
if (!Runtime::Current()->GetHeap()->IsHeapAddress(a)) {
Runtime::Current()->GetHeap()->DumpSpaces();
JniAbortF(function_name_, "jarray is an invalid %s: %p (%p)",
@@ -693,12 +700,12 @@
}
}
- Field* CheckFieldID(jfieldID fid) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ mirror::Field* CheckFieldID(jfieldID fid) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (fid == NULL) {
JniAbortF(function_name_, "jfieldID was NULL");
return NULL;
}
- Field* f = soa_.DecodeField(fid);
+ mirror::Field* f = soa_.DecodeField(fid);
if (!Runtime::Current()->GetHeap()->IsHeapAddress(f) || !f->IsField()) {
Runtime::Current()->GetHeap()->DumpSpaces();
JniAbortF(function_name_, "invalid jfieldID: %p", fid);
@@ -707,12 +714,12 @@
return f;
}
- AbstractMethod* CheckMethodID(jmethodID mid) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ mirror::AbstractMethod* CheckMethodID(jmethodID mid) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (mid == NULL) {
JniAbortF(function_name_, "jmethodID was NULL");
return NULL;
}
- AbstractMethod* m = soa_.DecodeMethod(mid);
+ mirror::AbstractMethod* m = soa_.DecodeMethod(mid);
if (!Runtime::Current()->GetHeap()->IsHeapAddress(m) || !m->IsMethod()) {
Runtime::Current()->GetHeap()->DumpSpaces();
JniAbortF(function_name_, "invalid jmethodID: %p", mid);
@@ -733,7 +740,7 @@
return;
}
- Object* o = soa_.Decode<Object*>(java_object);
+ mirror::Object* o = soa_.Decode<mirror::Object*>(java_object);
if (!Runtime::Current()->GetHeap()->IsHeapAddress(o)) {
Runtime::Current()->GetHeap()->DumpSpaces();
// TODO: when we remove work_around_app_jni_bugs, this should be impossible.
@@ -1084,7 +1091,7 @@
static void* CreateGuardedPACopy(JNIEnv* env, const jarray java_array, jboolean* isCopy) {
ScopedObjectAccess soa(env);
- Array* a = soa.Decode<Array*>(java_array);
+ mirror::Array* a = soa.Decode<mirror::Array*>(java_array);
size_t component_size = a->GetClass()->GetComponentSize();
size_t byte_count = a->GetLength() * component_size;
void* result = GuardedCopy::Create(a->GetRawData(component_size), byte_count, true);
@@ -1104,7 +1111,7 @@
}
ScopedObjectAccess soa(env);
- Array* a = soa.Decode<Array*>(java_array);
+ mirror::Array* a = soa.Decode<mirror::Array*>(java_array);
GuardedCopy::Check(__FUNCTION__, dataBuf, true);
@@ -1467,7 +1474,7 @@
#define NON_VOID_RETURN(_retsig, _ctype) return CHECK_JNI_EXIT(_retsig, (_ctype) result)
#define VOID_RETURN CHECK_JNI_EXIT_VOID()
-CALL(jobject, Object, Object* result, result = reinterpret_cast<Object*>, NON_VOID_RETURN("L", jobject), "L");
+CALL(jobject, Object, mirror::Object* result, result = reinterpret_cast<mirror::Object*>, NON_VOID_RETURN("L", jobject), "L");
CALL(jboolean, Boolean, jboolean result, result =, NON_VOID_RETURN("Z", jboolean), "Z");
CALL(jbyte, Byte, jbyte result, result =, NON_VOID_RETURN("B", jbyte), "B");
CALL(jchar, Char, jchar result, result =, NON_VOID_RETURN("C", jchar), "C");
@@ -1492,7 +1499,7 @@
CHECK_JNI_ENTRY(kFlag_CritOkay, "Esp", env, java_string, isCopy);
const jchar* result = baseEnv(env)->GetStringChars(env, java_string, isCopy);
if (sc.ForceCopy() && result != NULL) {
- String* s = sc.soa().Decode<String*>(java_string);
+ mirror::String* s = sc.soa().Decode<mirror::String*>(java_string);
int byteCount = s->GetLength() * 2;
result = (const jchar*) GuardedCopy::Create(result, byteCount, false);
if (isCopy != NULL) {
@@ -1719,7 +1726,7 @@
CHECK_JNI_ENTRY(kFlag_CritGet, "Esp", env, java_string, isCopy);
const jchar* result = baseEnv(env)->GetStringCritical(env, java_string, isCopy);
if (sc.ForceCopy() && result != NULL) {
- String* s = sc.soa().Decode<String*>(java_string);
+ mirror::String* s = sc.soa().Decode<mirror::String*>(java_string);
int byteCount = s->GetLength() * 2;
result = (const jchar*) GuardedCopy::Create(result, byteCount, false);
if (isCopy != NULL) {
diff --git a/src/class_linker-inl.h b/src/class_linker-inl.h
new file mode 100644
index 0000000..6cf4991
--- /dev/null
+++ b/src/class_linker-inl.h
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2011 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_CLASS_LINKER_INL_H_
+#define ART_SRC_CLASS_LINKER_INL_H_
+
+#include "class_linker.h"
+
+#include "mirror/dex_cache.h"
+#include "mirror/field.h"
+#include "mirror/iftable.h"
+#include "mirror/object_array.h"
+
+namespace art {
+
+inline mirror::String* ClassLinker::ResolveString(uint32_t string_idx,
+ const mirror::AbstractMethod* referrer) {
+ mirror::String* resolved_string = referrer->GetDexCacheStrings()->Get(string_idx);
+ if (UNLIKELY(resolved_string == NULL)) {
+ mirror::Class* declaring_class = referrer->GetDeclaringClass();
+ mirror::DexCache* dex_cache = declaring_class->GetDexCache();
+ const DexFile& dex_file = *dex_cache->GetDexFile();
+ resolved_string = ResolveString(dex_file, string_idx, dex_cache);
+ }
+ return resolved_string;
+}
+
+inline mirror::Class* ClassLinker::ResolveType(uint16_t type_idx,
+ const mirror::AbstractMethod* referrer) {
+ mirror::Class* resolved_type = referrer->GetDexCacheResolvedTypes()->Get(type_idx);
+ if (UNLIKELY(resolved_type == NULL)) {
+ mirror::Class* declaring_class = referrer->GetDeclaringClass();
+ mirror::DexCache* dex_cache = declaring_class->GetDexCache();
+ mirror::ClassLoader* class_loader = declaring_class->GetClassLoader();
+ const DexFile& dex_file = *dex_cache->GetDexFile();
+ resolved_type = ResolveType(dex_file, type_idx, dex_cache, class_loader);
+ }
+ return resolved_type;
+}
+
+inline mirror::Class* ClassLinker::ResolveType(uint16_t type_idx, const mirror::Field* referrer) {
+ mirror::Class* declaring_class = referrer->GetDeclaringClass();
+ mirror::DexCache* dex_cache = declaring_class->GetDexCache();
+ mirror::Class* resolved_type = dex_cache->GetResolvedType(type_idx);
+ if (UNLIKELY(resolved_type == NULL)) {
+ mirror::ClassLoader* class_loader = declaring_class->GetClassLoader();
+ const DexFile& dex_file = *dex_cache->GetDexFile();
+ resolved_type = ResolveType(dex_file, type_idx, dex_cache, class_loader);
+ }
+ return resolved_type;
+}
+
+inline mirror::AbstractMethod* ClassLinker::ResolveMethod(uint32_t method_idx,
+ const mirror::AbstractMethod* referrer,
+ InvokeType type) {
+ mirror::AbstractMethod* resolved_method =
+ referrer->GetDexCacheResolvedMethods()->Get(method_idx);
+ if (UNLIKELY(resolved_method == NULL || resolved_method->IsRuntimeMethod())) {
+ mirror::Class* declaring_class = referrer->GetDeclaringClass();
+ mirror::DexCache* dex_cache = declaring_class->GetDexCache();
+ mirror::ClassLoader* class_loader = declaring_class->GetClassLoader();
+ const DexFile& dex_file = *dex_cache->GetDexFile();
+ resolved_method = ResolveMethod(dex_file, method_idx, dex_cache, class_loader, referrer, type);
+ }
+ return resolved_method;
+}
+
+inline mirror::Field* ClassLinker::ResolveField(uint32_t field_idx,
+ const mirror::AbstractMethod* referrer,
+ bool is_static) {
+ mirror::Field* resolved_field =
+ referrer->GetDeclaringClass()->GetDexCache()->GetResolvedField(field_idx);
+ if (UNLIKELY(resolved_field == NULL)) {
+ mirror::Class* declaring_class = referrer->GetDeclaringClass();
+ mirror::DexCache* dex_cache = declaring_class->GetDexCache();
+ mirror::ClassLoader* class_loader = declaring_class->GetClassLoader();
+ const DexFile& dex_file = *dex_cache->GetDexFile();
+ resolved_field = ResolveField(dex_file, field_idx, dex_cache, class_loader, is_static);
+ }
+ return resolved_field;
+}
+
+template <class T>
+inline mirror::ObjectArray<T>* ClassLinker::AllocObjectArray(Thread* self, size_t length) {
+ return mirror::ObjectArray<T>::Alloc(self, GetClassRoot(kObjectArrayClass), length);
+}
+
+inline mirror::ObjectArray<mirror::Class>* ClassLinker::AllocClassArray(Thread* self,
+ size_t length) {
+ return mirror::ObjectArray<mirror::Class>::Alloc(self, GetClassRoot(kClassArrayClass), length);
+}
+
+inline mirror::ObjectArray<mirror::String>* ClassLinker::AllocStringArray(Thread* self,
+ size_t length) {
+ return mirror::ObjectArray<mirror::String>::Alloc(self, GetClassRoot(kJavaLangStringArrayClass),
+ length);
+}
+
+inline mirror::ObjectArray<mirror::AbstractMethod>* ClassLinker::AllocAbstractMethodArray(Thread* self,
+ size_t length) {
+ return mirror::ObjectArray<mirror::AbstractMethod>::Alloc(self,
+ GetClassRoot(kJavaLangReflectAbstractMethodArrayClass), length);
+}
+
+inline mirror::ObjectArray<mirror::AbstractMethod>* ClassLinker::AllocMethodArray(Thread* self,
+ size_t length) {
+ return mirror::ObjectArray<mirror::AbstractMethod>::Alloc(self,
+ GetClassRoot(kJavaLangReflectMethodArrayClass), length);
+}
+
+inline mirror::IfTable* ClassLinker::AllocIfTable(Thread* self, size_t ifcount) {
+ return down_cast<mirror::IfTable*>(
+ mirror::IfTable::Alloc(self, GetClassRoot(kObjectArrayClass), ifcount * mirror::IfTable::kMax));
+}
+
+inline mirror::ObjectArray<mirror::Field>* ClassLinker::AllocFieldArray(Thread* self,
+ size_t length) {
+ return mirror::ObjectArray<mirror::Field>::Alloc(self,
+ GetClassRoot(kJavaLangReflectFieldArrayClass),
+ length);
+}
+
+inline mirror::Class* ClassLinker::GetClassRoot(ClassRoot class_root)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ DCHECK(class_roots_ != NULL);
+ mirror::Class* klass = class_roots_->Get(class_root);
+ DCHECK(klass != NULL);
+ return klass;
+}
+
+} // namespace art
+
+#endif // ART_SRC_CLASS_LINKER_INL_H_
diff --git a/src/class_linker.cc b/src/class_linker.cc
index c43c397..9aa4dda 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -31,17 +31,28 @@
#include "base/logging.h"
#include "base/stl_util.h"
#include "base/unix_file/fd_file.h"
-#include "class_loader.h"
+#include "class_linker-inl.h"
#include "debugger.h"
-#include "dex_cache.h"
#include "dex_file.h"
+#include "gc/card_table-inl.h"
#include "heap.h"
#include "intern_table.h"
#include "interpreter/interpreter.h"
#include "leb128.h"
#include "oat.h"
#include "oat_file.h"
-#include "object.h"
+#include "mirror/class.h"
+#include "mirror/class-inl.h"
+#include "mirror/class_loader.h"
+#include "mirror/dex_cache.h"
+#include "mirror/field-inl.h"
+#include "mirror/iftable-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 "mirror/stack_trace_element.h"
#include "object_utils.h"
#include "os.h"
#include "runtime.h"
@@ -58,6 +69,7 @@
#include "thread.h"
#include "UniquePtr.h"
#include "utils.h"
+#include "verifier/method_verifier.h"
#include "well_known_classes.h"
namespace art {
@@ -92,7 +104,7 @@
va_end(args);
}
-static void ThrowNoSuchFieldError(const StringPiece& scope, Class* c, const StringPiece& type,
+static void ThrowNoSuchFieldError(const StringPiece& scope, mirror::Class* c, const StringPiece& type,
const StringPiece& name)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
ClassHelper kh(c);
@@ -116,7 +128,7 @@
va_end(args);
}
-static void ThrowEarlierClassFailure(Class* c)
+static void ThrowEarlierClassFailure(mirror::Class* c)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// The class failed to initialize on a previous attempt, so we want to throw
// a NoClassDefFoundError (v2 2.17.5). The exception to this rule is if we
@@ -239,45 +251,47 @@
// java_lang_Class comes first, it's needed for AllocClass
Thread* self = Thread::Current();
Heap* heap = Runtime::Current()->GetHeap();
- SirtRef<Class>
- java_lang_Class(self, down_cast<Class*>(heap->AllocObject(self, NULL, sizeof(ClassClass))));
+ SirtRef<mirror::Class>
+ java_lang_Class(self,
+ down_cast<mirror::Class*>(heap->AllocObject(self, NULL,
+ sizeof(mirror::ClassClass))));
CHECK(java_lang_Class.get() != NULL);
- Class::SetClassClass(java_lang_Class.get());
+ mirror::Class::SetClassClass(java_lang_Class.get());
java_lang_Class->SetClass(java_lang_Class.get());
- java_lang_Class->SetClassSize(sizeof(ClassClass));
- // AllocClass(Class*) can now be used
+ java_lang_Class->SetClassSize(sizeof(mirror::ClassClass));
+ // AllocClass(mirror::Class*) can now be used
// Class[] is used for reflection support.
- SirtRef<Class> class_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
+ SirtRef<mirror::Class> class_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
class_array_class->SetComponentType(java_lang_Class.get());
// java_lang_Object comes next so that object_array_class can be created.
- SirtRef<Class> java_lang_Object(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
+ SirtRef<mirror::Class> java_lang_Object(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
CHECK(java_lang_Object.get() != NULL);
// backfill Object as the super class of Class.
java_lang_Class->SetSuperClass(java_lang_Object.get());
- java_lang_Object->SetStatus(Class::kStatusLoaded);
+ java_lang_Object->SetStatus(mirror::Class::kStatusLoaded);
// Object[] next to hold class roots.
- SirtRef<Class> object_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
+ SirtRef<mirror::Class> object_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
object_array_class->SetComponentType(java_lang_Object.get());
// Setup the char class to be used for char[].
- SirtRef<Class> char_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
+ SirtRef<mirror::Class> char_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
// Setup the char[] class to be used for String.
- SirtRef<Class> char_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
+ SirtRef<mirror::Class> char_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
char_array_class->SetComponentType(char_class.get());
- CharArray::SetArrayClass(char_array_class.get());
+ mirror::CharArray::SetArrayClass(char_array_class.get());
// Setup String.
- SirtRef<Class> java_lang_String(self, AllocClass(self, java_lang_Class.get(), sizeof(StringClass)));
- String::SetClass(java_lang_String.get());
- java_lang_String->SetObjectSize(sizeof(String));
- java_lang_String->SetStatus(Class::kStatusResolved);
+ SirtRef<mirror::Class> java_lang_String(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::StringClass)));
+ mirror::String::SetClass(java_lang_String.get());
+ java_lang_String->SetObjectSize(sizeof(mirror::String));
+ java_lang_String->SetStatus(mirror::Class::kStatusResolved);
// Create storage for root classes, save away our work so far (requires descriptors).
- class_roots_ = ObjectArray<Class>::Alloc(self, object_array_class.get(), kClassRootsMax);
+ class_roots_ = mirror::ObjectArray<mirror::Class>::Alloc(self, object_array_class.get(), kClassRootsMax);
CHECK(class_roots_ != NULL);
SetClassRoot(kJavaLangClass, java_lang_Class.get());
SetClassRoot(kJavaLangObject, java_lang_Object.get());
@@ -300,68 +314,69 @@
array_iftable_ = AllocIfTable(self, 2);
// Create int array type for AllocDexCache (done in AppendToBootClassPath).
- SirtRef<Class> int_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
+ SirtRef<mirror::Class> int_array_class(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
int_array_class->SetComponentType(GetClassRoot(kPrimitiveInt));
- IntArray::SetArrayClass(int_array_class.get());
+ mirror::IntArray::SetArrayClass(int_array_class.get());
SetClassRoot(kIntArrayClass, int_array_class.get());
// now that these are registered, we can use AllocClass() and AllocObjectArray
// Set up DexCache. This cannot be done later since AppendToBootClassPath calls AllocDexCache.
- SirtRef<Class>
- java_lang_DexCache(self, AllocClass(self, java_lang_Class.get(), sizeof(DexCacheClass)));
+ SirtRef<mirror::Class>
+ java_lang_DexCache(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::DexCacheClass)));
SetClassRoot(kJavaLangDexCache, java_lang_DexCache.get());
- java_lang_DexCache->SetObjectSize(sizeof(DexCacheClass));
- java_lang_DexCache->SetStatus(Class::kStatusResolved);
+ java_lang_DexCache->SetObjectSize(sizeof(mirror::DexCacheClass));
+ java_lang_DexCache->SetStatus(mirror::Class::kStatusResolved);
// Constructor, Field, Method, and AbstractMethod are necessary so that FindClass can link members.
- SirtRef<Class> java_lang_reflect_Field(self, AllocClass(self, java_lang_Class.get(),
- sizeof(FieldClass)));
+ SirtRef<mirror::Class> java_lang_reflect_Field(self, AllocClass(self, java_lang_Class.get(),
+ sizeof(mirror::FieldClass)));
CHECK(java_lang_reflect_Field.get() != NULL);
- java_lang_reflect_Field->SetObjectSize(sizeof(Field));
+ java_lang_reflect_Field->SetObjectSize(sizeof(mirror::Field));
SetClassRoot(kJavaLangReflectField, java_lang_reflect_Field.get());
- java_lang_reflect_Field->SetStatus(Class::kStatusResolved);
- Field::SetClass(java_lang_reflect_Field.get());
+ java_lang_reflect_Field->SetStatus(mirror::Class::kStatusResolved);
+ mirror::Field::SetClass(java_lang_reflect_Field.get());
- SirtRef<Class> java_lang_reflect_AbstractMethod(self, AllocClass(self, java_lang_Class.get(),
- sizeof(MethodClass)));
+ SirtRef<mirror::Class> java_lang_reflect_AbstractMethod(self, AllocClass(self, java_lang_Class.get(),
+ sizeof(mirror::AbstractMethodClass)));
CHECK(java_lang_reflect_AbstractMethod.get() != NULL);
- java_lang_reflect_AbstractMethod->SetObjectSize(sizeof(AbstractMethod));
+ java_lang_reflect_AbstractMethod->SetObjectSize(sizeof(mirror::AbstractMethod));
SetClassRoot(kJavaLangReflectAbstractMethod, java_lang_reflect_AbstractMethod.get());
- java_lang_reflect_AbstractMethod->SetStatus(Class::kStatusResolved);
+ java_lang_reflect_AbstractMethod->SetStatus(mirror::Class::kStatusResolved);
- SirtRef<Class> java_lang_reflect_Constructor(self, AllocClass(self, java_lang_Class.get(),
- sizeof(MethodClass)));
+ SirtRef<mirror::Class> java_lang_reflect_Constructor(self, AllocClass(self, java_lang_Class.get(),
+ sizeof(mirror::AbstractMethodClass)));
CHECK(java_lang_reflect_Constructor.get() != NULL);
- java_lang_reflect_Constructor->SetObjectSize(sizeof(Constructor));
+ java_lang_reflect_Constructor->SetObjectSize(sizeof(mirror::Constructor));
java_lang_reflect_Constructor->SetSuperClass(java_lang_reflect_AbstractMethod.get());
SetClassRoot(kJavaLangReflectConstructor, java_lang_reflect_Constructor.get());
- java_lang_reflect_Constructor->SetStatus(Class::kStatusResolved);
+ java_lang_reflect_Constructor->SetStatus(mirror::Class::kStatusResolved);
- SirtRef<Class> java_lang_reflect_Method(self, AllocClass(self, java_lang_Class.get(),
- sizeof(MethodClass)));
+ SirtRef<mirror::Class> java_lang_reflect_Method(self, AllocClass(self, java_lang_Class.get(),
+ sizeof(mirror::AbstractMethodClass)));
CHECK(java_lang_reflect_Method.get() != NULL);
- java_lang_reflect_Method->SetObjectSize(sizeof(Method));
+ java_lang_reflect_Method->SetObjectSize(sizeof(mirror::Method));
java_lang_reflect_Method->SetSuperClass(java_lang_reflect_AbstractMethod.get());
SetClassRoot(kJavaLangReflectMethod, java_lang_reflect_Method.get());
- java_lang_reflect_Method->SetStatus(Class::kStatusResolved);
+ java_lang_reflect_Method->SetStatus(mirror::Class::kStatusResolved);
- AbstractMethod::SetClasses(java_lang_reflect_Constructor.get(), java_lang_reflect_Method.get());
+ mirror::AbstractMethod::SetClasses(java_lang_reflect_Constructor.get(),
+ java_lang_reflect_Method.get());
// Set up array classes for string, field, method
- SirtRef<Class> object_array_string(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
+ SirtRef<mirror::Class> object_array_string(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
object_array_string->SetComponentType(java_lang_String.get());
SetClassRoot(kJavaLangStringArrayClass, object_array_string.get());
- SirtRef<Class> object_array_abstract_method(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
+ SirtRef<mirror::Class> object_array_abstract_method(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
object_array_abstract_method->SetComponentType(java_lang_reflect_AbstractMethod.get());
SetClassRoot(kJavaLangReflectAbstractMethodArrayClass, object_array_abstract_method.get());
- SirtRef<Class> object_array_field(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
+ SirtRef<mirror::Class> object_array_field(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
object_array_field->SetComponentType(java_lang_reflect_Field.get());
SetClassRoot(kJavaLangReflectFieldArrayClass, object_array_field.get());
- SirtRef<Class> object_array_method(self, AllocClass(self, java_lang_Class.get(), sizeof(Class)));
+ SirtRef<mirror::Class> object_array_method(self, AllocClass(self, java_lang_Class.get(), sizeof(mirror::Class)));
object_array_method->SetComponentType(java_lang_reflect_Method.get());
SetClassRoot(kJavaLangReflectMethodArrayClass, object_array_method.get());
@@ -382,55 +397,55 @@
SetClassRoot(kPrimitiveChar, char_class.get()); // needs descriptor
// Object, String and DexCache need to be rerun through FindSystemClass to finish init
- java_lang_Object->SetStatus(Class::kStatusNotReady);
- Class* Object_class = FindSystemClass("Ljava/lang/Object;");
+ java_lang_Object->SetStatus(mirror::Class::kStatusNotReady);
+ mirror::Class* Object_class = FindSystemClass("Ljava/lang/Object;");
CHECK_EQ(java_lang_Object.get(), Object_class);
- CHECK_EQ(java_lang_Object->GetObjectSize(), sizeof(Object));
- java_lang_String->SetStatus(Class::kStatusNotReady);
- Class* String_class = FindSystemClass("Ljava/lang/String;");
+ CHECK_EQ(java_lang_Object->GetObjectSize(), sizeof(mirror::Object));
+ java_lang_String->SetStatus(mirror::Class::kStatusNotReady);
+ mirror::Class* String_class = FindSystemClass("Ljava/lang/String;");
CHECK_EQ(java_lang_String.get(), String_class);
- CHECK_EQ(java_lang_String->GetObjectSize(), sizeof(String));
- java_lang_DexCache->SetStatus(Class::kStatusNotReady);
- Class* DexCache_class = FindSystemClass("Ljava/lang/DexCache;");
+ CHECK_EQ(java_lang_String->GetObjectSize(), sizeof(mirror::String));
+ java_lang_DexCache->SetStatus(mirror::Class::kStatusNotReady);
+ mirror::Class* DexCache_class = FindSystemClass("Ljava/lang/DexCache;");
CHECK_EQ(java_lang_String.get(), String_class);
CHECK_EQ(java_lang_DexCache.get(), DexCache_class);
- CHECK_EQ(java_lang_DexCache->GetObjectSize(), sizeof(DexCache));
+ CHECK_EQ(java_lang_DexCache->GetObjectSize(), sizeof(mirror::DexCache));
// Setup the primitive array type classes - can't be done until Object has a vtable.
SetClassRoot(kBooleanArrayClass, FindSystemClass("[Z"));
- BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
+ mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
SetClassRoot(kByteArrayClass, FindSystemClass("[B"));
- ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
+ mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
- Class* found_char_array_class = FindSystemClass("[C");
+ mirror::Class* found_char_array_class = FindSystemClass("[C");
CHECK_EQ(char_array_class.get(), found_char_array_class);
SetClassRoot(kShortArrayClass, FindSystemClass("[S"));
- ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
+ mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
- Class* found_int_array_class = FindSystemClass("[I");
+ mirror::Class* found_int_array_class = FindSystemClass("[I");
CHECK_EQ(int_array_class.get(), found_int_array_class);
SetClassRoot(kLongArrayClass, FindSystemClass("[J"));
- LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
+ mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
SetClassRoot(kFloatArrayClass, FindSystemClass("[F"));
- FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
+ mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
SetClassRoot(kDoubleArrayClass, FindSystemClass("[D"));
- DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
+ mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
- Class* found_class_array_class = FindSystemClass("[Ljava/lang/Class;");
+ mirror::Class* found_class_array_class = FindSystemClass("[Ljava/lang/Class;");
CHECK_EQ(class_array_class.get(), found_class_array_class);
- Class* found_object_array_class = FindSystemClass("[Ljava/lang/Object;");
+ mirror::Class* found_object_array_class = FindSystemClass("[Ljava/lang/Object;");
CHECK_EQ(object_array_class.get(), found_object_array_class);
// Setup the single, global copy of "iftable".
- Class* java_lang_Cloneable = FindSystemClass("Ljava/lang/Cloneable;");
+ mirror::Class* java_lang_Cloneable = FindSystemClass("Ljava/lang/Cloneable;");
CHECK(java_lang_Cloneable != NULL);
- Class* java_io_Serializable = FindSystemClass("Ljava/io/Serializable;");
+ mirror::Class* java_io_Serializable = FindSystemClass("Ljava/io/Serializable;");
CHECK(java_io_Serializable != NULL);
// We assume that Cloneable/Serializable don't have superinterfaces -- normally we'd have to
// crawl up and explicitly list all of the supers as well.
@@ -446,79 +461,79 @@
CHECK_EQ(java_io_Serializable, kh.GetDirectInterface(1));
// Run Class, Constructor, Field, and Method through FindSystemClass. This initializes their
// dex_cache_ fields and register them in classes_.
- Class* Class_class = FindSystemClass("Ljava/lang/Class;");
+ mirror::Class* Class_class = FindSystemClass("Ljava/lang/Class;");
CHECK_EQ(java_lang_Class.get(), Class_class);
- java_lang_reflect_AbstractMethod->SetStatus(Class::kStatusNotReady);
- Class* Abstract_method_class = FindSystemClass("Ljava/lang/reflect/AbstractMethod;");
+ java_lang_reflect_AbstractMethod->SetStatus(mirror::Class::kStatusNotReady);
+ mirror::Class* Abstract_method_class = FindSystemClass("Ljava/lang/reflect/AbstractMethod;");
CHECK_EQ(java_lang_reflect_AbstractMethod.get(), Abstract_method_class);
// Method extends AbstractMethod so must reset after.
- java_lang_reflect_Method->SetStatus(Class::kStatusNotReady);
- Class* Method_class = FindSystemClass("Ljava/lang/reflect/Method;");
+ java_lang_reflect_Method->SetStatus(mirror::Class::kStatusNotReady);
+ mirror::Class* Method_class = FindSystemClass("Ljava/lang/reflect/Method;");
CHECK_EQ(java_lang_reflect_Method.get(), Method_class);
// Constructor extends AbstractMethod so must reset after.
- java_lang_reflect_Constructor->SetStatus(Class::kStatusNotReady);
- Class* Constructor_class = FindSystemClass("Ljava/lang/reflect/Constructor;");
+ java_lang_reflect_Constructor->SetStatus(mirror::Class::kStatusNotReady);
+ mirror::Class* Constructor_class = FindSystemClass("Ljava/lang/reflect/Constructor;");
CHECK_EQ(java_lang_reflect_Constructor.get(), Constructor_class);
- java_lang_reflect_Field->SetStatus(Class::kStatusNotReady);
- Class* Field_class = FindSystemClass("Ljava/lang/reflect/Field;");
+ java_lang_reflect_Field->SetStatus(mirror::Class::kStatusNotReady);
+ mirror::Class* Field_class = FindSystemClass("Ljava/lang/reflect/Field;");
CHECK_EQ(java_lang_reflect_Field.get(), Field_class);
- Class* String_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangStringArrayClass]);
+ mirror::Class* String_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangStringArrayClass]);
CHECK_EQ(object_array_string.get(), String_array_class);
- Class* Abstract_method_array_class =
+ mirror::Class* Abstract_method_array_class =
FindSystemClass(class_roots_descriptors_[kJavaLangReflectAbstractMethodArrayClass]);
CHECK_EQ(object_array_abstract_method.get(), Abstract_method_array_class);
- Class* Field_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangReflectFieldArrayClass]);
+ mirror::Class* Field_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangReflectFieldArrayClass]);
CHECK_EQ(object_array_field.get(), Field_array_class);
- Class* Method_array_class =
+ mirror::Class* Method_array_class =
FindSystemClass(class_roots_descriptors_[kJavaLangReflectMethodArrayClass]);
CHECK_EQ(object_array_method.get(), Method_array_class);
// End of special init trickery, subsequent classes may be loaded via FindSystemClass.
// Create java.lang.reflect.Proxy root.
- Class* java_lang_reflect_Proxy = FindSystemClass("Ljava/lang/reflect/Proxy;");
+ mirror::Class* java_lang_reflect_Proxy = FindSystemClass("Ljava/lang/reflect/Proxy;");
SetClassRoot(kJavaLangReflectProxy, java_lang_reflect_Proxy);
// java.lang.ref classes need to be specially flagged, but otherwise are normal classes
- Class* java_lang_ref_Reference = FindSystemClass("Ljava/lang/ref/Reference;");
+ mirror::Class* java_lang_ref_Reference = FindSystemClass("Ljava/lang/ref/Reference;");
SetClassRoot(kJavaLangRefReference, java_lang_ref_Reference);
- Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
+ mirror::Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
java_lang_ref_FinalizerReference->SetAccessFlags(
java_lang_ref_FinalizerReference->GetAccessFlags() |
kAccClassIsReference | kAccClassIsFinalizerReference);
- Class* java_lang_ref_PhantomReference = FindSystemClass("Ljava/lang/ref/PhantomReference;");
+ mirror::Class* java_lang_ref_PhantomReference = FindSystemClass("Ljava/lang/ref/PhantomReference;");
java_lang_ref_PhantomReference->SetAccessFlags(
java_lang_ref_PhantomReference->GetAccessFlags() |
kAccClassIsReference | kAccClassIsPhantomReference);
- Class* java_lang_ref_SoftReference = FindSystemClass("Ljava/lang/ref/SoftReference;");
+ mirror::Class* java_lang_ref_SoftReference = FindSystemClass("Ljava/lang/ref/SoftReference;");
java_lang_ref_SoftReference->SetAccessFlags(
java_lang_ref_SoftReference->GetAccessFlags() | kAccClassIsReference);
- Class* java_lang_ref_WeakReference = FindSystemClass("Ljava/lang/ref/WeakReference;");
+ mirror::Class* java_lang_ref_WeakReference = FindSystemClass("Ljava/lang/ref/WeakReference;");
java_lang_ref_WeakReference->SetAccessFlags(
java_lang_ref_WeakReference->GetAccessFlags() |
kAccClassIsReference | kAccClassIsWeakReference);
// Setup the ClassLoader, verifying the object_size_.
- Class* java_lang_ClassLoader = FindSystemClass("Ljava/lang/ClassLoader;");
- CHECK_EQ(java_lang_ClassLoader->GetObjectSize(), sizeof(ClassLoader));
+ mirror::Class* java_lang_ClassLoader = FindSystemClass("Ljava/lang/ClassLoader;");
+ CHECK_EQ(java_lang_ClassLoader->GetObjectSize(), sizeof(mirror::ClassLoader));
SetClassRoot(kJavaLangClassLoader, java_lang_ClassLoader);
// Set up java.lang.Throwable, java.lang.ClassNotFoundException, and
// java.lang.StackTraceElement as a convenience.
SetClassRoot(kJavaLangThrowable, FindSystemClass("Ljava/lang/Throwable;"));
- Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
+ mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
SetClassRoot(kJavaLangClassNotFoundException, FindSystemClass("Ljava/lang/ClassNotFoundException;"));
SetClassRoot(kJavaLangStackTraceElement, FindSystemClass("Ljava/lang/StackTraceElement;"));
SetClassRoot(kJavaLangStackTraceElementArrayClass, FindSystemClass("[Ljava/lang/StackTraceElement;"));
- StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
+ mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
FinishInit();
@@ -532,37 +547,37 @@
// Note: we hard code the field indexes here rather than using FindInstanceField
// as the types of the field can't be resolved prior to the runtime being
// fully initialized
- Class* java_lang_ref_Reference = GetClassRoot(kJavaLangRefReference);
- Class* java_lang_ref_ReferenceQueue = FindSystemClass("Ljava/lang/ref/ReferenceQueue;");
- Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
+ mirror::Class* java_lang_ref_Reference = GetClassRoot(kJavaLangRefReference);
+ mirror::Class* java_lang_ref_ReferenceQueue = FindSystemClass("Ljava/lang/ref/ReferenceQueue;");
+ mirror::Class* java_lang_ref_FinalizerReference = FindSystemClass("Ljava/lang/ref/FinalizerReference;");
const DexFile& java_lang_dex = *java_lang_ref_Reference->GetDexCache()->GetDexFile();
- Field* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
+ mirror::Field* pendingNext = java_lang_ref_Reference->GetInstanceField(0);
FieldHelper fh(pendingNext, this);
CHECK_STREQ(fh.GetName(), "pendingNext");
CHECK_EQ(java_lang_dex.GetFieldId(pendingNext->GetDexFieldIndex()).type_idx_,
java_lang_ref_Reference->GetDexTypeIndex());
- Field* queue = java_lang_ref_Reference->GetInstanceField(1);
+ mirror::Field* queue = java_lang_ref_Reference->GetInstanceField(1);
fh.ChangeField(queue);
CHECK_STREQ(fh.GetName(), "queue");
CHECK_EQ(java_lang_dex.GetFieldId(queue->GetDexFieldIndex()).type_idx_,
java_lang_ref_ReferenceQueue->GetDexTypeIndex());
- Field* queueNext = java_lang_ref_Reference->GetInstanceField(2);
+ mirror::Field* queueNext = java_lang_ref_Reference->GetInstanceField(2);
fh.ChangeField(queueNext);
CHECK_STREQ(fh.GetName(), "queueNext");
CHECK_EQ(java_lang_dex.GetFieldId(queueNext->GetDexFieldIndex()).type_idx_,
java_lang_ref_Reference->GetDexTypeIndex());
- Field* referent = java_lang_ref_Reference->GetInstanceField(3);
+ mirror::Field* referent = java_lang_ref_Reference->GetInstanceField(3);
fh.ChangeField(referent);
CHECK_STREQ(fh.GetName(), "referent");
CHECK_EQ(java_lang_dex.GetFieldId(referent->GetDexFieldIndex()).type_idx_,
GetClassRoot(kJavaLangObject)->GetDexTypeIndex());
- Field* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
+ mirror::Field* zombie = java_lang_ref_FinalizerReference->GetInstanceField(2);
fh.ChangeField(zombie);
CHECK_STREQ(fh.GetName(), "zombie");
CHECK_EQ(java_lang_dex.GetFieldId(zombie->GetDexFieldIndex()).type_idx_,
@@ -578,7 +593,7 @@
// ensure all class_roots_ are initialized
for (size_t i = 0; i < kClassRootsMax; i++) {
ClassRoot class_root = static_cast<ClassRoot>(i);
- Class* klass = GetClassRoot(class_root);
+ mirror::Class* klass = GetClassRoot(class_root);
CHECK(klass != NULL);
DCHECK(klass->IsArrayClass() || klass->IsPrimitive() || klass->GetDexCache() != NULL);
// note SetClassRoot does additional validation.
@@ -597,7 +612,7 @@
void ClassLinker::RunRootClinits() {
Thread* self = Thread::Current();
for (size_t i = 0; i < ClassLinker::kClassRootsMax; ++i) {
- Class* c = GetClassRoot(ClassRoot(i));
+ mirror::Class* c = GetClassRoot(ClassRoot(i));
if (!c->IsArrayClass() && !c->IsPrimitive()) {
EnsureInitialized(GetClassRoot(ClassRoot(i)), true, true);
self->AssertNoPendingException();
@@ -699,7 +714,8 @@
const ImageHeader& image_header = space->GetImageHeader();
// Grab location but don't use Object::AsString as we haven't yet initialized the roots to
// check the down cast
- String* oat_location = down_cast<String*>(image_header.GetImageRoot(ImageHeader::kOatLocation));
+ mirror::String* oat_location =
+ down_cast<mirror::String*>(image_header.GetImageRoot(ImageHeader::kOatLocation));
std::string oat_filename;
oat_filename += runtime->GetHostPrefix();
oat_filename += oat_location->ToModifiedUtf8();
@@ -971,21 +987,22 @@
CHECK_EQ(oat_file->GetOatHeader().GetImageFileLocationOatChecksum(), 0U);
CHECK_EQ(oat_file->GetOatHeader().GetImageFileLocationOatDataBegin(), 0U);
CHECK(oat_file->GetOatHeader().GetImageFileLocation().empty());
- Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
- ObjectArray<DexCache>* dex_caches = dex_caches_object->AsObjectArray<DexCache>();
+ mirror::Object* dex_caches_object = space->GetImageHeader().GetImageRoot(ImageHeader::kDexCaches);
+ mirror::ObjectArray<mirror::DexCache>* dex_caches =
+ dex_caches_object->AsObjectArray<mirror::DexCache>();
- ObjectArray<Class>* class_roots =
- space->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)->AsObjectArray<Class>();
+ mirror::ObjectArray<mirror::Class>* class_roots =
+ space->GetImageHeader().GetImageRoot(ImageHeader::kClassRoots)->AsObjectArray<mirror::Class>();
// Special case of setting up the String class early so that we can test arbitrary objects
// as being Strings or not
- String::SetClass(class_roots->Get(kJavaLangString));
+ mirror::String::SetClass(class_roots->Get(kJavaLangString));
CHECK_EQ(oat_file->GetOatHeader().GetDexFileCount(),
static_cast<uint32_t>(dex_caches->GetLength()));
Thread* self = Thread::Current();
for (int i = 0; i < dex_caches->GetLength(); i++) {
- SirtRef<DexCache> dex_cache(self, dex_caches->Get(i));
+ SirtRef<mirror::DexCache> dex_cache(self, dex_caches->Get(i));
const std::string& dex_file_location(dex_cache->GetLocation()->ToModifiedUtf8());
const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file_location);
CHECK(oat_dex_file != NULL) << oat_file->GetLocation() << " " << dex_file_location;
@@ -1008,33 +1025,33 @@
}
// reinit class_roots_
- Class::SetClassClass(class_roots->Get(kJavaLangClass));
+ mirror::Class::SetClassClass(class_roots->Get(kJavaLangClass));
class_roots_ = class_roots;
// reinit array_iftable_ from any array class instance, they should be ==
array_iftable_ = GetClassRoot(kObjectArrayClass)->GetIfTable();
DCHECK(array_iftable_ == GetClassRoot(kBooleanArrayClass)->GetIfTable());
// String class root was set above
- Field::SetClass(GetClassRoot(kJavaLangReflectField));
- AbstractMethod::SetClasses(GetClassRoot(kJavaLangReflectConstructor),
+ mirror::Field::SetClass(GetClassRoot(kJavaLangReflectField));
+ mirror::AbstractMethod::SetClasses(GetClassRoot(kJavaLangReflectConstructor),
GetClassRoot(kJavaLangReflectMethod));
- BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
- ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
- CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
- DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
- FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
- IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
- LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
- ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
- Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
- StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
+ mirror::BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
+ mirror::ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
+ mirror::CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
+ mirror::DoubleArray::SetArrayClass(GetClassRoot(kDoubleArrayClass));
+ mirror::FloatArray::SetArrayClass(GetClassRoot(kFloatArrayClass));
+ mirror::IntArray::SetArrayClass(GetClassRoot(kIntArrayClass));
+ mirror::LongArray::SetArrayClass(GetClassRoot(kLongArrayClass));
+ mirror::ShortArray::SetArrayClass(GetClassRoot(kShortArrayClass));
+ mirror::Throwable::SetClass(GetClassRoot(kJavaLangThrowable));
+ mirror::StackTraceElement::SetClass(GetClassRoot(kJavaLangStackTraceElement));
FinishInit();
VLOG(startup) << "ClassLinker::InitFromImage exiting";
}
-void ClassLinker::InitFromImageCallback(Object* obj, void* arg) {
+void ClassLinker::InitFromImageCallback(mirror::Object* obj, void* arg) {
DCHECK(obj != NULL);
DCHECK(arg != NULL);
ClassLinker* class_linker = reinterpret_cast<ClassLinker*>(arg);
@@ -1045,9 +1062,9 @@
}
if (obj->IsClass()) {
// restore class to ClassLinker::classes_ table
- Class* klass = obj->AsClass();
+ mirror::Class* klass = obj->AsClass();
ClassHelper kh(klass, class_linker);
- Class* existing = class_linker->InsertClass(kh.GetDescriptor(), klass, true);
+ mirror::Class* existing = class_linker->InsertClass(kh.GetDescriptor(), klass, true);
DCHECK(existing == NULL) << kh.GetDescriptor();
return;
}
@@ -1056,7 +1073,7 @@
// Keep in sync with InitCallback. Anything we visit, we need to
// reinit references to when reinitializing a ClassLinker from a
// mapped image.
-void ClassLinker::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
+void ClassLinker::VisitRoots(RootVisitor* visitor, void* arg) {
visitor(class_roots_, arg);
Thread* self = Thread::Current();
{
@@ -1096,16 +1113,16 @@
}
}
-static bool GetClassesVisitor(Class* c, void* arg) {
- std::set<Class*>* classes = reinterpret_cast<std::set<Class*>*>(arg);
+static bool GetClassesVisitor(mirror::Class* c, void* arg) {
+ std::set<mirror::Class*>* classes = reinterpret_cast<std::set<mirror::Class*>*>(arg);
classes->insert(c);
return true;
}
void ClassLinker::VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) const {
- std::set<Class*> classes;
+ std::set<mirror::Class*> classes;
VisitClasses(GetClassesVisitor, &classes);
- typedef std::set<Class*>::const_iterator It; // TODO: C++0x auto
+ typedef std::set<mirror::Class*>::const_iterator It; // TODO: C++0x auto
for (It it = classes.begin(), end = classes.end(); it != end; ++it) {
if (!visitor(*it, arg)) {
return;
@@ -1115,57 +1132,61 @@
ClassLinker::~ClassLinker() {
- Class::ResetClass();
- String::ResetClass();
- Field::ResetClass();
- AbstractMethod::ResetClasses();
- BooleanArray::ResetArrayClass();
- ByteArray::ResetArrayClass();
- CharArray::ResetArrayClass();
- DoubleArray::ResetArrayClass();
- FloatArray::ResetArrayClass();
- IntArray::ResetArrayClass();
- LongArray::ResetArrayClass();
- ShortArray::ResetArrayClass();
- Throwable::ResetClass();
- StackTraceElement::ResetClass();
+ mirror::Class::ResetClass();
+ mirror::String::ResetClass();
+ mirror::Field::ResetClass();
+ mirror::AbstractMethod::ResetClasses();
+ mirror::BooleanArray::ResetArrayClass();
+ mirror::ByteArray::ResetArrayClass();
+ mirror::CharArray::ResetArrayClass();
+ mirror::DoubleArray::ResetArrayClass();
+ mirror::FloatArray::ResetArrayClass();
+ mirror::IntArray::ResetArrayClass();
+ mirror::LongArray::ResetArrayClass();
+ mirror::ShortArray::ResetArrayClass();
+ mirror::Throwable::ResetClass();
+ mirror::StackTraceElement::ResetClass();
STLDeleteElements(&boot_class_path_);
STLDeleteElements(&oat_files_);
}
-DexCache* ClassLinker::AllocDexCache(Thread* self, const DexFile& dex_file) {
+mirror::DexCache* ClassLinker::AllocDexCache(Thread* self, const DexFile& dex_file) {
Heap* heap = Runtime::Current()->GetHeap();
- Class* dex_cache_class = GetClassRoot(kJavaLangDexCache);
- SirtRef<DexCache> dex_cache(self,
- down_cast<DexCache*>(heap->AllocObject(self, dex_cache_class,
- dex_cache_class->GetObjectSize())));
+ mirror::Class* dex_cache_class = GetClassRoot(kJavaLangDexCache);
+ SirtRef<mirror::DexCache> dex_cache(self,
+ down_cast<mirror::DexCache*>(heap->AllocObject(self, dex_cache_class,
+ dex_cache_class->GetObjectSize())));
if (dex_cache.get() == NULL) {
return NULL;
}
- SirtRef<String> location(self, intern_table_->InternStrong(dex_file.GetLocation().c_str()));
+ SirtRef<mirror::String>
+ location(self, intern_table_->InternStrong(dex_file.GetLocation().c_str()));
if (location.get() == NULL) {
return NULL;
}
- SirtRef<ObjectArray<String> > strings(self, AllocStringArray(self, dex_file.NumStringIds()));
+ SirtRef<mirror::ObjectArray<mirror::String> >
+ strings(self, AllocStringArray(self, dex_file.NumStringIds()));
if (strings.get() == NULL) {
return NULL;
}
- SirtRef<ObjectArray<Class> > types(self, AllocClassArray(self, dex_file.NumTypeIds()));
+ SirtRef<mirror::ObjectArray<mirror::Class> >
+ types(self, AllocClassArray(self, dex_file.NumTypeIds()));
if (types.get() == NULL) {
return NULL;
}
- SirtRef<ObjectArray<AbstractMethod> >
+ SirtRef<mirror::ObjectArray<mirror::AbstractMethod> >
methods(self, AllocAbstractMethodArray(self, dex_file.NumMethodIds()));
if (methods.get() == NULL) {
return NULL;
}
- SirtRef<ObjectArray<Field> > fields(self, AllocFieldArray(self, dex_file.NumFieldIds()));
+ SirtRef<mirror::ObjectArray<mirror::Field> >
+ fields(self, AllocFieldArray(self, dex_file.NumFieldIds()));
if (fields.get() == NULL) {
return NULL;
}
- SirtRef<ObjectArray<StaticStorageBase> >
+ SirtRef<mirror::ObjectArray<mirror::StaticStorageBase> >
initialized_static_storage(self,
- AllocObjectArray<StaticStorageBase>(self, dex_file.NumTypeIds()));
+ AllocObjectArray<mirror::StaticStorageBase>(self, dex_file.NumTypeIds()));
if (initialized_static_storage.get() == NULL) {
return NULL;
}
@@ -1180,40 +1201,41 @@
return dex_cache.get();
}
-Class* ClassLinker::AllocClass(Thread* self, Class* java_lang_Class, size_t class_size) {
- DCHECK_GE(class_size, sizeof(Class));
+mirror::Class* ClassLinker::AllocClass(Thread* self, mirror::Class* java_lang_Class,
+ size_t class_size) {
+ DCHECK_GE(class_size, sizeof(mirror::Class));
Heap* heap = Runtime::Current()->GetHeap();
- SirtRef<Class> klass(self,
+ SirtRef<mirror::Class> klass(self,
heap->AllocObject(self, java_lang_Class, class_size)->AsClass());
klass->SetPrimitiveType(Primitive::kPrimNot); // default to not being primitive
klass->SetClassSize(class_size);
return klass.get();
}
-Class* ClassLinker::AllocClass(Thread* self, size_t class_size) {
+mirror::Class* ClassLinker::AllocClass(Thread* self, size_t class_size) {
return AllocClass(self, GetClassRoot(kJavaLangClass), class_size);
}
-Field* ClassLinker::AllocField(Thread* self) {
- return down_cast<Field*>(GetClassRoot(kJavaLangReflectField)->AllocObject(self));
+mirror::Field* ClassLinker::AllocField(Thread* self) {
+ return down_cast<mirror::Field*>(GetClassRoot(kJavaLangReflectField)->AllocObject(self));
}
-Method* ClassLinker::AllocMethod(Thread* self) {
- return down_cast<Method*>(GetClassRoot(kJavaLangReflectMethod)->AllocObject(self));
+mirror::Method* ClassLinker::AllocMethod(Thread* self) {
+ return down_cast<mirror::Method*>(GetClassRoot(kJavaLangReflectMethod)->AllocObject(self));
}
-Constructor* ClassLinker::AllocConstructor(Thread* self) {
- return down_cast<Constructor*>(GetClassRoot(kJavaLangReflectConstructor)->AllocObject(self));
+mirror::Constructor* ClassLinker::AllocConstructor(Thread* self) {
+ return down_cast<mirror::Constructor*>(GetClassRoot(kJavaLangReflectConstructor)->AllocObject(self));
}
-ObjectArray<StackTraceElement>* ClassLinker::AllocStackTraceElementArray(Thread* self,
- size_t length) {
- return ObjectArray<StackTraceElement>::Alloc(self,
- GetClassRoot(kJavaLangStackTraceElementArrayClass),
- length);
+mirror::ObjectArray<mirror::StackTraceElement>* ClassLinker::AllocStackTraceElementArray(Thread* self,
+ size_t length) {
+ return mirror::ObjectArray<mirror::StackTraceElement>::Alloc(self,
+ GetClassRoot(kJavaLangStackTraceElementArrayClass),
+ length);
}
-static Class* EnsureResolved(Thread* self, Class* klass)
+static mirror::Class* EnsureResolved(Thread* self, mirror::Class* klass)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(klass != NULL);
// Wait for the class if it has not already been linked.
@@ -1223,7 +1245,7 @@
if (!klass->IsResolved() && klass->GetClinitThreadId() == self->GetTid()) {
self->ThrowNewException("Ljava/lang/ClassCircularityError;",
PrettyDescriptor(klass).c_str());
- klass->SetStatus(Class::kStatusError);
+ klass->SetStatus(mirror::Class::kStatusError);
return NULL;
}
// Wait for the pending initialization to complete.
@@ -1243,11 +1265,11 @@
return klass;
}
-Class* ClassLinker::FindSystemClass(const char* descriptor) {
+mirror::Class* ClassLinker::FindSystemClass(const char* descriptor) {
return FindClass(descriptor, NULL);
}
-Class* ClassLinker::FindClass(const char* descriptor, ClassLoader* class_loader) {
+mirror::Class* ClassLinker::FindClass(const char* descriptor, mirror::ClassLoader* class_loader) {
DCHECK_NE(*descriptor, '\0') << "descriptor is empty string";
Thread* self = Thread::Current();
DCHECK(self != NULL);
@@ -1258,7 +1280,7 @@
return FindPrimitiveClass(descriptor[0]);
}
// Find the class in the loaded classes table.
- Class* klass = LookupClass(descriptor, class_loader);
+ mirror::Class* klass = LookupClass(descriptor, class_loader);
if (klass != NULL) {
return EnsureResolved(self, klass);
}
@@ -1274,7 +1296,7 @@
} else if (Runtime::Current()->UseCompileTimeClassPath()) {
// first try the boot class path
- Class* system_class = FindSystemClass(descriptor);
+ mirror::Class* system_class = FindSystemClass(descriptor);
if (system_class != NULL) {
return system_class;
}
@@ -1321,8 +1343,8 @@
class_name_string.c_str());
return NULL;
} else {
- // success, return Class*
- return soa.Decode<Class*>(result.get());
+ // success, return mirror::Class*
+ return soa.Decode<mirror::Class*>(result.get());
}
}
@@ -1330,12 +1352,12 @@
return NULL;
}
-Class* ClassLinker::DefineClass(const StringPiece& descriptor,
- ClassLoader* class_loader,
- const DexFile& dex_file,
- const DexFile::ClassDef& dex_class_def) {
+mirror::Class* ClassLinker::DefineClass(const StringPiece& descriptor,
+ mirror::ClassLoader* class_loader,
+ const DexFile& dex_file,
+ const DexFile::ClassDef& dex_class_def) {
Thread* self = Thread::Current();
- SirtRef<Class> klass(self, NULL);
+ SirtRef<mirror::Class> klass(self, NULL);
// Load the class from the dex file.
if (!init_done_) {
// finish up init of hand crafted class_roots_
@@ -1365,13 +1387,13 @@
LoadClass(dex_file, dex_class_def, klass, class_loader);
// Check for a pending exception during load
if (self->IsExceptionPending()) {
- klass->SetStatus(Class::kStatusError);
+ klass->SetStatus(mirror::Class::kStatusError);
return NULL;
}
ObjectLock lock(self, klass.get());
klass->SetClinitThreadId(self->GetTid());
// Add the newly loaded class to the loaded classes table.
- SirtRef<Class> existing(self, InsertClass(descriptor, klass.get(), false));
+ SirtRef<mirror::Class> existing(self, InsertClass(descriptor, klass.get(), false));
if (existing.get() != NULL) {
// We failed to insert because we raced with another thread.
return EnsureResolved(self, existing.get());
@@ -1380,7 +1402,7 @@
CHECK(!klass->IsLoaded());
if (!LoadSuperAndInterfaces(klass, dex_file)) {
// Loading failed.
- klass->SetStatus(Class::kStatusError);
+ klass->SetStatus(mirror::Class::kStatusError);
lock.NotifyAll();
return NULL;
}
@@ -1389,7 +1411,7 @@
CHECK(!klass->IsResolved());
if (!LinkClass(klass, NULL)) {
// Linking failed.
- klass->SetStatus(Class::kStatusError);
+ klass->SetStatus(mirror::Class::kStatusError);
lock.NotifyAll();
return NULL;
}
@@ -1433,7 +1455,7 @@
}
}
// start with generic class data
- size_t size = sizeof(Class);
+ size_t size = sizeof(mirror::Class);
// follow with reference fields which must be contiguous at start
size += (num_ref * sizeof(uint32_t));
// if there are 64-bit fields to add, make sure they are aligned
@@ -1502,10 +1524,10 @@
return 0;
}
-const OatFile::OatMethod ClassLinker::GetOatMethodFor(const AbstractMethod* method) {
+const OatFile::OatMethod ClassLinker::GetOatMethodFor(const mirror::AbstractMethod* method) {
// Although we overwrite the trampoline of non-static methods, we may get here via the resolution
// method for direct methods (or virtual methods made direct).
- Class* declaring_class = method->GetDeclaringClass();
+ mirror::Class* declaring_class = method->GetDeclaringClass();
size_t oat_method_index;
if (method->IsStatic() || method->IsDirect()) {
// Simple case where the oat method index was stashed at load time.
@@ -1536,7 +1558,7 @@
}
// Special case to get oat code without overwriting a trampoline.
-const void* ClassLinker::GetOatCodeFor(const AbstractMethod* method) {
+const void* ClassLinker::GetOatCodeFor(const mirror::AbstractMethod* method) {
CHECK(Runtime::Current()->IsCompiler() || method->GetDeclaringClass()->IsInitializing());
return GetOatMethodFor(method).GetCode();
}
@@ -1550,7 +1572,7 @@
return oat_class->GetOatMethod(oat_method_idx).GetCode();
}
-void ClassLinker::FixupStaticTrampolines(Class* klass) {
+void ClassLinker::FixupStaticTrampolines(mirror::Class* klass) {
ClassHelper kh(klass);
const DexFile::ClassDef* dex_class_def = kh.GetClassDef();
CHECK(dex_class_def != NULL);
@@ -1577,7 +1599,7 @@
// Link the code of methods skipped by LinkCode
const void* trampoline = Runtime::Current()->GetResolutionStubArray(Runtime::kStaticMethod)->GetData();
for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
- AbstractMethod* method = klass->GetDirectMethod(i);
+ mirror::AbstractMethod* method = klass->GetDirectMethod(i);
if (Runtime::Current()->IsMethodTracingActive()) {
Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
if (instrumentation->GetSavedCodeFromMap(method) == trampoline) {
@@ -1596,7 +1618,7 @@
}
}
-static void LinkCode(SirtRef<AbstractMethod>& method, const OatFile::OatClass* oat_class,
+static void LinkCode(SirtRef<mirror::AbstractMethod>& method, const OatFile::OatClass* oat_class,
uint32_t method_index)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// Every kind of method should at least get an invoke stub from the oat_method.
@@ -1627,11 +1649,11 @@
void ClassLinker::LoadClass(const DexFile& dex_file,
const DexFile::ClassDef& dex_class_def,
- SirtRef<Class>& klass,
- ClassLoader* class_loader) {
+ SirtRef<mirror::Class>& klass,
+ mirror::ClassLoader* class_loader) {
CHECK(klass.get() != NULL);
CHECK(klass->GetDexCache() != NULL);
- CHECK_EQ(Class::kStatusNotReady, klass->GetStatus());
+ CHECK_EQ(mirror::Class::kStatusNotReady, klass->GetStatus());
const char* descriptor = dex_file.GetClassDescriptor(dex_class_def);
CHECK(descriptor != NULL);
@@ -1643,7 +1665,7 @@
klass->SetAccessFlags(access_flags);
klass->SetClassLoader(class_loader);
DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
- klass->SetStatus(Class::kStatusIdx);
+ klass->SetStatus(mirror::Class::kStatusIdx);
klass->SetDexTypeIndex(dex_class_def.class_idx_);
@@ -1661,12 +1683,12 @@
klass->SetIFields(AllocFieldArray(self, it.NumInstanceFields()));
}
for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
- SirtRef<Field> sfield(self, AllocField(self));
+ SirtRef<mirror::Field> sfield(self, AllocField(self));
klass->SetStaticField(i, sfield.get());
LoadField(dex_file, it, klass, sfield);
}
for (size_t i = 0; it.HasNextInstanceField(); i++, it.Next()) {
- SirtRef<Field> ifield(self, AllocField(self));
+ SirtRef<mirror::Field> ifield(self, AllocField(self));
klass->SetInstanceField(i, ifield.get());
LoadField(dex_file, it, klass, ifield);
}
@@ -1687,7 +1709,7 @@
}
size_t class_def_method_index = 0;
for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
- SirtRef<AbstractMethod> method(self, LoadMethod(self, dex_file, it, klass));
+ SirtRef<mirror::AbstractMethod> method(self, LoadMethod(self, dex_file, it, klass));
klass->SetDirectMethod(i, method.get());
if (oat_class.get() != NULL) {
LinkCode(method, oat_class.get(), class_def_method_index);
@@ -1696,7 +1718,7 @@
class_def_method_index++;
}
for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
- SirtRef<AbstractMethod> method(self, LoadMethod(self, dex_file, it, klass));
+ SirtRef<mirror::AbstractMethod> method(self, LoadMethod(self, dex_file, it, klass));
klass->SetVirtualMethod(i, method.get());
DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
if (oat_class.get() != NULL) {
@@ -1708,21 +1730,21 @@
}
void ClassLinker::LoadField(const DexFile& /*dex_file*/, const ClassDataItemIterator& it,
- SirtRef<Class>& klass, SirtRef<Field>& dst) {
+ SirtRef<mirror::Class>& klass, SirtRef<mirror::Field>& dst) {
uint32_t field_idx = it.GetMemberIndex();
dst->SetDexFieldIndex(field_idx);
dst->SetDeclaringClass(klass.get());
dst->SetAccessFlags(it.GetMemberAccessFlags());
}
-AbstractMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file,
- const ClassDataItemIterator& it,
- SirtRef<Class>& klass) {
+mirror::AbstractMethod* ClassLinker::LoadMethod(Thread* self, const DexFile& dex_file,
+ const ClassDataItemIterator& it,
+ SirtRef<mirror::Class>& klass) {
uint32_t dex_method_idx = it.GetMemberIndex();
const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
StringPiece method_name(dex_file.GetMethodName(method_id));
- AbstractMethod* dst = NULL;
+ mirror::AbstractMethod* dst = NULL;
if (method_name == "<init>") {
dst = AllocConstructor(self);
} else {
@@ -1780,11 +1802,11 @@
void ClassLinker::AppendToBootClassPath(const DexFile& dex_file) {
Thread* self = Thread::Current();
- SirtRef<DexCache> dex_cache(self, AllocDexCache(self, dex_file));
+ SirtRef<mirror::DexCache> dex_cache(self, AllocDexCache(self, dex_file));
AppendToBootClassPath(dex_file, dex_cache);
}
-void ClassLinker::AppendToBootClassPath(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
+void ClassLinker::AppendToBootClassPath(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache) {
CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
boot_class_path_.push_back(&dex_file);
RegisterDexFile(dex_file, dex_cache);
@@ -1805,7 +1827,7 @@
return IsDexFileRegisteredLocked(dex_file);
}
-void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
+void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache) {
dex_lock_.AssertHeld(Thread::Current());
CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
CHECK(dex_cache->GetLocation()->Equals(dex_file.GetLocation()));
@@ -1825,7 +1847,7 @@
// Don't alloc while holding the lock, since allocation may need to
// suspend all threads and another thread may need the dex_lock_ to
// get to a suspend point.
- SirtRef<DexCache> dex_cache(self, AllocDexCache(self, dex_file));
+ SirtRef<mirror::DexCache> dex_cache(self, AllocDexCache(self, dex_file));
{
MutexLock mu(self, dex_lock_);
if (IsDexFileRegisteredLocked(dex_file)) {
@@ -1835,16 +1857,16 @@
}
}
-void ClassLinker::RegisterDexFile(const DexFile& dex_file, SirtRef<DexCache>& dex_cache) {
+void ClassLinker::RegisterDexFile(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache) {
MutexLock mu(Thread::Current(), dex_lock_);
RegisterDexFileLocked(dex_file, dex_cache);
}
-DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) const {
+mirror::DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) const {
MutexLock mu(Thread::Current(), dex_lock_);
// Search assuming unique-ness of dex file.
for (size_t i = 0; i != dex_caches_.size(); ++i) {
- DexCache* dex_cache = dex_caches_[i];
+ mirror::DexCache* dex_cache = dex_caches_[i];
if (dex_cache->GetDexFile() == &dex_file) {
return dex_cache;
}
@@ -1852,35 +1874,39 @@
// Search matching by location name.
std::string location(dex_file.GetLocation());
for (size_t i = 0; i != dex_caches_.size(); ++i) {
- DexCache* dex_cache = dex_caches_[i];
+ mirror::DexCache* dex_cache = dex_caches_[i];
if (dex_cache->GetDexFile()->GetLocation() == location) {
return dex_cache;
}
}
// Failure, dump diagnostic and abort.
for (size_t i = 0; i != dex_caches_.size(); ++i) {
- DexCache* dex_cache = dex_caches_[i];
+ mirror::DexCache* dex_cache = dex_caches_[i];
LOG(ERROR) << "Registered dex file " << i << " = " << dex_cache->GetDexFile()->GetLocation();
}
LOG(FATAL) << "Failed to find DexCache for DexFile " << location;
return NULL;
}
-void ClassLinker::FixupDexCaches(AbstractMethod* resolution_method) const {
+void ClassLinker::FixupDexCaches(mirror::AbstractMethod* resolution_method) const {
MutexLock mu(Thread::Current(), dex_lock_);
for (size_t i = 0; i != dex_caches_.size(); ++i) {
dex_caches_[i]->Fixup(resolution_method);
}
}
-Class* ClassLinker::InitializePrimitiveClass(Class* primitive_class, Primitive::Type type) {
+mirror::Class* ClassLinker::CreatePrimitiveClass(Thread* self, Primitive::Type type) {
+ return InitializePrimitiveClass(AllocClass(self, sizeof(mirror::Class)), type);
+}
+
+mirror::Class* ClassLinker::InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type) {
CHECK(primitive_class != NULL);
// Must hold lock on object when initializing.
ObjectLock lock(Thread::Current(), primitive_class);
primitive_class->SetAccessFlags(kAccPublic | kAccFinal | kAccAbstract);
primitive_class->SetPrimitiveType(type);
- primitive_class->SetStatus(Class::kStatusInitialized);
- Class* existing = InsertClass(Primitive::Descriptor(type), primitive_class, false);
+ primitive_class->SetStatus(mirror::Class::kStatusInitialized);
+ mirror::Class* existing = InsertClass(Primitive::Descriptor(type), primitive_class, false);
CHECK(existing == NULL) << "InitPrimitiveClass(" << type << ") failed";
return primitive_class;
}
@@ -1898,11 +1924,12 @@
// array class; that always comes from the base element class.
//
// Returns NULL with an exception raised on failure.
-Class* ClassLinker::CreateArrayClass(const std::string& descriptor, ClassLoader* class_loader) {
+mirror::Class* ClassLinker::CreateArrayClass(const std::string& descriptor,
+ mirror::ClassLoader* class_loader) {
CHECK_EQ('[', descriptor[0]);
// Identify the underlying component type
- Class* component_type = FindClass(descriptor.substr(1).c_str(), class_loader);
+ mirror::Class* component_type = FindClass(descriptor.substr(1).c_str(), class_loader);
if (component_type == NULL) {
DCHECK(Thread::Current()->IsExceptionPending());
return NULL;
@@ -1926,7 +1953,7 @@
// class to the hash table --- necessary because of possible races with
// other threads.)
if (class_loader != component_type->GetClassLoader()) {
- Class* new_class = LookupClass(descriptor.c_str(), component_type->GetClassLoader());
+ mirror::Class* new_class = LookupClass(descriptor.c_str(), component_type->GetClassLoader());
if (new_class != NULL) {
return new_class;
}
@@ -1941,7 +1968,7 @@
// Array classes are simple enough that we don't need to do a full
// link step.
Thread* self = Thread::Current();
- SirtRef<Class> new_class(self, NULL);
+ SirtRef<mirror::Class> new_class(self, NULL);
if (!init_done_) {
// Classes that were hand created, ie not by FindSystemClass
if (descriptor == "[Ljava/lang/Class;") {
@@ -1963,7 +1990,7 @@
}
}
if (new_class.get() == NULL) {
- new_class.reset(AllocClass(self, sizeof(Class)));
+ new_class.reset(AllocClass(self, sizeof(mirror::Class)));
if (new_class.get() == NULL) {
return NULL;
}
@@ -1971,12 +1998,12 @@
}
ObjectLock lock(self, new_class.get()); // Must hold lock on object when initializing.
DCHECK(new_class->GetComponentType() != NULL);
- Class* java_lang_Object = GetClassRoot(kJavaLangObject);
+ mirror::Class* java_lang_Object = GetClassRoot(kJavaLangObject);
new_class->SetSuperClass(java_lang_Object);
new_class->SetVTable(java_lang_Object->GetVTable());
new_class->SetPrimitiveType(Primitive::kPrimNot);
new_class->SetClassLoader(component_type->GetClassLoader());
- new_class->SetStatus(Class::kStatusInitialized);
+ new_class->SetStatus(mirror::Class::kStatusInitialized);
// don't need to set new_class->SetObjectSize(..)
// because Object::SizeOf delegates to Array::SizeOf
@@ -2006,7 +2033,7 @@
new_class->SetAccessFlags(((new_class->GetComponentType()->GetAccessFlags() &
~kAccInterface) | kAccFinal) & kAccJavaFlagsMask);
- Class* existing = InsertClass(descriptor, new_class.get(), false);
+ mirror::Class* existing = InsertClass(descriptor, new_class.get(), false);
if (existing == NULL) {
return new_class.get();
}
@@ -2019,7 +2046,7 @@
return existing;
}
-Class* ClassLinker::FindPrimitiveClass(char type) {
+mirror::Class* ClassLinker::FindPrimitiveClass(char type) {
switch (Primitive::GetType(type)) {
case Primitive::kPrimByte:
return GetClassRoot(kPrimitiveByte);
@@ -2047,9 +2074,9 @@
return NULL;
}
-Class* ClassLinker::InsertClass(const StringPiece& descriptor, Class* klass, bool image_class) {
+mirror::Class* ClassLinker::InsertClass(const StringPiece& descriptor, mirror::Class* klass, bool image_class) {
if (VLOG_IS_ON(class_linker)) {
- DexCache* dex_cache = klass->GetDexCache();
+ mirror::DexCache* dex_cache = klass->GetDexCache();
std::string source;
if (dex_cache != NULL) {
source += " from ";
@@ -2060,7 +2087,7 @@
size_t hash = StringPieceHash()(descriptor);
MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
Table& classes = image_class ? image_classes_ : classes_;
- Class* existing = LookupClassLocked(descriptor.data(), klass->GetClassLoader(), hash, classes);
+ mirror::Class* existing = LookupClassLocked(descriptor.data(), klass->GetClassLoader(), hash, classes);
#ifndef NDEBUG
// Check we don't have the class in the other table in error
Table& other_classes = image_class ? classes_ : image_classes_;
@@ -2074,22 +2101,24 @@
return NULL;
}
-bool ClassLinker::RemoveClass(const char* descriptor, const ClassLoader* class_loader) {
+bool ClassLinker::RemoveClass(const char* descriptor, const mirror::ClassLoader* class_loader) {
size_t hash = Hash(descriptor);
MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
typedef Table::iterator It; // TODO: C++0x auto
// TODO: determine if its better to search classes_ or image_classes_ first
ClassHelper kh;
- for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
- Class* klass = it->second;
+ for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash;
+ ++it) {
+ mirror::Class* klass = it->second;
kh.ChangeClass(klass);
if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
classes_.erase(it);
return true;
}
}
- for (It it = image_classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
- Class* klass = it->second;
+ for (It it = image_classes_.lower_bound(hash), end = classes_.end();
+ it != end && it->first == hash; ++it) {
+ mirror::Class* klass = it->second;
kh.ChangeClass(klass);
if (strcmp(kh.GetDescriptor(), descriptor) == 0 && klass->GetClassLoader() == class_loader) {
image_classes_.erase(it);
@@ -2099,28 +2128,30 @@
return false;
}
-Class* ClassLinker::LookupClass(const char* descriptor, const ClassLoader* class_loader) {
+mirror::Class* ClassLinker::LookupClass(const char* descriptor,
+ const mirror::ClassLoader* class_loader) {
size_t hash = Hash(descriptor);
MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
// TODO: determine if its better to search classes_ or image_classes_ first
- Class* klass = LookupClassLocked(descriptor, class_loader, hash, classes_);
+ mirror::Class* klass = LookupClassLocked(descriptor, class_loader, hash, classes_);
if (klass != NULL) {
return klass;
}
return LookupClassLocked(descriptor, class_loader, hash, image_classes_);
}
-Class* ClassLinker::LookupClassLocked(const char* descriptor, const ClassLoader* class_loader,
- size_t hash, const Table& classes) {
+mirror::Class* ClassLinker::LookupClassLocked(const char* descriptor,
+ const mirror::ClassLoader* class_loader,
+ size_t hash, const Table& classes) {
ClassHelper kh(NULL, this);
typedef Table::const_iterator It; // TODO: C++0x auto
for (It it = classes.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
- Class* klass = it->second;
+ mirror::Class* klass = it->second;
kh.ChangeClass(klass);
if (strcmp(descriptor, kh.GetDescriptor()) == 0 && klass->GetClassLoader() == class_loader) {
#ifndef NDEBUG
for (++it; it != end && it->first == hash; ++it) {
- Class* klass2 = it->second;
+ mirror::Class* klass2 = it->second;
kh.ChangeClass(klass2);
CHECK(!(strcmp(descriptor, kh.GetDescriptor()) == 0 && klass2->GetClassLoader() == class_loader))
<< PrettyClass(klass) << " " << klass << " " << klass->GetClassLoader() << " "
@@ -2133,7 +2164,7 @@
return NULL;
}
-void ClassLinker::LookupClasses(const char* descriptor, std::vector<Class*>& classes) {
+void ClassLinker::LookupClasses(const char* descriptor, std::vector<mirror::Class*>& classes) {
classes.clear();
size_t hash = Hash(descriptor);
MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
@@ -2141,14 +2172,14 @@
// TODO: determine if its better to search classes_ or image_classes_ first
ClassHelper kh(NULL, this);
for (It it = classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
- Class* klass = it->second;
+ mirror::Class* klass = it->second;
kh.ChangeClass(klass);
if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
classes.push_back(klass);
}
}
for (It it = image_classes_.lower_bound(hash), end = classes_.end(); it != end && it->first == hash; ++it) {
- Class* klass = it->second;
+ mirror::Class* klass = it->second;
kh.ChangeClass(klass);
if (strcmp(descriptor, kh.GetDescriptor()) == 0) {
classes.push_back(klass);
@@ -2156,7 +2187,7 @@
}
}
-void ClassLinker::VerifyClass(Class* klass) {
+void ClassLinker::VerifyClass(mirror::Class* klass) {
// TODO: assert that the monitor on the Class is held
Thread* self = Thread::Current();
ObjectLock lock(self, klass);
@@ -2174,16 +2205,17 @@
return;
}
- if (klass->GetStatus() == Class::kStatusResolved) {
- klass->SetStatus(Class::kStatusVerifying);
+ if (klass->GetStatus() == mirror::Class::kStatusResolved) {
+ klass->SetStatus(mirror::Class::kStatusVerifying);
} else {
- CHECK_EQ(klass->GetStatus(), Class::kStatusRetryVerificationAtRuntime) << PrettyClass(klass);
+ CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusRetryVerificationAtRuntime)
+ << PrettyClass(klass);
CHECK(!Runtime::Current()->IsCompiler());
- klass->SetStatus(Class::kStatusVerifyingAtRuntime);
+ klass->SetStatus(mirror::Class::kStatusVerifyingAtRuntime);
}
// Verify super class.
- Class* super = klass->GetSuperClass();
+ mirror::Class* super = klass->GetSuperClass();
std::string error_msg;
if (super != NULL) {
// Acquire lock to prevent races on verifying the super class.
@@ -2198,7 +2230,7 @@
error_msg += " that attempts to sub-class erroneous class ";
error_msg += PrettyDescriptor(super);
LOG(ERROR) << error_msg << " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
- SirtRef<Throwable> cause(self, self->GetException());
+ SirtRef<mirror::Throwable> cause(self, self->GetException());
if (cause.get() != NULL) {
self->ClearException();
}
@@ -2206,24 +2238,24 @@
if (cause.get() != NULL) {
self->GetException()->SetCause(cause.get());
}
- klass->SetStatus(Class::kStatusError);
+ klass->SetStatus(mirror::Class::kStatusError);
return;
}
}
// Try to use verification information from the oat file, otherwise do runtime verification.
const DexFile& dex_file = *klass->GetDexCache()->GetDexFile();
- Class::Status oat_file_class_status(Class::kStatusNotReady);
+ mirror::Class::Status oat_file_class_status(mirror::Class::kStatusNotReady);
bool preverified = VerifyClassUsingOatFile(dex_file, klass, oat_file_class_status);
verifier::MethodVerifier::FailureKind verifier_failure = verifier::MethodVerifier::kNoFailure;
- if (oat_file_class_status == Class::kStatusError) {
+ if (oat_file_class_status == mirror::Class::kStatusError) {
LOG(WARNING) << "Skipping runtime verification of erroneous class " << PrettyDescriptor(klass)
<< " in " << klass->GetDexCache()->GetLocation()->ToModifiedUtf8();
error_msg = "Rejecting class ";
error_msg += PrettyDescriptor(klass);
error_msg += " because it failed compile-time verification";
Thread::Current()->ThrowNewException("Ljava/lang/VerifyError;", error_msg.c_str());
- klass->SetStatus(Class::kStatusError);
+ klass->SetStatus(mirror::Class::kStatusError);
return;
}
if (!preverified) {
@@ -2239,16 +2271,16 @@
// Make sure all classes referenced by catch blocks are resolved.
ResolveClassExceptionHandlerTypes(dex_file, klass);
if (verifier_failure == verifier::MethodVerifier::kNoFailure) {
- klass->SetStatus(Class::kStatusVerified);
+ klass->SetStatus(mirror::Class::kStatusVerified);
} else {
CHECK_EQ(verifier_failure, verifier::MethodVerifier::kSoftFailure);
// Soft failures at compile time should be retried at runtime. Soft
// failures at runtime will be handled by slow paths in the generated
// code. Set status accordingly.
if (Runtime::Current()->IsCompiler()) {
- klass->SetStatus(Class::kStatusRetryVerificationAtRuntime);
+ klass->SetStatus(mirror::Class::kStatusRetryVerificationAtRuntime);
} else {
- klass->SetStatus(Class::kStatusVerified);
+ klass->SetStatus(mirror::Class::kStatusVerified);
}
}
} else {
@@ -2257,12 +2289,12 @@
<< " because: " << error_msg;
self->AssertNoPendingException();
self->ThrowNewException("Ljava/lang/VerifyError;", error_msg.c_str());
- klass->SetStatus(Class::kStatusError);
+ klass->SetStatus(mirror::Class::kStatusError);
}
}
-bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, Class* klass,
- Class::Status& oat_file_class_status) {
+bool ClassLinker::VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class* klass,
+ mirror::Class::Status& oat_file_class_status) {
if (!Runtime::Current()->IsStarted()) {
return false;
}
@@ -2281,11 +2313,11 @@
CHECK(oat_class.get() != NULL)
<< dex_file.GetLocation() << " " << PrettyClass(klass) << " " << descriptor;
oat_file_class_status = oat_class->GetStatus();
- if (oat_file_class_status == Class::kStatusVerified ||
- oat_file_class_status == Class::kStatusInitialized) {
+ if (oat_file_class_status == mirror::Class::kStatusVerified ||
+ oat_file_class_status == mirror::Class::kStatusInitialized) {
return true;
}
- if (oat_file_class_status == Class::kStatusRetryVerificationAtRuntime) {
+ if (oat_file_class_status == mirror::Class::kStatusRetryVerificationAtRuntime) {
// Compile time verification failed with a soft error. Compile time verification can fail
// because we have incomplete type information. Consider the following:
// class ... {
@@ -2305,12 +2337,12 @@
// at compile time).
return false;
}
- if (oat_file_class_status == Class::kStatusError) {
+ if (oat_file_class_status == mirror::Class::kStatusError) {
// Compile time verification failed with a hard error. This is caused by invalid instructions
// in the class. These errors are unrecoverable.
return false;
}
- if (oat_file_class_status == Class::kStatusNotReady) {
+ if (oat_file_class_status == mirror::Class::kStatusNotReady) {
// Status is uninitialized if we couldn't determine the status at compile time, for example,
// not loading the class.
// TODO: when the verifier doesn't rely on Class-es failing to resolve/load the type hierarchy
@@ -2323,7 +2355,7 @@
return false;
}
-void ClassLinker::ResolveClassExceptionHandlerTypes(const DexFile& dex_file, Class* klass) {
+void ClassLinker::ResolveClassExceptionHandlerTypes(const DexFile& dex_file, mirror::Class* klass) {
for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
ResolveMethodExceptionHandlerTypes(dex_file, klass->GetDirectMethod(i));
}
@@ -2332,7 +2364,8 @@
}
}
-void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, AbstractMethod* method) {
+void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file,
+ mirror::AbstractMethod* method) {
// similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
if (code_item == NULL) {
@@ -2350,7 +2383,7 @@
// Ensure exception types are resolved so that they don't need resolution to be delivered,
// unresolved exception types will be ignored by exception delivery
if (iterator.GetHandlerTypeIndex() != DexFile::kDexNoIndex16) {
- Class* exception_type = linker->ResolveType(iterator.GetHandlerTypeIndex(), method);
+ mirror::Class* exception_type = linker->ResolveType(iterator.GetHandlerTypeIndex(), method);
if (exception_type == NULL) {
DCHECK(Thread::Current()->IsExceptionPending());
Thread::Current()->ClearException();
@@ -2361,26 +2394,29 @@
}
}
-static void CheckProxyConstructor(AbstractMethod* constructor);
-static void CheckProxyMethod(AbstractMethod* method, SirtRef<AbstractMethod>& prototype);
+static void CheckProxyConstructor(mirror::AbstractMethod* constructor);
+static void CheckProxyMethod(mirror::AbstractMethod* method,
+ SirtRef<mirror::AbstractMethod>& prototype);
-Class* ClassLinker::CreateProxyClass(String* name, ObjectArray<Class>* interfaces,
- ClassLoader* loader, ObjectArray<AbstractMethod>* methods,
- ObjectArray<ObjectArray<Class> >* throws) {
+mirror::Class* ClassLinker::CreateProxyClass(mirror::String* name,
+ mirror::ObjectArray<mirror::Class>* interfaces,
+ mirror::ClassLoader* loader,
+ mirror::ObjectArray<mirror::AbstractMethod>* methods,
+ mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >* throws) {
Thread* self = Thread::Current();
- SirtRef<Class> klass(self, AllocClass(self, GetClassRoot(kJavaLangClass),
- sizeof(SynthesizedProxyClass)));
+ SirtRef<mirror::Class> klass(self, AllocClass(self, GetClassRoot(kJavaLangClass),
+ sizeof(mirror::SynthesizedProxyClass)));
CHECK(klass.get() != NULL);
DCHECK(klass->GetClass() != NULL);
- klass->SetObjectSize(sizeof(Proxy));
+ klass->SetObjectSize(sizeof(mirror::Proxy));
klass->SetAccessFlags(kAccClassIsProxy | kAccPublic | kAccFinal);
klass->SetClassLoader(loader);
DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
klass->SetName(name);
- Class* proxy_class = GetClassRoot(kJavaLangReflectProxy);
+ mirror::Class* proxy_class = GetClassRoot(kJavaLangReflectProxy);
klass->SetDexCache(proxy_class->GetDexCache());
- klass->SetStatus(Class::kStatusIdx);
+ klass->SetStatus(mirror::Class::kStatusIdx);
klass->SetDexTypeIndex(DexFile::kDexNoIndex16);
@@ -2388,13 +2424,13 @@
klass->SetSFields(AllocFieldArray(self, 2));
// 1. Create a static field 'interfaces' that holds the _declared_ interfaces implemented by
// our proxy, so Class.getInterfaces doesn't return the flattened set.
- SirtRef<Field> interfaces_sfield(self, AllocField(self));
+ SirtRef<mirror::Field> interfaces_sfield(self, AllocField(self));
klass->SetStaticField(0, interfaces_sfield.get());
interfaces_sfield->SetDexFieldIndex(0);
interfaces_sfield->SetDeclaringClass(klass.get());
interfaces_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
// 2. Create a static field 'throws' that holds exceptions thrown by our methods.
- SirtRef<Field> throws_sfield(self, AllocField(self));
+ SirtRef<mirror::Field> throws_sfield(self, AllocField(self));
klass->SetStaticField(1, throws_sfield.get());
throws_sfield->SetDexFieldIndex(1);
throws_sfield->SetDeclaringClass(klass.get());
@@ -2408,24 +2444,24 @@
size_t num_virtual_methods = methods->GetLength();
klass->SetVirtualMethods(AllocMethodArray(self, num_virtual_methods));
for (size_t i = 0; i < num_virtual_methods; ++i) {
- SirtRef<AbstractMethod> prototype(self, methods->Get(i));
+ SirtRef<mirror::AbstractMethod> prototype(self, methods->Get(i));
klass->SetVirtualMethod(i, CreateProxyMethod(self, klass, prototype));
}
klass->SetSuperClass(proxy_class); // The super class is java.lang.reflect.Proxy
- klass->SetStatus(Class::kStatusLoaded); // Class is now effectively in the loaded state
+ klass->SetStatus(mirror::Class::kStatusLoaded); // Class is now effectively in the loaded state
DCHECK(!Thread::Current()->IsExceptionPending());
// Link the fields and virtual methods, creating vtable and iftables
if (!LinkClass(klass, interfaces)) {
- klass->SetStatus(Class::kStatusError);
+ klass->SetStatus(mirror::Class::kStatusError);
return NULL;
}
{
ObjectLock lock(self, klass.get()); // Must hold lock on object when initializing.
interfaces_sfield->SetObject(klass.get(), interfaces);
throws_sfield->SetObject(klass.get(), throws);
- klass->SetStatus(Class::kStatusInitialized);
+ klass->SetStatus(mirror::Class::kStatusInitialized);
}
// sanity checks
@@ -2433,7 +2469,7 @@
CHECK(klass->GetIFields() == NULL);
CheckProxyConstructor(klass->GetDirectMethod(0));
for (size_t i = 0; i < num_virtual_methods; ++i) {
- SirtRef<AbstractMethod> prototype(self, methods->Get(i));
+ SirtRef<mirror::AbstractMethod> prototype(self, methods->Get(i));
CheckProxyMethod(klass->GetVirtualMethod(i), prototype);
}
@@ -2445,27 +2481,29 @@
name->ToModifiedUtf8().c_str()));
CHECK_EQ(PrettyField(klass->GetStaticField(1)), throws_field_name);
- SynthesizedProxyClass* synth_proxy_class = down_cast<SynthesizedProxyClass*>(klass.get());
+ mirror::SynthesizedProxyClass* synth_proxy_class =
+ down_cast<mirror::SynthesizedProxyClass*>(klass.get());
CHECK_EQ(synth_proxy_class->GetInterfaces(), interfaces);
CHECK_EQ(synth_proxy_class->GetThrows(), throws);
}
return klass.get();
}
-std::string ClassLinker::GetDescriptorForProxy(const Class* proxy_class) {
+std::string ClassLinker::GetDescriptorForProxy(const mirror::Class* proxy_class) {
DCHECK(proxy_class->IsProxyClass());
- String* name = proxy_class->GetName();
+ mirror::String* name = proxy_class->GetName();
DCHECK(name != NULL);
return DotToDescriptor(name->ToModifiedUtf8().c_str());
}
-AbstractMethod* ClassLinker::FindMethodForProxy(const Class* proxy_class, const AbstractMethod* proxy_method) {
+mirror::AbstractMethod* ClassLinker::FindMethodForProxy(const mirror::Class* proxy_class,
+ const mirror::AbstractMethod* proxy_method) {
DCHECK(proxy_class->IsProxyClass());
DCHECK(proxy_method->IsProxyMethod());
// Locate the dex cache of the original interface/Object
- DexCache* dex_cache = NULL;
+ mirror::DexCache* dex_cache = NULL;
{
- ObjectArray<Class>* resolved_types = proxy_method->GetDexCacheResolvedTypes();
+ mirror::ObjectArray<mirror::Class>* resolved_types = proxy_method->GetDexCacheResolvedTypes();
MutexLock mu(Thread::Current(), dex_lock_);
for (size_t i = 0; i != dex_caches_.size(); ++i) {
if (dex_caches_[i]->GetResolvedTypes() == resolved_types) {
@@ -2476,27 +2514,31 @@
}
CHECK(dex_cache != NULL);
uint32_t method_idx = proxy_method->GetDexMethodIndex();
- AbstractMethod* resolved_method = dex_cache->GetResolvedMethod(method_idx);
+ mirror::AbstractMethod* resolved_method = dex_cache->GetResolvedMethod(method_idx);
CHECK(resolved_method != NULL);
return resolved_method;
}
-AbstractMethod* ClassLinker::CreateProxyConstructor(Thread* self, SirtRef<Class>& klass, Class* proxy_class) {
+mirror::AbstractMethod* ClassLinker::CreateProxyConstructor(Thread* self,
+ SirtRef<mirror::Class>& klass,
+ mirror::Class* proxy_class) {
// Create constructor for Proxy that must initialize h
- ObjectArray<AbstractMethod>* proxy_direct_methods = proxy_class->GetDirectMethods();
+ mirror::ObjectArray<mirror::AbstractMethod>* proxy_direct_methods =
+ proxy_class->GetDirectMethods();
CHECK_EQ(proxy_direct_methods->GetLength(), 15);
- AbstractMethod* proxy_constructor = proxy_direct_methods->Get(2);
+ mirror::AbstractMethod* proxy_constructor = proxy_direct_methods->Get(2);
// Clone the existing constructor of Proxy (our constructor would just invoke it so steal its
// code_ too)
- AbstractMethod* constructor = down_cast<AbstractMethod*>(proxy_constructor->Clone(self));
+ mirror::AbstractMethod* constructor =
+ down_cast<mirror::AbstractMethod*>(proxy_constructor->Clone(self));
// Make this constructor public and fix the class to be our Proxy version
constructor->SetAccessFlags((constructor->GetAccessFlags() & ~kAccProtected) | kAccPublic);
constructor->SetDeclaringClass(klass.get());
return constructor;
}
-static void CheckProxyConstructor(AbstractMethod* constructor)
+static void CheckProxyConstructor(mirror::AbstractMethod* constructor)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
CHECK(constructor->IsConstructor());
MethodHelper mh(constructor);
@@ -2505,15 +2547,15 @@
DCHECK(constructor->IsPublic());
}
-AbstractMethod* ClassLinker::CreateProxyMethod(Thread* self, SirtRef<Class>& klass,
- SirtRef<AbstractMethod>& prototype) {
+mirror::AbstractMethod* ClassLinker::CreateProxyMethod(Thread* self, SirtRef<mirror::Class>& klass,
+ SirtRef<mirror::AbstractMethod>& prototype) {
// Ensure prototype is in dex cache so that we can use the dex cache to look up the overridden
// prototype method
prototype->GetDeclaringClass()->GetDexCache()->SetResolvedMethod(prototype->GetDexMethodIndex(),
prototype.get());
// We steal everything from the prototype (such as DexCache, invoke stub, etc.) then specialize
// as necessary
- AbstractMethod* method = down_cast<AbstractMethod*>(prototype->Clone(self));
+ mirror::AbstractMethod* method = down_cast<mirror::AbstractMethod*>(prototype->Clone(self));
// Set class to be the concrete proxy class and clear the abstract flag, modify exceptions to
// the intersection of throw exceptions as defined in Proxy
@@ -2522,7 +2564,8 @@
// At runtime the method looks like a reference and argument saving method, clone the code
// related parameters from this method.
- AbstractMethod* refs_and_args = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
+ mirror::AbstractMethod* refs_and_args =
+ Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
method->SetCoreSpillMask(refs_and_args->GetCoreSpillMask());
method->SetFpSpillMask(refs_and_args->GetFpSpillMask());
method->SetFrameSizeInBytes(refs_and_args->GetFrameSizeInBytes());
@@ -2536,7 +2579,8 @@
return method;
}
-static void CheckProxyMethod(AbstractMethod* method, SirtRef<AbstractMethod>& prototype)
+static void CheckProxyMethod(mirror::AbstractMethod* method,
+ SirtRef<mirror::AbstractMethod>& prototype)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// Basic sanity
CHECK(!prototype->IsFinal());
@@ -2560,18 +2604,18 @@
CHECK_EQ(mh.GetReturnType(), mh2.GetReturnType());
}
-bool ClassLinker::InitializeClass(Class* klass, bool can_run_clinit, bool can_init_statics) {
+bool ClassLinker::InitializeClass(mirror::Class* klass, bool can_run_clinit, bool can_init_statics) {
CHECK(klass->IsResolved() || klass->IsErroneous())
<< PrettyClass(klass) << ": state=" << klass->GetStatus();
Thread* self = Thread::Current();
- AbstractMethod* clinit = NULL;
+ mirror::AbstractMethod* clinit = NULL;
{
// see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
ObjectLock lock(self, klass);
- if (klass->GetStatus() == Class::kStatusInitialized) {
+ if (klass->GetStatus() == mirror::Class::kStatusInitialized) {
return true;
}
@@ -2580,11 +2624,11 @@
return false;
}
- if (klass->GetStatus() == Class::kStatusResolved ||
- klass->GetStatus() == Class::kStatusRetryVerificationAtRuntime) {
+ if (klass->GetStatus() == mirror::Class::kStatusResolved ||
+ klass->GetStatus() == mirror::Class::kStatusRetryVerificationAtRuntime) {
VerifyClass(klass);
- if (klass->GetStatus() != Class::kStatusVerified) {
- if (klass->GetStatus() == Class::kStatusError) {
+ if (klass->GetStatus() != mirror::Class::kStatusVerified) {
+ if (klass->GetStatus() == mirror::Class::kStatusError) {
CHECK(self->IsExceptionPending());
}
return false;
@@ -2606,7 +2650,7 @@
// to initializing and we need to wait. Either way, this
// invocation of InitializeClass will not be responsible for
// running <clinit> and will return.
- if (klass->GetStatus() == Class::kStatusInitializing) {
+ if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
// We caught somebody else in the act; was it us?
if (klass->GetClinitThreadId() == self->GetTid()) {
// Yes. That's fine. Return so we can continue initializing.
@@ -2617,15 +2661,15 @@
}
if (!ValidateSuperClassDescriptors(klass)) {
- klass->SetStatus(Class::kStatusError);
+ klass->SetStatus(mirror::Class::kStatusError);
lock.NotifyAll();
return false;
}
- DCHECK_EQ(klass->GetStatus(), Class::kStatusVerified) << PrettyClass(klass);
+ DCHECK_EQ(klass->GetStatus(), mirror::Class::kStatusVerified) << PrettyClass(klass);
klass->SetClinitThreadId(self->GetTid());
- klass->SetStatus(Class::kStatusInitializing);
+ klass->SetStatus(mirror::Class::kStatusInitializing);
}
uint64_t t0 = NanoTime();
@@ -2665,7 +2709,7 @@
if (self->IsExceptionPending()) {
WrapExceptionInInitializer();
- klass->SetStatus(Class::kStatusError);
+ klass->SetStatus(mirror::Class::kStatusError);
success = false;
} else {
RuntimeStats* global_stats = Runtime::Current()->GetStats();
@@ -2677,10 +2721,10 @@
// Set the class as initialized except if we can't initialize static fields and static field
// initialization is necessary.
if (!can_init_statics && has_static_field_initializers) {
- klass->SetStatus(Class::kStatusVerified); // Don't leave class in initializing state.
+ klass->SetStatus(mirror::Class::kStatusVerified); // Don't leave class in initializing state.
success = false;
} else {
- klass->SetStatus(Class::kStatusInitialized);
+ klass->SetStatus(mirror::Class::kStatusInitialized);
}
if (VLOG_IS_ON(class_linker)) {
ClassHelper kh(klass);
@@ -2692,7 +2736,7 @@
return success;
}
-bool ClassLinker::WaitForInitializeClass(Class* klass, Thread* self, ObjectLock& lock)
+bool ClassLinker::WaitForInitializeClass(mirror::Class* klass, Thread* self, ObjectLock& lock)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
while (true) {
self->AssertNoPendingException();
@@ -2703,14 +2747,14 @@
// "interruptShouldThrow" was set), bail out.
if (self->IsExceptionPending()) {
WrapExceptionInInitializer();
- klass->SetStatus(Class::kStatusError);
+ klass->SetStatus(mirror::Class::kStatusError);
return false;
}
// Spurious wakeup? Go back to waiting.
- if (klass->GetStatus() == Class::kStatusInitializing) {
+ if (klass->GetStatus() == mirror::Class::kStatusInitializing) {
continue;
}
- if (klass->GetStatus() == Class::kStatusVerified && Runtime::Current()->IsCompiler()) {
+ if (klass->GetStatus() == mirror::Class::kStatusVerified && Runtime::Current()->IsCompiler()) {
// Compile time initialization failed.
return false;
}
@@ -2729,16 +2773,16 @@
LOG(FATAL) << "Not Reached" << PrettyClass(klass);
}
-bool ClassLinker::ValidateSuperClassDescriptors(const Class* klass) {
+bool ClassLinker::ValidateSuperClassDescriptors(const mirror::Class* klass) {
if (klass->IsInterface()) {
return true;
}
// begin with the methods local to the superclass
if (klass->HasSuperClass() &&
klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
- const Class* super = klass->GetSuperClass();
+ const mirror::Class* super = klass->GetSuperClass();
for (int i = super->GetVTable()->GetLength() - 1; i >= 0; --i) {
- const AbstractMethod* method = klass->GetVTable()->Get(i);
+ const mirror::AbstractMethod* method = klass->GetVTable()->Get(i);
if (method != super->GetVTable()->Get(i) &&
!IsSameMethodSignatureInDifferentClassContexts(method, super, klass)) {
ThrowLinkageError("Class %s method %s resolves differently in superclass %s",
@@ -2748,12 +2792,12 @@
}
}
}
- IfTable* iftable = klass->GetIfTable();
+ mirror::IfTable* iftable = klass->GetIfTable();
for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
- Class* interface = iftable->GetInterface(i);
+ mirror::Class* interface = iftable->GetInterface(i);
if (klass->GetClassLoader() != interface->GetClassLoader()) {
for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
- const AbstractMethod* method = iftable->GetMethodArray(i)->Get(j);
+ const mirror::AbstractMethod* method = iftable->GetMethodArray(i)->Get(j);
if (!IsSameMethodSignatureInDifferentClassContexts(method, interface,
method->GetDeclaringClass())) {
ThrowLinkageError("Class %s method %s resolves differently in interface %s",
@@ -2770,9 +2814,9 @@
// Returns true if classes referenced by the signature of the method are the
// same classes in klass1 as they are in klass2.
-bool ClassLinker::IsSameMethodSignatureInDifferentClassContexts(const AbstractMethod* method,
- const Class* klass1,
- const Class* klass2) {
+bool ClassLinker::IsSameMethodSignatureInDifferentClassContexts(const mirror::AbstractMethod* method,
+ const mirror::Class* klass1,
+ const mirror::Class* klass2) {
if (klass1 == klass2) {
return true;
}
@@ -2803,29 +2847,29 @@
// Returns true if the descriptor resolves to the same class in the context of klass1 and klass2.
bool ClassLinker::IsSameDescriptorInDifferentClassContexts(const char* descriptor,
- const Class* klass1,
- const Class* klass2) {
+ const mirror::Class* klass1,
+ const mirror::Class* klass2) {
CHECK(descriptor != NULL);
CHECK(klass1 != NULL);
CHECK(klass2 != NULL);
if (klass1 == klass2) {
return true;
}
- Class* found1 = FindClass(descriptor, klass1->GetClassLoader());
+ mirror::Class* found1 = FindClass(descriptor, klass1->GetClassLoader());
if (found1 == NULL) {
Thread::Current()->ClearException();
}
- Class* found2 = FindClass(descriptor, klass2->GetClassLoader());
+ mirror::Class* found2 = FindClass(descriptor, klass2->GetClassLoader());
if (found2 == NULL) {
Thread::Current()->ClearException();
}
return found1 == found2;
}
-bool ClassLinker::InitializeSuperClass(Class* klass, bool can_run_clinit, bool can_init_fields) {
+bool ClassLinker::InitializeSuperClass(mirror::Class* klass, bool can_run_clinit, bool can_init_fields) {
CHECK(klass != NULL);
if (!klass->IsInterface() && klass->HasSuperClass()) {
- Class* super_class = klass->GetSuperClass();
+ mirror::Class* super_class = klass->GetSuperClass();
if (!super_class->IsInitialized()) {
CHECK(!super_class->IsInterface());
// Must hold lock on object when initializing and setting status.
@@ -2835,11 +2879,11 @@
if (!super_initialized) {
if (!can_run_clinit) {
// Don't set status to error when we can't run <clinit>.
- CHECK_EQ(klass->GetStatus(), Class::kStatusInitializing) << PrettyClass(klass);
- klass->SetStatus(Class::kStatusVerified);
+ CHECK_EQ(klass->GetStatus(), mirror::Class::kStatusInitializing) << PrettyClass(klass);
+ klass->SetStatus(mirror::Class::kStatusVerified);
return false;
}
- klass->SetStatus(Class::kStatusError);
+ klass->SetStatus(mirror::Class::kStatusError);
klass->NotifyAll();
return false;
}
@@ -2848,7 +2892,7 @@
return true;
}
-bool ClassLinker::EnsureInitialized(Class* c, bool can_run_clinit, bool can_init_fields) {
+bool ClassLinker::EnsureInitialized(mirror::Class* c, bool can_run_clinit, bool can_init_fields) {
DCHECK(c != NULL);
if (c->IsInitialized()) {
return true;
@@ -2864,8 +2908,8 @@
}
void ClassLinker::ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
- Class* c, SafeMap<uint32_t, Field*>& field_map) {
- ClassLoader* cl = c->GetClassLoader();
+ mirror::Class* c, SafeMap<uint32_t, mirror::Field*>& field_map) {
+ mirror::ClassLoader* cl = c->GetClassLoader();
const byte* class_data = dex_file.GetClassData(dex_class_def);
ClassDataItemIterator it(dex_file, class_data);
for (size_t i = 0; it.HasNextStaticField(); i++, it.Next()) {
@@ -2873,12 +2917,12 @@
}
}
-bool ClassLinker::InitializeStaticFields(Class* klass) {
+bool ClassLinker::InitializeStaticFields(mirror::Class* klass) {
size_t num_static_fields = klass->NumStaticFields();
if (num_static_fields == 0) {
return false;
}
- DexCache* dex_cache = klass->GetDexCache();
+ mirror::DexCache* dex_cache = klass->GetDexCache();
// TODO: this seems like the wrong check. do we really want !IsPrimitive && !IsArray?
if (dex_cache == NULL) {
return false;
@@ -2892,7 +2936,7 @@
if (it.HasNext()) {
// We reordered the fields, so we need to be able to map the field indexes to the right fields.
- SafeMap<uint32_t, Field*> field_map;
+ SafeMap<uint32_t, mirror::Field*> field_map;
ConstructFieldMap(dex_file, *dex_class_def, klass, field_map);
for (size_t i = 0; it.HasNext(); i++, it.Next()) {
it.ReadValueToField(field_map.Get(i));
@@ -2902,8 +2946,9 @@
return false;
}
-bool ClassLinker::LinkClass(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
- CHECK_EQ(Class::kStatusLoaded, klass->GetStatus());
+bool ClassLinker::LinkClass(SirtRef<mirror::Class>& klass,
+ mirror::ObjectArray<mirror::Class>* interfaces) {
+ CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
if (!LinkSuperClass(klass)) {
return false;
}
@@ -2918,19 +2963,19 @@
}
CreateReferenceInstanceOffsets(klass);
CreateReferenceStaticOffsets(klass);
- CHECK_EQ(Class::kStatusLoaded, klass->GetStatus());
- klass->SetStatus(Class::kStatusResolved);
+ CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
+ klass->SetStatus(mirror::Class::kStatusResolved);
return true;
}
-bool ClassLinker::LoadSuperAndInterfaces(SirtRef<Class>& klass, const DexFile& dex_file) {
- CHECK_EQ(Class::kStatusIdx, klass->GetStatus());
+bool ClassLinker::LoadSuperAndInterfaces(SirtRef<mirror::Class>& klass, const DexFile& dex_file) {
+ CHECK_EQ(mirror::Class::kStatusIdx, klass->GetStatus());
StringPiece descriptor(dex_file.StringByTypeIdx(klass->GetDexTypeIndex()));
const DexFile::ClassDef* class_def = dex_file.FindClassDef(descriptor);
CHECK(class_def != NULL);
uint16_t super_class_idx = class_def->superclass_idx_;
if (super_class_idx != DexFile::kDexNoIndex16) {
- Class* super_class = ResolveType(dex_file, super_class_idx, klass.get());
+ mirror::Class* super_class = ResolveType(dex_file, super_class_idx, klass.get());
if (super_class == NULL) {
DCHECK(Thread::Current()->IsExceptionPending());
return false;
@@ -2949,7 +2994,7 @@
if (interfaces != NULL) {
for (size_t i = 0; i < interfaces->Size(); i++) {
uint16_t idx = interfaces->GetTypeItem(i).type_idx_;
- Class* interface = ResolveType(dex_file, idx, klass.get());
+ mirror::Class* interface = ResolveType(dex_file, idx, klass.get());
if (interface == NULL) {
DCHECK(Thread::Current()->IsExceptionPending());
return false;
@@ -2966,13 +3011,13 @@
}
}
// Mark the class as loaded.
- klass->SetStatus(Class::kStatusLoaded);
+ klass->SetStatus(mirror::Class::kStatusLoaded);
return true;
}
-bool ClassLinker::LinkSuperClass(SirtRef<Class>& klass) {
+bool ClassLinker::LinkSuperClass(SirtRef<mirror::Class>& klass) {
CHECK(!klass->IsPrimitive());
- Class* super = klass->GetSuperClass();
+ mirror::Class* super = klass->GetSuperClass();
if (klass.get() == GetClassRoot(kJavaLangObject)) {
if (super != NULL) {
Thread::Current()->ThrowNewExceptionF("Ljava/lang/ClassFormatError;",
@@ -3031,7 +3076,8 @@
}
// Populate the class vtable and itable. Compute return type indices.
-bool ClassLinker::LinkMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
+bool ClassLinker::LinkMethods(SirtRef<mirror::Class>& klass,
+ mirror::ObjectArray<mirror::Class>* interfaces) {
if (klass->IsInterface()) {
// No vtable.
size_t count = klass->NumVirtualMethods();
@@ -3051,24 +3097,24 @@
return true;
}
-bool ClassLinker::LinkVirtualMethods(SirtRef<Class>& klass) {
+bool ClassLinker::LinkVirtualMethods(SirtRef<mirror::Class>& klass) {
Thread* self = Thread::Current();
if (klass->HasSuperClass()) {
uint32_t max_count = klass->NumVirtualMethods() + klass->GetSuperClass()->GetVTable()->GetLength();
size_t actual_count = klass->GetSuperClass()->GetVTable()->GetLength();
CHECK_LE(actual_count, max_count);
// TODO: do not assign to the vtable field until it is fully constructed.
- SirtRef<ObjectArray<AbstractMethod> >
+ SirtRef<mirror::ObjectArray<mirror::AbstractMethod> >
vtable(self, klass->GetSuperClass()->GetVTable()->CopyOf(self, max_count));
// See if any of our virtual methods override the superclass.
MethodHelper local_mh(NULL, this);
MethodHelper super_mh(NULL, this);
for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
- AbstractMethod* local_method = klass->GetVirtualMethodDuringLinking(i);
+ mirror::AbstractMethod* local_method = klass->GetVirtualMethodDuringLinking(i);
local_mh.ChangeMethod(local_method);
size_t j = 0;
for (; j < actual_count; ++j) {
- AbstractMethod* super_method = vtable->Get(j);
+ mirror::AbstractMethod* super_method = vtable->Get(j);
super_mh.ChangeMethod(super_method);
if (local_mh.HasSameNameAndSignature(&super_mh)) {
if (klass->CanAccessMember(super_method->GetDeclaringClass(), super_method->GetAccessFlags())) {
@@ -3112,10 +3158,10 @@
ThrowClassFormatError("Too many methods: %d", num_virtual_methods);
return false;
}
- SirtRef<ObjectArray<AbstractMethod> >
+ SirtRef<mirror::ObjectArray<mirror::AbstractMethod> >
vtable(self, AllocMethodArray(self, num_virtual_methods));
for (size_t i = 0; i < num_virtual_methods; ++i) {
- AbstractMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i);
+ mirror::AbstractMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i);
vtable->Set(i, virtual_method);
virtual_method->SetMethodIndex(i & 0xFFFF);
}
@@ -3124,7 +3170,8 @@
return true;
}
-bool ClassLinker::LinkInterfaceMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces) {
+bool ClassLinker::LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
+ mirror::ObjectArray<mirror::Class>* interfaces) {
size_t super_ifcount;
if (klass->HasSuperClass()) {
super_ifcount = klass->GetSuperClass()->GetIfTableCount();
@@ -3136,7 +3183,7 @@
uint32_t num_interfaces = interfaces == NULL ? kh.NumDirectInterfaces() : interfaces->GetLength();
ifcount += num_interfaces;
for (size_t i = 0; i < num_interfaces; i++) {
- Class* interface = interfaces == NULL ? kh.GetDirectInterface(i) : interfaces->Get(i);
+ mirror::Class* interface = interfaces == NULL ? kh.GetDirectInterface(i) : interfaces->Get(i);
ifcount += interface->GetIfTableCount();
}
if (ifcount == 0) {
@@ -3148,7 +3195,7 @@
if (ifcount == super_ifcount) {
// Class implements same interfaces as parent, are any of these not marker interfaces?
bool has_non_marker_interface = false;
- IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
+ mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
for (size_t i = 0; i < ifcount; ++i) {
if (super_iftable->GetMethodArrayCount(i) > 0) {
has_non_marker_interface = true;
@@ -3162,18 +3209,18 @@
}
}
Thread* self = Thread::Current();
- SirtRef<IfTable> iftable(self, AllocIfTable(self, ifcount));
+ SirtRef<mirror::IfTable> iftable(self, AllocIfTable(self, ifcount));
if (super_ifcount != 0) {
- IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
+ mirror::IfTable* super_iftable = klass->GetSuperClass()->GetIfTable();
for (size_t i = 0; i < super_ifcount; i++) {
- Class* super_interface = super_iftable->GetInterface(i);
+ mirror::Class* super_interface = super_iftable->GetInterface(i);
iftable->SetInterface(i, super_interface);
}
}
// Flatten the interface inheritance hierarchy.
size_t idx = super_ifcount;
for (size_t i = 0; i < num_interfaces; i++) {
- Class* interface = interfaces == NULL ? kh.GetDirectInterface(i) : interfaces->Get(i);
+ mirror::Class* interface = interfaces == NULL ? kh.GetDirectInterface(i) : interfaces->Get(i);
DCHECK(interface != NULL);
if (!interface->IsInterface()) {
ClassHelper ih(interface);
@@ -3186,7 +3233,7 @@
// Check if interface is already in iftable
bool duplicate = false;
for (size_t j = 0; j < idx; j++) {
- Class* existing_interface = iftable->GetInterface(j);
+ mirror::Class* existing_interface = iftable->GetInterface(j);
if (existing_interface == interface) {
duplicate = true;
break;
@@ -3197,10 +3244,10 @@
iftable->SetInterface(idx++, interface);
// Add this interface's non-duplicate super-interfaces.
for (int32_t j = 0; j < interface->GetIfTableCount(); j++) {
- Class* super_interface = interface->GetIfTable()->GetInterface(j);
+ mirror::Class* super_interface = interface->GetIfTable()->GetInterface(j);
bool super_duplicate = false;
for (size_t k = 0; k < idx; k++) {
- Class* existing_interface = iftable->GetInterface(k);
+ mirror::Class* existing_interface = iftable->GetInterface(k);
if (existing_interface == super_interface) {
super_duplicate = true;
break;
@@ -3214,7 +3261,7 @@
}
// Shrink iftable in case duplicates were found
if (idx < ifcount) {
- iftable.reset(down_cast<IfTable*>(iftable->CopyOf(self, idx * IfTable::kMax)));
+ iftable.reset(down_cast<mirror::IfTable*>(iftable->CopyOf(self, idx * mirror::IfTable::kMax)));
ifcount = idx;
} else {
CHECK_EQ(idx, ifcount);
@@ -3225,18 +3272,19 @@
if (klass->IsInterface()) {
return true;
}
- std::vector<AbstractMethod*> miranda_list;
+ std::vector<mirror::AbstractMethod*> miranda_list;
MethodHelper vtable_mh(NULL, this);
MethodHelper interface_mh(NULL, this);
for (size_t i = 0; i < ifcount; ++i) {
- Class* interface = iftable->GetInterface(i);
+ mirror::Class* interface = iftable->GetInterface(i);
size_t num_methods = interface->NumVirtualMethods();
if (num_methods > 0) {
- ObjectArray<AbstractMethod>* method_array = AllocMethodArray(self, num_methods);
+ mirror::ObjectArray<mirror::AbstractMethod>* method_array =
+ AllocMethodArray(self, num_methods);
iftable->SetMethodArray(i, method_array);
- ObjectArray<AbstractMethod>* vtable = klass->GetVTableDuringLinking();
+ mirror::ObjectArray<mirror::AbstractMethod>* vtable = klass->GetVTableDuringLinking();
for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
- AbstractMethod* interface_method = interface->GetVirtualMethod(j);
+ mirror::AbstractMethod* interface_method = interface->GetVirtualMethod(j);
interface_mh.ChangeMethod(interface_method);
int32_t k;
// For each method listed in the interface's method list, find the
@@ -3248,7 +3296,7 @@
// those don't end up in the virtual method table, so it shouldn't
// matter which direction we go. We walk it backward anyway.)
for (k = vtable->GetLength() - 1; k >= 0; --k) {
- AbstractMethod* vtable_method = vtable->Get(k);
+ mirror::AbstractMethod* vtable_method = vtable->Get(k);
vtable_mh.ChangeMethod(vtable_method);
if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
if (!vtable_method->IsPublic()) {
@@ -3262,9 +3310,9 @@
}
}
if (k < 0) {
- SirtRef<AbstractMethod> miranda_method(self, NULL);
+ SirtRef<mirror::AbstractMethod> miranda_method(self, NULL);
for (size_t mir = 0; mir < miranda_list.size(); mir++) {
- AbstractMethod* mir_method = miranda_list[mir];
+ mirror::AbstractMethod* mir_method = miranda_list[mir];
vtable_mh.ChangeMethod(mir_method);
if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
miranda_method.reset(miranda_list[mir]);
@@ -3273,7 +3321,7 @@
}
if (miranda_method.get() == NULL) {
// point the interface table at a phantom slot
- miranda_method.reset(down_cast<AbstractMethod*>(interface_method->Clone(self)));
+ miranda_method.reset(down_cast<mirror::AbstractMethod*>(interface_method->Clone(self)));
miranda_list.push_back(miranda_method.get());
}
method_array->Set(j, miranda_method.get());
@@ -3288,13 +3336,14 @@
? AllocMethodArray(self, new_method_count)
: klass->GetVirtualMethods()->CopyOf(self, new_method_count));
- SirtRef<ObjectArray<AbstractMethod> > vtable(self, klass->GetVTableDuringLinking());
+ SirtRef<mirror::ObjectArray<mirror::AbstractMethod> >
+ vtable(self, klass->GetVTableDuringLinking());
CHECK(vtable.get() != NULL);
int old_vtable_count = vtable->GetLength();
int new_vtable_count = old_vtable_count + miranda_list.size();
vtable.reset(vtable->CopyOf(self, new_vtable_count));
for (size_t i = 0; i < miranda_list.size(); ++i) {
- AbstractMethod* method = miranda_list[i];
+ mirror::AbstractMethod* method = miranda_list[i];
// Leave the declaring class alone as type indices are relative to it
method->SetAccessFlags(method->GetAccessFlags() | kAccMiranda);
method->SetMethodIndex(0xFFFF & (old_vtable_count + i));
@@ -3305,7 +3354,7 @@
klass->SetVTable(vtable.get());
}
- ObjectArray<AbstractMethod>* vtable = klass->GetVTableDuringLinking();
+ mirror::ObjectArray<mirror::AbstractMethod>* vtable = klass->GetVTableDuringLinking();
for (int i = 0; i < vtable->GetLength(); ++i) {
CHECK(vtable->Get(i) != NULL);
}
@@ -3315,12 +3364,12 @@
return true;
}
-bool ClassLinker::LinkInstanceFields(SirtRef<Class>& klass) {
+bool ClassLinker::LinkInstanceFields(SirtRef<mirror::Class>& klass) {
CHECK(klass.get() != NULL);
return LinkFields(klass, false);
}
-bool ClassLinker::LinkStaticFields(SirtRef<Class>& klass) {
+bool ClassLinker::LinkStaticFields(SirtRef<mirror::Class>& klass) {
CHECK(klass.get() != NULL);
size_t allocated_class_size = klass->GetClassSize();
bool success = LinkFields(klass, true);
@@ -3333,7 +3382,8 @@
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
: fh_(fh) {}
// No thread safety analysis as will be called from STL. Checked lock held in constructor.
- bool operator()(const Field* field1, const Field* field2) NO_THREAD_SAFETY_ANALYSIS {
+ bool operator()(const mirror::Field* field1, const mirror::Field* field2)
+ NO_THREAD_SAFETY_ANALYSIS {
// First come reference fields, then 64-bit, and finally 32-bit
fh_->ChangeField(field1);
Primitive::Type type1 = fh_->GetTypeAsPrimitiveType();
@@ -3360,11 +3410,11 @@
FieldHelper* fh_;
};
-bool ClassLinker::LinkFields(SirtRef<Class>& klass, bool is_static) {
+bool ClassLinker::LinkFields(SirtRef<mirror::Class>& klass, bool is_static) {
size_t num_fields =
is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
- ObjectArray<Field>* fields =
+ mirror::ObjectArray<mirror::Field>* fields =
is_static ? klass->GetSFields() : klass->GetIFields();
// Initialize size and field_offset
@@ -3372,9 +3422,9 @@
MemberOffset field_offset(0);
if (is_static) {
size = klass->GetClassSize();
- field_offset = Class::FieldsOffset();
+ field_offset = mirror::Class::FieldsOffset();
} else {
- Class* super_class = klass->GetSuperClass();
+ mirror::Class* super_class = klass->GetSuperClass();
if (super_class != NULL) {
CHECK(super_class->IsResolved());
field_offset = MemberOffset(super_class->GetObjectSize());
@@ -3386,7 +3436,7 @@
// we want a relatively stable order so that adding new fields
// minimizes disruption of C++ version such as Class and Method.
- std::deque<Field*> grouped_and_sorted_fields;
+ std::deque<mirror::Field*> grouped_and_sorted_fields;
for (size_t i = 0; i < num_fields; i++) {
grouped_and_sorted_fields.push_back(fields->Get(i));
}
@@ -3399,7 +3449,7 @@
size_t current_field = 0;
size_t num_reference_fields = 0;
for (; current_field < num_fields; current_field++) {
- Field* field = grouped_and_sorted_fields.front();
+ mirror::Field* field = grouped_and_sorted_fields.front();
fh.ChangeField(field);
Primitive::Type type = fh.GetTypeAsPrimitiveType();
bool isPrimitive = type != Primitive::kPrimNot;
@@ -3418,7 +3468,7 @@
// into place. If we can't find one, we'll have to pad it.
if (current_field != num_fields && !IsAligned<8>(field_offset.Uint32Value())) {
for (size_t i = 0; i < grouped_and_sorted_fields.size(); i++) {
- Field* field = grouped_and_sorted_fields[i];
+ mirror::Field* field = grouped_and_sorted_fields[i];
fh.ChangeField(field);
Primitive::Type type = fh.GetTypeAsPrimitiveType();
CHECK(type != Primitive::kPrimNot); // should only be working on primitive types
@@ -3439,7 +3489,7 @@
// finish assigning field offsets to all fields.
DCHECK(current_field == num_fields || IsAligned<8>(field_offset.Uint32Value()));
while (!grouped_and_sorted_fields.empty()) {
- Field* field = grouped_and_sorted_fields.front();
+ mirror::Field* field = grouped_and_sorted_fields.front();
grouped_and_sorted_fields.pop_front();
fh.ChangeField(field);
Primitive::Type type = fh.GetTypeAsPrimitiveType();
@@ -3469,12 +3519,13 @@
// non-reference fields, and all double-wide fields are aligned.
bool seen_non_ref = false;
for (size_t i = 0; i < num_fields; i++) {
- Field* field = fields->Get(i);
+ mirror::Field* field = fields->Get(i);
if (false) { // enable to debug field layout
LOG(INFO) << "LinkFields: " << (is_static ? "static" : "instance")
<< " class=" << PrettyClass(klass.get())
<< " field=" << PrettyField(field)
- << " offset=" << field->GetField32(MemberOffset(Field::OffsetOffset()), false);
+ << " offset=" << field->GetField32(MemberOffset(mirror::Field::OffsetOffset()),
+ false);
}
fh.ChangeField(field);
Primitive::Type type = fh.GetTypeAsPrimitiveType();
@@ -3512,9 +3563,9 @@
// Set the bitmap of reference offsets, refOffsets, from the ifields
// list.
-void ClassLinker::CreateReferenceInstanceOffsets(SirtRef<Class>& klass) {
+void ClassLinker::CreateReferenceInstanceOffsets(SirtRef<mirror::Class>& klass) {
uint32_t reference_offsets = 0;
- Class* super_class = klass->GetSuperClass();
+ mirror::Class* super_class = klass->GetSuperClass();
if (super_class != NULL) {
reference_offsets = super_class->GetReferenceInstanceOffsets();
// If our superclass overflowed, we don't stand a chance.
@@ -3526,23 +3577,23 @@
CreateReferenceOffsets(klass, false, reference_offsets);
}
-void ClassLinker::CreateReferenceStaticOffsets(SirtRef<Class>& klass) {
+void ClassLinker::CreateReferenceStaticOffsets(SirtRef<mirror::Class>& klass) {
CreateReferenceOffsets(klass, true, 0);
}
-void ClassLinker::CreateReferenceOffsets(SirtRef<Class>& klass, bool is_static,
+void ClassLinker::CreateReferenceOffsets(SirtRef<mirror::Class>& klass, bool is_static,
uint32_t reference_offsets) {
size_t num_reference_fields =
is_static ? klass->NumReferenceStaticFieldsDuringLinking()
: klass->NumReferenceInstanceFieldsDuringLinking();
- const ObjectArray<Field>* fields =
+ const mirror::ObjectArray<mirror::Field>* fields =
is_static ? klass->GetSFields() : klass->GetIFields();
// All of the fields that contain object references are guaranteed
// to be at the beginning of the fields list.
for (size_t i = 0; i < num_reference_fields; ++i) {
// Note that byte_offset is the offset from the beginning of
// object, not the offset into instance data
- const Field* field = fields->Get(i);
+ const mirror::Field* field = fields->Get(i);
MemberOffset byte_offset = field->GetOffsetDuringLinking();
CHECK_EQ(byte_offset.Uint32Value() & (CLASS_OFFSET_ALIGNMENT - 1), 0U);
if (CLASS_CAN_ENCODE_OFFSET(byte_offset.Uint32Value())) {
@@ -3562,27 +3613,27 @@
}
}
-String* ClassLinker::ResolveString(const DexFile& dex_file,
- uint32_t string_idx, DexCache* dex_cache) {
+mirror::String* ClassLinker::ResolveString(const DexFile& dex_file,
+ uint32_t string_idx, mirror::DexCache* dex_cache) {
DCHECK(dex_cache != NULL);
- String* resolved = dex_cache->GetResolvedString(string_idx);
+ mirror::String* resolved = dex_cache->GetResolvedString(string_idx);
if (resolved != NULL) {
return resolved;
}
const DexFile::StringId& string_id = dex_file.GetStringId(string_idx);
int32_t utf16_length = dex_file.GetStringLength(string_id);
const char* utf8_data = dex_file.GetStringData(string_id);
- String* string = intern_table_->InternStrong(utf16_length, utf8_data);
+ mirror::String* string = intern_table_->InternStrong(utf16_length, utf8_data);
dex_cache->SetResolvedString(string_idx, string);
return string;
}
-Class* ClassLinker::ResolveType(const DexFile& dex_file,
- uint16_t type_idx,
- DexCache* dex_cache,
- ClassLoader* class_loader) {
+mirror::Class* ClassLinker::ResolveType(const DexFile& dex_file,
+ uint16_t type_idx,
+ mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader) {
DCHECK(dex_cache != NULL);
- Class* resolved = dex_cache->GetResolvedType(type_idx);
+ mirror::Class* resolved = dex_cache->GetResolvedType(type_idx);
if (resolved == NULL) {
const char* descriptor = dex_file.StringByTypeIdx(type_idx);
resolved = FindClass(descriptor, class_loader);
@@ -3604,21 +3655,21 @@
return resolved;
}
-AbstractMethod* ClassLinker::ResolveMethod(const DexFile& dex_file,
- uint32_t method_idx,
- DexCache* dex_cache,
- ClassLoader* class_loader,
- const AbstractMethod* referrer,
- InvokeType type) {
+mirror::AbstractMethod* ClassLinker::ResolveMethod(const DexFile& dex_file,
+ uint32_t method_idx,
+ mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader,
+ const mirror::AbstractMethod* referrer,
+ InvokeType type) {
DCHECK(dex_cache != NULL);
// Check for hit in the dex cache.
- AbstractMethod* resolved = dex_cache->GetResolvedMethod(method_idx);
+ mirror::AbstractMethod* resolved = dex_cache->GetResolvedMethod(method_idx);
if (resolved != NULL) {
return resolved;
}
// Fail, get the declaring class.
const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
- Class* klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
+ mirror::Class* klass = ResolveType(dex_file, method_id.class_idx_, dex_cache, class_loader);
if (klass == NULL) {
DCHECK(Thread::Current()->IsExceptionPending());
return NULL;
@@ -3689,8 +3740,8 @@
// If we found something, check that it can be accessed by the referrer.
if (resolved != NULL && referrer != NULL) {
- Class* methods_class = resolved->GetDeclaringClass();
- Class* referring_class = referrer->GetDeclaringClass();
+ mirror::Class* methods_class = resolved->GetDeclaringClass();
+ mirror::Class* referring_class = referrer->GetDeclaringClass();
if (!referring_class->CanAccess(methods_class)) {
ThrowIllegalAccessErrorClassForMethodDispatch(referring_class, methods_class,
referrer, resolved, type);
@@ -3751,18 +3802,18 @@
}
}
-Field* ClassLinker::ResolveField(const DexFile& dex_file,
- uint32_t field_idx,
- DexCache* dex_cache,
- ClassLoader* class_loader,
- bool is_static) {
+mirror::Field* ClassLinker::ResolveField(const DexFile& dex_file,
+ uint32_t field_idx,
+ mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader,
+ bool is_static) {
DCHECK(dex_cache != NULL);
- Field* resolved = dex_cache->GetResolvedField(field_idx);
+ mirror::Field* resolved = dex_cache->GetResolvedField(field_idx);
if (resolved != NULL) {
return resolved;
}
const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
- Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
+ mirror::Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
if (klass == NULL) {
DCHECK(Thread::Current()->IsExceptionPending());
return NULL;
@@ -3791,17 +3842,17 @@
return resolved;
}
-Field* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
- uint32_t field_idx,
- DexCache* dex_cache,
- ClassLoader* class_loader) {
+mirror::Field* ClassLinker::ResolveFieldJLS(const DexFile& dex_file,
+ uint32_t field_idx,
+ mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader) {
DCHECK(dex_cache != NULL);
- Field* resolved = dex_cache->GetResolvedField(field_idx);
+ mirror::Field* resolved = dex_cache->GetResolvedField(field_idx);
if (resolved != NULL) {
return resolved;
}
const DexFile::FieldId& field_id = dex_file.GetFieldId(field_idx);
- Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
+ mirror::Class* klass = ResolveType(dex_file, field_id.class_idx_, dex_cache, class_loader);
if (klass == NULL) {
DCHECK(Thread::Current()->IsExceptionPending());
return NULL;
@@ -3818,9 +3869,10 @@
return resolved;
}
-const char* ClassLinker::MethodShorty(uint32_t method_idx, AbstractMethod* referrer, uint32_t* length) {
- Class* declaring_class = referrer->GetDeclaringClass();
- DexCache* dex_cache = declaring_class->GetDexCache();
+const char* ClassLinker::MethodShorty(uint32_t method_idx, mirror::AbstractMethod* referrer,
+ uint32_t* length) {
+ mirror::Class* declaring_class = referrer->GetDeclaringClass();
+ mirror::DexCache* dex_cache = declaring_class->GetDexCache();
const DexFile& dex_file = *dex_cache->GetDexFile();
const DexFile::MethodId& method_id = dex_file.GetMethodId(method_idx);
return dex_file.GetMethodShorty(method_id, length);
@@ -3829,7 +3881,7 @@
void ClassLinker::DumpAllClasses(int flags) const {
// TODO: at the time this was written, it wasn't safe to call PrettyField with the ClassLinker
// lock held, because it might need to resolve a field's type, which would try to take the lock.
- std::vector<Class*> all_classes;
+ std::vector<mirror::Class*> all_classes;
{
MutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
typedef Table::const_iterator It; // TODO: C++0x auto
@@ -3865,7 +3917,7 @@
return dex_lock_.GetExclusiveOwnerTid();
}
-void ClassLinker::SetClassRoot(ClassRoot class_root, Class* klass) {
+void ClassLinker::SetClassRoot(ClassRoot class_root, mirror::Class* klass) {
DCHECK(!init_done_);
DCHECK(klass != NULL);
diff --git a/src/class_linker.h b/src/class_linker.h
index 09a43c5..3039d55 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -23,23 +23,26 @@
#include "base/macros.h"
#include "base/mutex.h"
-#include "dex_cache.h"
#include "dex_file.h"
#include "gtest/gtest.h"
-#include "heap.h"
+#include "root_visitor.h"
#include "oat_file.h"
-#include "object.h"
-#include "safe_map.h"
namespace art {
-
+namespace mirror {
class ClassLoader;
+class DexCache;
+class DexCacheTest_Open_Test;
+class IfTable;
+template<class T> class ObjectArray;
+class StackTraceElement;
+}
class ImageSpace;
class InternTable;
class ObjectLock;
template<class T> class SirtRef;
-typedef bool (ClassVisitor)(Class* c, void* arg);
+typedef bool (ClassVisitor)(mirror::Class* c, void* arg);
class ClassLinker {
public:
@@ -56,33 +59,33 @@
// Finds a class by its descriptor, loading it if necessary.
// If class_loader is null, searches boot_class_path_.
- Class* FindClass(const char* descriptor, ClassLoader* class_loader)
+ mirror::Class* FindClass(const char* descriptor, mirror::ClassLoader* class_loader)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Class* FindSystemClass(const char* descriptor)
+ mirror::Class* FindSystemClass(const char* descriptor)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Define a new a class based on a ClassDef from a DexFile
- Class* DefineClass(const StringPiece& descriptor, ClassLoader* class_loader,
- const DexFile& dex_file, const DexFile::ClassDef& dex_class_def)
+ mirror::Class* DefineClass(const StringPiece& descriptor, mirror::ClassLoader* class_loader,
+ const DexFile& dex_file, const DexFile::ClassDef& dex_class_def)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Finds a class by its descriptor, returning NULL if it isn't wasn't loaded
// by the given 'class_loader'.
- Class* LookupClass(const char* descriptor, const ClassLoader* class_loader)
+ mirror::Class* LookupClass(const char* descriptor, const mirror::ClassLoader* class_loader)
LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Finds all the classes with the given descriptor, regardless of ClassLoader.
- void LookupClasses(const char* descriptor, std::vector<Class*>& classes)
+ void LookupClasses(const char* descriptor, std::vector<mirror::Class*>& classes)
LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Class* FindPrimitiveClass(char type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ mirror::Class* FindPrimitiveClass(char type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// General class unloading is not supported, this is used to prune
// unwanted classes during image writing.
- bool RemoveClass(const char* descriptor, const ClassLoader* class_loader)
+ bool RemoveClass(const char* descriptor, const mirror::ClassLoader* class_loader)
LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -98,27 +101,20 @@
// Resolve a String with the given index from the DexFile, storing the
// result in the DexCache. The referrer is used to identify the
// target DexCache and ClassLoader to use for resolution.
- String* ResolveString(uint32_t string_idx, const AbstractMethod* referrer)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- String* resolved_string = referrer->GetDexCacheStrings()->Get(string_idx);
- if (UNLIKELY(resolved_string == NULL)) {
- Class* declaring_class = referrer->GetDeclaringClass();
- DexCache* dex_cache = declaring_class->GetDexCache();
- const DexFile& dex_file = *dex_cache->GetDexFile();
- resolved_string = ResolveString(dex_file, string_idx, dex_cache);
- }
- return resolved_string;
- }
+ mirror::String* ResolveString(uint32_t string_idx, const mirror::AbstractMethod* referrer)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Resolve a String with the given index from the DexFile, storing the
// result in the DexCache.
- String* ResolveString(const DexFile& dex_file, uint32_t string_idx, DexCache* dex_cache)
+ mirror::String* ResolveString(const DexFile& dex_file, uint32_t string_idx,
+ mirror::DexCache* dex_cache)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Resolve a Type with the given index from the DexFile, storing the
// result in the DexCache. The referrer is used to identity the
// target DexCache and ClassLoader to use for resolution.
- Class* ResolveType(const DexFile& dex_file, uint16_t type_idx, const Class* referrer)
+ mirror::Class* ResolveType(const DexFile& dex_file, uint16_t type_idx,
+ const mirror::Class* referrer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return ResolveType(dex_file,
type_idx,
@@ -129,40 +125,20 @@
// Resolve a Type with the given index from the DexFile, storing the
// result in the DexCache. The referrer is used to identify the
// target DexCache and ClassLoader to use for resolution.
- Class* ResolveType(uint16_t type_idx, const AbstractMethod* referrer)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Class* resolved_type = referrer->GetDexCacheResolvedTypes()->Get(type_idx);
- if (UNLIKELY(resolved_type == NULL)) {
- Class* declaring_class = referrer->GetDeclaringClass();
- DexCache* dex_cache = declaring_class->GetDexCache();
- ClassLoader* class_loader = declaring_class->GetClassLoader();
- const DexFile& dex_file = *dex_cache->GetDexFile();
- resolved_type = ResolveType(dex_file, type_idx, dex_cache, class_loader);
- }
- return resolved_type;
- }
+ mirror::Class* ResolveType(uint16_t type_idx, const mirror::AbstractMethod* referrer)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Class* ResolveType(uint16_t type_idx, const Field* referrer)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Class* declaring_class = referrer->GetDeclaringClass();
- DexCache* dex_cache = declaring_class->GetDexCache();
- Class* resolved_type = dex_cache->GetResolvedType(type_idx);
- if (UNLIKELY(resolved_type == NULL)) {
- ClassLoader* class_loader = declaring_class->GetClassLoader();
- const DexFile& dex_file = *dex_cache->GetDexFile();
- resolved_type = ResolveType(dex_file, type_idx, dex_cache, class_loader);
- }
- return resolved_type;
- }
+ mirror::Class* ResolveType(uint16_t type_idx, const mirror::Field* referrer)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Resolve a type with the given ID from the DexFile, storing the
// result in DexCache. The ClassLoader is used to search for the
// type, since it may be referenced from but not contained within
// the given DexFile.
- Class* ResolveType(const DexFile& dex_file,
- uint16_t type_idx,
- DexCache* dex_cache,
- ClassLoader* class_loader)
+ mirror::Class* ResolveType(const DexFile& dex_file,
+ uint16_t type_idx,
+ mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Resolve a method with a given ID from the DexFile, storing the
@@ -170,50 +146,31 @@
// in ResolveType. What is unique is the method type argument which
// is used to determine if this method is a direct, static, or
// virtual method.
- AbstractMethod* ResolveMethod(const DexFile& dex_file,
- uint32_t method_idx,
- DexCache* dex_cache,
- ClassLoader* class_loader,
- const AbstractMethod* referrer,
- InvokeType type)
+ mirror::AbstractMethod* ResolveMethod(const DexFile& dex_file,
+ uint32_t method_idx,
+ mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader,
+ const mirror::AbstractMethod* referrer,
+ InvokeType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- AbstractMethod* ResolveMethod(uint32_t method_idx, const AbstractMethod* referrer, InvokeType type)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* resolved_method = referrer->GetDexCacheResolvedMethods()->Get(method_idx);
- if (UNLIKELY(resolved_method == NULL || resolved_method->IsRuntimeMethod())) {
- Class* declaring_class = referrer->GetDeclaringClass();
- DexCache* dex_cache = declaring_class->GetDexCache();
- ClassLoader* class_loader = declaring_class->GetClassLoader();
- const DexFile& dex_file = *dex_cache->GetDexFile();
- resolved_method = ResolveMethod(dex_file, method_idx, dex_cache, class_loader, referrer, type);
- }
- return resolved_method;
- }
+ mirror::AbstractMethod* ResolveMethod(uint32_t method_idx, const mirror::AbstractMethod* referrer,
+ InvokeType type)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Field* ResolveField(uint32_t field_idx, const AbstractMethod* referrer, bool is_static)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* resolved_field =
- referrer->GetDeclaringClass()->GetDexCache()->GetResolvedField(field_idx);
- if (UNLIKELY(resolved_field == NULL)) {
- Class* declaring_class = referrer->GetDeclaringClass();
- DexCache* dex_cache = declaring_class->GetDexCache();
- ClassLoader* class_loader = declaring_class->GetClassLoader();
- const DexFile& dex_file = *dex_cache->GetDexFile();
- resolved_field = ResolveField(dex_file, field_idx, dex_cache, class_loader, is_static);
- }
- return resolved_field;
- }
+ mirror::Field* ResolveField(uint32_t field_idx, const mirror::AbstractMethod* referrer,
+ bool is_static)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Resolve a field with a given ID from the DexFile, storing the
// result in DexCache. The ClassLinker and ClassLoader are used as
// in ResolveType. What is unique is the is_static argument which is
// used to determine if we are resolving a static or non-static
// field.
- Field* ResolveField(const DexFile& dex_file,
+ mirror::Field* ResolveField(const DexFile& dex_file,
uint32_t field_idx,
- DexCache* dex_cache,
- ClassLoader* class_loader,
+ mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader,
bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -221,20 +178,20 @@
// result in DexCache. The ClassLinker and ClassLoader are used as
// in ResolveType. No is_static argument is provided so that Java
// field resolution semantics are followed.
- Field* ResolveFieldJLS(const DexFile& dex_file,
- uint32_t field_idx,
- DexCache* dex_cache,
- ClassLoader* class_loader)
+ mirror::Field* ResolveFieldJLS(const DexFile& dex_file,
+ uint32_t field_idx,
+ mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Get shorty from method index without resolution. Used to do handlerization.
- const char* MethodShorty(uint32_t method_idx, AbstractMethod* referrer, uint32_t* length)
+ const char* MethodShorty(uint32_t method_idx, mirror::AbstractMethod* referrer, uint32_t* length)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Returns true on success, false if there's an exception pending.
// can_run_clinit=false allows the compiler to attempt to init a class,
// given the restriction that no <clinit> execution is possible.
- bool EnsureInitialized(Class* c, bool can_run_clinit, bool can_init_fields)
+ bool EnsureInitialized(mirror::Class* c, bool can_run_clinit, bool can_init_fields)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Initializes classes that have instances in the image but that have
@@ -244,7 +201,7 @@
void RegisterDexFile(const DexFile& dex_file)
LOCKS_EXCLUDED(dex_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void RegisterDexFile(const DexFile& dex_file, SirtRef<DexCache>& dex_cache)
+ void RegisterDexFile(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache)
LOCKS_EXCLUDED(dex_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -262,15 +219,15 @@
void VisitClassesWithoutClassesLock(ClassVisitor* visitor, void* arg) const
LOCKS_EXCLUDED(Locks::classlinker_classes_lock_);
- void VisitRoots(Heap::RootVisitor* visitor, void* arg)
+ void VisitRoots(RootVisitor* visitor, void* arg)
LOCKS_EXCLUDED(Locks::classlinker_classes_lock_, dex_lock_);
- DexCache* FindDexCache(const DexFile& dex_file) const
+ mirror::DexCache* FindDexCache(const DexFile& dex_file) const
LOCKS_EXCLUDED(dex_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
bool IsDexFileRegistered(const DexFile& dex_file) const
LOCKS_EXCLUDED(dex_lock_);
- void FixupDexCaches(AbstractMethod* resolution_method) const
+ void FixupDexCaches(mirror::AbstractMethod* resolution_method) const
LOCKS_EXCLUDED(dex_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -310,66 +267,54 @@
// TODO: replace this with multiple methods that allocate the correct managed type.
template <class T>
- ObjectArray<T>* AllocObjectArray(Thread* self, size_t length)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return ObjectArray<T>::Alloc(self, GetClassRoot(kObjectArrayClass), length);
- }
-
- ObjectArray<Class>* AllocClassArray(Thread* self, size_t length)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return ObjectArray<Class>::Alloc(self, GetClassRoot(kClassArrayClass), length);
- }
-
- ObjectArray<String>* AllocStringArray(Thread* self, size_t length)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return ObjectArray<String>::Alloc(self, GetClassRoot(kJavaLangStringArrayClass), length);
- }
-
- ObjectArray<AbstractMethod>* AllocAbstractMethodArray(Thread* self, size_t length)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return ObjectArray<AbstractMethod>::Alloc(self,
- GetClassRoot(kJavaLangReflectAbstractMethodArrayClass), length);
- }
-
- ObjectArray<AbstractMethod>* AllocMethodArray(Thread* self, size_t length)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return ObjectArray<AbstractMethod>::Alloc(self,
- GetClassRoot(kJavaLangReflectMethodArrayClass), length);
- }
-
- IfTable* AllocIfTable(Thread* self, size_t ifcount) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return down_cast<IfTable*>(
- IfTable::Alloc(self, GetClassRoot(kObjectArrayClass), ifcount * IfTable::kMax));
- }
-
- ObjectArray<Field>* AllocFieldArray(Thread* self, size_t length)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return ObjectArray<Field>::Alloc(self, GetClassRoot(kJavaLangReflectFieldArrayClass), length);
- }
-
- ObjectArray<StackTraceElement>* AllocStackTraceElementArray(Thread* self, size_t length)
+ mirror::ObjectArray<T>* AllocObjectArray(Thread* self, size_t length)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void VerifyClass(Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool VerifyClassUsingOatFile(const DexFile& dex_file, Class* klass,
- Class::Status& oat_file_class_status)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void ResolveClassExceptionHandlerTypes(const DexFile& dex_file, Class* klass)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, AbstractMethod* klass)
+ mirror::ObjectArray<mirror::Class>* AllocClassArray(Thread* self, size_t length)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Class* CreateProxyClass(String* name, ObjectArray<Class>* interfaces, ClassLoader* loader,
- ObjectArray<AbstractMethod>* methods, ObjectArray<ObjectArray<Class> >* throws)
+ mirror::ObjectArray<mirror::String>* AllocStringArray(Thread* self, size_t length)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- std::string GetDescriptorForProxy(const Class* proxy_class)
+
+ mirror::ObjectArray<mirror::AbstractMethod>* AllocAbstractMethodArray(Thread* self, size_t length)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- AbstractMethod* FindMethodForProxy(const Class* proxy_class, const AbstractMethod* proxy_method)
+
+ mirror::ObjectArray<mirror::AbstractMethod>* AllocMethodArray(Thread* self, size_t length)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ mirror::IfTable* AllocIfTable(Thread* self, size_t ifcount)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ mirror::ObjectArray<mirror::Field>* AllocFieldArray(Thread* self, size_t length)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ mirror::ObjectArray<mirror::StackTraceElement>* AllocStackTraceElementArray(Thread* self,
+ size_t length)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ void VerifyClass(mirror::Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ bool VerifyClassUsingOatFile(const DexFile& dex_file, mirror::Class* klass,
+ mirror::Class::Status& oat_file_class_status)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void ResolveClassExceptionHandlerTypes(const DexFile& dex_file, mirror::Class* klass)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, mirror::AbstractMethod* klass)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ mirror::Class* CreateProxyClass(mirror::String* name, mirror::ObjectArray<mirror::Class>* interfaces,
+ mirror::ClassLoader* loader,
+ mirror::ObjectArray<mirror::AbstractMethod>* methods,
+ mirror::ObjectArray<mirror::ObjectArray<mirror::Class> >* throws)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ std::string GetDescriptorForProxy(const mirror::Class* proxy_class)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ mirror::AbstractMethod* FindMethodForProxy(const mirror::Class* proxy_class,
+ const mirror::AbstractMethod* proxy_method)
LOCKS_EXCLUDED(dex_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Get the oat code for a method when its class isn't yet initialized
- const void* GetOatCodeFor(const AbstractMethod* method)
+ const void* GetOatCodeFor(const mirror::AbstractMethod* method)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Get the oat code for a method from a method index.
@@ -389,7 +334,7 @@
private:
explicit ClassLinker(InternTable*);
- const OatFile::OatMethod GetOatMethodFor(const AbstractMethod* method)
+ const OatFile::OatMethod GetOatMethodFor(const mirror::AbstractMethod* method)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Initialize class linker by bootstraping from dex files
@@ -401,43 +346,41 @@
OatFile* OpenOat(const ImageSpace* space)
LOCKS_EXCLUDED(dex_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- static void InitFromImageCallback(Object* obj, void* arg)
+ static void InitFromImageCallback(mirror::Object* obj, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void FinishInit() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// For early bootstrapping by Init
- Class* AllocClass(Thread* self, Class* java_lang_Class, size_t class_size)
+ mirror::Class* AllocClass(Thread* self, mirror::Class* java_lang_Class, size_t class_size)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- // Alloc* convenience functions to avoid needing to pass in Class*
+ // Alloc* convenience functions to avoid needing to pass in mirror::Class*
// values that are known to the ClassLinker such as
// kObjectArrayClass and kJavaLangString etc.
- Class* AllocClass(Thread* self, size_t class_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- DexCache* AllocDexCache(Thread* self, const DexFile& dex_file)
+ mirror::Class* AllocClass(Thread* self, size_t class_size) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ mirror::DexCache* AllocDexCache(Thread* self, const DexFile& dex_file)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Field* AllocField(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* AllocMethod(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Constructor* AllocConstructor(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ mirror::Field* AllocField(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ mirror::Method* AllocMethod(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ mirror::Constructor* AllocConstructor(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Class* CreatePrimitiveClass(Thread* self, Primitive::Type type)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return InitializePrimitiveClass(AllocClass(self, sizeof(Class)), type);
- }
- Class* InitializePrimitiveClass(Class* primitive_class, Primitive::Type type)
+ mirror::Class* CreatePrimitiveClass(Thread* self, Primitive::Type type)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ mirror::Class* InitializePrimitiveClass(mirror::Class* primitive_class, Primitive::Type type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Class* CreateArrayClass(const std::string& descriptor, ClassLoader* class_loader)
+ mirror::Class* CreateArrayClass(const std::string& descriptor, mirror::ClassLoader* class_loader)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void AppendToBootClassPath(const DexFile& dex_file)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void AppendToBootClassPath(const DexFile& dex_file, SirtRef<DexCache>& dex_cache)
+ void AppendToBootClassPath(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void ConstructFieldMap(const DexFile& dex_file, const DexFile::ClassDef& dex_class_def,
- Class* c, SafeMap<uint32_t, Field*>& field_map)
+ mirror::Class* c, SafeMap<uint32_t, mirror::Field*>& field_map)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
size_t SizeOfClass(const DexFile& dex_file,
@@ -445,18 +388,20 @@
void LoadClass(const DexFile& dex_file,
const DexFile::ClassDef& dex_class_def,
- SirtRef<Class>& klass,
- ClassLoader* class_loader)
+ SirtRef<mirror::Class>& klass,
+ mirror::ClassLoader* class_loader)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void LoadField(const DexFile& dex_file, const ClassDataItemIterator& it, SirtRef<Class>& klass,
- SirtRef<Field>& dst) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void LoadField(const DexFile& dex_file, const ClassDataItemIterator& it,
+ SirtRef<mirror::Class>& klass, SirtRef<mirror::Field>& dst)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- AbstractMethod* LoadMethod(Thread* self, const DexFile& dex_file,
- const ClassDataItemIterator& dex_method,
- SirtRef<Class>& klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ mirror::AbstractMethod* LoadMethod(Thread* self, const DexFile& dex_file,
+ const ClassDataItemIterator& dex_method,
+ SirtRef<mirror::Class>& klass)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void FixupStaticTrampolines(Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void FixupStaticTrampolines(mirror::Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Finds the associated oat class for a dex_file and descriptor
const OatFile::OatClass* GetOatClass(const DexFile& dex_file, const char* descriptor);
@@ -464,74 +409,75 @@
// Attempts to insert a class into a class table. Returns NULL if
// the class was inserted, otherwise returns an existing class with
// the same descriptor and ClassLoader.
- Class* InsertClass(const StringPiece& descriptor, Class* klass, bool image_class)
+ mirror::Class* InsertClass(const StringPiece& descriptor, mirror::Class* klass, bool image_class)
LOCKS_EXCLUDED(Locks::classlinker_classes_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void RegisterDexFileLocked(const DexFile& dex_file, SirtRef<DexCache>& dex_cache)
+ void RegisterDexFileLocked(const DexFile& dex_file, SirtRef<mirror::DexCache>& dex_cache)
EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
bool IsDexFileRegisteredLocked(const DexFile& dex_file) const EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
void RegisterOatFileLocked(const OatFile& oat_file) EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
EXCLUSIVE_LOCKS_REQUIRED(dex_lock_);
- bool InitializeClass(Class* klass, bool can_run_clinit, bool can_init_statics)
+ bool InitializeClass(mirror::Class* klass, bool can_run_clinit, bool can_init_statics)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool WaitForInitializeClass(Class* klass, Thread* self, ObjectLock& lock);
- bool ValidateSuperClassDescriptors(const Class* klass)
+ bool WaitForInitializeClass(mirror::Class* klass, Thread* self, ObjectLock& lock);
+ bool ValidateSuperClassDescriptors(const mirror::Class* klass)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool InitializeSuperClass(Class* klass, bool can_run_clinit, bool can_init_fields)
+ bool InitializeSuperClass(mirror::Class* klass, bool can_run_clinit, bool can_init_fields)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Initialize static fields, returns true if fields were initialized.
- bool InitializeStaticFields(Class* klass)
+ bool InitializeStaticFields(mirror::Class* klass)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
bool IsSameDescriptorInDifferentClassContexts(const char* descriptor,
- const Class* klass1,
- const Class* klass2)
+ const mirror::Class* klass1,
+ const mirror::Class* klass2)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool IsSameMethodSignatureInDifferentClassContexts(const AbstractMethod* descriptor,
- const Class* klass1,
- const Class* klass2)
+ bool IsSameMethodSignatureInDifferentClassContexts(const mirror::AbstractMethod* method,
+ const mirror::Class* klass1,
+ const mirror::Class* klass2)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool LinkClass(SirtRef<Class>& klass, ObjectArray<Class>* interfaces)
+ bool LinkClass(SirtRef<mirror::Class>& klass, mirror::ObjectArray<mirror::Class>* interfaces)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool LinkSuperClass(SirtRef<Class>& klass)
+ bool LinkSuperClass(SirtRef<mirror::Class>& klass)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool LoadSuperAndInterfaces(SirtRef<Class>& klass, const DexFile& dex_file)
+ bool LoadSuperAndInterfaces(SirtRef<mirror::Class>& klass, const DexFile& dex_file)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool LinkMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces)
+ bool LinkMethods(SirtRef<mirror::Class>& klass, mirror::ObjectArray<mirror::Class>* interfaces)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool LinkVirtualMethods(SirtRef<Class>& klass)
+ bool LinkVirtualMethods(SirtRef<mirror::Class>& klass)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool LinkInterfaceMethods(SirtRef<Class>& klass, ObjectArray<Class>* interfaces)
+ bool LinkInterfaceMethods(SirtRef<mirror::Class>& klass,
+ mirror::ObjectArray<mirror::Class>* interfaces)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool LinkStaticFields(SirtRef<Class>& klass)
+ bool LinkStaticFields(SirtRef<mirror::Class>& klass)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool LinkInstanceFields(SirtRef<Class>& klass)
+ bool LinkInstanceFields(SirtRef<mirror::Class>& klass)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool LinkFields(SirtRef<Class>& klass, bool is_static)
+ bool LinkFields(SirtRef<mirror::Class>& klass, bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void CreateReferenceInstanceOffsets(SirtRef<Class>& klass)
+ void CreateReferenceInstanceOffsets(SirtRef<mirror::Class>& klass)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void CreateReferenceStaticOffsets(SirtRef<Class>& klass)
+ void CreateReferenceStaticOffsets(SirtRef<mirror::Class>& klass)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void CreateReferenceOffsets(SirtRef<Class>& klass, bool is_static,
+ void CreateReferenceOffsets(SirtRef<mirror::Class>& klass, bool is_static,
uint32_t reference_offsets)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// For use by ImageWriter to find DexCaches for its roots
- const std::vector<DexCache*>& GetDexCaches() {
+ const std::vector<mirror::DexCache*>& GetDexCaches() {
return dex_caches_;
}
@@ -547,28 +493,29 @@
EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- AbstractMethod* CreateProxyConstructor(Thread* self, SirtRef<Class>& klass, Class* proxy_class)
+ mirror::AbstractMethod* CreateProxyConstructor(Thread* self, SirtRef<mirror::Class>& klass,
+ mirror::Class* proxy_class)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- AbstractMethod* CreateProxyMethod(Thread* self, SirtRef<Class>& klass,
- SirtRef<AbstractMethod>& prototype)
+ mirror::AbstractMethod* CreateProxyMethod(Thread* self, SirtRef<mirror::Class>& klass,
+ SirtRef<mirror::AbstractMethod>& prototype)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
std::vector<const DexFile*> boot_class_path_;
mutable Mutex dex_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
- std::vector<DexCache*> dex_caches_ GUARDED_BY(dex_lock_);
+ std::vector<mirror::DexCache*> dex_caches_ GUARDED_BY(dex_lock_);
std::vector<const OatFile*> oat_files_ GUARDED_BY(dex_lock_);
// multimap from a string hash code of a class descriptor to
- // Class* instances. Results should be compared for a matching
+ // mirror::Class* instances. Results should be compared for a matching
// Class::descriptor_ and Class::class_loader_.
- typedef std::multimap<size_t, Class*> Table;
- Table image_classes_ GUARDED_BY(Locks::classlinker_classes_lock_);
+ typedef std::multimap<size_t, mirror::Class*> Table;
+ Table image_classes_ GUARDED_BY(Locks::classlinker_classes_lock_);
Table classes_ GUARDED_BY(Locks::classlinker_classes_lock_);
- Class* LookupClassLocked(const char* descriptor, const ClassLoader* class_loader,
- size_t hash, const Table& classes)
+ mirror::Class* LookupClassLocked(const char* descriptor, const mirror::ClassLoader* class_loader,
+ size_t hash, const Table& classes)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
EXCLUSIVE_LOCKS_REQUIRED(Locks::classlinker_classes_lock_);
@@ -615,20 +562,14 @@
kJavaLangStackTraceElementArrayClass,
kClassRootsMax,
};
- ObjectArray<Class>* class_roots_;
+ mirror::ObjectArray<mirror::Class>* class_roots_;
- Class* GetClassRoot(ClassRoot class_root)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DCHECK(class_roots_ != NULL);
- Class* klass = class_roots_->Get(class_root);
- DCHECK(klass != NULL);
- return klass;
- }
+ mirror::Class* GetClassRoot(ClassRoot class_root) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void SetClassRoot(ClassRoot class_root, Class* klass)
+ void SetClassRoot(ClassRoot class_root, mirror::Class* klass)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- ObjectArray<Class>* GetClassRoots() {
+ mirror::ObjectArray<mirror::Class>* GetClassRoots() {
DCHECK(class_roots_ != NULL);
return class_roots_;
}
@@ -641,7 +582,7 @@
return descriptor;
}
- IfTable* array_iftable_;
+ mirror::IfTable* array_iftable_;
bool init_done_;
bool is_dirty_;
@@ -652,7 +593,7 @@
friend class ImageWriter; // for GetClassRoots
friend class ObjectTest;
FRIEND_TEST(ClassLinkerTest, ClassRootDescriptors);
- FRIEND_TEST(DexCacheTest, Open);
+ FRIEND_TEST(mirror::DexCacheTest, Open);
FRIEND_TEST(ExceptionTest, FindExceptionHandler);
FRIEND_TEST(ObjectTest, AllocObjectArray);
DISALLOW_COPY_AND_ASSIGN(ClassLinker);
diff --git a/src/class_linker_test.cc b/src/class_linker_test.cc
index d32e91e..893e7a4 100644
--- a/src/class_linker_test.cc
+++ b/src/class_linker_test.cc
@@ -19,13 +19,24 @@
#include <string>
#include "UniquePtr.h"
+#include "class_linker-inl.h"
#include "common_test.h"
-#include "dex_cache.h"
#include "dex_file.h"
#include "heap.h"
+#include "mirror/class-inl.h"
+#include "mirror/dex_cache.h"
+#include "mirror/field-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 "mirror/stack_trace_element.h"
#include "runtime_support.h"
#include "sirt_ref.h"
+using namespace art::mirror;
+
namespace art {
class ClassLinkerTest : public CommonTest {
@@ -600,10 +611,10 @@
};
};
-struct MethodClassOffsets : public CheckOffsets<MethodClass> {
- MethodClassOffsets() : CheckOffsets<MethodClass>(true, "Ljava/lang/reflect/Method;") {
+struct MethodClassOffsets : public CheckOffsets<AbstractMethodClass> {
+ MethodClassOffsets() : CheckOffsets<AbstractMethodClass>(true, "Ljava/lang/reflect/Method;") {
// alphabetical references
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(MethodClass, ORDER_BY_SIGNATURE_), "ORDER_BY_SIGNATURE"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethodClass, ORDER_BY_SIGNATURE_), "ORDER_BY_SIGNATURE"));
};
};
diff --git a/src/common_test.h b/src/common_test.h
index 5a5479a..46a8309 100644
--- a/src/common_test.h
+++ b/src/common_test.h
@@ -26,12 +26,12 @@
#include "base/stringprintf.h"
#include "base/unix_file/fd_file.h"
#include "class_linker.h"
-#include "class_loader.h"
#include "compiler.h"
#include "dex_file.h"
#include "gtest/gtest.h"
#include "heap.h"
#include "instruction_set.h"
+#include "mirror/class_loader.h"
#include "oat_file.h"
#include "object_utils.h"
#include "os.h"
@@ -171,7 +171,7 @@
class CommonTest : public testing::Test {
public:
- static void MakeExecutable(const ByteArray* code_array) {
+ static void MakeExecutable(const mirror::ByteArray* code_array) {
CHECK(code_array != NULL);
MakeExecutable(code_array->GetData(), code_array->GetLength());
}
@@ -189,7 +189,7 @@
const uint32_t* mapping_table,
const uint16_t* vmap_table,
const uint8_t* gc_map,
- const AbstractMethod::InvokeStub* invoke_stub) {
+ const mirror::AbstractMethod::InvokeStub* invoke_stub) {
return OatFile::OatMethod(NULL,
reinterpret_cast<uint32_t>(code),
frame_size_in_bytes,
@@ -205,7 +205,7 @@
);
}
- void MakeExecutable(AbstractMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ void MakeExecutable(mirror::AbstractMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
CHECK(method != NULL);
MethodHelper mh(method);
@@ -215,8 +215,8 @@
const std::vector<uint8_t>& invoke_stub = compiled_invoke_stub->GetCode();
MakeExecutable(invoke_stub);
- const AbstractMethod::InvokeStub* method_invoke_stub =
- reinterpret_cast<const AbstractMethod::InvokeStub*>(
+ const mirror::AbstractMethod::InvokeStub* method_invoke_stub =
+ reinterpret_cast<const mirror::AbstractMethod::InvokeStub*>(
CompiledCode::CodePointer(&invoke_stub[0],
compiled_invoke_stub->GetInstructionSet()));
@@ -224,7 +224,7 @@
<< " invoke_stub=" << reinterpret_cast<void*>(method_invoke_stub);
if (!method->IsAbstract()) {
- const DexCache* dex_cache = method->GetDeclaringClass()->GetDexCache();
+ const mirror::DexCache* dex_cache = method->GetDeclaringClass()->GetDexCache();
const DexFile& dex_file = *dex_cache->GetDexFile();
const CompiledMethod* compiled_method =
compiler_->GetCompiledMethod(Compiler::MethodReference(&dex_file,
@@ -473,14 +473,14 @@
ScopedLocalRef<jobject> class_loader_local(soa.Env(),
soa.Env()->AllocObject(WellKnownClasses::dalvik_system_PathClassLoader));
jobject class_loader = soa.Env()->NewGlobalRef(class_loader_local.get());
- soa.Self()->SetClassLoaderOverride(soa.Decode<ClassLoader*>(class_loader_local.get()));
+ soa.Self()->SetClassLoaderOverride(soa.Decode<mirror::ClassLoader*>(class_loader_local.get()));
Runtime::Current()->SetCompileTimeClassPath(class_loader, class_path);
return class_loader;
}
- void CompileClass(ClassLoader* class_loader, const char* class_name) {
+ void CompileClass(mirror::ClassLoader* class_loader, const char* class_name) {
std::string class_descriptor(DotToDescriptor(class_name));
- Class* klass = class_linker_->FindClass(class_descriptor.c_str(), class_loader);
+ mirror::Class* klass = class_linker_->FindClass(class_descriptor.c_str(), class_loader);
CHECK(klass != NULL) << "Class not found " << class_name;
for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
CompileMethod(klass->GetDirectMethod(i));
@@ -490,7 +490,7 @@
}
}
- void CompileMethod(AbstractMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ void CompileMethod(mirror::AbstractMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
CHECK(method != NULL);
compiler_->CompileOne(method);
MakeExecutable(method);
@@ -498,29 +498,29 @@
MakeExecutable(runtime_->GetJniDlsymLookupStub());
}
- void CompileDirectMethod(ClassLoader* class_loader,
+ void CompileDirectMethod(mirror::ClassLoader* class_loader,
const char* class_name,
const char* method_name,
const char* signature)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
std::string class_descriptor(DotToDescriptor(class_name));
- Class* klass = class_linker_->FindClass(class_descriptor.c_str(), class_loader);
+ mirror::Class* klass = class_linker_->FindClass(class_descriptor.c_str(), class_loader);
CHECK(klass != NULL) << "Class not found " << class_name;
- AbstractMethod* method = klass->FindDirectMethod(method_name, signature);
+ mirror::AbstractMethod* method = klass->FindDirectMethod(method_name, signature);
CHECK(method != NULL) << "Direct method not found: "
<< class_name << "." << method_name << signature;
CompileMethod(method);
}
- void CompileVirtualMethod(ClassLoader* class_loader,
+ void CompileVirtualMethod(mirror::ClassLoader* class_loader,
const char* class_name,
const char* method_name,
const char* signature)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
std::string class_descriptor(DotToDescriptor(class_name));
- Class* klass = class_linker_->FindClass(class_descriptor.c_str(), class_loader);
+ mirror::Class* klass = class_linker_->FindClass(class_descriptor.c_str(), class_loader);
CHECK(klass != NULL) << "Class not found " << class_name;
- AbstractMethod* method = klass->FindVirtualMethod(method_name, signature);
+ mirror::AbstractMethod* method = klass->FindVirtualMethod(method_name, signature);
CHECK(method != NULL) << "Virtual method not found: "
<< class_name << "." << method_name << signature;
CompileMethod(method);
diff --git a/src/common_throws.cc b/src/common_throws.cc
index cefc4ab..734d544 100644
--- a/src/common_throws.cc
+++ b/src/common_throws.cc
@@ -17,8 +17,12 @@
#include "common_throws.h"
#include "base/logging.h"
+#include "class_linker-inl.h"
#include "dex_instruction.h"
#include "invoke_type.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
#include "object_utils.h"
#include "thread.h"
@@ -26,7 +30,7 @@
namespace art {
-static void AddReferrerLocation(std::ostream& os, const AbstractMethod* referrer)
+static void AddReferrerLocation(std::ostream& os, const mirror::AbstractMethod* referrer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (referrer != NULL) {
ClassHelper kh(referrer->GetDeclaringClass());
@@ -37,7 +41,7 @@
}
}
-static void AddReferrerLocationFromClass(std::ostream& os, Class* referrer)
+static void AddReferrerLocationFromClass(std::ostream& os, mirror::Class* referrer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (referrer != NULL) {
ClassHelper kh(referrer);
@@ -51,16 +55,16 @@
// NullPointerException
-void ThrowNullPointerExceptionForFieldAccess(Field* field, bool is_read) {
+void ThrowNullPointerExceptionForFieldAccess(mirror::Field* field, bool is_read) {
std::ostringstream msg;
msg << "Attempt to " << (is_read ? "read from" : "write to")
<< " field '" << PrettyField(field, true) << "' on a null object reference";
Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;", msg.str().c_str());
}
-void ThrowNullPointerExceptionForMethodAccess(AbstractMethod* caller, uint32_t method_idx,
+void ThrowNullPointerExceptionForMethodAccess(mirror::AbstractMethod* caller, uint32_t method_idx,
InvokeType type) {
- DexCache* dex_cache = caller->GetDeclaringClass()->GetDexCache();
+ mirror::DexCache* dex_cache = caller->GetDeclaringClass()->GetDexCache();
const DexFile& dex_file = *dex_cache->GetDexFile();
std::ostringstream msg;
msg << "Attempt to invoke " << type << " method '"
@@ -68,7 +72,7 @@
Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;", msg.str().c_str());
}
-void ThrowNullPointerExceptionFromDexPC(AbstractMethod* throw_method, uint32_t dex_pc) {
+void ThrowNullPointerExceptionFromDexPC(mirror::AbstractMethod* throw_method, uint32_t dex_pc) {
const DexFile::CodeItem* code = MethodHelper(throw_method).GetCodeItem();
CHECK_LT(dex_pc, code->insns_size_in_code_units_);
const Instruction* instr = Instruction::At(&code->insns_[dex_pc]);
@@ -93,7 +97,7 @@
case Instruction::IGET_BYTE:
case Instruction::IGET_CHAR:
case Instruction::IGET_SHORT: {
- Field* field =
+ mirror::Field* field =
Runtime::Current()->GetClassLinker()->ResolveField(dec_insn.vC, throw_method, false);
ThrowNullPointerExceptionForFieldAccess(field, true /* read */);
break;
@@ -105,7 +109,7 @@
case Instruction::IPUT_BYTE:
case Instruction::IPUT_CHAR:
case Instruction::IPUT_SHORT: {
- Field* field =
+ mirror::Field* field =
Runtime::Current()->GetClassLinker()->ResolveField(dec_insn.vC, throw_method, false);
ThrowNullPointerExceptionForFieldAccess(field, false /* write */);
break;
@@ -149,7 +153,7 @@
// IllegalAccessError
-void ThrowIllegalAccessErrorClass(Class* referrer, Class* accessed) {
+void ThrowIllegalAccessErrorClass(mirror::Class* referrer, mirror::Class* accessed) {
std::ostringstream msg;
msg << "Illegal class access: '" << PrettyDescriptor(referrer) << "' attempting to access '"
<< PrettyDescriptor(accessed) << "'";
@@ -157,9 +161,9 @@
Thread::Current()->ThrowNewException("Ljava/lang/IllegalAccessError;", msg.str().c_str());
}
-void ThrowIllegalAccessErrorClassForMethodDispatch(Class* referrer, Class* accessed,
- const AbstractMethod* caller,
- const AbstractMethod* called,
+void ThrowIllegalAccessErrorClassForMethodDispatch(mirror::Class* referrer, mirror::Class* accessed,
+ const mirror::AbstractMethod* caller,
+ const mirror::AbstractMethod* called,
InvokeType type) {
std::ostringstream msg;
msg << "Illegal class access ('" << PrettyDescriptor(referrer) << "' attempting to access '"
@@ -169,7 +173,7 @@
Thread::Current()->ThrowNewException("Ljava/lang/IllegalAccessError;", msg.str().c_str());
}
-void ThrowIllegalAccessErrorMethod(Class* referrer, AbstractMethod* accessed) {
+void ThrowIllegalAccessErrorMethod(mirror::Class* referrer, mirror::AbstractMethod* accessed) {
std::ostringstream msg;
msg << "Method '" << PrettyMethod(accessed) << "' is inaccessible to class '"
<< PrettyDescriptor(referrer) << "'";
@@ -177,7 +181,7 @@
Thread::Current()->ThrowNewException("Ljava/lang/IllegalAccessError;", msg.str().c_str());
}
-void ThrowIllegalAccessErrorField(Class* referrer, Field* accessed) {
+void ThrowIllegalAccessErrorField(mirror::Class* referrer, mirror::Field* accessed) {
std::ostringstream msg;
msg << "Field '" << PrettyField(accessed, false) << "' is inaccessible to class '"
<< PrettyDescriptor(referrer) << "'";
@@ -185,7 +189,8 @@
Thread::Current()->ThrowNewException("Ljava/lang/IllegalAccessError;", msg.str().c_str());
}
-void ThrowIllegalAccessErrorFinalField(const AbstractMethod* referrer, Field* accessed) {
+void ThrowIllegalAccessErrorFinalField(const mirror::AbstractMethod* referrer,
+ mirror::Field* accessed) {
std::ostringstream msg;
msg << "Final field '" << PrettyField(accessed, false) << "' cannot be written to by method '"
<< PrettyMethod(referrer) << "'";
@@ -196,7 +201,8 @@
// IncompatibleClassChangeError
void ThrowIncompatibleClassChangeError(InvokeType expected_type, InvokeType found_type,
- AbstractMethod* method, const AbstractMethod* referrer) {
+ mirror::AbstractMethod* method,
+ const mirror::AbstractMethod* referrer) {
std::ostringstream msg;
msg << "The method '" << PrettyMethod(method) << "' was expected to be of type "
<< expected_type << " but instead was found to be of type " << found_type;
@@ -205,9 +211,9 @@
msg.str().c_str());
}
-void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(const AbstractMethod* interface_method,
- Object* this_object,
- const AbstractMethod* referrer) {
+void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(const mirror::AbstractMethod* interface_method,
+ mirror::Object* this_object,
+ const mirror::AbstractMethod* referrer) {
// Referrer is calling interface_method on this_object, however, the interface_method isn't
// implemented by this_object.
CHECK(this_object != NULL);
@@ -221,8 +227,8 @@
msg.str().c_str());
}
-void ThrowIncompatibleClassChangeErrorField(const Field* resolved_field, bool is_static,
- const AbstractMethod* referrer) {
+void ThrowIncompatibleClassChangeErrorField(const mirror::Field* resolved_field, bool is_static,
+ const mirror::AbstractMethod* referrer) {
std::ostringstream msg;
msg << "Expected '" << PrettyField(resolved_field) << "' to be a "
<< (is_static ? "static" : "instance") << " field" << " rather than a "
@@ -234,8 +240,8 @@
// NoSuchMethodError
-void ThrowNoSuchMethodError(InvokeType type, Class* c, const StringPiece& name,
- const StringPiece& signature, const AbstractMethod* referrer) {
+void ThrowNoSuchMethodError(InvokeType type, mirror::Class* c, const StringPiece& name,
+ const StringPiece& signature, const mirror::AbstractMethod* referrer) {
std::ostringstream msg;
ClassHelper kh(c);
msg << "No " << type << " method " << name << signature
@@ -244,8 +250,8 @@
Thread::Current()->ThrowNewException("Ljava/lang/NoSuchMethodError;", msg.str().c_str());
}
-void ThrowNoSuchMethodError(uint32_t method_idx, const AbstractMethod* referrer) {
- DexCache* dex_cache = referrer->GetDeclaringClass()->GetDexCache();
+void ThrowNoSuchMethodError(uint32_t method_idx, const mirror::AbstractMethod* referrer) {
+ mirror::DexCache* dex_cache = referrer->GetDeclaringClass()->GetDexCache();
const DexFile& dex_file = *dex_cache->GetDexFile();
std::ostringstream msg;
msg << "No method '" << PrettyMethod(method_idx, dex_file, true) << "'";
diff --git a/src/common_throws.h b/src/common_throws.h
index 33769c4..9e28bd7 100644
--- a/src/common_throws.h
+++ b/src/common_throws.h
@@ -18,62 +18,73 @@
#define ART_SRC_COMMON_THROWS_H_
#include "base/mutex.h"
-#include "object.h"
+#include "invoke_type.h"
namespace art {
+namespace mirror {
+class AbstractMethod;
+class Class;
+class Field;
+class Object;
+} // namespace mirror
+class StringPiece;
// NullPointerException
-void ThrowNullPointerExceptionForFieldAccess(Field* field, bool is_read)
+void ThrowNullPointerExceptionForFieldAccess(mirror::Field* field, bool is_read)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-void ThrowNullPointerExceptionForMethodAccess(AbstractMethod* caller, uint32_t method_idx, InvokeType type)
+void ThrowNullPointerExceptionForMethodAccess(mirror::AbstractMethod* caller, uint32_t method_idx,
+ InvokeType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-void ThrowNullPointerExceptionFromDexPC(AbstractMethod* throw_method, uint32_t dex_pc)
+void ThrowNullPointerExceptionFromDexPC(mirror::AbstractMethod* throw_method, uint32_t dex_pc)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// IllegalAccessError
-void ThrowIllegalAccessErrorClass(Class* referrer, Class* accessed)
+void ThrowIllegalAccessErrorClass(mirror::Class* referrer, mirror::Class* accessed)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-void ThrowIllegalAccessErrorClassForMethodDispatch(Class* referrer, Class* accessed,
- const AbstractMethod* caller, const AbstractMethod* called,
+void ThrowIllegalAccessErrorClassForMethodDispatch(mirror::Class* referrer, mirror::Class* accessed,
+ const mirror::AbstractMethod* caller,
+ const mirror::AbstractMethod* called,
InvokeType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-void ThrowIllegalAccessErrorMethod(Class* referrer, AbstractMethod* accessed)
+void ThrowIllegalAccessErrorMethod(mirror::Class* referrer, mirror::AbstractMethod* accessed)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-void ThrowIllegalAccessErrorField(Class* referrer, Field* accessed)
+void ThrowIllegalAccessErrorField(mirror::Class* referrer, mirror::Field* accessed)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-void ThrowIllegalAccessErrorFinalField(const AbstractMethod* referrer, Field* accessed)
+void ThrowIllegalAccessErrorFinalField(const mirror::AbstractMethod* referrer,
+ mirror::Field* accessed)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// IncompatibleClassChangeError
void ThrowIncompatibleClassChangeError(InvokeType expected_type, InvokeType found_type,
- AbstractMethod* method, const AbstractMethod* referrer)
+ mirror::AbstractMethod* method,
+ const mirror::AbstractMethod* referrer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(const AbstractMethod* interface_method,
- Object* this_object,
- const AbstractMethod* referrer)
+void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(const mirror::AbstractMethod* interface_method,
+ mirror::Object* this_object,
+ const mirror::AbstractMethod* referrer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-void ThrowIncompatibleClassChangeErrorField(const Field* resolved_field, bool is_static,
- const AbstractMethod* referrer)
+void ThrowIncompatibleClassChangeErrorField(const mirror::Field* resolved_field, bool is_static,
+ const mirror::AbstractMethod* referrer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// NoSuchMethodError
-void ThrowNoSuchMethodError(InvokeType type, Class* c, const StringPiece& name,
- const StringPiece& signature, const AbstractMethod* referrer)
+void ThrowNoSuchMethodError(InvokeType type, mirror::Class* c, const StringPiece& name,
+ const StringPiece& signature, const mirror::AbstractMethod* referrer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-void ThrowNoSuchMethodError(uint32_t method_idx, const AbstractMethod* referrer)
+void ThrowNoSuchMethodError(uint32_t method_idx, const mirror::AbstractMethod* referrer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
} // namespace art
diff --git a/src/compiled_class.h b/src/compiled_class.h
index 97dd8ee..f050ee6 100644
--- a/src/compiled_class.h
+++ b/src/compiled_class.h
@@ -17,19 +17,19 @@
#ifndef ART_SRC_COMPILED_CLASS_H_
#define ART_SRC_COMPILED_CLASS_H_
-#include "object.h"
+#include "mirror/class.h"
namespace art {
class CompiledClass {
public:
- explicit CompiledClass(Class::Status status) : status_(status) {}
+ explicit CompiledClass(mirror::Class::Status status) : status_(status) {}
~CompiledClass() {}
- Class::Status GetStatus() const {
+ mirror::Class::Status GetStatus() const {
return status_;
}
private:
- const Class::Status status_;
+ const mirror::Class::Status status_;
};
} // namespace art
diff --git a/src/compiler.cc b/src/compiler.cc
index 18460ce..903b70a 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -23,15 +23,22 @@
#include "base/stl_util.h"
#include "class_linker.h"
-#include "class_loader.h"
-#include "dex_cache.h"
#include "jni_internal.h"
#include "oat_compilation_unit.h"
#include "oat_file.h"
#include "oat/runtime/stub.h"
#include "object_utils.h"
#include "runtime.h"
+#include "gc/card_table-inl.h"
#include "gc/space.h"
+#include "mirror/class_loader.h"
+#include "mirror/class-inl.h"
+#include "mirror/dex_cache.h"
+#include "mirror/field-inl.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
+#include "mirror/throwable.h"
#include "scoped_thread_state_change.h"
#include "ScopedLocalRef.h"
#include "thread.h"
@@ -431,7 +438,7 @@
return res;
}
-ByteArray* Compiler::CreateResolutionStub(InstructionSet instruction_set,
+mirror::ByteArray* Compiler::CreateResolutionStub(InstructionSet instruction_set,
Runtime::TrampolineType type) {
switch (instruction_set) {
case kArm:
@@ -447,7 +454,7 @@
}
}
-ByteArray* Compiler::CreateJniDlsymLookupStub(InstructionSet instruction_set) {
+mirror::ByteArray* Compiler::CreateJniDlsymLookupStub(InstructionSet instruction_set) {
switch (instruction_set) {
case kArm:
case kThumb2:
@@ -462,7 +469,7 @@
}
}
-ByteArray* Compiler::CreateAbstractMethodErrorStub(InstructionSet instruction_set) {
+mirror::ByteArray* Compiler::CreateAbstractMethodErrorStub(InstructionSet instruction_set) {
switch (instruction_set) {
case kArm:
case kThumb2:
@@ -497,7 +504,7 @@
}
}
-void Compiler::CompileOne(const AbstractMethod* method) {
+void Compiler::CompileOne(const mirror::AbstractMethod* method) {
DCHECK(!Runtime::Current()->IsStarted());
Thread* self = Thread::Current();
jobject class_loader;
@@ -566,12 +573,12 @@
bool Compiler::CanAssumeTypeIsPresentInDexCache(const DexFile& dex_file,
uint32_t type_idx) {
ScopedObjectAccess soa(Thread::Current());
- DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
+ mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
if (!IsImage()) {
stats_->TypeNotInDexCache();
return false;
}
- Class* resolved_class = dex_cache->GetResolvedType(type_idx);
+ mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
if (resolved_class == NULL) {
stats_->TypeNotInDexCache();
return false;
@@ -593,7 +600,7 @@
if (IsImage()) {
// We resolve all const-string strings when building for the image.
ScopedObjectAccess soa(Thread::Current());
- DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
+ mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
Runtime::Current()->GetClassLinker()->ResolveString(dex_file, string_idx, dex_cache);
result = true;
}
@@ -608,15 +615,15 @@
bool Compiler::CanAccessTypeWithoutChecks(uint32_t referrer_idx, const DexFile& dex_file,
uint32_t type_idx) {
ScopedObjectAccess soa(Thread::Current());
- DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
+ mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
// Get type from dex cache assuming it was populated by the verifier
- Class* resolved_class = dex_cache->GetResolvedType(type_idx);
+ mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
if (resolved_class == NULL) {
stats_->TypeNeedsAccessCheck();
return false; // Unknown class needs access checks.
}
const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx);
- Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_);
+ mirror::Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_);
if (referrer_class == NULL) {
stats_->TypeNeedsAccessCheck();
return false; // Incomplete referrer knowledge needs access check.
@@ -636,15 +643,15 @@
const DexFile& dex_file,
uint32_t type_idx) {
ScopedObjectAccess soa(Thread::Current());
- DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
+ mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(dex_file);
// Get type from dex cache assuming it was populated by the verifier.
- Class* resolved_class = dex_cache->GetResolvedType(type_idx);
+ mirror::Class* resolved_class = dex_cache->GetResolvedType(type_idx);
if (resolved_class == NULL) {
stats_->TypeNeedsAccessCheck();
return false; // Unknown class needs access checks.
}
const DexFile::MethodId& method_id = dex_file.GetMethodId(referrer_idx);
- Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_);
+ mirror::Class* referrer_class = dex_cache->GetResolvedType(method_id.class_idx_);
if (referrer_class == NULL) {
stats_->TypeNeedsAccessCheck();
return false; // Incomplete referrer knowledge needs access check.
@@ -660,33 +667,33 @@
return result;
}
-static Class* ComputeCompilingMethodsClass(ScopedObjectAccess& soa,
- OatCompilationUnit* mUnit)
+static mirror::Class* ComputeCompilingMethodsClass(ScopedObjectAccess& soa,
+ OatCompilationUnit* mUnit)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
- ClassLoader* class_loader = soa.Decode<ClassLoader*>(mUnit->class_loader_);
+ mirror::DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
+ mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(mUnit->class_loader_);
const DexFile::MethodId& referrer_method_id = mUnit->dex_file_->GetMethodId(mUnit->method_idx_);
return mUnit->class_linker_->ResolveType(*mUnit->dex_file_, referrer_method_id.class_idx_,
dex_cache, class_loader);
}
-static Field* ComputeFieldReferencedFromCompilingMethod(ScopedObjectAccess& soa,
- OatCompilationUnit* mUnit,
- uint32_t field_idx)
+static mirror::Field* ComputeFieldReferencedFromCompilingMethod(ScopedObjectAccess& soa,
+ OatCompilationUnit* mUnit,
+ uint32_t field_idx)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
- ClassLoader* class_loader = soa.Decode<ClassLoader*>(mUnit->class_loader_);
+ mirror::DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
+ mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(mUnit->class_loader_);
return mUnit->class_linker_->ResolveField(*mUnit->dex_file_, field_idx, dex_cache,
class_loader, false);
}
-static AbstractMethod* ComputeMethodReferencedFromCompilingMethod(ScopedObjectAccess& soa,
- OatCompilationUnit* mUnit,
- uint32_t method_idx,
- InvokeType type)
+static mirror::AbstractMethod* ComputeMethodReferencedFromCompilingMethod(ScopedObjectAccess& soa,
+ OatCompilationUnit* mUnit,
+ uint32_t method_idx,
+ InvokeType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
- ClassLoader* class_loader = soa.Decode<ClassLoader*>(mUnit->class_loader_);
+ mirror::DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
+ mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(mUnit->class_loader_);
return mUnit->class_linker_->ResolveMethod(*mUnit->dex_file_, method_idx, dex_cache,
class_loader, NULL, type);
}
@@ -698,11 +705,11 @@
field_offset = -1;
is_volatile = true;
// Try to resolve field and ignore if an Incompatible Class Change Error (ie is static).
- Field* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx);
+ mirror::Field* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx);
if (resolved_field != NULL && !resolved_field->IsStatic()) {
- Class* referrer_class = ComputeCompilingMethodsClass(soa, mUnit);
+ mirror::Class* referrer_class = ComputeCompilingMethodsClass(soa, mUnit);
if (referrer_class != NULL) {
- Class* fields_class = resolved_field->GetDeclaringClass();
+ mirror::Class* fields_class = resolved_field->GetDeclaringClass();
bool access_ok = referrer_class->CanAccess(fields_class) &&
referrer_class->CanAccessMember(fields_class,
resolved_field->GetAccessFlags());
@@ -711,7 +718,7 @@
// protected field being made public by a sub-class. Resort to the dex file to determine
// the correct class for the access check.
const DexFile& dex_file = *referrer_class->GetDexCache()->GetDexFile();
- Class* dex_fields_class = mUnit->class_linker_->ResolveType(dex_file,
+ mirror::Class* dex_fields_class = mUnit->class_linker_->ResolveType(dex_file,
dex_file.GetFieldId(field_idx).class_idx_,
referrer_class);
access_ok = referrer_class->CanAccess(dex_fields_class) &&
@@ -746,11 +753,11 @@
is_referrers_class = false;
is_volatile = true;
// Try to resolve field and ignore if an Incompatible Class Change Error (ie isn't static).
- Field* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx);
+ mirror::Field* resolved_field = ComputeFieldReferencedFromCompilingMethod(soa, mUnit, field_idx);
if (resolved_field != NULL && resolved_field->IsStatic()) {
- Class* referrer_class = ComputeCompilingMethodsClass(soa, mUnit);
+ mirror::Class* referrer_class = ComputeCompilingMethodsClass(soa, mUnit);
if (referrer_class != NULL) {
- Class* fields_class = resolved_field->GetDeclaringClass();
+ mirror::Class* fields_class = resolved_field->GetDeclaringClass();
if (fields_class == referrer_class) {
is_referrers_class = true; // implies no worrying about class initialization
field_offset = resolved_field->GetOffset().Int32Value();
@@ -767,7 +774,7 @@
// the correct class for the access check. Don't change the field's class as that is
// used to identify the SSB.
const DexFile& dex_file = *referrer_class->GetDexCache()->GetDexFile();
- Class* dex_fields_class =
+ mirror::Class* dex_fields_class =
mUnit->class_linker_->ResolveType(dex_file,
dex_file.GetFieldId(field_idx).class_idx_,
referrer_class);
@@ -781,7 +788,7 @@
// in its static storage base (which may fail if it doesn't have a slot for it)
// TODO: for images we can elide the static storage base null check
// if we know there's a non-null entry in the image
- DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
+ mirror::DexCache* dex_cache = mUnit->class_linker_->FindDexCache(*mUnit->dex_file_);
if (fields_class->GetDexCache() == dex_cache) {
// common case where the dex cache of both the referrer and the field are the same,
// no need to search the dex file
@@ -820,7 +827,8 @@
return false; // Incomplete knowledge needs slow path.
}
-void Compiler::GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type, AbstractMethod* method,
+void Compiler::GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type,
+ mirror::AbstractMethod* method,
uintptr_t& direct_code, uintptr_t& direct_method) {
// For direct and static methods compute possible direct_code and direct_method values, ie
// an address for the Method* being invoked and an address of the code for that Method*.
@@ -876,15 +884,15 @@
vtable_idx = -1;
direct_code = 0;
direct_method = 0;
- AbstractMethod* resolved_method =
+ mirror::AbstractMethod* resolved_method =
ComputeMethodReferencedFromCompilingMethod(soa, mUnit, method_idx, type);
if (resolved_method != NULL) {
// Don't try to fast-path if we don't understand the caller's class or this appears to be an
// Incompatible Class Change Error.
- Class* referrer_class = ComputeCompilingMethodsClass(soa, mUnit);
+ mirror::Class* referrer_class = ComputeCompilingMethodsClass(soa, mUnit);
bool icce = resolved_method->CheckIncompatibleClassChange(type);
if (referrer_class != NULL && !icce) {
- Class* methods_class = resolved_method->GetDeclaringClass();
+ mirror::Class* methods_class = resolved_method->GetDeclaringClass();
if (!referrer_class->CanAccess(methods_class) ||
!referrer_class->CanAccessMember(methods_class,
resolved_method->GetAccessFlags())) {
@@ -1068,7 +1076,7 @@
// classes found in the boot classpath. Since at runtime we will
// select the class from the boot classpath, do not attempt to resolve
// or compile it now.
-static bool SkipClass(ClassLoader* class_loader,
+static bool SkipClass(mirror::ClassLoader* class_loader,
const DexFile& dex_file,
const DexFile::ClassDef& class_def)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -1077,7 +1085,7 @@
}
const char* descriptor = dex_file.GetClassDescriptor(class_def);
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- Class* klass = class_linker->FindClass(descriptor, NULL);
+ mirror::Class* klass = class_linker->FindClass(descriptor, NULL);
if (klass == NULL) {
Thread* self = Thread::Current();
CHECK(self->IsExceptionPending());
@@ -1090,7 +1098,7 @@
static void ResolveClassFieldsAndMethods(const CompilationContext* context, size_t class_def_index)
LOCKS_EXCLUDED(Locks::mutator_lock_) {
ScopedObjectAccess soa(Thread::Current());
- ClassLoader* class_loader = soa.Decode<ClassLoader*>(context->GetClassLoader());
+ mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(context->GetClassLoader());
const DexFile& dex_file = *context->GetDexFile();
// Method and Field are the worst. We can't resolve without either
@@ -1115,11 +1123,11 @@
}
Thread* self = Thread::Current();
ClassLinker* class_linker = context->GetClassLinker();
- DexCache* dex_cache = class_linker->FindDexCache(dex_file);
+ mirror::DexCache* dex_cache = class_linker->FindDexCache(dex_file);
ClassDataItemIterator it(dex_file, class_data);
while (it.HasNextStaticField()) {
- Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
- class_loader, true);
+ mirror::Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
+ class_loader, true);
if (field == NULL) {
CHECK(self->IsExceptionPending());
self->ClearException();
@@ -1134,8 +1142,8 @@
requires_constructor_barrier = true;
}
- Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
- class_loader, false);
+ mirror::Field* field = class_linker->ResolveField(dex_file, it.GetMemberIndex(), dex_cache,
+ class_loader, false);
if (field == NULL) {
CHECK(self->IsExceptionPending());
self->ClearException();
@@ -1147,9 +1155,9 @@
class_def_index);
}
while (it.HasNextDirectMethod()) {
- AbstractMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
- class_loader, NULL,
- it.GetMethodInvokeType(class_def));
+ mirror::AbstractMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
+ dex_cache, class_loader, NULL,
+ it.GetMethodInvokeType(class_def));
if (method == NULL) {
CHECK(self->IsExceptionPending());
self->ClearException();
@@ -1157,9 +1165,9 @@
it.Next();
}
while (it.HasNextVirtualMethod()) {
- AbstractMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
- class_loader, NULL,
- it.GetMethodInvokeType(class_def));
+ mirror::AbstractMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(),
+ dex_cache, class_loader, NULL,
+ it.GetMethodInvokeType(class_def));
if (method == NULL) {
CHECK(self->IsExceptionPending());
self->ClearException();
@@ -1175,9 +1183,9 @@
ScopedObjectAccess soa(Thread::Current());
ClassLinker* class_linker = context->GetClassLinker();
const DexFile& dex_file = *context->GetDexFile();
- DexCache* dex_cache = class_linker->FindDexCache(dex_file);
- ClassLoader* class_loader = soa.Decode<ClassLoader*>(context->GetClassLoader());
- Class* klass = class_linker->ResolveType(dex_file, type_idx, dex_cache, class_loader);
+ mirror::DexCache* dex_cache = class_linker->FindDexCache(dex_file);
+ mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(context->GetClassLoader());
+ mirror::Class* klass = class_linker->ResolveType(dex_file, type_idx, dex_cache, class_loader);
if (klass == NULL) {
CHECK(soa.Self()->IsExceptionPending());
@@ -1214,9 +1222,9 @@
ScopedObjectAccess soa(Thread::Current());
const DexFile::ClassDef& class_def = context->GetDexFile()->GetClassDef(class_def_index);
const char* descriptor = context->GetDexFile()->GetClassDescriptor(class_def);
- Class* klass =
+ mirror::Class* klass =
context->GetClassLinker()->FindClass(descriptor,
- soa.Decode<ClassLoader*>(context->GetClassLoader()));
+ soa.Decode<mirror::ClassLoader*>(context->GetClassLoader()));
if (klass == NULL) {
Thread* self = Thread::Current();
CHECK(self->IsExceptionPending());
@@ -1227,11 +1235,11 @@
* This is to ensure the class is structurally sound for compilation. An unsound class
* will be rejected by the verifier and later skipped during compilation in the compiler.
*/
- DexCache* dex_cache = context->GetClassLinker()->FindDexCache(*context->GetDexFile());
+ mirror::DexCache* dex_cache = context->GetClassLinker()->FindDexCache(*context->GetDexFile());
std::string error_msg;
if (verifier::MethodVerifier::VerifyClass(context->GetDexFile(),
dex_cache,
- soa.Decode<ClassLoader*>(context->GetClassLoader()),
+ soa.Decode<mirror::ClassLoader*>(context->GetClassLoader()),
class_def_index, error_msg) ==
verifier::MethodVerifier::kHardFailure) {
const DexFile::ClassDef& class_def = context->GetDexFile()->GetClassDef(class_def_index);
@@ -1446,9 +1454,9 @@
LOCKS_EXCLUDED(Locks::mutator_lock_) {
const DexFile::ClassDef& class_def = context->GetDexFile()->GetClassDef(class_def_index);
ScopedObjectAccess soa(Thread::Current());
- ClassLoader* class_loader = soa.Decode<ClassLoader*>(context->GetClassLoader());
+ mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(context->GetClassLoader());
const char* descriptor = context->GetDexFile()->GetClassDescriptor(class_def);
- Class* klass = context->GetClassLinker()->FindClass(descriptor, class_loader);
+ mirror::Class* klass = context->GetClassLinker()->FindClass(descriptor, class_loader);
Thread* self = Thread::Current();
bool compiling_boot = Runtime::Current()->GetHeap()->GetSpaces().size() == 1;
bool can_init_static_fields = compiling_boot &&
@@ -1480,10 +1488,10 @@
LOG(INFO) << "Initializing: " << descriptor;
if (StringPiece(descriptor) == "Ljava/lang/Void;"){
// Hand initialize j.l.Void to avoid Dex file operations in un-started runtime.
- ObjectArray<Field>* fields = klass->GetSFields();
+ mirror::ObjectArray<mirror::Field>* fields = klass->GetSFields();
CHECK_EQ(fields->GetLength(), 1);
fields->Get(0)->SetObj(klass, context->GetClassLinker()->FindPrimitiveClass('V'));
- klass->SetStatus(Class::kStatusInitialized);
+ klass->SetStatus(mirror::Class::kStatusInitialized);
} else {
context->GetClassLinker()->EnsureInitialized(klass, true, can_init_static_fields);
}
@@ -1497,7 +1505,7 @@
}
}
// Record the final class status if necessary.
- Class::Status status = klass->GetStatus();
+ mirror::Class::Status status = klass->GetStatus();
Compiler::ClassReference ref(context->GetDexFile(), class_def_index);
CompiledClass* compiled_class = context->GetCompiler()->GetCompiledClass(ref);
if (compiled_class == NULL) {
@@ -1550,7 +1558,7 @@
const DexFile::ClassDef& class_def = dex_file.GetClassDef(class_def_index);
{
ScopedObjectAccess soa(Thread::Current());
- ClassLoader* class_loader = soa.Decode<ClassLoader*>(context->GetClassLoader());
+ mirror::ClassLoader* class_loader = soa.Decode<mirror::ClassLoader*>(context->GetClassLoader());
if (SkipClass(class_loader, dex_file, class_def)) {
return;
}
diff --git a/src/compiler.h b/src/compiler.h
index 13130d7..0f99f4d 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -24,12 +24,10 @@
#include "base/mutex.h"
#include "compiled_class.h"
#include "compiled_method.h"
-#include "dex_cache.h"
#include "dex_file.h"
#include "instruction_set.h"
#include "invoke_type.h"
#include "oat_file.h"
-#include "object.h"
#include "runtime.h"
#include "safe_map.h"
#include "thread_pool.h"
@@ -79,7 +77,7 @@
LOCKS_EXCLUDED(Locks::mutator_lock_);
// Compile a single Method
- void CompileOne(const AbstractMethod* method)
+ void CompileOne(const mirror::AbstractMethod* method)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
bool IsDebuggingSupported() {
@@ -101,16 +99,16 @@
CompilerTls* GetTls();
// Stub to throw AbstractMethodError
- static ByteArray* CreateAbstractMethodErrorStub(InstructionSet instruction_set)
+ static mirror::ByteArray* CreateAbstractMethodErrorStub(InstructionSet instruction_set)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Generate the trampoline that's invoked by unresolved direct methods
- static ByteArray* CreateResolutionStub(InstructionSet instruction_set,
- Runtime::TrampolineType type)
+ static mirror::ByteArray* CreateResolutionStub(InstructionSet instruction_set,
+ Runtime::TrampolineType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- static ByteArray* CreateJniDlsymLookupStub(InstructionSet instruction_set)
+ static mirror::ByteArray* CreateJniDlsymLookupStub(InstructionSet instruction_set)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// A class is uniquely located by its DexFile and the class_defs_ table index into that DexFile
@@ -273,7 +271,8 @@
private:
// Compute constant code and method pointers when possible
- void GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type, AbstractMethod* method,
+ void GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type,
+ mirror::AbstractMethod* method,
uintptr_t& direct_code, uintptr_t& direct_method)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -397,11 +396,11 @@
CompilerEnableAutoElfLoadingFn compiler_enable_auto_elf_loading_;
typedef const void* (*CompilerGetMethodCodeAddrFn)
- (const Compiler& compiler, const CompiledMethod* cm, const AbstractMethod* method);
+ (const Compiler& compiler, const CompiledMethod* cm, const mirror::AbstractMethod* method);
CompilerGetMethodCodeAddrFn compiler_get_method_code_addr_;
- typedef const AbstractMethod::InvokeStub* (*CompilerGetMethodInvokeStubAddrFn)
- (const Compiler& compiler, const CompiledInvokeStub* cm, const AbstractMethod* method);
+ typedef const mirror::AbstractMethod::InvokeStub* (*CompilerGetMethodInvokeStubAddrFn)
+ (const Compiler& compiler, const CompiledInvokeStub* cm, const mirror::AbstractMethod* method);
CompilerGetMethodInvokeStubAddrFn compiler_get_method_invoke_stub_addr_;
diff --git a/src/compiler/codegen/arm/call_arm.cc b/src/compiler/codegen/arm/call_arm.cc
index cb3af5e..47306f4 100644
--- a/src/compiler/codegen/arm/call_arm.cc
+++ b/src/compiler/codegen/arm/call_arm.cc
@@ -489,7 +489,7 @@
GenNullCheck(cu, rl_src.s_reg_low, r0, opt_flags);
LoadWordDisp(cu, rARM_SELF, Thread::ThinLockIdOffset().Int32Value(), r2);
NewLIR3(cu, kThumb2Ldrex, r1, r0,
- Object::MonitorOffset().Int32Value() >> 2); // Get object->lock
+ mirror::Object::MonitorOffset().Int32Value() >> 2); // Get object->lock
// Align owner
OpRegImm(cu, kOpLsl, r2, LW_LOCK_OWNER_SHIFT);
// Is lock unheld on lock or held by us (==thread_id) on unlock?
@@ -498,7 +498,7 @@
OpRegImm(cu, kOpCmp, r1, 0);
OpIT(cu, kCondEq, "");
NewLIR4(cu, kThumb2Strex, r1, r2, r0,
- Object::MonitorOffset().Int32Value() >> 2);
+ mirror::Object::MonitorOffset().Int32Value() >> 2);
OpRegImm(cu, kOpCmp, r1, 0);
OpIT(cu, kCondNe, "T");
// Go expensive route - artLockObjectFromCode(self, obj);
@@ -522,7 +522,7 @@
LoadValueDirectFixed(cu, rl_src, r0); // Get obj
LockCallTemps(cu); // Prepare for explicit register usage
GenNullCheck(cu, rl_src.s_reg_low, r0, opt_flags);
- LoadWordDisp(cu, r0, Object::MonitorOffset().Int32Value(), r1); // Get lock
+ LoadWordDisp(cu, r0, mirror::Object::MonitorOffset().Int32Value(), r1); // Get lock
LoadWordDisp(cu, rARM_SELF, Thread::ThinLockIdOffset().Int32Value(), r2);
// Is lock unheld on lock or held by us (==thread_id) on unlock?
OpRegRegImm(cu, kOpAnd, r3, r1,
@@ -532,7 +532,7 @@
NewLIR3(cu, kThumb2Bfc, r1, LW_HASH_STATE_SHIFT, LW_LOCK_OWNER_SHIFT - 1);
OpRegReg(cu, kOpSub, r1, r2);
OpIT(cu, kCondEq, "EE");
- StoreWordDisp(cu, r0, Object::MonitorOffset().Int32Value(), r3);
+ StoreWordDisp(cu, r0, mirror::Object::MonitorOffset().Int32Value(), r3);
// Go expensive route - UnlockObjectFromCode(obj);
LoadWordDisp(cu, rARM_SELF, ENTRYPOINT_OFFSET(pUnlockObjectFromCode), rARM_LR);
ClobberCalleeSave(cu);
diff --git a/src/compiler/codegen/arm/int_arm.cc b/src/compiler/codegen/arm/int_arm.cc
index e86f379..6a1178e 100644
--- a/src/compiler/codegen/arm/int_arm.cc
+++ b/src/compiler/codegen/arm/int_arm.cc
@@ -565,16 +565,16 @@
RegLocation rl_index, RegLocation rl_dest, int scale)
{
RegisterClass reg_class = oat_reg_class_by_size(size);
- int len_offset = Array::LengthOffset().Int32Value();
+ int len_offset = mirror::Array::LengthOffset().Int32Value();
int data_offset;
RegLocation rl_result;
rl_array = LoadValue(cu, rl_array, kCoreReg);
rl_index = LoadValue(cu, rl_index, kCoreReg);
if (rl_dest.wide) {
- data_offset = Array::DataOffset(sizeof(int64_t)).Int32Value();
+ data_offset = mirror::Array::DataOffset(sizeof(int64_t)).Int32Value();
} else {
- data_offset = Array::DataOffset(sizeof(int32_t)).Int32Value();
+ data_offset = mirror::Array::DataOffset(sizeof(int32_t)).Int32Value();
}
/* null object? */
@@ -637,13 +637,13 @@
RegLocation rl_index, RegLocation rl_src, int scale)
{
RegisterClass reg_class = oat_reg_class_by_size(size);
- int len_offset = Array::LengthOffset().Int32Value();
+ int len_offset = mirror::Array::LengthOffset().Int32Value();
int data_offset;
if (size == kLong || size == kDouble) {
- data_offset = Array::DataOffset(sizeof(int64_t)).Int32Value();
+ data_offset = mirror::Array::DataOffset(sizeof(int64_t)).Int32Value();
} else {
- data_offset = Array::DataOffset(sizeof(int32_t)).Int32Value();
+ data_offset = mirror::Array::DataOffset(sizeof(int32_t)).Int32Value();
}
rl_array = LoadValue(cu, rl_array, kCoreReg);
@@ -706,8 +706,8 @@
void ArmCodegen::GenArrayObjPut(CompilationUnit* cu, int opt_flags, RegLocation rl_array,
RegLocation rl_index, RegLocation rl_src, int scale)
{
- int len_offset = Array::LengthOffset().Int32Value();
- int data_offset = Array::DataOffset(sizeof(Object*)).Int32Value();
+ int len_offset = mirror::Array::LengthOffset().Int32Value();
+ int data_offset = mirror::Array::DataOffset(sizeof(mirror::Object*)).Int32Value();
FlushAllRegs(cu); // Use explicit registers
LockCallTemps(cu);
@@ -727,7 +727,7 @@
LIR* null_value_check = OpCmpImmBranch(cu, kCondEq, r_value, 0, NULL);
// Get the array's class.
- LoadWordDisp(cu, r_array, Object::ClassOffset().Int32Value(), r_array_class);
+ LoadWordDisp(cu, r_array, mirror::Object::ClassOffset().Int32Value(), r_array_class);
CallRuntimeHelperRegReg(cu, ENTRYPOINT_OFFSET(pCanPutArrayElementFromCode), r_value,
r_array_class, true);
// Redo LoadValues in case they didn't survive the call.
diff --git a/src/compiler/codegen/gen_common.cc b/src/compiler/codegen/gen_common.cc
index e1054db..acaad5b 100644
--- a/src/compiler/codegen/gen_common.cc
+++ b/src/compiler/codegen/gen_common.cc
@@ -330,7 +330,7 @@
SRegOffset(cu, rl_first.s_reg_low));
// Set up the target pointer
OpRegRegImm(cu, kOpAdd, r_dst, TargetReg(kRet0),
- Array::DataOffset(component_size).Int32Value());
+ mirror::Array::DataOffset(component_size).Int32Value());
// Set up the loop counter (known to be > 0)
LoadConstant(cu, r_idx, elems - 1);
// Generate the copy loop. Going backwards for convenience
@@ -342,14 +342,15 @@
OpDecAndBranch(cu, kCondGe, r_idx, target);
if (cu->instruction_set == kX86) {
// Restore the target pointer
- OpRegRegImm(cu, kOpAdd, TargetReg(kRet0), r_dst, -Array::DataOffset(component_size).Int32Value());
+ OpRegRegImm(cu, kOpAdd, TargetReg(kRet0), r_dst,
+ -mirror::Array::DataOffset(component_size).Int32Value());
}
} else if (!info->is_range) {
// TUNING: interleave
for (int i = 0; i < elems; i++) {
RegLocation rl_arg = LoadValue(cu, info->args[i], kCoreReg);
StoreBaseDisp(cu, TargetReg(kRet0),
- Array::DataOffset(component_size).Int32Value() +
+ mirror::Array::DataOffset(component_size).Int32Value() +
i * 4, rl_arg.low_reg, kWord);
// If the LoadValue caused a temp to be allocated, free it
if (IsTemp(cu, rl_arg.low_reg)) {
@@ -386,7 +387,7 @@
RegLocation rl_method = LoadCurrMethod(cu);
rBase = AllocTemp(cu);
LoadWordDisp(cu, rl_method.low_reg,
- AbstractMethod::DeclaringClassOffset().Int32Value(), rBase);
+ mirror::AbstractMethod::DeclaringClassOffset().Int32Value(), rBase);
if (IsTemp(cu, rl_method.low_reg)) {
FreeTemp(cu, rl_method.low_reg);
}
@@ -404,10 +405,10 @@
rBase = TargetReg(kArg0);
LockTemp(cu, rBase);
LoadWordDisp(cu, r_method,
- AbstractMethod::DexCacheInitializedStaticStorageOffset().Int32Value(),
+ mirror::AbstractMethod::DexCacheInitializedStaticStorageOffset().Int32Value(),
rBase);
LoadWordDisp(cu, rBase,
- Array::DataOffset(sizeof(Object*)).Int32Value() +
+ mirror::Array::DataOffset(sizeof(mirror::Object*)).Int32Value() +
sizeof(int32_t*) * ssb_index, rBase);
// rBase now points at appropriate static storage base (Class*)
// or NULL if not initialized. Check for NULL and call helper if NULL.
@@ -480,7 +481,7 @@
RegLocation rl_method = LoadCurrMethod(cu);
rBase = AllocTemp(cu);
LoadWordDisp(cu, rl_method.low_reg,
- AbstractMethod::DeclaringClassOffset().Int32Value(), rBase);
+ mirror::AbstractMethod::DeclaringClassOffset().Int32Value(), rBase);
} else {
// Medium path, static storage base in a different class which
// requires checks that the other class is initialized
@@ -495,10 +496,10 @@
rBase = TargetReg(kArg0);
LockTemp(cu, rBase);
LoadWordDisp(cu, r_method,
- AbstractMethod::DexCacheInitializedStaticStorageOffset().Int32Value(),
+ mirror::AbstractMethod::DexCacheInitializedStaticStorageOffset().Int32Value(),
rBase);
LoadWordDisp(cu, rBase,
- Array::DataOffset(sizeof(Object*)).Int32Value() +
+ mirror::Array::DataOffset(sizeof(mirror::Object*)).Int32Value() +
sizeof(int32_t*) * ssb_index, rBase);
// rBase now points at appropriate static storage base (Class*)
// or NULL if not initialized. Check for NULL and call helper if NULL.
@@ -619,7 +620,7 @@
OpRegCopy(cu, TargetReg(kArg0), v1);
if (target_x86) {
// x86 leaves the array pointer in v2, so load the array length that the handler expects
- OpRegMem(cu, kOpMov, TargetReg(kArg1), v2, Array::LengthOffset().Int32Value());
+ OpRegMem(cu, kOpMov, TargetReg(kArg1), v2, mirror::Array::LengthOffset().Int32Value());
} else {
OpRegCopy(cu, TargetReg(kArg1), v2);
}
@@ -629,7 +630,7 @@
OpRegCopy(cu, TargetReg(kArg2), v1);
if (target_x86) {
// x86 leaves the array pointer in v2; load the array length that the handler expects
- OpRegMem(cu, kOpMov, TargetReg(kArg1), v2, Array::LengthOffset().Int32Value());
+ OpRegMem(cu, kOpMov, TargetReg(kArg1), v2, mirror::Array::LengthOffset().Int32Value());
} else {
OpRegCopy(cu, TargetReg(kArg1), v2);
}
@@ -637,7 +638,7 @@
} else {
if (target_x86) {
// x86 leaves the array pointer in v2; load the array length that the handler expects
- OpRegMem(cu, kOpMov, TargetReg(kArg1), v2, Array::LengthOffset().Int32Value());
+ OpRegMem(cu, kOpMov, TargetReg(kArg1), v2, mirror::Array::LengthOffset().Int32Value());
} else {
OpRegCopy(cu, TargetReg(kArg1), v2);
}
@@ -799,10 +800,10 @@
} else {
// We're don't need access checks, load type from dex cache
int32_t dex_cache_offset =
- AbstractMethod::DexCacheResolvedTypesOffset().Int32Value();
+ mirror::AbstractMethod::DexCacheResolvedTypesOffset().Int32Value();
LoadWordDisp(cu, rl_method.low_reg, dex_cache_offset, res_reg);
int32_t offset_of_type =
- Array::DataOffset(sizeof(Class*)).Int32Value() + (sizeof(Class*)
+ mirror::Array::DataOffset(sizeof(mirror::Class*)).Int32Value() + (sizeof(mirror::Class*)
* type_idx);
LoadWordDisp(cu, res_reg, offset_of_type, rl_result.low_reg);
if (!cu->compiler->CanAssumeTypeIsPresentInDexCache(*cu->dex_file,
@@ -844,8 +845,8 @@
void Codegen::GenConstString(CompilationUnit* cu, uint32_t string_idx, RegLocation rl_dest)
{
/* NOTE: Most strings should be available at compile time */
- int32_t offset_of_string = Array::DataOffset(sizeof(String*)).Int32Value() +
- (sizeof(String*) * string_idx);
+ int32_t offset_of_string = mirror::Array::DataOffset(sizeof(mirror::String*)).Int32Value() +
+ (sizeof(mirror::String*) * string_idx);
if (!cu->compiler->CanAssumeStringIsPresentInDexCache(
*cu->dex_file, string_idx) || SLOW_STRING_PATH) {
// slow path, resolve string if not in dex cache
@@ -853,7 +854,7 @@
LockCallTemps(cu); // Using explicit registers
LoadCurrMethodDirect(cu, TargetReg(kArg2));
LoadWordDisp(cu, TargetReg(kArg2),
- AbstractMethod::DexCacheStringsOffset().Int32Value(), TargetReg(kArg0));
+ mirror::AbstractMethod::DexCacheStringsOffset().Int32Value(), TargetReg(kArg0));
// Might call out to helper, which will return resolved string in kRet0
int r_tgt = CallHelperSetup(cu, ENTRYPOINT_OFFSET(pResolveStringFromCode));
LoadWordDisp(cu, TargetReg(kArg0), offset_of_string, TargetReg(kRet0));
@@ -888,7 +889,7 @@
int res_reg = AllocTemp(cu);
RegLocation rl_result = EvalLoc(cu, rl_dest, kCoreReg, true);
LoadWordDisp(cu, rl_method.low_reg,
- AbstractMethod::DexCacheStringsOffset().Int32Value(), res_reg);
+ mirror::AbstractMethod::DexCacheStringsOffset().Int32Value(), res_reg);
LoadWordDisp(cu, res_reg, offset_of_string, rl_result.low_reg);
StoreValue(cu, rl_dest, rl_result);
}
@@ -942,9 +943,9 @@
// Load dex cache entry into class_reg (kArg2)
LoadValueDirectFixed(cu, rl_src, TargetReg(kArg0)); // kArg0 <= ref
LoadWordDisp(cu, TargetReg(kArg1),
- AbstractMethod::DexCacheResolvedTypesOffset().Int32Value(), class_reg);
+ mirror::AbstractMethod::DexCacheResolvedTypesOffset().Int32Value(), class_reg);
int32_t offset_of_type =
- Array::DataOffset(sizeof(Class*)).Int32Value() + (sizeof(Class*)
+ mirror::Array::DataOffset(sizeof(mirror::Class*)).Int32Value() + (sizeof(mirror::Class*)
* type_idx);
LoadWordDisp(cu, class_reg, offset_of_type, class_reg);
if (!cu->compiler->CanAssumeTypeIsPresentInDexCache(
@@ -968,8 +969,8 @@
}
LIR* branch1 = OpCmpImmBranch(cu, kCondEq, TargetReg(kArg0), 0, NULL);
/* load object->klass_ */
- DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
- LoadWordDisp(cu, TargetReg(kArg0), Object::ClassOffset().Int32Value(), TargetReg(kArg1));
+ DCHECK_EQ(mirror::Object::ClassOffset().Int32Value(), 0);
+ LoadWordDisp(cu, TargetReg(kArg0), mirror::Object::ClassOffset().Int32Value(), TargetReg(kArg1));
/* kArg0 is ref, kArg1 is ref->klass_, kArg2 is class */
LIR* call_inst;
LIR* branchover = NULL;
@@ -1026,10 +1027,10 @@
} else {
// Load dex cache entry into class_reg (kArg2)
LoadWordDisp(cu, TargetReg(kArg1),
- AbstractMethod::DexCacheResolvedTypesOffset().Int32Value(), class_reg);
+ mirror::AbstractMethod::DexCacheResolvedTypesOffset().Int32Value(), class_reg);
int32_t offset_of_type =
- Array::DataOffset(sizeof(Class*)).Int32Value() +
- (sizeof(Class*) * type_idx);
+ mirror::Array::DataOffset(sizeof(mirror::Class*)).Int32Value() +
+ (sizeof(mirror::Class*) * type_idx);
LoadWordDisp(cu, class_reg, offset_of_type, class_reg);
if (!cu->compiler->CanAssumeTypeIsPresentInDexCache(
*cu->dex_file, type_idx)) {
@@ -1051,8 +1052,8 @@
/* Null is OK - continue */
LIR* branch1 = OpCmpImmBranch(cu, kCondEq, TargetReg(kArg0), 0, NULL);
/* load object->klass_ */
- DCHECK_EQ(Object::ClassOffset().Int32Value(), 0);
- LoadWordDisp(cu, TargetReg(kArg0), Object::ClassOffset().Int32Value(), TargetReg(kArg1));
+ DCHECK_EQ(mirror::Object::ClassOffset().Int32Value(), 0);
+ LoadWordDisp(cu, TargetReg(kArg0), mirror::Object::ClassOffset().Int32Value(), TargetReg(kArg1));
/* kArg1 now contains object->klass_ */
LIR* branch2;
if (cu->instruction_set == kThumb2) {
diff --git a/src/compiler/codegen/gen_invoke.cc b/src/compiler/codegen/gen_invoke.cc
index fe60aff..78425c4 100644
--- a/src/compiler/codegen/gen_invoke.cc
+++ b/src/compiler/codegen/gen_invoke.cc
@@ -365,7 +365,7 @@
break;
case 1: // Get method->dex_cache_resolved_methods_
cg->LoadWordDisp(cu, cg->TargetReg(kArg0),
- AbstractMethod::DexCacheResolvedMethodsOffset().Int32Value(), cg->TargetReg(kArg0));
+ mirror::AbstractMethod::DexCacheResolvedMethodsOffset().Int32Value(), cg->TargetReg(kArg0));
// Set up direct code if known.
if (direct_code != 0) {
if (direct_code != static_cast<unsigned int>(-1)) {
@@ -384,13 +384,14 @@
break;
case 2: // Grab target method*
cg->LoadWordDisp(cu, cg->TargetReg(kArg0),
- Array::DataOffset(sizeof(Object*)).Int32Value() + dex_idx * 4,
+ mirror::Array::DataOffset(sizeof(mirror::Object*)).Int32Value() + dex_idx * 4,
cg-> TargetReg(kArg0));
break;
case 3: // Grab the code from the method*
if (cu->instruction_set != kX86) {
if (direct_code == 0) {
- cg->LoadWordDisp(cu, cg->TargetReg(kArg0), AbstractMethod::GetCodeOffset().Int32Value(),
+ cg->LoadWordDisp(cu, cg->TargetReg(kArg0),
+ mirror::AbstractMethod::GetCodeOffset().Int32Value(),
cg->TargetReg(kInvokeTgt));
}
break;
@@ -428,20 +429,22 @@
case 1: // Is "this" null? [use kArg1]
cg->GenNullCheck(cu, info->args[0].s_reg_low, cg->TargetReg(kArg1), info->opt_flags);
// get this->klass_ [use kArg1, set kInvokeTgt]
- cg->LoadWordDisp(cu, cg->TargetReg(kArg1), Object::ClassOffset().Int32Value(),
+ cg->LoadWordDisp(cu, cg->TargetReg(kArg1), mirror::Object::ClassOffset().Int32Value(),
cg->TargetReg(kInvokeTgt));
break;
case 2: // Get this->klass_->vtable [usr kInvokeTgt, set kInvokeTgt]
- cg->LoadWordDisp(cu, cg->TargetReg(kInvokeTgt), Class::VTableOffset().Int32Value(),
+ cg->LoadWordDisp(cu, cg->TargetReg(kInvokeTgt), mirror::Class::VTableOffset().Int32Value(),
cg->TargetReg(kInvokeTgt));
break;
case 3: // Get target method [use kInvokeTgt, set kArg0]
cg->LoadWordDisp(cu, cg->TargetReg(kInvokeTgt), (method_idx * 4) +
- Array::DataOffset(sizeof(Object*)).Int32Value(), cg->TargetReg(kArg0));
+ mirror::Array::DataOffset(sizeof(mirror::Object*)).Int32Value(),
+ cg->TargetReg(kArg0));
break;
case 4: // Get the compiled code address [uses kArg0, sets kInvokeTgt]
if (cu->instruction_set != kX86) {
- cg->LoadWordDisp(cu, cg->TargetReg(kArg0), AbstractMethod::GetCodeOffset().Int32Value(),
+ cg->LoadWordDisp(cu, cg->TargetReg(kArg0),
+ mirror::AbstractMethod::GetCodeOffset().Int32Value(),
cg->TargetReg(kInvokeTgt));
break;
}
@@ -503,12 +506,12 @@
break;
case 1: // Get method->dex_cache_resolved_methods_ [set/use kArg0]
cg->LoadWordDisp(cu, cg->TargetReg(kArg0),
- AbstractMethod::DexCacheResolvedMethodsOffset().Int32Value(),
+ mirror::AbstractMethod::DexCacheResolvedMethodsOffset().Int32Value(),
cg->TargetReg(kArg0));
break;
case 2: // Grab target method* [set/use kArg0]
cg->LoadWordDisp(cu, cg->TargetReg(kArg0),
- Array::DataOffset(sizeof(Object*)).Int32Value() + dex_idx * 4,
+ mirror::Array::DataOffset(sizeof(mirror::Object*)).Int32Value() + dex_idx * 4,
cg->TargetReg(kArg0));
break;
default:
@@ -837,13 +840,13 @@
return false;
}
// Location of reference to data array
- int value_offset = String::ValueOffset().Int32Value();
+ int value_offset = mirror::String::ValueOffset().Int32Value();
// Location of count
- int count_offset = String::CountOffset().Int32Value();
+ int count_offset = mirror::String::CountOffset().Int32Value();
// Starting offset within data array
- int offset_offset = String::OffsetOffset().Int32Value();
+ int offset_offset = mirror::String::OffsetOffset().Int32Value();
// Start of char data with array_
- int data_offset = Array::DataOffset(sizeof(uint16_t)).Int32Value();
+ int data_offset = mirror::Array::DataOffset(sizeof(uint16_t)).Int32Value();
RegLocation rl_obj = info->args[0];
RegLocation rl_idx = info->args[1];
@@ -921,7 +924,7 @@
RegLocation rl_dest = InlineTarget(cu, info);
RegLocation rl_result = EvalLoc(cu, rl_dest, kCoreReg, true);
GenNullCheck(cu, rl_obj.s_reg_low, rl_obj.low_reg, info->opt_flags);
- LoadWordDisp(cu, rl_obj.low_reg, String::CountOffset().Int32Value(),
+ LoadWordDisp(cu, rl_obj.low_reg, mirror::String::CountOffset().Int32Value(),
rl_result.low_reg);
if (is_empty) {
// dst = (dst == 0);
@@ -1284,7 +1287,7 @@
} else {
if (fast_path && info->type != kInterface) {
call_inst = OpMem(cu, kOpBlx, TargetReg(kArg0),
- AbstractMethod::GetCodeOffset().Int32Value());
+ mirror::AbstractMethod::GetCodeOffset().Int32Value());
} else {
int trampoline = 0;
switch (info->type) {
diff --git a/src/compiler/codegen/mips/int_mips.cc b/src/compiler/codegen/mips/int_mips.cc
index e2a5a02..86f0527 100644
--- a/src/compiler/codegen/mips/int_mips.cc
+++ b/src/compiler/codegen/mips/int_mips.cc
@@ -439,16 +439,16 @@
RegLocation rl_index, RegLocation rl_dest, int scale)
{
RegisterClass reg_class = oat_reg_class_by_size(size);
- int len_offset = Array::LengthOffset().Int32Value();
+ int len_offset = mirror::Array::LengthOffset().Int32Value();
int data_offset;
RegLocation rl_result;
rl_array = LoadValue(cu, rl_array, kCoreReg);
rl_index = LoadValue(cu, rl_index, kCoreReg);
if (size == kLong || size == kDouble) {
- data_offset = Array::DataOffset(sizeof(int64_t)).Int32Value();
+ data_offset = mirror::Array::DataOffset(sizeof(int64_t)).Int32Value();
} else {
- data_offset = Array::DataOffset(sizeof(int32_t)).Int32Value();
+ data_offset = mirror::Array::DataOffset(sizeof(int32_t)).Int32Value();
}
/* null object? */
@@ -511,13 +511,13 @@
RegLocation rl_index, RegLocation rl_src, int scale)
{
RegisterClass reg_class = oat_reg_class_by_size(size);
- int len_offset = Array::LengthOffset().Int32Value();
+ int len_offset = mirror::Array::LengthOffset().Int32Value();
int data_offset;
if (size == kLong || size == kDouble) {
- data_offset = Array::DataOffset(sizeof(int64_t)).Int32Value();
+ data_offset = mirror::Array::DataOffset(sizeof(int64_t)).Int32Value();
} else {
- data_offset = Array::DataOffset(sizeof(int32_t)).Int32Value();
+ data_offset = mirror::Array::DataOffset(sizeof(int32_t)).Int32Value();
}
rl_array = LoadValue(cu, rl_array, kCoreReg);
@@ -583,8 +583,8 @@
void MipsCodegen::GenArrayObjPut(CompilationUnit* cu, int opt_flags, RegLocation rl_array,
RegLocation rl_index, RegLocation rl_src, int scale)
{
- int len_offset = Array::LengthOffset().Int32Value();
- int data_offset = Array::DataOffset(sizeof(Object*)).Int32Value();
+ int len_offset = mirror::Array::LengthOffset().Int32Value();
+ int data_offset = mirror::Array::DataOffset(sizeof(mirror::Object*)).Int32Value();
FlushAllRegs(cu); // Use explicit registers
LockCallTemps(cu);
@@ -604,7 +604,7 @@
LIR* null_value_check = OpCmpImmBranch(cu, kCondEq, r_value, 0, NULL);
// Get the array's class.
- LoadWordDisp(cu, r_array, Object::ClassOffset().Int32Value(), r_array_class);
+ LoadWordDisp(cu, r_array, mirror::Object::ClassOffset().Int32Value(), r_array_class);
CallRuntimeHelperRegReg(cu, ENTRYPOINT_OFFSET(pCanPutArrayElementFromCode), r_value,
r_array_class, true);
// Redo LoadValues in case they didn't survive the call.
diff --git a/src/compiler/codegen/mir_to_gbc.cc b/src/compiler/codegen/mir_to_gbc.cc
index e38977a..2657b79 100644
--- a/src/compiler/codegen/mir_to_gbc.cc
+++ b/src/compiler/codegen/mir_to_gbc.cc
@@ -2684,7 +2684,7 @@
cg->GenNullCheck(cu, rl_src.s_reg_low, rl_src.low_reg, opt_flags->getZExtValue());
RegLocation rl_dest = GetLoc(cu, call_inst);
RegLocation rl_result = EvalLoc(cu, rl_dest, kCoreReg, true);
- int len_offset = Array::LengthOffset().Int32Value();
+ int len_offset = mirror::Array::LengthOffset().Int32Value();
cg->LoadWordDisp(cu, rl_src.low_reg, len_offset, rl_result.low_reg);
cg->StoreValue(cu, rl_dest, rl_result);
}
diff --git a/src/compiler/codegen/mir_to_lir.cc b/src/compiler/codegen/mir_to_lir.cc
index 2bc0f86..77d581f 100644
--- a/src/compiler/codegen/mir_to_lir.cc
+++ b/src/compiler/codegen/mir_to_lir.cc
@@ -210,7 +210,7 @@
case Instruction::ARRAY_LENGTH:
int len_offset;
- len_offset = Array::LengthOffset().Int32Value();
+ len_offset = mirror::Array::LengthOffset().Int32Value();
rl_src[0] = cg->LoadValue(cu, rl_src[0], kCoreReg);
cg->GenNullCheck(cu, rl_src[0].s_reg_low, rl_src[0].low_reg, opt_flags);
rl_result = EvalLoc(cu, rl_dest, kCoreReg, true);
diff --git a/src/compiler/codegen/x86/call_x86.cc b/src/compiler/codegen/x86/call_x86.cc
index 727c5e8..f9b25c8 100644
--- a/src/compiler/codegen/x86/call_x86.cc
+++ b/src/compiler/codegen/x86/call_x86.cc
@@ -163,7 +163,7 @@
NewLIR2(cu, kX86Mov32RT, rDX, Thread::ThinLockIdOffset().Int32Value());
NewLIR2(cu, kX86Sal32RI, rDX, LW_LOCK_OWNER_SHIFT);
NewLIR2(cu, kX86Xor32RR, rAX, rAX);
- NewLIR3(cu, kX86LockCmpxchgMR, rCX, Object::MonitorOffset().Int32Value(), rDX);
+ NewLIR3(cu, kX86LockCmpxchgMR, rCX, mirror::Object::MonitorOffset().Int32Value(), rDX);
LIR* branch = NewLIR2(cu, kX86Jcc8, 0, kX86CondEq);
// If lock is held, go the expensive route - artLockObjectFromCode(self, obj);
CallRuntimeHelperReg(cu, ENTRYPOINT_OFFSET(pLockObjectFromCode), rCX, true);
@@ -180,10 +180,10 @@
// TODO: clear hash state?
NewLIR2(cu, kX86Mov32RT, rDX, Thread::ThinLockIdOffset().Int32Value());
NewLIR2(cu, kX86Sal32RI, rDX, LW_LOCK_OWNER_SHIFT);
- NewLIR3(cu, kX86Mov32RM, rCX, rAX, Object::MonitorOffset().Int32Value());
+ NewLIR3(cu, kX86Mov32RM, rCX, rAX, mirror::Object::MonitorOffset().Int32Value());
OpRegReg(cu, kOpSub, rCX, rDX);
LIR* branch = NewLIR2(cu, kX86Jcc8, 0, kX86CondNe);
- NewLIR3(cu, kX86Mov32MR, rAX, Object::MonitorOffset().Int32Value(), rCX);
+ NewLIR3(cu, kX86Mov32MR, rAX, mirror::Object::MonitorOffset().Int32Value(), rCX);
LIR* branch2 = NewLIR1(cu, kX86Jmp8, 0);
branch->target = NewLIR0(cu, kPseudoTargetLabel);
// Otherwise, go the expensive route - UnlockObjectFromCode(obj);
diff --git a/src/compiler/codegen/x86/int_x86.cc b/src/compiler/codegen/x86/int_x86.cc
index 0f1fc53..f2d023c 100644
--- a/src/compiler/codegen/x86/int_x86.cc
+++ b/src/compiler/codegen/x86/int_x86.cc
@@ -446,16 +446,16 @@
RegLocation rl_index, RegLocation rl_dest, int scale)
{
RegisterClass reg_class = oat_reg_class_by_size(size);
- int len_offset = Array::LengthOffset().Int32Value();
+ int len_offset = mirror::Array::LengthOffset().Int32Value();
int data_offset;
RegLocation rl_result;
rl_array = LoadValue(cu, rl_array, kCoreReg);
rl_index = LoadValue(cu, rl_index, kCoreReg);
if (size == kLong || size == kDouble) {
- data_offset = Array::DataOffset(sizeof(int64_t)).Int32Value();
+ data_offset = mirror::Array::DataOffset(sizeof(int64_t)).Int32Value();
} else {
- data_offset = Array::DataOffset(sizeof(int32_t)).Int32Value();
+ data_offset = mirror::Array::DataOffset(sizeof(int32_t)).Int32Value();
}
/* null object? */
@@ -494,13 +494,13 @@
RegLocation rl_index, RegLocation rl_src, int scale)
{
RegisterClass reg_class = oat_reg_class_by_size(size);
- int len_offset = Array::LengthOffset().Int32Value();
+ int len_offset = mirror::Array::LengthOffset().Int32Value();
int data_offset;
if (size == kLong || size == kDouble) {
- data_offset = Array::DataOffset(sizeof(int64_t)).Int32Value();
+ data_offset = mirror::Array::DataOffset(sizeof(int64_t)).Int32Value();
} else {
- data_offset = Array::DataOffset(sizeof(int32_t)).Int32Value();
+ data_offset = mirror::Array::DataOffset(sizeof(int32_t)).Int32Value();
}
rl_array = LoadValue(cu, rl_array, kCoreReg);
@@ -537,8 +537,8 @@
void X86Codegen::GenArrayObjPut(CompilationUnit* cu, int opt_flags, RegLocation rl_array,
RegLocation rl_index, RegLocation rl_src, int scale)
{
- int len_offset = Array::LengthOffset().Int32Value();
- int data_offset = Array::DataOffset(sizeof(Object*)).Int32Value();
+ int len_offset = mirror::Array::LengthOffset().Int32Value();
+ int data_offset = mirror::Array::DataOffset(sizeof(mirror::Object*)).Int32Value();
FlushAllRegs(cu); // Use explicit registers
LockCallTemps(cu);
@@ -558,7 +558,7 @@
LIR* null_value_check = OpCmpImmBranch(cu, kCondEq, r_value, 0, NULL);
// Get the array's class.
- LoadWordDisp(cu, r_array, Object::ClassOffset().Int32Value(), r_array_class);
+ LoadWordDisp(cu, r_array, mirror::Object::ClassOffset().Int32Value(), r_array_class);
CallRuntimeHelperRegReg(cu, ENTRYPOINT_OFFSET(pCanPutArrayElementFromCode), r_value,
r_array_class, true);
// Redo LoadValues in case they didn't survive the call.
diff --git a/src/compiler/compiler_internals.h b/src/compiler/compiler_internals.h
index 1379a3b..746999d 100644
--- a/src/compiler/compiler_internals.h
+++ b/src/compiler/compiler_internals.h
@@ -28,11 +28,10 @@
#include "compiler.h"
#include "compiler_ir.h"
#include "compiler_utility.h"
-#include "dex_cache.h"
#include "frontend.h"
#include "gc/card_table.h"
+#include "mirror/dex_cache.h"
#include "monitor.h"
-#include "object.h"
#include "ralloc.h"
#include "thread.h"
#include "utils.h"
diff --git a/src/compiler/frontend.cc b/src/compiler/frontend.cc
index 31423ef..6ccbc07 100644
--- a/src/compiler/frontend.cc
+++ b/src/compiler/frontend.cc
@@ -19,7 +19,7 @@
#include "dataflow.h"
#include "ssa_transformation.h"
#include "leb128.h"
-#include "object.h"
+#include "mirror/object.h"
#include "runtime.h"
#include "codegen/codegen_util.h"
#include "codegen/mir_to_gbc.h"
diff --git a/src/compiler_llvm/compiler_llvm.h b/src/compiler_llvm/compiler_llvm.h
index 9aa9791..bb14c49 100644
--- a/src/compiler_llvm/compiler_llvm.h
+++ b/src/compiler_llvm/compiler_llvm.h
@@ -21,7 +21,7 @@
#include "compiler.h"
#include "dex_file.h"
#include "instruction_set.h"
-#include "object.h"
+#include "mirror/object.h"
#include "procedure_linkage_table.h"
#include <UniquePtr.h>
@@ -31,13 +31,15 @@
#include <vector>
namespace art {
- class ClassLoader;
class CompiledInvokeStub;
class CompiledMethod;
class Compiler;
class OatCompilationUnit;
- class AbstractMethod;
-}
+ namespace mirror {
+ class AbstractMethod;
+ class ClassLoader;
+ } // namespace mirror
+} // namespace art
namespace llvm {
@@ -47,7 +49,7 @@
class PointerType;
class StructType;
class Type;
-}
+} // namespace llvm
namespace art {
diff --git a/src/compiler_llvm/gbc_expander.cc b/src/compiler_llvm/gbc_expander.cc
index a7970d5..0348874 100644
--- a/src/compiler_llvm/gbc_expander.cc
+++ b/src/compiler_llvm/gbc_expander.cc
@@ -19,8 +19,8 @@
#include "compiler.h"
#include "greenland/intrinsic_helper.h"
+#include "mirror/object.h"
#include "oat_compilation_unit.h"
-#include "object.h"
#include "thread.h"
#include "verifier/method_verifier.h"
diff --git a/src/compiler_llvm/jni_compiler.cc b/src/compiler_llvm/jni_compiler.cc
index da55d94..e81afed 100644
--- a/src/compiler_llvm/jni_compiler.cc
+++ b/src/compiler_llvm/jni_compiler.cc
@@ -23,8 +23,8 @@
#include "compiler.h"
#include "compiler_llvm.h"
#include "ir_builder.h"
+#include "mirror/object.h"
#include "oat_compilation_unit.h"
-#include "object.h"
#include "runtime.h"
#include "runtime_support_func.h"
#include "utils_llvm.h"
diff --git a/src/compiler_llvm/jni_compiler.h b/src/compiler_llvm/jni_compiler.h
index c428775..0731e92 100644
--- a/src/compiler_llvm/jni_compiler.h
+++ b/src/compiler_llvm/jni_compiler.h
@@ -21,14 +21,16 @@
namespace art {
class ClassLinker;
- class ClassLoader;
class CompiledMethod;
class Compiler;
- class DexCache;
class DexFile;
- class AbstractMethod;
class OatCompilationUnit;
-}
+ namespace mirror {
+ class AbstractMethod;
+ class ClassLoader;
+ class DexCache;
+ } // namespace mirror
+} // namespace art
namespace llvm {
class AllocaInst;
@@ -39,7 +41,7 @@
class Module;
class Type;
class Value;
-}
+} // namespace llvm
namespace art {
namespace compiler_llvm {
diff --git a/src/compiler_llvm/method_compiler.cc b/src/compiler_llvm/method_compiler.cc
index ccec7e9..bc3fb92 100644
--- a/src/compiler_llvm/method_compiler.cc
+++ b/src/compiler_llvm/method_compiler.cc
@@ -25,8 +25,8 @@
#include "dalvik_reg.h"
#include "greenland/inferred_reg_category_map.h"
#include "ir_builder.h"
+#include "mirror/object.h"
#include "oat_compilation_unit.h"
-#include "object.h"
#include "object_utils.h"
#include "runtime_support_func.h"
#include "runtime_support_llvm.h"
diff --git a/src/compiler_llvm/method_compiler.h b/src/compiler_llvm/method_compiler.h
index f67866a..dd9d182 100644
--- a/src/compiler_llvm/method_compiler.h
+++ b/src/compiler_llvm/method_compiler.h
@@ -34,17 +34,20 @@
namespace art {
class ClassLinker;
- class ClassLoader;
class CompiledMethod;
class Compiler;
- class DexCache;
- class Field;
class OatCompilationUnit;
+ namespace mirror {
+ class ClassLoader;
+ class DexCache;
+ class Field;
+ } // namespace mirror
+
namespace greenland {
class InferredRegCategoryMap;
- }
-}
+ } // namespace greenland
+} // namespace art
namespace llvm {
@@ -55,7 +58,7 @@
class LLVMContext;
class Module;
class Type;
-}
+} // namespace llvm
namespace art {
diff --git a/src/compiler_llvm/runtime_support_builder.cc b/src/compiler_llvm/runtime_support_builder.cc
index 169f8e8..36b5fa1 100644
--- a/src/compiler_llvm/runtime_support_builder.cc
+++ b/src/compiler_llvm/runtime_support_builder.cc
@@ -19,7 +19,7 @@
#include "gc/card_table.h"
#include "ir_builder.h"
#include "monitor.h"
-#include "object.h"
+#include "mirror/object.h"
#include "thread.h"
#include <llvm/DerivedTypes.h>
@@ -179,7 +179,7 @@
kTBAARuntimeInfo);
Value* monitor =
irb_.LoadFromObjectOffset(object,
- Object::MonitorOffset().Int32Value(),
+ mirror::Object::MonitorOffset().Int32Value(),
irb_.getJIntTy(),
kTBAARuntimeInfo);
@@ -199,7 +199,7 @@
irb_.SetInsertPoint(bb_fast);
// Set all bits to zero (except hash state)
irb_.StoreToObjectOffset(object,
- Object::MonitorOffset().Int32Value(),
+ mirror::Object::MonitorOffset().Int32Value(),
hash_state,
kTBAARuntimeInfo);
irb_.CreateBr(bb_cont);
diff --git a/src/compiler_llvm/runtime_support_builder_thumb2.cc b/src/compiler_llvm/runtime_support_builder_thumb2.cc
index 3299afe..c18ae83 100644
--- a/src/compiler_llvm/runtime_support_builder_thumb2.cc
+++ b/src/compiler_llvm/runtime_support_builder_thumb2.cc
@@ -17,8 +17,8 @@
#include "runtime_support_builder_thumb2.h"
#include "ir_builder.h"
+#include "mirror/object.h"
#include "monitor.h"
-#include "object.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 d3552e9..8de90ff 100644
--- a/src/compiler_llvm/runtime_support_llvm.cc
+++ b/src/compiler_llvm/runtime_support_llvm.cc
@@ -22,8 +22,8 @@
#include "compiler_runtime_func_list.h"
#include "dex_file.h"
#include "dex_instruction.h"
+#include "mirror/object.h"
#include "nth_caller_visitor.h"
-#include "object.h"
#include "object_utils.h"
#include "reflection.h"
#include "runtime_support.h"
@@ -60,7 +60,7 @@
return NULL;
}
-void art_lock_object_from_code(Object* obj, Thread* thread)
+void art_lock_object_from_code(mirror::Object* obj, Thread* thread)
EXCLUSIVE_LOCK_FUNCTION(monitor_lock_) {
DCHECK(obj != NULL); // Assumed to have been checked before entry
obj->MonitorEnter(thread); // May block
@@ -69,7 +69,7 @@
DCHECK(!thread->IsExceptionPending());
}
-void art_unlock_object_from_code(Object* obj, Thread* thread)
+void art_unlock_object_from_code(mirror::Object* obj, Thread* thread)
UNLOCK_FUNCTION(monitor_lock_) {
DCHECK(obj != NULL); // Assumed to have been checked before entry
// MonitorExit may throw exception
@@ -82,7 +82,7 @@
}
ShadowFrame* art_push_shadow_frame_from_code(Thread* thread, ShadowFrame* new_shadow_frame,
- AbstractMethod* method, uint32_t num_vregs) {
+ mirror::AbstractMethod* method, uint32_t num_vregs) {
ShadowFrame* old_frame = thread->PushShadowFrame(new_shadow_frame);
new_shadow_frame->SetMethod(method);
new_shadow_frame->SetNumberOfVRegs(num_vregs);
@@ -120,13 +120,13 @@
void art_throw_no_such_method_from_code(int32_t method_idx)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// We need the calling method as context for the method_idx.
- AbstractMethod* method = Thread::Current()->GetCurrentMethod();
+ mirror::AbstractMethod* method = Thread::Current()->GetCurrentMethod();
ThrowNoSuchMethodError(method_idx, method);
}
void art_throw_null_pointer_exception_from_code(uint32_t dex_pc)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* throw_method =
+ mirror::AbstractMethod* throw_method =
Thread::Current()->GetManagedStack()->GetTopShadowFrame()->GetMethod();
ThrowNullPointerExceptionFromDexPC(throw_method, dex_pc);
}
@@ -135,21 +135,21 @@
ThrowStackOverflowError(Thread::Current());
}
-void art_throw_exception_from_code(Object* exception) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Thread::Current()->DeliverException(static_cast<Throwable*>(exception));
+void art_throw_exception_from_code(mirror::Object* exception) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ Thread::Current()->DeliverException(static_cast<mirror::Throwable*>(exception));
}
void* art_get_and_clear_exception(Thread* self)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(self->IsExceptionPending());
- Throwable* exception = self->GetException();
+ mirror::Throwable* exception = self->GetException();
self->ClearException();
return exception;
}
-int32_t art_find_catch_block_from_code(AbstractMethod* current_method, uint32_t ti_offset)
+int32_t art_find_catch_block_from_code(mirror::AbstractMethod* current_method, uint32_t ti_offset)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Class* exception_type = Thread::Current()->GetException()->GetClass();
+ mirror::Class* exception_type = Thread::Current()->GetException()->GetClass();
MethodHelper mh(current_method);
const DexFile::CodeItem* code_item = mh.GetCodeItem();
DCHECK_LT(ti_offset, code_item->tries_size_);
@@ -164,7 +164,7 @@
return iter_index;
}
// Does this catch exception type apply?
- Class* iter_exception_type = mh.GetDexCacheResolvedType(iter_type_idx);
+ mirror::Class* iter_exception_type = mh.GetDexCacheResolvedType(iter_type_idx);
if (iter_exception_type == NULL) {
// The verifier should take care of resolving all exception classes early
LOG(WARNING) << "Unresolved exception class when finding catch block: "
@@ -183,57 +183,57 @@
// Object Space
//----------------------------------------------------------------------------
-Object* art_alloc_object_from_code(uint32_t type_idx,
- AbstractMethod* referrer,
+mirror::Object* art_alloc_object_from_code(uint32_t type_idx,
+ mirror::AbstractMethod* referrer,
Thread* thread)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return AllocObjectFromCode(type_idx, referrer, thread, false);
}
-Object* art_alloc_object_from_code_with_access_check(uint32_t type_idx,
- AbstractMethod* referrer,
+mirror::Object* art_alloc_object_from_code_with_access_check(uint32_t type_idx,
+ mirror::AbstractMethod* referrer,
Thread* thread)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return AllocObjectFromCode(type_idx, referrer, thread, true);
}
-Object* art_alloc_array_from_code(uint32_t type_idx,
- AbstractMethod* referrer,
+mirror::Object* art_alloc_array_from_code(uint32_t type_idx,
+ mirror::AbstractMethod* referrer,
uint32_t length,
Thread* self)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return AllocArrayFromCode(type_idx, referrer, length, self, false);
}
-Object* art_alloc_array_from_code_with_access_check(uint32_t type_idx,
- AbstractMethod* referrer,
+mirror::Object* art_alloc_array_from_code_with_access_check(uint32_t type_idx,
+ mirror::AbstractMethod* referrer,
uint32_t length,
Thread* self)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return AllocArrayFromCode(type_idx, referrer, length, self, true);
}
-Object* art_check_and_alloc_array_from_code(uint32_t type_idx,
- AbstractMethod* referrer,
+mirror::Object* art_check_and_alloc_array_from_code(uint32_t type_idx,
+ mirror::AbstractMethod* referrer,
uint32_t length,
Thread* thread)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return CheckAndAllocArrayFromCode(type_idx, referrer, length, thread, false);
}
-Object* art_check_and_alloc_array_from_code_with_access_check(uint32_t type_idx,
- AbstractMethod* referrer,
+mirror::Object* art_check_and_alloc_array_from_code_with_access_check(uint32_t type_idx,
+ mirror::AbstractMethod* referrer,
uint32_t length,
Thread* thread)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return CheckAndAllocArrayFromCode(type_idx, referrer, length, thread, true);
}
-static AbstractMethod* FindMethodHelper(uint32_t method_idx, Object* this_object,
- AbstractMethod* caller_method, bool access_check,
+static mirror::AbstractMethod* FindMethodHelper(uint32_t method_idx, mirror::Object* this_object,
+ mirror::AbstractMethod* caller_method, bool access_check,
InvokeType type, Thread* thread)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* method = FindMethodFast(method_idx, this_object, caller_method, access_check, type);
+ mirror::AbstractMethod* method = FindMethodFast(method_idx, this_object, caller_method, access_check, type);
if (UNLIKELY(method == NULL)) {
method = FindMethodFromCode(method_idx, this_object, caller_method,
thread, access_check, type);
@@ -254,71 +254,71 @@
return method;
}
-Object* art_find_static_method_from_code_with_access_check(uint32_t method_idx,
- Object* this_object,
- AbstractMethod* referrer,
+mirror::Object* art_find_static_method_from_code_with_access_check(uint32_t method_idx,
+ mirror::Object* this_object,
+ mirror::AbstractMethod* referrer,
Thread* thread)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return FindMethodHelper(method_idx, this_object, referrer, true, kStatic, thread);
}
-Object* art_find_direct_method_from_code_with_access_check(uint32_t method_idx,
- Object* this_object,
- AbstractMethod* referrer,
+mirror::Object* art_find_direct_method_from_code_with_access_check(uint32_t method_idx,
+ mirror::Object* this_object,
+ mirror::AbstractMethod* referrer,
Thread* thread)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return FindMethodHelper(method_idx, this_object, referrer, true, kDirect, thread);
}
-Object* art_find_virtual_method_from_code_with_access_check(uint32_t method_idx,
- Object* this_object,
- AbstractMethod* referrer,
+mirror::Object* art_find_virtual_method_from_code_with_access_check(uint32_t method_idx,
+ mirror::Object* this_object,
+ mirror::AbstractMethod* referrer,
Thread* thread)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return FindMethodHelper(method_idx, this_object, referrer, true, kVirtual, thread);
}
-Object* art_find_super_method_from_code_with_access_check(uint32_t method_idx,
- Object* this_object,
- AbstractMethod* referrer,
+mirror::Object* art_find_super_method_from_code_with_access_check(uint32_t method_idx,
+ mirror::Object* this_object,
+ mirror::AbstractMethod* referrer,
Thread* thread)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return FindMethodHelper(method_idx, this_object, referrer, true, kSuper, thread);
}
-Object*
+mirror::Object*
art_find_interface_method_from_code_with_access_check(uint32_t method_idx,
- Object* this_object,
- AbstractMethod* referrer,
+ mirror::Object* this_object,
+ mirror::AbstractMethod* referrer,
Thread* thread)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return FindMethodHelper(method_idx, this_object, referrer, true, kInterface, thread);
}
-Object* art_find_interface_method_from_code(uint32_t method_idx,
- Object* this_object,
- AbstractMethod* referrer,
+mirror::Object* art_find_interface_method_from_code(uint32_t method_idx,
+ mirror::Object* this_object,
+ mirror::AbstractMethod* referrer,
Thread* thread)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return FindMethodHelper(method_idx, this_object, referrer, false, kInterface, thread);
}
-Object* art_initialize_static_storage_from_code(uint32_t type_idx,
- AbstractMethod* referrer,
+mirror::Object* art_initialize_static_storage_from_code(uint32_t type_idx,
+ mirror::AbstractMethod* referrer,
Thread* thread)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return ResolveVerifyAndClinit(type_idx, referrer, thread, true, false);
}
-Object* art_initialize_type_from_code(uint32_t type_idx,
- AbstractMethod* referrer,
+mirror::Object* art_initialize_type_from_code(uint32_t type_idx,
+ mirror::AbstractMethod* referrer,
Thread* thread)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return ResolveVerifyAndClinit(type_idx, referrer, thread, false, false);
}
-Object* art_initialize_type_and_verify_access_from_code(uint32_t type_idx,
- AbstractMethod* referrer,
+mirror::Object* art_initialize_type_and_verify_access_from_code(uint32_t type_idx,
+ mirror::AbstractMethod* referrer,
Thread* thread)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// Called when caller isn't guaranteed to have access to a type and the dex cache may be
@@ -326,14 +326,14 @@
return ResolveVerifyAndClinit(type_idx, referrer, thread, false, true);
}
-Object* art_resolve_string_from_code(AbstractMethod* referrer, uint32_t string_idx)
+mirror::Object* art_resolve_string_from_code(mirror::AbstractMethod* referrer, uint32_t string_idx)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return ResolveStringFromCode(referrer, string_idx);
}
-int32_t art_set32_static_from_code(uint32_t field_idx, AbstractMethod* referrer, int32_t new_value)
+int32_t art_set32_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, int32_t new_value)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite, sizeof(uint32_t));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite, sizeof(uint32_t));
if (LIKELY(field != NULL)) {
field->Set32(field->GetDeclaringClass(), new_value);
return 0;
@@ -347,9 +347,9 @@
return -1;
}
-int32_t art_set64_static_from_code(uint32_t field_idx, AbstractMethod* referrer, int64_t new_value)
+int32_t art_set64_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, int64_t new_value)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite, sizeof(uint64_t));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite, sizeof(uint64_t));
if (LIKELY(field != NULL)) {
field->Set64(field->GetDeclaringClass(), new_value);
return 0;
@@ -363,15 +363,15 @@
return -1;
}
-int32_t art_set_obj_static_from_code(uint32_t field_idx, AbstractMethod* referrer, Object* new_value)
+int32_t art_set_obj_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, mirror::Object* new_value)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, StaticObjectWrite, sizeof(Object*));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, StaticObjectWrite, sizeof(mirror::Object*));
if (LIKELY(field != NULL)) {
field->SetObj(field->GetDeclaringClass(), new_value);
return 0;
}
field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
- StaticObjectWrite, sizeof(Object*));
+ StaticObjectWrite, sizeof(mirror::Object*));
if (LIKELY(field != NULL)) {
field->SetObj(field->GetDeclaringClass(), new_value);
return 0;
@@ -379,9 +379,9 @@
return -1;
}
-int32_t art_get32_static_from_code(uint32_t field_idx, AbstractMethod* referrer)
+int32_t art_get32_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(uint32_t));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(uint32_t));
if (LIKELY(field != NULL)) {
return field->Get32(field->GetDeclaringClass());
}
@@ -393,9 +393,9 @@
return 0;
}
-int64_t art_get64_static_from_code(uint32_t field_idx, AbstractMethod* referrer)
+int64_t art_get64_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(uint64_t));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(uint64_t));
if (LIKELY(field != NULL)) {
return field->Get64(field->GetDeclaringClass());
}
@@ -407,24 +407,24 @@
return 0;
}
-Object* art_get_obj_static_from_code(uint32_t field_idx, AbstractMethod* referrer)
+mirror::Object* art_get_obj_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, StaticObjectRead, sizeof(Object*));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, StaticObjectRead, sizeof(mirror::Object*));
if (LIKELY(field != NULL)) {
return field->GetObj(field->GetDeclaringClass());
}
field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
- StaticObjectRead, sizeof(Object*));
+ StaticObjectRead, sizeof(mirror::Object*));
if (LIKELY(field != NULL)) {
return field->GetObj(field->GetDeclaringClass());
}
return 0;
}
-int32_t art_set32_instance_from_code(uint32_t field_idx, AbstractMethod* referrer,
- Object* obj, uint32_t new_value)
+int32_t art_set32_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer,
+ mirror::Object* obj, uint32_t new_value)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite, sizeof(uint32_t));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite, sizeof(uint32_t));
if (LIKELY(field != NULL)) {
field->Set32(obj, new_value);
return 0;
@@ -438,10 +438,10 @@
return -1;
}
-int32_t art_set64_instance_from_code(uint32_t field_idx, AbstractMethod* referrer,
- Object* obj, int64_t new_value)
+int32_t art_set64_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer,
+ mirror::Object* obj, int64_t new_value)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite, sizeof(uint64_t));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite, sizeof(uint64_t));
if (LIKELY(field != NULL)) {
field->Set64(obj, new_value);
return 0;
@@ -455,16 +455,16 @@
return -1;
}
-int32_t art_set_obj_instance_from_code(uint32_t field_idx, AbstractMethod* referrer,
- Object* obj, Object* new_value)
+int32_t art_set_obj_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer,
+ mirror::Object* obj, mirror::Object* new_value)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, InstanceObjectWrite, sizeof(Object*));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, InstanceObjectWrite, sizeof(mirror::Object*));
if (LIKELY(field != NULL)) {
field->SetObj(obj, new_value);
return 0;
}
field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
- InstanceObjectWrite, sizeof(Object*));
+ InstanceObjectWrite, sizeof(mirror::Object*));
if (LIKELY(field != NULL)) {
field->SetObj(obj, new_value);
return 0;
@@ -472,9 +472,9 @@
return -1;
}
-int32_t art_get32_instance_from_code(uint32_t field_idx, AbstractMethod* referrer, Object* obj)
+int32_t art_get32_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, mirror::Object* obj)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(uint32_t));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(uint32_t));
if (LIKELY(field != NULL)) {
return field->Get32(obj);
}
@@ -486,9 +486,9 @@
return 0;
}
-int64_t art_get64_instance_from_code(uint32_t field_idx, AbstractMethod* referrer, Object* obj)
+int64_t art_get64_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, mirror::Object* obj)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(uint64_t));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(uint64_t));
if (LIKELY(field != NULL)) {
return field->Get64(obj);
}
@@ -500,22 +500,22 @@
return 0;
}
-Object* art_get_obj_instance_from_code(uint32_t field_idx, AbstractMethod* referrer, Object* obj)
+mirror::Object* art_get_obj_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, mirror::Object* obj)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, InstanceObjectRead, sizeof(Object*));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, InstanceObjectRead, sizeof(mirror::Object*));
if (LIKELY(field != NULL)) {
return field->GetObj(obj);
}
field = FindFieldFromCode(field_idx, referrer, Thread::Current(),
- InstanceObjectRead, sizeof(Object*));
+ InstanceObjectRead, sizeof(mirror::Object*));
if (LIKELY(field != NULL)) {
return field->GetObj(obj);
}
return 0;
}
-void art_fill_array_data_from_code(AbstractMethod* method, uint32_t dex_pc,
- Array* array, uint32_t payload_offset)
+void art_fill_array_data_from_code(mirror::AbstractMethod* method, uint32_t dex_pc,
+ mirror::Array* array, uint32_t payload_offset)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// Test: Is array equal to null? (Guard NullPointerException)
if (UNLIKELY(array == NULL)) {
@@ -555,14 +555,14 @@
// Type checking, in the nature of casting
//----------------------------------------------------------------------------
-int32_t art_is_assignable_from_code(const Class* dest_type, const Class* src_type)
+int32_t art_is_assignable_from_code(const mirror::Class* dest_type, const mirror::Class* src_type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(dest_type != NULL);
DCHECK(src_type != NULL);
return dest_type->IsAssignableFrom(src_type) ? 1 : 0;
}
-void art_check_cast_from_code(const Class* dest_type, const Class* src_type)
+void art_check_cast_from_code(const mirror::Class* dest_type, const mirror::Class* src_type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(dest_type->IsClass()) << PrettyClass(dest_type);
DCHECK(src_type->IsClass()) << PrettyClass(src_type);
@@ -574,16 +574,16 @@
}
}
-void art_check_put_array_element_from_code(const Object* element, const Object* array)
+void art_check_put_array_element_from_code(const mirror::Object* element, const mirror::Object* array)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (element == NULL) {
return;
}
DCHECK(array != NULL);
- Class* array_class = array->GetClass();
+ mirror::Class* array_class = array->GetClass();
DCHECK(array_class != NULL);
- Class* component_type = array_class->GetComponentType();
- Class* element_class = element->GetClass();
+ mirror::Class* component_type = array_class->GetComponentType();
+ mirror::Class* element_class = element->GetClass();
if (UNLIKELY(!component_type->IsAssignableFrom(element_class))) {
Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;",
"%s cannot be stored in an array of type %s",
@@ -634,11 +634,11 @@
PopLocalReferences(saved_local_ref_cookie, self);
}
-Object* art_jni_method_end_with_reference(jobject result, uint32_t saved_local_ref_cookie,
+mirror::Object* art_jni_method_end_with_reference(jobject result, uint32_t saved_local_ref_cookie,
Thread* self)
SHARED_LOCK_FUNCTION(Locks::mutator_lock_) {
self->TransitionFromSuspendedToRunnable();
- Object* o = self->DecodeJObject(result); // Must decode before pop.
+ mirror::Object* o = self->DecodeJObject(result); // Must decode before pop.
PopLocalReferences(saved_local_ref_cookie, self);
// Process result.
if (UNLIKELY(self->GetJniEnv()->check_jni)) {
@@ -650,13 +650,13 @@
return o;
}
-Object* art_jni_method_end_with_reference_synchronized(jobject result,
+mirror::Object* art_jni_method_end_with_reference_synchronized(jobject result,
uint32_t saved_local_ref_cookie,
jobject locked, Thread* self)
SHARED_LOCK_FUNCTION(Locks::mutator_lock_) {
self->TransitionFromSuspendedToRunnable();
UnlockJniSynchronizedMethod(locked, self); // Must decode before pop.
- Object* o = self->DecodeJObject(result);
+ mirror::Object* o = self->DecodeJObject(result);
PopLocalReferences(saved_local_ref_cookie, self);
// Process result.
if (UNLIKELY(self->GetJniEnv()->check_jni)) {
@@ -711,12 +711,12 @@
// Handler for invocation on proxy methods. Create a boxed argument array and invoke the invocation
// handler which is a field within the proxy object receiver. The var args encode the arguments
// with the last argument being a pointer to a JValue to store the result in.
-void art_proxy_invoke_handler_from_code(AbstractMethod* proxy_method, ...)
+void art_proxy_invoke_handler_from_code(mirror::AbstractMethod* proxy_method, ...)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
va_list ap;
va_start(ap, proxy_method);
- Object* receiver = va_arg(ap, Object*);
+ mirror::Object* receiver = va_arg(ap, mirror::Object*);
Thread* self = va_arg(ap, Thread*);
MethodHelper proxy_mh(proxy_method);
@@ -734,19 +734,19 @@
jobject rcvr_jobj = soa.AddLocalReference<jobject>(receiver);
// Convert proxy method into expected interface method.
- AbstractMethod* interface_method = proxy_method->FindOverriddenMethod();
+ mirror::AbstractMethod* interface_method = proxy_method->FindOverriddenMethod();
DCHECK(interface_method != NULL);
DCHECK(!interface_method->IsProxyMethod()) << PrettyMethod(interface_method);
jobject interface_method_jobj = soa.AddLocalReference<jobject>(interface_method);
- // Record arguments and turn Object* arguments into jobject to survive GC.
+ // Record arguments and turn mirror::Object* arguments into jobject to survive GC.
std::vector<jvalue> args;
const size_t num_params = proxy_mh.NumArgs();
for (size_t i = 1; i < num_params; ++i) {
jvalue val;
switch (proxy_mh.GetParamPrimitiveType(i)) {
case Primitive::kPrimNot:
- val.l = soa.AddLocalReference<jobject>(va_arg(ap, Object*));
+ val.l = soa.AddLocalReference<jobject>(va_arg(ap, mirror::Object*));
break;
case Primitive::kPrimBoolean: // Fall-through.
case Primitive::kPrimByte: // Fall-through.
diff --git a/src/compiler_llvm/runtime_support_llvm.h b/src/compiler_llvm/runtime_support_llvm.h
index 6c133c9..6a0b339 100644
--- a/src/compiler_llvm/runtime_support_llvm.h
+++ b/src/compiler_llvm/runtime_support_llvm.h
@@ -17,7 +17,7 @@
#ifndef ART_SRC_COMPILER_LLVM_RUNTIME_SUPPORT_LLVM_H_
#define ART_SRC_COMPILER_LLVM_RUNTIME_SUPPORT_LLVM_H_
-#include "object.h"
+#include "mirror/object.h"
namespace art {
diff --git a/src/compiler_llvm/stub_compiler.cc b/src/compiler_llvm/stub_compiler.cc
index d03400f..3a28b87 100644
--- a/src/compiler_llvm/stub_compiler.cc
+++ b/src/compiler_llvm/stub_compiler.cc
@@ -22,7 +22,7 @@
#include "compiler.h"
#include "compiler_llvm.h"
#include "ir_builder.h"
-#include "object.h"
+#include "mirror/object.h"
#include "runtime_support_func.h"
#include "utils_llvm.h"
diff --git a/src/compiler_test.cc b/src/compiler_test.cc
index f513511..bd25eb3 100644
--- a/src/compiler_test.cc
+++ b/src/compiler_test.cc
@@ -22,10 +22,13 @@
#include "UniquePtr.h"
#include "class_linker.h"
#include "common_test.h"
-#include "dex_cache.h"
#include "dex_file.h"
#include "heap.h"
-#include "object.h"
+#include "mirror/class.h"
+#include "mirror/class-inl.h"
+#include "mirror/dex_cache.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object_array-inl.h"
namespace art {
@@ -69,7 +72,7 @@
const DexFile::ClassDef& class_def = dex_file.GetClassDef(i);
const char* descriptor = dex_file.GetClassDescriptor(class_def);
ScopedObjectAccess soa(Thread::Current());
- Class* c = class_linker->FindClass(descriptor, soa.Decode<ClassLoader*>(class_loader));
+ mirror::Class* c = class_linker->FindClass(descriptor, soa.Decode<mirror::ClassLoader*>(class_loader));
CHECK(c != NULL);
for (size_t i = 0; i < c->NumDirectMethods(); i++) {
MakeExecutable(c->GetDirectMethod(i));
@@ -92,21 +95,21 @@
// All libcore references should resolve
ScopedObjectAccess soa(Thread::Current());
const DexFile* dex = java_lang_dex_file_;
- DexCache* dex_cache = class_linker_->FindDexCache(*dex);
+ mirror::DexCache* dex_cache = class_linker_->FindDexCache(*dex);
EXPECT_EQ(dex->NumStringIds(), dex_cache->NumStrings());
for (size_t i = 0; i < dex_cache->NumStrings(); i++) {
- const String* string = dex_cache->GetResolvedString(i);
+ const mirror::String* string = dex_cache->GetResolvedString(i);
EXPECT_TRUE(string != NULL) << "string_idx=" << i;
}
EXPECT_EQ(dex->NumTypeIds(), dex_cache->NumResolvedTypes());
for (size_t i = 0; i < dex_cache->NumResolvedTypes(); i++) {
- Class* type = dex_cache->GetResolvedType(i);
+ mirror::Class* type = dex_cache->GetResolvedType(i);
EXPECT_TRUE(type != NULL) << "type_idx=" << i
<< " " << dex->GetTypeDescriptor(dex->GetTypeId(i));
}
EXPECT_EQ(dex->NumMethodIds(), dex_cache->NumResolvedMethods());
for (size_t i = 0; i < dex_cache->NumResolvedMethods(); i++) {
- AbstractMethod* method = dex_cache->GetResolvedMethod(i);
+ mirror::AbstractMethod* method = dex_cache->GetResolvedMethod(i);
EXPECT_TRUE(method != NULL) << "method_idx=" << i
<< " " << dex->GetMethodDeclaringClassDescriptor(dex->GetMethodId(i))
<< " " << dex->GetMethodName(dex->GetMethodId(i));
@@ -117,7 +120,7 @@
}
EXPECT_EQ(dex->NumFieldIds(), dex_cache->NumResolvedFields());
for (size_t i = 0; i < dex_cache->NumResolvedFields(); i++) {
- Field* field = dex_cache->GetResolvedField(i);
+ mirror::Field* field = dex_cache->GetResolvedField(i);
EXPECT_TRUE(field != NULL) << "field_idx=" << i
<< " " << dex->GetFieldDeclaringClassDescriptor(dex->GetFieldId(i))
<< " " << dex->GetFieldName(dex->GetFieldId(i));
diff --git a/src/debugger.cc b/src/debugger.cc
index 3e93511..3121725 100644
--- a/src/debugger.cc
+++ b/src/debugger.cc
@@ -21,10 +21,19 @@
#include <set>
#include "class_linker.h"
-#include "class_loader.h"
+#include "class_linker-inl.h"
#include "dex_instruction.h"
+#include "gc/card_table-inl.h"
#include "gc/large_object_space.h"
#include "gc/space.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/class.h"
+#include "mirror/class-inl.h"
+#include "mirror/class_loader.h"
+#include "mirror/field-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
+#include "mirror/throwable.h"
#include "oat/runtime/context.h"
#include "object_utils.h"
#include "safe_map.h"
@@ -34,6 +43,7 @@
#include "sirt_ref.h"
#include "stack_indirect_reference_table.h"
#include "thread_list.h"
+#include "utf.h"
#include "well_known_classes.h"
namespace art {
@@ -42,14 +52,14 @@
static const size_t kNumAllocRecords = 512; // Must be power of 2.
static const uintptr_t kInvalidId = 1;
-static const Object* kInvalidObject = reinterpret_cast<Object*>(kInvalidId);
+static const mirror::Object* kInvalidObject = reinterpret_cast<mirror::Object*>(kInvalidId);
class ObjectRegistry {
public:
ObjectRegistry() : lock_("ObjectRegistry lock") {
}
- JDWP::ObjectId Add(Object* o) {
+ JDWP::ObjectId Add(mirror::Object* o) {
if (o == NULL) {
return 0;
}
@@ -76,14 +86,14 @@
}
MutexLock mu(Thread::Current(), lock_);
- typedef SafeMap<JDWP::ObjectId, Object*>::iterator It; // C++0x auto
+ typedef SafeMap<JDWP::ObjectId, mirror::Object*>::iterator It; // C++0x auto
It it = map_.find(id);
return (it != map_.end()) ? reinterpret_cast<T>(it->second) : reinterpret_cast<T>(kInvalidId);
}
- void VisitRoots(Heap::RootVisitor* visitor, void* arg) {
+ void VisitRoots(RootVisitor* visitor, void* arg) {
MutexLock mu(Thread::Current(), lock_);
- typedef SafeMap<JDWP::ObjectId, Object*>::iterator It; // C++0x auto
+ typedef SafeMap<JDWP::ObjectId, mirror::Object*>::iterator It; // C++0x auto
for (It it = map_.begin(); it != map_.end(); ++it) {
visitor(it->second, arg);
}
@@ -91,11 +101,11 @@
private:
Mutex lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
- SafeMap<JDWP::ObjectId, Object*> map_;
+ SafeMap<JDWP::ObjectId, mirror::Object*> map_;
};
struct AllocRecordStackTraceElement {
- AbstractMethod* method;
+ mirror::AbstractMethod* method;
uint32_t dex_pc;
int32_t LineNumber() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -104,7 +114,7 @@
};
struct AllocRecord {
- Class* type;
+ mirror::Class* type;
size_t byte_count;
uint16_t thin_lock_id;
AllocRecordStackTraceElement stack[kMaxAllocRecordStackDepth]; // Unused entries have NULL method.
@@ -119,9 +129,9 @@
};
struct Breakpoint {
- AbstractMethod* method;
+ mirror::AbstractMethod* method;
uint32_t dex_pc;
- Breakpoint(AbstractMethod* method, uint32_t dex_pc) : method(method), dex_pc(dex_pc) {}
+ Breakpoint(mirror::AbstractMethod* method, uint32_t dex_pc) : method(method), dex_pc(dex_pc) {}
};
static std::ostream& operator<<(std::ostream& os, const Breakpoint& rhs)
@@ -138,7 +148,7 @@
JDWP::JdwpStepSize step_size;
JDWP::JdwpStepDepth step_depth;
- const AbstractMethod* method;
+ const mirror::AbstractMethod* method;
int32_t line_number; // Or -1 for native methods.
std::set<uint32_t> dex_pcs;
int stack_depth;
@@ -180,7 +190,7 @@
static std::vector<Breakpoint> gBreakpoints GUARDED_BY(Locks::breakpoint_lock_);
static SingleStepControl gSingleStepControl GUARDED_BY(Locks::breakpoint_lock_);
-static bool IsBreakpoint(AbstractMethod* m, uint32_t dex_pc)
+static bool IsBreakpoint(mirror::AbstractMethod* m, uint32_t dex_pc)
LOCKS_EXCLUDED(Locks::breakpoint_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
MutexLock mu(Thread::Current(), *Locks::breakpoint_lock_);
@@ -200,9 +210,9 @@
return thread->IsSuspended() && thread->GetDebugSuspendCount() > 0;
}
-static Array* DecodeArray(JDWP::RefTypeId id, JDWP::JdwpError& status)
+static mirror::Array* DecodeArray(JDWP::RefTypeId id, JDWP::JdwpError& status)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Object* o = gRegistry->Get<Object*>(id);
+ mirror::Object* o = gRegistry->Get<mirror::Object*>(id);
if (o == NULL || o == kInvalidObject) {
status = JDWP::ERR_INVALID_OBJECT;
return NULL;
@@ -215,9 +225,9 @@
return o->AsArray();
}
-static Class* DecodeClass(JDWP::RefTypeId id, JDWP::JdwpError& status)
+static mirror::Class* DecodeClass(JDWP::RefTypeId id, JDWP::JdwpError& status)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Object* o = gRegistry->Get<Object*>(id);
+ mirror::Object* o = gRegistry->Get<mirror::Object*>(id);
if (o == NULL || o == kInvalidObject) {
status = JDWP::ERR_INVALID_OBJECT;
return NULL;
@@ -234,13 +244,13 @@
EXCLUSIVE_LOCKS_REQUIRED(Locks::thread_list_lock_)
LOCKS_EXCLUDED(Locks::thread_suspend_count_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Object* thread_peer = gRegistry->Get<Object*>(thread_id);
+ mirror::Object* thread_peer = gRegistry->Get<mirror::Object*>(thread_id);
if (thread_peer == NULL || thread_peer == kInvalidObject) {
// This isn't even an object.
return JDWP::ERR_INVALID_OBJECT;
}
- Class* java_lang_Thread = soa.Decode<Class*>(WellKnownClasses::java_lang_Thread);
+ mirror::Class* java_lang_Thread = soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_Thread);
if (!java_lang_Thread->IsAssignableFrom(thread_peer->GetClass())) {
// This isn't a thread.
return JDWP::ERR_INVALID_THREAD;
@@ -260,7 +270,7 @@
return static_cast<JDWP::JdwpTag>(descriptor[0]);
}
-static JDWP::JdwpTag TagFromClass(Class* c)
+static JDWP::JdwpTag TagFromClass(mirror::Class* c)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
CHECK(c != NULL);
if (c->IsArrayClass()) {
@@ -291,7 +301,7 @@
*
* Null objects are tagged JT_OBJECT.
*/
-static JDWP::JdwpTag TagFromObject(const Object* o)
+static JDWP::JdwpTag TagFromObject(const mirror::Object* o)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return (o == NULL) ? JDWP::JT_OBJECT : TagFromClass(o->GetClass());
}
@@ -567,14 +577,14 @@
exit(status); // This is all dalvik did.
}
-void Dbg::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
+void Dbg::VisitRoots(RootVisitor* visitor, void* arg) {
if (gRegistry != NULL) {
gRegistry->VisitRoots(visitor, arg);
}
}
std::string Dbg::GetClassName(JDWP::RefTypeId class_id) {
- Object* o = gRegistry->Get<Object*>(class_id);
+ mirror::Object* o = gRegistry->Get<mirror::Object*>(class_id);
if (o == NULL) {
return "NULL";
}
@@ -589,7 +599,7 @@
JDWP::JdwpError Dbg::GetClassObject(JDWP::RefTypeId id, JDWP::ObjectId& class_object_id) {
JDWP::JdwpError status;
- Class* c = DecodeClass(id, status);
+ mirror::Class* c = DecodeClass(id, status);
if (c == NULL) {
return status;
}
@@ -599,7 +609,7 @@
JDWP::JdwpError Dbg::GetSuperclass(JDWP::RefTypeId id, JDWP::RefTypeId& superclass_id) {
JDWP::JdwpError status;
- Class* c = DecodeClass(id, status);
+ mirror::Class* c = DecodeClass(id, status);
if (c == NULL) {
return status;
}
@@ -613,7 +623,7 @@
}
JDWP::JdwpError Dbg::GetClassLoader(JDWP::RefTypeId id, JDWP::ExpandBuf* pReply) {
- Object* o = gRegistry->Get<Object*>(id);
+ mirror::Object* o = gRegistry->Get<mirror::Object*>(id);
if (o == NULL || o == kInvalidObject) {
return JDWP::ERR_INVALID_OBJECT;
}
@@ -623,7 +633,7 @@
JDWP::JdwpError Dbg::GetModifiers(JDWP::RefTypeId id, JDWP::ExpandBuf* pReply) {
JDWP::JdwpError status;
- Class* c = DecodeClass(id, status);
+ mirror::Class* c = DecodeClass(id, status);
if (c == NULL) {
return status;
}
@@ -641,7 +651,7 @@
JDWP::JdwpError Dbg::GetMonitorInfo(JDWP::ObjectId object_id, JDWP::ExpandBuf* reply)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Object* o = gRegistry->Get<Object*>(object_id);
+ mirror::Object* o = gRegistry->Get<mirror::Object*>(object_id);
if (o == NULL || o == kInvalidObject) {
return JDWP::ERR_INVALID_OBJECT;
}
@@ -699,14 +709,14 @@
return true;
}
- static void AppendOwnedMonitors(Object* owned_monitor, void* arg) {
+ static void AppendOwnedMonitors(mirror::Object* owned_monitor, void* arg) {
OwnedMonitorVisitor* visitor = reinterpret_cast<OwnedMonitorVisitor*>(arg);
visitor->monitors.push_back(owned_monitor);
visitor->stack_depths.push_back(visitor->current_stack_depth);
}
size_t current_stack_depth;
- std::vector<Object*> monitors;
+ std::vector<mirror::Object*> monitors;
std::vector<uint32_t> stack_depths;
};
UniquePtr<Context> context(Context::Create());
@@ -743,11 +753,11 @@
std::vector<uint64_t>& counts)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- std::vector<Class*> classes;
+ std::vector<mirror::Class*> classes;
counts.clear();
for (size_t i = 0; i < class_ids.size(); ++i) {
JDWP::JdwpError status;
- Class* c = DecodeClass(class_ids[i], status);
+ mirror::Class* c = DecodeClass(class_ids[i], status);
if (c == NULL) {
return status;
}
@@ -762,12 +772,12 @@
JDWP::JdwpError Dbg::GetInstances(JDWP::RefTypeId class_id, int32_t max_count, std::vector<JDWP::ObjectId>& instances)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
JDWP::JdwpError status;
- Class* c = DecodeClass(class_id, status);
+ mirror::Class* c = DecodeClass(class_id, status);
if (c == NULL) {
return status;
}
- std::vector<Object*> raw_instances;
+ std::vector<mirror::Object*> raw_instances;
Runtime::Current()->GetHeap()->GetInstances(c, max_count, raw_instances);
for (size_t i = 0; i < raw_instances.size(); ++i) {
instances.push_back(gRegistry->Add(raw_instances[i]));
@@ -778,12 +788,12 @@
JDWP::JdwpError Dbg::GetReferringObjects(JDWP::ObjectId object_id, int32_t max_count,
std::vector<JDWP::ObjectId>& referring_objects)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Object* o = gRegistry->Get<Object*>(object_id);
+ mirror::Object* o = gRegistry->Get<mirror::Object*>(object_id);
if (o == NULL || o == kInvalidObject) {
return JDWP::ERR_INVALID_OBJECT;
}
- std::vector<Object*> raw_instances;
+ std::vector<mirror::Object*> raw_instances;
Runtime::Current()->GetHeap()->GetReferringObjects(o, max_count, raw_instances);
for (size_t i = 0; i < raw_instances.size(); ++i) {
referring_objects.push_back(gRegistry->Add(raw_instances[i]));
@@ -793,7 +803,7 @@
JDWP::JdwpError Dbg::GetReflectedType(JDWP::RefTypeId class_id, JDWP::ExpandBuf* pReply) {
JDWP::JdwpError status;
- Class* c = DecodeClass(class_id, status);
+ mirror::Class* c = DecodeClass(class_id, status);
if (c == NULL) {
return status;
}
@@ -811,11 +821,11 @@
explicit ClassListCreator(std::vector<JDWP::RefTypeId>& classes) : classes(classes) {
}
- static bool Visit(Class* c, void* arg) {
+ static bool Visit(mirror::Class* c, void* arg) {
return reinterpret_cast<ClassListCreator*>(arg)->Visit(c);
}
- bool Visit(Class* c) {
+ bool Visit(mirror::Class* c) {
if (!c->IsPrimitive()) {
classes.push_back(static_cast<JDWP::RefTypeId>(gRegistry->Add(c)));
}
@@ -831,7 +841,7 @@
JDWP::JdwpError Dbg::GetClassInfo(JDWP::RefTypeId class_id, JDWP::JdwpTypeTag* pTypeTag, uint32_t* pStatus, std::string* pDescriptor) {
JDWP::JdwpError status;
- Class* c = DecodeClass(class_id, status);
+ mirror::Class* c = DecodeClass(class_id, status);
if (c == NULL) {
return status;
}
@@ -855,7 +865,7 @@
}
void Dbg::FindLoadedClassBySignature(const char* descriptor, std::vector<JDWP::RefTypeId>& ids) {
- std::vector<Class*> classes;
+ std::vector<mirror::Class*> classes;
Runtime::Current()->GetClassLinker()->LookupClasses(descriptor, classes);
ids.clear();
for (size_t i = 0; i < classes.size(); ++i) {
@@ -864,7 +874,7 @@
}
JDWP::JdwpError Dbg::GetReferenceType(JDWP::ObjectId object_id, JDWP::ExpandBuf* pReply) {
- Object* o = gRegistry->Get<Object*>(object_id);
+ mirror::Object* o = gRegistry->Get<mirror::Object*>(object_id);
if (o == NULL || o == kInvalidObject) {
return JDWP::ERR_INVALID_OBJECT;
}
@@ -887,7 +897,7 @@
JDWP::JdwpError Dbg::GetSignature(JDWP::RefTypeId class_id, std::string& signature) {
JDWP::JdwpError status;
- Class* c = DecodeClass(class_id, status);
+ mirror::Class* c = DecodeClass(class_id, status);
if (c == NULL) {
return status;
}
@@ -897,7 +907,7 @@
JDWP::JdwpError Dbg::GetSourceFile(JDWP::RefTypeId class_id, std::string& result) {
JDWP::JdwpError status;
- Class* c = DecodeClass(class_id, status);
+ mirror::Class* c = DecodeClass(class_id, status);
if (c == NULL) {
return status;
}
@@ -906,7 +916,7 @@
}
JDWP::JdwpError Dbg::GetObjectTag(JDWP::ObjectId object_id, uint8_t& tag) {
- Object* o = gRegistry->Get<Object*>(object_id);
+ mirror::Object* o = gRegistry->Get<mirror::Object*>(object_id);
if (o == kInvalidObject) {
return JDWP::ERR_INVALID_OBJECT;
}
@@ -946,7 +956,7 @@
JDWP::JdwpError Dbg::GetArrayLength(JDWP::ObjectId array_id, int& length) {
JDWP::JdwpError status;
- Array* a = DecodeArray(array_id, status);
+ mirror::Array* a = DecodeArray(array_id, status);
if (a == NULL) {
return status;
}
@@ -956,7 +966,7 @@
JDWP::JdwpError Dbg::OutputArray(JDWP::ObjectId array_id, int offset, int count, JDWP::ExpandBuf* pReply) {
JDWP::JdwpError status;
- Array* a = DecodeArray(array_id, status);
+ mirror::Array* a = DecodeArray(array_id, status);
if (a == NULL) {
return status;
}
@@ -988,9 +998,9 @@
memcpy(dst, &src[offset * width], count * width);
}
} else {
- ObjectArray<Object>* oa = a->AsObjectArray<Object>();
+ mirror::ObjectArray<mirror::Object>* oa = a->AsObjectArray<mirror::Object>();
for (int i = 0; i < count; ++i) {
- Object* element = oa->Get(offset + i);
+ mirror::Object* element = oa->Get(offset + i);
JDWP::JdwpTag specific_tag = (element != NULL) ? TagFromObject(element) : tag;
expandBufAdd1(pReply, specific_tag);
expandBufAddObjectId(pReply, gRegistry->Add(element));
@@ -1004,7 +1014,7 @@
const uint8_t* src)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
JDWP::JdwpError status;
- Array* a = DecodeArray(array_id, status);
+ mirror::Array* a = DecodeArray(array_id, status);
if (a == NULL) {
return status;
}
@@ -1040,10 +1050,10 @@
memcpy(&dst[offset * width], src, count * width);
}
} else {
- ObjectArray<Object>* oa = a->AsObjectArray<Object>();
+ mirror::ObjectArray<mirror::Object>* oa = a->AsObjectArray<mirror::Object>();
for (int i = 0; i < count; ++i) {
JDWP::ObjectId id = JDWP::ReadObjectId(&src);
- Object* o = gRegistry->Get<Object*>(id);
+ mirror::Object* o = gRegistry->Get<mirror::Object*>(id);
if (o == kInvalidObject) {
return JDWP::ERR_INVALID_OBJECT;
}
@@ -1055,12 +1065,12 @@
}
JDWP::ObjectId Dbg::CreateString(const std::string& str) {
- return gRegistry->Add(String::AllocFromModifiedUtf8(Thread::Current(), str.c_str()));
+ return gRegistry->Add(mirror::String::AllocFromModifiedUtf8(Thread::Current(), str.c_str()));
}
JDWP::JdwpError Dbg::CreateObject(JDWP::RefTypeId class_id, JDWP::ObjectId& new_object) {
JDWP::JdwpError status;
- Class* c = DecodeClass(class_id, status);
+ mirror::Class* c = DecodeClass(class_id, status);
if (c == NULL) {
return status;
}
@@ -1074,24 +1084,24 @@
JDWP::JdwpError Dbg::CreateArrayObject(JDWP::RefTypeId array_class_id, uint32_t length,
JDWP::ObjectId& new_array) {
JDWP::JdwpError status;
- Class* c = DecodeClass(array_class_id, status);
+ mirror::Class* c = DecodeClass(array_class_id, status);
if (c == NULL) {
return status;
}
- new_array = gRegistry->Add(Array::Alloc(Thread::Current(), c, length));
+ new_array = gRegistry->Add(mirror::Array::Alloc(Thread::Current(), c, length));
return JDWP::ERR_NONE;
}
bool Dbg::MatchType(JDWP::RefTypeId instance_class_id, JDWP::RefTypeId class_id) {
JDWP::JdwpError status;
- Class* c1 = DecodeClass(instance_class_id, status);
+ mirror::Class* c1 = DecodeClass(instance_class_id, status);
CHECK(c1 != NULL);
- Class* c2 = DecodeClass(class_id, status);
+ mirror::Class* c2 = DecodeClass(class_id, status);
CHECK(c2 != NULL);
return c1->IsAssignableFrom(c2);
}
-static JDWP::FieldId ToFieldId(const Field* f)
+static JDWP::FieldId ToFieldId(const mirror::Field* f)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#ifdef MOVING_GARBAGE_COLLECTOR
UNIMPLEMENTED(FATAL);
@@ -1100,7 +1110,7 @@
#endif
}
-static JDWP::MethodId ToMethodId(const AbstractMethod* m)
+static JDWP::MethodId ToMethodId(const mirror::AbstractMethod* m)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#ifdef MOVING_GARBAGE_COLLECTOR
UNIMPLEMENTED(FATAL);
@@ -1109,30 +1119,30 @@
#endif
}
-static Field* FromFieldId(JDWP::FieldId fid)
+static mirror::Field* FromFieldId(JDWP::FieldId fid)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#ifdef MOVING_GARBAGE_COLLECTOR
UNIMPLEMENTED(FATAL);
#else
- return reinterpret_cast<Field*>(static_cast<uintptr_t>(fid));
+ return reinterpret_cast<mirror::Field*>(static_cast<uintptr_t>(fid));
#endif
}
-static AbstractMethod* FromMethodId(JDWP::MethodId mid)
+static mirror::AbstractMethod* FromMethodId(JDWP::MethodId mid)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#ifdef MOVING_GARBAGE_COLLECTOR
UNIMPLEMENTED(FATAL);
#else
- return reinterpret_cast<AbstractMethod*>(static_cast<uintptr_t>(mid));
+ return reinterpret_cast<mirror::AbstractMethod*>(static_cast<uintptr_t>(mid));
#endif
}
-static void SetLocation(JDWP::JdwpLocation& location, AbstractMethod* m, uint32_t dex_pc)
+static void SetLocation(JDWP::JdwpLocation& location, mirror::AbstractMethod* m, uint32_t dex_pc)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (m == NULL) {
memset(&location, 0, sizeof(location));
} else {
- Class* c = m->GetDeclaringClass();
+ mirror::Class* c = m->GetDeclaringClass();
location.type_tag = c->IsInterface() ? JDWP::TT_INTERFACE : JDWP::TT_CLASS;
location.class_id = gRegistry->Add(c);
location.method_id = ToMethodId(m);
@@ -1142,13 +1152,13 @@
std::string Dbg::GetMethodName(JDWP::MethodId method_id)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* m = FromMethodId(method_id);
+ mirror::AbstractMethod* m = FromMethodId(method_id);
return MethodHelper(m).GetName();
}
std::string Dbg::GetFieldName(JDWP::FieldId field_id)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* f = FromFieldId(field_id);
+ mirror::Field* f = FromFieldId(field_id);
return FieldHelper(f).GetName();
}
@@ -1190,7 +1200,7 @@
return newSlot;
}
-static uint16_t DemangleSlot(uint16_t slot, AbstractMethod* m)
+static uint16_t DemangleSlot(uint16_t slot, mirror::AbstractMethod* m)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (slot == kEclipseWorkaroundSlot) {
return 0;
@@ -1204,7 +1214,7 @@
JDWP::JdwpError Dbg::OutputDeclaredFields(JDWP::RefTypeId class_id, bool with_generic, JDWP::ExpandBuf* pReply) {
JDWP::JdwpError status;
- Class* c = DecodeClass(class_id, status);
+ mirror::Class* c = DecodeClass(class_id, status);
if (c == NULL) {
return status;
}
@@ -1215,7 +1225,7 @@
expandBufAdd4BE(pReply, instance_field_count + static_field_count);
for (size_t i = 0; i < instance_field_count + static_field_count; ++i) {
- Field* f = (i < instance_field_count) ? c->GetInstanceField(i) : c->GetStaticField(i - instance_field_count);
+ mirror::Field* f = (i < instance_field_count) ? c->GetInstanceField(i) : c->GetStaticField(i - instance_field_count);
FieldHelper fh(f);
expandBufAddFieldId(pReply, ToFieldId(f));
expandBufAddUtf8String(pReply, fh.GetName());
@@ -1232,7 +1242,7 @@
JDWP::JdwpError Dbg::OutputDeclaredMethods(JDWP::RefTypeId class_id, bool with_generic,
JDWP::ExpandBuf* pReply) {
JDWP::JdwpError status;
- Class* c = DecodeClass(class_id, status);
+ mirror::Class* c = DecodeClass(class_id, status);
if (c == NULL) {
return status;
}
@@ -1243,7 +1253,7 @@
expandBufAdd4BE(pReply, direct_method_count + virtual_method_count);
for (size_t i = 0; i < direct_method_count + virtual_method_count; ++i) {
- AbstractMethod* m = (i < direct_method_count) ? c->GetDirectMethod(i) : c->GetVirtualMethod(i - direct_method_count);
+ mirror::AbstractMethod* m = (i < direct_method_count) ? c->GetDirectMethod(i) : c->GetVirtualMethod(i - direct_method_count);
MethodHelper mh(m);
expandBufAddMethodId(pReply, ToMethodId(m));
expandBufAddUtf8String(pReply, mh.GetName());
@@ -1259,7 +1269,7 @@
JDWP::JdwpError Dbg::OutputDeclaredInterfaces(JDWP::RefTypeId class_id, JDWP::ExpandBuf* pReply) {
JDWP::JdwpError status;
- Class* c = DecodeClass(class_id, status);
+ mirror::Class* c = DecodeClass(class_id, status);
if (c == NULL) {
return status;
}
@@ -1287,7 +1297,7 @@
return true;
}
};
- AbstractMethod* m = FromMethodId(method_id);
+ mirror::AbstractMethod* m = FromMethodId(method_id);
MethodHelper mh(m);
uint64_t start, end;
if (m->IsNative()) {
@@ -1341,14 +1351,14 @@
++pContext->variable_count;
}
};
- AbstractMethod* m = FromMethodId(method_id);
+ mirror::AbstractMethod* m = FromMethodId(method_id);
MethodHelper mh(m);
const DexFile::CodeItem* code_item = mh.GetCodeItem();
// arg_count considers doubles and longs to take 2 units.
// variable_count considers everything to take 1 unit.
std::string shorty(mh.GetShorty());
- expandBufAdd4BE(pReply, AbstractMethod::NumArgRegisters(shorty));
+ expandBufAdd4BE(pReply, mirror::AbstractMethod::NumArgRegisters(shorty));
// We don't know the total number of variables yet, so leave a blank and update it later.
size_t variable_count_offset = expandBufGetLength(pReply);
@@ -1368,7 +1378,7 @@
JDWP::JdwpError Dbg::GetBytecodes(JDWP::RefTypeId, JDWP::MethodId method_id,
std::vector<uint8_t>& bytecodes)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* m = FromMethodId(method_id);
+ mirror::AbstractMethod* m = FromMethodId(method_id);
if (m == NULL) {
return JDWP::ERR_INVALID_METHODID;
}
@@ -1396,18 +1406,18 @@
bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
JDWP::JdwpError status;
- Class* c = DecodeClass(ref_type_id, status);
+ mirror::Class* c = DecodeClass(ref_type_id, status);
if (ref_type_id != 0 && c == NULL) {
return status;
}
- Object* o = gRegistry->Get<Object*>(object_id);
+ mirror::Object* o = gRegistry->Get<mirror::Object*>(object_id);
if ((!is_static && o == NULL) || o == kInvalidObject) {
return JDWP::ERR_INVALID_OBJECT;
}
- Field* f = FromFieldId(field_id);
+ mirror::Field* f = FromFieldId(field_id);
- Class* receiver_class = c;
+ mirror::Class* receiver_class = c;
if (receiver_class == NULL && o != NULL) {
receiver_class = o->GetClass();
}
@@ -1448,7 +1458,7 @@
LOG(FATAL) << "Unknown tag: " << tag;
}
} else {
- Object* value = f->GetObject(o);
+ mirror::Object* value = f->GetObject(o);
expandBufAdd1(pReply, TagFromObject(value));
expandBufAddObjectId(pReply, gRegistry->Add(value));
}
@@ -1467,11 +1477,11 @@
static JDWP::JdwpError SetFieldValueImpl(JDWP::ObjectId object_id, JDWP::FieldId field_id,
uint64_t value, int width, bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Object* o = gRegistry->Get<Object*>(object_id);
+ mirror::Object* o = gRegistry->Get<mirror::Object*>(object_id);
if ((!is_static && o == NULL) || o == kInvalidObject) {
return JDWP::ERR_INVALID_OBJECT;
}
- Field* f = FromFieldId(field_id);
+ mirror::Field* f = FromFieldId(field_id);
// The RI only enforces the static/non-static mismatch in one direction.
// TODO: should we change the tests and check both?
@@ -1499,12 +1509,12 @@
f->Set32(o, value);
}
} else {
- Object* v = gRegistry->Get<Object*>(value);
+ mirror::Object* v = gRegistry->Get<mirror::Object*>(value);
if (v == kInvalidObject) {
return JDWP::ERR_INVALID_OBJECT;
}
if (v != NULL) {
- Class* field_type = FieldHelper(f).GetType();
+ mirror::Class* field_type = FieldHelper(f).GetType();
if (!field_type->IsAssignableFrom(v->GetClass())) {
return JDWP::ERR_INVALID_OBJECT;
}
@@ -1525,7 +1535,7 @@
}
std::string Dbg::StringToUtf8(JDWP::ObjectId string_id) {
- String* s = gRegistry->Get<String*>(string_id);
+ mirror::String* s = gRegistry->Get<mirror::String*>(string_id);
return s->ToModifiedUtf8();
}
@@ -1539,9 +1549,11 @@
}
// We still need to report the zombie threads' names, so we can't just call Thread::GetThreadName.
- Object* thread_object = gRegistry->Get<Object*>(thread_id);
- Field* java_lang_Thread_name_field = soa.DecodeField(WellKnownClasses::java_lang_Thread_name);
- String* s = reinterpret_cast<String*>(java_lang_Thread_name_field->GetObject(thread_object));
+ mirror::Object* thread_object = gRegistry->Get<mirror::Object*>(thread_id);
+ mirror::Field* java_lang_Thread_name_field =
+ soa.DecodeField(WellKnownClasses::java_lang_Thread_name);
+ mirror::String* s =
+ reinterpret_cast<mirror::String*>(java_lang_Thread_name_field->GetObject(thread_object));
if (s != NULL) {
name = s->ToModifiedUtf8();
}
@@ -1550,7 +1562,7 @@
JDWP::JdwpError Dbg::GetThreadGroup(JDWP::ObjectId thread_id, JDWP::ExpandBuf* pReply) {
ScopedObjectAccess soa(Thread::Current());
- Object* thread_object = gRegistry->Get<Object*>(thread_id);
+ mirror::Object* thread_object = gRegistry->Get<mirror::Object*>(thread_id);
if (thread_object == kInvalidObject) {
return JDWP::ERR_INVALID_OBJECT;
}
@@ -1568,11 +1580,11 @@
return error;
}
- Class* c = Runtime::Current()->GetClassLinker()->FindSystemClass("Ljava/lang/Thread;");
+ mirror::Class* c = Runtime::Current()->GetClassLinker()->FindSystemClass("Ljava/lang/Thread;");
CHECK(c != NULL);
- Field* f = c->FindInstanceField("group", "Ljava/lang/ThreadGroup;");
+ mirror::Field* f = c->FindInstanceField("group", "Ljava/lang/ThreadGroup;");
CHECK(f != NULL);
- Object* group = f->GetObject(thread_object);
+ mirror::Object* group = f->GetObject(thread_object);
CHECK(group != NULL);
JDWP::ObjectId thread_group_id = gRegistry->Add(group);
@@ -1582,40 +1594,40 @@
std::string Dbg::GetThreadGroupName(JDWP::ObjectId thread_group_id) {
ScopedObjectAccess soa(Thread::Current());
- Object* thread_group = gRegistry->Get<Object*>(thread_group_id);
+ mirror::Object* thread_group = gRegistry->Get<mirror::Object*>(thread_group_id);
CHECK(thread_group != NULL);
- Class* c = Runtime::Current()->GetClassLinker()->FindSystemClass("Ljava/lang/ThreadGroup;");
+ mirror::Class* c = Runtime::Current()->GetClassLinker()->FindSystemClass("Ljava/lang/ThreadGroup;");
CHECK(c != NULL);
- Field* f = c->FindInstanceField("name", "Ljava/lang/String;");
+ mirror::Field* f = c->FindInstanceField("name", "Ljava/lang/String;");
CHECK(f != NULL);
- String* s = reinterpret_cast<String*>(f->GetObject(thread_group));
+ mirror::String* s = reinterpret_cast<mirror::String*>(f->GetObject(thread_group));
return s->ToModifiedUtf8();
}
JDWP::ObjectId Dbg::GetThreadGroupParent(JDWP::ObjectId thread_group_id) {
- Object* thread_group = gRegistry->Get<Object*>(thread_group_id);
+ mirror::Object* thread_group = gRegistry->Get<mirror::Object*>(thread_group_id);
CHECK(thread_group != NULL);
- Class* c = Runtime::Current()->GetClassLinker()->FindSystemClass("Ljava/lang/ThreadGroup;");
+ mirror::Class* c = Runtime::Current()->GetClassLinker()->FindSystemClass("Ljava/lang/ThreadGroup;");
CHECK(c != NULL);
- Field* f = c->FindInstanceField("parent", "Ljava/lang/ThreadGroup;");
+ mirror::Field* f = c->FindInstanceField("parent", "Ljava/lang/ThreadGroup;");
CHECK(f != NULL);
- Object* parent = f->GetObject(thread_group);
+ mirror::Object* parent = f->GetObject(thread_group);
return gRegistry->Add(parent);
}
JDWP::ObjectId Dbg::GetSystemThreadGroupId() {
ScopedObjectAccessUnchecked soa(Thread::Current());
- Field* f = soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_systemThreadGroup);
- Object* group = f->GetObject(f->GetDeclaringClass());
+ mirror::Field* f = soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_systemThreadGroup);
+ mirror::Object* group = f->GetObject(f->GetDeclaringClass());
return gRegistry->Add(group);
}
JDWP::ObjectId Dbg::GetMainThreadGroupId() {
ScopedObjectAccess soa(Thread::Current());
- Field* f = soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_mainThreadGroup);
- Object* group = f->GetObject(f->GetDeclaringClass());
+ mirror::Field* f = soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_mainThreadGroup);
+ mirror::Object* group = f->GetObject(f->GetDeclaringClass());
return gRegistry->Add(group);
}
@@ -1691,7 +1703,7 @@
void Dbg::GetThreads(JDWP::ObjectId thread_group_id, std::vector<JDWP::ObjectId>& thread_ids) {
class ThreadListVisitor {
public:
- ThreadListVisitor(const ScopedObjectAccessUnchecked& soa, Object* desired_thread_group,
+ ThreadListVisitor(const ScopedObjectAccessUnchecked& soa, mirror::Object* desired_thread_group,
std::vector<JDWP::ObjectId>& thread_ids)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
: soa_(soa), desired_thread_group_(desired_thread_group), thread_ids_(thread_ids) {}
@@ -1708,20 +1720,20 @@
// query all threads, so it's easier if we just don't tell them about this thread.
return;
}
- Object* peer = t->GetPeer();
+ mirror::Object* peer = t->GetPeer();
if (IsInDesiredThreadGroup(peer)) {
thread_ids_.push_back(gRegistry->Add(peer));
}
}
private:
- bool IsInDesiredThreadGroup(Object* peer)
+ bool IsInDesiredThreadGroup(mirror::Object* peer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// peer might be NULL if the thread is still starting up.
if (peer == NULL) {
// We can't tell the debugger about this thread yet.
// TODO: if we identified threads to the debugger by their Thread*
- // rather than their peer's Object*, we could fix this.
+ // rather than their peer's mirror::Object*, we could fix this.
// Doing so might help us report ZOMBIE threads too.
return false;
}
@@ -1729,17 +1741,17 @@
if (desired_thread_group_ == NULL) {
return true;
}
- Object* group = soa_.DecodeField(WellKnownClasses::java_lang_Thread_group)->GetObject(peer);
+ mirror::Object* group = soa_.DecodeField(WellKnownClasses::java_lang_Thread_group)->GetObject(peer);
return (group == desired_thread_group_);
}
const ScopedObjectAccessUnchecked& soa_;
- Object* const desired_thread_group_;
+ mirror::Object* const desired_thread_group_;
std::vector<JDWP::ObjectId>& thread_ids_;
};
ScopedObjectAccessUnchecked soa(Thread::Current());
- Object* thread_group = gRegistry->Get<Object*>(thread_group_id);
+ mirror::Object* thread_group = gRegistry->Get<mirror::Object*>(thread_group_id);
ThreadListVisitor tlv(soa, thread_group, thread_ids);
MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
Runtime::Current()->GetThreadList()->ForEach(ThreadListVisitor::Visit, &tlv);
@@ -1747,16 +1759,17 @@
void Dbg::GetChildThreadGroups(JDWP::ObjectId thread_group_id, std::vector<JDWP::ObjectId>& child_thread_group_ids) {
ScopedObjectAccess soa(Thread::Current());
- Object* thread_group = gRegistry->Get<Object*>(thread_group_id);
+ mirror::Object* thread_group = gRegistry->Get<mirror::Object*>(thread_group_id);
// Get the ArrayList<ThreadGroup> "groups" out of this thread group...
- Field* groups_field = thread_group->GetClass()->FindInstanceField("groups", "Ljava/util/List;");
- Object* groups_array_list = groups_field->GetObject(thread_group);
+ mirror::Field* groups_field = thread_group->GetClass()->FindInstanceField("groups", "Ljava/util/List;");
+ mirror::Object* groups_array_list = groups_field->GetObject(thread_group);
// Get the array and size out of the ArrayList<ThreadGroup>...
- Field* array_field = groups_array_list->GetClass()->FindInstanceField("array", "[Ljava/lang/Object;");
- Field* size_field = groups_array_list->GetClass()->FindInstanceField("size", "I");
- ObjectArray<Object>* groups_array = array_field->GetObject(groups_array_list)->AsObjectArray<Object>();
+ mirror::Field* array_field = groups_array_list->GetClass()->FindInstanceField("array", "[Ljava/lang/Object;");
+ mirror::Field* size_field = groups_array_list->GetClass()->FindInstanceField("size", "I");
+ mirror::ObjectArray<mirror::Object>* groups_array =
+ array_field->GetObject(groups_array_list)->AsObjectArray<mirror::Object>();
const int32_t size = size_field->GetInt(groups_array_list);
// Copy the first 'size' elements out of the array into the result.
@@ -1871,7 +1884,7 @@
ScopedLocalRef<jobject> peer(Thread::Current()->GetJniEnv(), NULL);
{
ScopedObjectAccess soa(Thread::Current());
- peer.reset(soa.AddLocalReference<jobject>(gRegistry->Get<Object*>(thread_id)));
+ peer.reset(soa.AddLocalReference<jobject>(gRegistry->Get<mirror::Object*>(thread_id)));
}
if (peer.get() == NULL) {
return JDWP::ERR_THREAD_NOT_ALIVE;
@@ -1890,7 +1903,7 @@
void Dbg::ResumeThread(JDWP::ObjectId thread_id) {
ScopedObjectAccessUnchecked soa(Thread::Current());
- Object* peer = gRegistry->Get<Object*>(thread_id);
+ mirror::Object* peer = gRegistry->Get<mirror::Object*>(thread_id);
Thread* thread;
{
MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
@@ -1925,21 +1938,21 @@
if (frame_id != GetFrameId()) {
return true; // continue
}
- AbstractMethod* m = GetMethod();
+ mirror::AbstractMethod* m = GetMethod();
if (m->IsNative() || m->IsStatic()) {
this_object = NULL;
} else {
uint16_t reg = DemangleSlot(0, m);
- this_object = reinterpret_cast<Object*>(GetVReg(m, reg, kReferenceVReg));
+ this_object = reinterpret_cast<mirror::Object*>(GetVReg(m, reg, kReferenceVReg));
}
return false;
}
- Object* this_object;
+ mirror::Object* this_object;
JDWP::FrameId frame_id;
};
-static Object* GetThis(Thread* self, AbstractMethod* m, size_t frame_id)
+static mirror::Object* GetThis(Thread* self, mirror::AbstractMethod* m, size_t frame_id)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// TODO: should we return the 'this' we passed through to non-static native methods?
if (m->IsNative() || m->IsStatic()) {
@@ -1989,7 +2002,7 @@
return true; // Not our frame, carry on.
}
// TODO: check that the tag is compatible with the actual type of the slot!
- AbstractMethod* m = GetMethod();
+ mirror::AbstractMethod* m = GetMethod();
uint16_t reg = DemangleSlot(slot_, m);
switch (tag_) {
@@ -2037,7 +2050,7 @@
case JDWP::JT_ARRAY:
{
CHECK_EQ(width_, sizeof(JDWP::ObjectId));
- Object* o = reinterpret_cast<Object*>(GetVReg(m, reg, kReferenceVReg));
+ mirror::Object* o = reinterpret_cast<mirror::Object*>(GetVReg(m, reg, kReferenceVReg));
VLOG(jdwp) << "get array local " << reg << " = " << o;
if (!Runtime::Current()->GetHeap()->IsHeapAddress(o)) {
LOG(FATAL) << "Register " << reg << " expected to hold array: " << o;
@@ -2053,7 +2066,7 @@
case JDWP::JT_THREAD_GROUP:
{
CHECK_EQ(width_, sizeof(JDWP::ObjectId));
- Object* o = reinterpret_cast<Object*>(GetVReg(m, reg, kReferenceVReg));
+ mirror::Object* o = reinterpret_cast<mirror::Object*>(GetVReg(m, reg, kReferenceVReg));
VLOG(jdwp) << "get object local " << reg << " = " << o;
if (!Runtime::Current()->GetHeap()->IsHeapAddress(o)) {
LOG(FATAL) << "Register " << reg << " expected to hold object: " << o;
@@ -2128,7 +2141,7 @@
return true; // Not our frame, carry on.
}
// TODO: check that the tag is compatible with the actual type of the slot!
- AbstractMethod* m = GetMethod();
+ mirror::AbstractMethod* m = GetMethod();
uint16_t reg = DemangleSlot(slot_, m);
switch (tag_) {
@@ -2155,7 +2168,7 @@
case JDWP::JT_STRING:
{
CHECK_EQ(width_, sizeof(JDWP::ObjectId));
- Object* o = gRegistry->Get<Object*>(static_cast<JDWP::ObjectId>(value_));
+ mirror::Object* o = gRegistry->Get<mirror::Object*>(static_cast<JDWP::ObjectId>(value_));
if (o == kInvalidObject) {
UNIMPLEMENTED(FATAL) << "return an error code when given an invalid object to store";
}
@@ -2198,8 +2211,8 @@
visitor.WalkStack();
}
-void Dbg::PostLocationEvent(const AbstractMethod* m, int dex_pc, Object* this_object, int event_flags) {
- Class* c = m->GetDeclaringClass();
+void Dbg::PostLocationEvent(const mirror::AbstractMethod* m, int dex_pc, mirror::Object* this_object, int event_flags) {
+ mirror::Class* c = m->GetDeclaringClass();
JDWP::JdwpLocation location;
location.type_tag = c->IsInterface() ? JDWP::TT_INTERFACE : JDWP::TT_CLASS;
@@ -2220,8 +2233,9 @@
}
void Dbg::PostException(Thread* thread,
- JDWP::FrameId throw_frame_id, AbstractMethod* throw_method, uint32_t throw_dex_pc,
- AbstractMethod* catch_method, uint32_t catch_dex_pc, Throwable* exception) {
+ JDWP::FrameId throw_frame_id, mirror::AbstractMethod* throw_method,
+ uint32_t throw_dex_pc, mirror::AbstractMethod* catch_method,
+ uint32_t catch_dex_pc, mirror::Throwable* exception) {
if (!IsDebuggerActive()) {
return;
}
@@ -2252,7 +2266,7 @@
gJdwpState->PostException(&throw_location, exception_id, exception_class_id, &catch_location, this_id);
}
-void Dbg::PostClassPrepare(Class* c) {
+void Dbg::PostClassPrepare(mirror::Class* c) {
if (!IsDebuggerActive()) {
return;
}
@@ -2271,7 +2285,7 @@
}
size_t frame_id;
- AbstractMethod* m = self->GetCurrentMethod(NULL, &frame_id);
+ mirror::AbstractMethod* m = self->GetCurrentMethod(NULL, &frame_id);
//LOG(INFO) << "UpdateDebugger " << PrettyMethod(m) << "@" << dex_pc << " frame " << frame_id;
if (dex_pc == -1) {
@@ -2375,14 +2389,14 @@
void Dbg::WatchLocation(const JDWP::JdwpLocation* location) {
MutexLock mu(Thread::Current(), *Locks::breakpoint_lock_);
- AbstractMethod* m = FromMethodId(location->method_id);
+ mirror::AbstractMethod* m = FromMethodId(location->method_id);
gBreakpoints.push_back(Breakpoint(m, location->dex_pc));
VLOG(jdwp) << "Set breakpoint #" << (gBreakpoints.size() - 1) << ": " << gBreakpoints[gBreakpoints.size() - 1];
}
void Dbg::UnwatchLocation(const JDWP::JdwpLocation* location) {
MutexLock mu(Thread::Current(), *Locks::breakpoint_lock_);
- AbstractMethod* m = FromMethodId(location->method_id);
+ mirror::AbstractMethod* m = FromMethodId(location->method_id);
for (size_t i = 0; i < gBreakpoints.size(); ++i) {
if (gBreakpoints[i].method == m && gBreakpoints[i].dex_pc == location->dex_pc) {
VLOG(jdwp) << "Removed breakpoint #" << i << ": " << gBreakpoints[i];
@@ -2428,11 +2442,11 @@
// annotalysis.
bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
Locks::breakpoint_lock_->AssertHeld(Thread::Current());
- const AbstractMethod* m = GetMethod();
+ const mirror::AbstractMethod* m = GetMethod();
if (!m->IsRuntimeMethod()) {
++gSingleStepControl.stack_depth;
if (gSingleStepControl.method == NULL) {
- const DexCache* dex_cache = m->GetDeclaringClass()->GetDexCache();
+ const mirror::DexCache* dex_cache = m->GetDeclaringClass()->GetDexCache();
gSingleStepControl.method = m;
gSingleStepControl.line_number = -1;
if (dex_cache != NULL) {
@@ -2497,7 +2511,7 @@
uint32_t last_pc;
};
gSingleStepControl.dex_pcs.clear();
- const AbstractMethod* m = gSingleStepControl.method;
+ const mirror::AbstractMethod* m = gSingleStepControl.method;
if (m->IsNative()) {
gSingleStepControl.line_number = -1;
} else {
@@ -2618,23 +2632,23 @@
}
JDWP::JdwpError status;
- Object* receiver = gRegistry->Get<Object*>(object_id);
+ mirror::Object* receiver = gRegistry->Get<mirror::Object*>(object_id);
if (receiver == kInvalidObject) {
return JDWP::ERR_INVALID_OBJECT;
}
- Object* thread = gRegistry->Get<Object*>(thread_id);
+ mirror::Object* thread = gRegistry->Get<mirror::Object*>(thread_id);
if (thread == kInvalidObject) {
return JDWP::ERR_INVALID_OBJECT;
}
// TODO: check that 'thread' is actually a java.lang.Thread!
- Class* c = DecodeClass(class_id, status);
+ mirror::Class* c = DecodeClass(class_id, status);
if (c == NULL) {
return status;
}
- AbstractMethod* m = FromMethodId(method_id);
+ mirror::AbstractMethod* m = FromMethodId(method_id);
if (m->IsStatic() != (receiver == NULL)) {
return JDWP::ERR_INVALID_METHODID;
}
@@ -2739,13 +2753,13 @@
// We can be called while an exception is pending. We need
// to preserve that across the method invocation.
- SirtRef<Throwable> old_exception(soa.Self(), soa.Self()->GetException());
+ SirtRef<mirror::Throwable> old_exception(soa.Self(), soa.Self()->GetException());
soa.Self()->ClearException();
// Translate the method through the vtable, unless the debugger wants to suppress it.
- AbstractMethod* m = pReq->method_;
+ mirror::AbstractMethod* m = pReq->method_;
if ((pReq->options_ & JDWP::INVOKE_NONVIRTUAL) == 0 && pReq->receiver_ != NULL) {
- AbstractMethod* actual_method = pReq->class_->FindVirtualMethodForVirtualOrInterface(pReq->method_);
+ mirror::AbstractMethod* actual_method = pReq->class_->FindVirtualMethodForVirtualOrInterface(pReq->method_);
if (actual_method != m) {
VLOG(jdwp) << "ExecuteMethod translated " << PrettyMethod(m) << " to " << PrettyMethod(actual_method);
m = actual_method;
@@ -2764,7 +2778,7 @@
pReq->exception = gRegistry->Add(soa.Self()->GetException());
pReq->result_tag = BasicTagFromDescriptor(MethodHelper(m).GetShorty());
if (pReq->exception != 0) {
- Object* exc = soa.Self()->GetException();
+ mirror::Object* exc = soa.Self()->GetException();
VLOG(jdwp) << " JDWP invocation returning with exception=" << exc << " " << PrettyTypeOf(exc);
soa.Self()->ClearException();
pReq->result_value.SetJ(0);
@@ -2801,7 +2815,7 @@
* throwing exceptions) we really want to do the registration late.
*/
void Dbg::RegisterObjectId(JDWP::ObjectId id) {
- gRegistry->Add(reinterpret_cast<Object*>(id));
+ gRegistry->Add(reinterpret_cast<mirror::Object*>(id));
}
/*
@@ -2949,7 +2963,7 @@
} else {
CHECK(type == CHUNK_TYPE("THCR") || type == CHUNK_TYPE("THNM")) << type;
ScopedObjectAccessUnchecked soa(Thread::Current());
- SirtRef<String> name(soa.Self(), t->GetThreadName(soa));
+ SirtRef<mirror::String> name(soa.Self(), t->GetThreadName(soa));
size_t char_count = (name.get() != NULL) ? name->GetLength() : 0;
const jchar* chars = (name.get() != NULL) ? name->GetCharArray()->GetData() : NULL;
@@ -3239,7 +3253,7 @@
Flush();
}
}
- const Object *obj = (const Object *)start;
+ const mirror::Object* obj = reinterpret_cast<const mirror::Object*>(start);
// Determine the type of this chunk.
// OLD-TODO: if context.merge, see if this chunk is different from the last chunk.
@@ -3282,7 +3296,7 @@
*p_++ = length - 1;
}
- uint8_t ExamineObject(const Object* o, bool is_native_heap)
+ uint8_t ExamineObject(const mirror::Object* o, bool is_native_heap)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) {
if (o == NULL) {
return HPSG_STATE(SOLIDITY_FREE, 0);
@@ -3300,7 +3314,7 @@
return HPSG_STATE(SOLIDITY_HARD, KIND_NATIVE);
}
- Class* c = o->GetClass();
+ mirror::Class* c = o->GetClass();
if (c == NULL) {
// The object was probably just created but hasn't been initialized yet.
return HPSG_STATE(SOLIDITY_HARD, KIND_OBJECT);
@@ -3416,7 +3430,7 @@
if (depth >= kMaxAllocRecordStackDepth) {
return false;
}
- AbstractMethod* m = GetMethod();
+ mirror::AbstractMethod* m = GetMethod();
if (!m->IsRuntimeMethod()) {
record->stack[depth].method = m;
record->stack[depth].dex_pc = GetDexPc();
@@ -3437,7 +3451,7 @@
size_t depth;
};
-void Dbg::RecordAllocation(Class* type, size_t byte_count) {
+void Dbg::RecordAllocation(mirror::Class* type, size_t byte_count) {
Thread* self = Thread::Current();
CHECK(self != NULL);
@@ -3499,7 +3513,7 @@
<< PrettyClass(record->type);
for (size_t stack_frame = 0; stack_frame < kMaxAllocRecordStackDepth; ++stack_frame) {
- const AbstractMethod* m = record->stack[stack_frame].method;
+ const mirror::AbstractMethod* m = record->stack[stack_frame].method;
if (m == NULL) {
break;
}
@@ -3619,7 +3633,7 @@
MethodHelper mh;
for (size_t i = 0; i < kMaxAllocRecordStackDepth; i++) {
- AbstractMethod* m = record->stack[i].method;
+ mirror::AbstractMethod* m = record->stack[i].method;
if (m != NULL) {
mh.ChangeMethod(m);
class_names.Add(mh.GetDeclaringClassDescriptor());
diff --git a/src/debugger.h b/src/debugger.h
index b34a401..a796349 100644
--- a/src/debugger.h
+++ b/src/debugger.h
@@ -26,10 +26,17 @@
#include <string>
#include "jdwp/jdwp.h"
-#include "object.h"
+#include "jni.h"
+#include "jvalue.h"
+#include "root_visitor.h"
namespace art {
-
+namespace mirror {
+class AbstractMethod;
+class Class;
+class Object;
+class Throwable;
+} // namespace mirror
struct AllocRecord;
class Thread;
@@ -53,10 +60,10 @@
bool invoke_needed_;
/* request */
- Object* receiver_; /* not used for ClassType.InvokeMethod */
- Object* thread_;
- Class* class_;
- AbstractMethod* method_;
+ mirror::Object* receiver_; /* not used for ClassType.InvokeMethod */
+ mirror::Object* thread_;
+ mirror::Class* class_;
+ mirror::AbstractMethod* method_;
uint32_t arg_count_;
uint64_t* arg_values_; /* will be NULL if arg_count_ == 0 */
uint32_t options_;
@@ -118,7 +125,7 @@
static void Exit(int status);
- static void VisitRoots(Heap::RootVisitor* visitor, void* arg);
+ static void VisitRoots(RootVisitor* visitor, void* arg);
/*
* Class, Object, Array
@@ -311,17 +318,19 @@
kMethodEntry = 0x04,
kMethodExit = 0x08,
};
- static void PostLocationEvent(const AbstractMethod* method, int pcOffset, Object* thisPtr, int eventFlags)
+ static void PostLocationEvent(const mirror::AbstractMethod* method, int pcOffset,
+ mirror::Object* thisPtr, int eventFlags)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- static void PostException(Thread* thread, JDWP::FrameId throw_frame_id, AbstractMethod* throw_method,
- uint32_t throw_dex_pc, AbstractMethod* catch_method, uint32_t catch_dex_pc,
- Throwable* exception)
+ static void PostException(Thread* thread, JDWP::FrameId throw_frame_id,
+ mirror::AbstractMethod* throw_method,
+ uint32_t throw_dex_pc, mirror::AbstractMethod* catch_method,
+ uint32_t catch_dex_pc, mirror::Throwable* exception)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
static void PostThreadStart(Thread* t)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
static void PostThreadDeath(Thread* t)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- static void PostClassPrepare(Class* c)
+ static void PostClassPrepare(mirror::Class* c)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
static void UpdateDebugger(int32_t dex_pc, Thread* self)
@@ -373,12 +382,11 @@
/*
* Recent allocation tracking support.
*/
- static void RecordAllocation(Class* type, size_t byte_count)
+ static void RecordAllocation(mirror::Class* type, size_t byte_count)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
static void SetAllocTrackingEnabled(bool enabled);
static inline bool IsAllocTrackingEnabled() { return recent_allocation_records_ != NULL; }
- static jbyteArray GetRecentAllocations()
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ static jbyteArray GetRecentAllocations() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
static void DumpRecentAllocations();
enum HpifWhen {
diff --git a/src/dex2oat.cc b/src/dex2oat.cc
index a2d35e4..bc38bdc 100644
--- a/src/dex2oat.cc
+++ b/src/dex2oat.cc
@@ -27,10 +27,14 @@
#include "base/stringpiece.h"
#include "base/unix_file/fd_file.h"
#include "class_linker.h"
-#include "class_loader.h"
#include "compiler.h"
#include "image_writer.h"
#include "leb128.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/class-inl.h"
+#include "mirror/class_loader.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
#include "oat_writer.h"
#include "object_utils.h"
#include "os.h"
@@ -161,7 +165,7 @@
continue;
}
std::string descriptor(DotToDescriptor(dot.c_str()));
- SirtRef<Class> klass(self, class_linker->FindSystemClass(descriptor.c_str()));
+ SirtRef<mirror::Class> klass(self, class_linker->FindSystemClass(descriptor.c_str()));
if (klass.get() == NULL) {
LOG(WARNING) << "Failed to find class " << descriptor;
Thread::Current()->ClearException();
@@ -173,7 +177,7 @@
// exceptions are resolved by the verifier when there is a catch block in an interested method.
// Do this here so that exception classes appear to have been specified image classes.
std::set<std::pair<uint16_t, const DexFile*> > unresolved_exception_types;
- SirtRef<Class> java_lang_Throwable(self,
+ SirtRef<mirror::Class> java_lang_Throwable(self,
class_linker->FindSystemClass("Ljava/lang/Throwable;"));
do {
unresolved_exception_types.clear();
@@ -185,10 +189,10 @@
it != end; ++it) {
uint16_t exception_type_idx = it->first;
const DexFile* dex_file = it->second;
- DexCache* dex_cache = class_linker->FindDexCache(*dex_file);
- ClassLoader* class_loader = NULL;
- SirtRef<Class> klass(self, class_linker->ResolveType(*dex_file, exception_type_idx,
- dex_cache, class_loader));
+ mirror::DexCache* dex_cache = class_linker->FindDexCache(*dex_file);
+ mirror:: ClassLoader* class_loader = NULL;
+ SirtRef<mirror::Class> klass(self, class_linker->ResolveType(*dex_file, exception_type_idx,
+ dex_cache, class_loader));
if (klass.get() == NULL) {
const DexFile::TypeId& type_id = dex_file->GetTypeId(exception_type_idx);
const char* descriptor = dex_file->GetTypeDescriptor(type_id);
@@ -404,25 +408,25 @@
}
}
- static bool ResolveCatchBlockExceptionsClassVisitor(Class* c, void* arg)
+ static bool ResolveCatchBlockExceptionsClassVisitor(mirror::Class* c, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
std::set<std::pair<uint16_t, const DexFile*> >* exceptions_to_resolve =
reinterpret_cast<std::set<std::pair<uint16_t, const DexFile*> >*>(arg);
MethodHelper mh;
for (size_t i = 0; i < c->NumVirtualMethods(); ++i) {
- AbstractMethod* m = c->GetVirtualMethod(i);
+ mirror::AbstractMethod* m = c->GetVirtualMethod(i);
mh.ChangeMethod(m);
ResolveExceptionsForMethod(&mh, *exceptions_to_resolve);
}
for (size_t i = 0; i < c->NumDirectMethods(); ++i) {
- AbstractMethod* m = c->GetDirectMethod(i);
+ mirror::AbstractMethod* m = c->GetDirectMethod(i);
mh.ChangeMethod(m);
ResolveExceptionsForMethod(&mh, *exceptions_to_resolve);
}
return true;
}
- static bool RecordImageClassesVisitor(Class* klass, void* arg)
+ static bool RecordImageClassesVisitor(mirror::Class* klass, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
std::set<std::string>* image_classes = reinterpret_cast<std::set<std::string>*>(arg);
if (klass->IsArrayClass() || klass->IsPrimitive()) {
diff --git a/src/dex_file.cc b/src/dex_file.cc
index 7398616..e67e767 100644
--- a/src/dex_file.cc
+++ b/src/dex_file.cc
@@ -30,7 +30,10 @@
#include "dex_file_verifier.h"
#include "globals.h"
#include "leb128.h"
-#include "object.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/field.h"
+#include "mirror/field-inl.h"
+#include "mirror/string.h"
#include "os.h"
#include "safe_map.h"
#include "thread.h"
@@ -94,6 +97,14 @@
return DexFile::OpenFile(filename, location, true);
}
+int DexFile::GetPermissions() const {
+ if (mem_map_.get() == NULL) {
+ return 0;
+ } else {
+ return mem_map_->GetProtect();
+ }
+}
+
const DexFile* DexFile::OpenFile(const std::string& filename,
const std::string& location,
bool verify) {
@@ -146,7 +157,6 @@
const char* DexFile::kClassesDex = "classes.dex";
-// Open classes.dex from within a .zip, .jar, .apk, ...
const DexFile* DexFile::OpenZip(const std::string& filename,
const std::string& location) {
UniquePtr<ZipArchive> zip_archive(ZipArchive::Open(filename));
@@ -157,6 +167,16 @@
return DexFile::Open(*zip_archive.get(), location);
}
+const DexFile* DexFile::OpenMemory(const std::string& location,
+ uint32_t location_checksum,
+ MemMap* mem_map) {
+ return OpenMemory(mem_map->Begin(),
+ mem_map->Size(),
+ location,
+ location_checksum,
+ mem_map);
+}
+
const DexFile* DexFile::Open(const ZipArchive& zip_archive, const std::string& location) {
CHECK(!location.empty());
UniquePtr<ZipEntry> zip_entry(zip_archive.Find(kClassesDex));
@@ -584,7 +604,7 @@
return descriptor;
}
-int32_t DexFile::GetLineNumFromPC(const AbstractMethod* method, uint32_t rel_pc) const {
+int32_t DexFile::GetLineNumFromPC(const mirror::AbstractMethod* method, uint32_t rel_pc) const {
// For native method, lineno should be -2 to indicate it is native. Note that
// "line number == -2" is how libcore tells from StackTraceElement.
if (method->GetCodeItemOffset() == 0) {
@@ -601,6 +621,12 @@
return context.line_num_;
}
+const DexFile::TryItem* DexFile::GetTryItems(const CodeItem& code_item, uint32_t offset) {
+ const uint16_t* insns_end_ = &code_item.insns_[code_item.insns_size_in_code_units_];
+ return reinterpret_cast<const TryItem*>
+ (RoundUp(reinterpret_cast<uint32_t>(insns_end_), 4)) + offset;
+}
+
int32_t DexFile::FindCatchHandlerOffset(const CodeItem &code_item, int32_t tries_size,
uint32_t address) {
// Note: Signed type is important for max and min.
@@ -900,8 +926,8 @@
}
EncodedStaticFieldValueIterator::EncodedStaticFieldValueIterator(const DexFile& dex_file,
- DexCache* dex_cache,
- ClassLoader* class_loader,
+ mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader,
ClassLinker* linker,
const DexFile::ClassDef& class_def)
: dex_file_(dex_file), dex_cache_(dex_cache), class_loader_(class_loader), linker_(linker),
@@ -976,7 +1002,7 @@
ptr_ += width;
}
-void EncodedStaticFieldValueIterator::ReadValueToField(Field* field) const {
+void EncodedStaticFieldValueIterator::ReadValueToField(mirror::Field* field) const {
switch (type_) {
case kBoolean: field->SetBoolean(field->GetDeclaringClass(), jval_.z); break;
case kByte: field->SetByte(field->GetDeclaringClass(), jval_.b); break;
@@ -988,12 +1014,12 @@
case kDouble: field->SetDouble(field->GetDeclaringClass(), jval_.d); break;
case kNull: field->SetObject(field->GetDeclaringClass(), NULL); break;
case kString: {
- String* resolved = linker_->ResolveString(dex_file_, jval_.i, dex_cache_);
+ mirror::String* resolved = linker_->ResolveString(dex_file_, jval_.i, dex_cache_);
field->SetObject(field->GetDeclaringClass(), resolved);
break;
}
case kType: {
- Class* resolved = linker_->ResolveType(dex_file_, jval_.i, dex_cache_, class_loader_);
+ mirror::Class* resolved = linker_->ResolveType(dex_file_, jval_.i, dex_cache_, class_loader_);
field->SetObject(field->GetDeclaringClass(), resolved);
break;
}
diff --git a/src/dex_file.h b/src/dex_file.h
index 184d950..14b4ba0 100644
--- a/src/dex_file.h
+++ b/src/dex_file.h
@@ -29,10 +29,16 @@
#include "modifiers.h"
#include "safe_map.h"
#include "UniquePtr.h"
-#include "utils.h"
namespace art {
+namespace mirror {
+class AbstractMethod;
+class ClassLoader;
+class DexCache;
+class Field;
+} // namespace mirror
+class ClassLinker;
class ZipArchive;
// TODO: move all of the macro functionality into the DexCache class.
@@ -675,11 +681,7 @@
}
}
- static const TryItem* GetTryItems(const CodeItem& code_item, uint32_t offset) {
- const uint16_t* insns_end_ = &code_item.insns_[code_item.insns_size_in_code_units_];
- return reinterpret_cast<const TryItem*>
- (RoundUp(reinterpret_cast<uint32_t>(insns_end_), 4)) + offset;
- }
+ static const TryItem* GetTryItems(const CodeItem& code_item, uint32_t offset);
// Get the base of the encoded data for the given DexCode.
static const byte* GetCatchHandlerData(const CodeItem& code_item, uint32_t offset) {
@@ -775,7 +777,7 @@
// Returns -2 for native methods (as expected in exception traces).
//
// This is used by runtime; therefore use art::Method not art::DexFile::Method.
- int32_t GetLineNumFromPC(const AbstractMethod* method, uint32_t rel_pc) const
+ int32_t GetLineNumFromPC(const mirror::AbstractMethod* method, uint32_t rel_pc) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void DecodeDebugInfo(const CodeItem* code_item, bool is_static, uint32_t method_idx,
@@ -790,13 +792,7 @@
}
}
- int GetPermissions() const {
- if (mem_map_.get() == NULL) {
- return 0;
- } else {
- return mem_map_->GetProtect();
- }
- }
+ int GetPermissions() const;
private:
// Opens a .dex file
@@ -811,13 +807,7 @@
// Opens a .dex file at the given address backed by a MemMap
static const DexFile* OpenMemory(const std::string& location,
uint32_t location_checksum,
- MemMap* mem_map) {
- return OpenMemory(mem_map->Begin(),
- mem_map->Size(),
- location,
- location_checksum,
- mem_map);
- }
+ MemMap* mem_map);
// Opens a .dex file at the given address, optionally backed by a MemMap
static const DexFile* OpenMemory(const byte* dex_file,
@@ -1116,19 +1106,14 @@
DISALLOW_IMPLICIT_CONSTRUCTORS(ClassDataItemIterator);
};
-class ClassLinker;
-class ClassLoader;
-class DexCache;
-class Field;
-
class EncodedStaticFieldValueIterator {
public:
- EncodedStaticFieldValueIterator(const DexFile& dex_file, DexCache* dex_cache, ClassLoader* class_loader,
+ EncodedStaticFieldValueIterator(const DexFile& dex_file, mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader,
ClassLinker* linker, const DexFile::ClassDef& class_def)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void ReadValueToField(Field* field) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void ReadValueToField(mirror::Field* field) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
bool HasNext() { return pos_ < array_size_; }
@@ -1158,14 +1143,14 @@
static const byte kEncodedValueArgShift = 5;
const DexFile& dex_file_;
- DexCache* dex_cache_; // dex cache to resolve literal objects
- ClassLoader* class_loader_; // ClassLoader to resolve types
- ClassLinker* linker_; // linker to resolve literal objects
- size_t array_size_; // size of array
- size_t pos_; // current position
- const byte* ptr_; // pointer into encoded data array
- ValueType type_; // type of current encoded value
- jvalue jval_; // value of current encoded value
+ mirror::DexCache* dex_cache_; // Dex cache to resolve literal objects.
+ mirror::ClassLoader* class_loader_; // ClassLoader to resolve types.
+ ClassLinker* linker_; // Linker to resolve literal objects.
+ size_t array_size_; // Size of array.
+ size_t pos_; // Current position.
+ const byte* ptr_; // Pointer into encoded data array.
+ ValueType type_; // Type of current encoded value.
+ jvalue jval_; // Value of current encoded value.
DISALLOW_IMPLICIT_CONSTRUCTORS(EncodedStaticFieldValueIterator);
};
std::ostream& operator<<(std::ostream& os, const EncodedStaticFieldValueIterator::ValueType& code);
diff --git a/src/dex_file_verifier.cc b/src/dex_file_verifier.cc
index 83ef31a..2f9054e 100644
--- a/src/dex_file_verifier.cc
+++ b/src/dex_file_verifier.cc
@@ -18,9 +18,10 @@
#include "base/stringprintf.h"
#include "leb128.h"
-#include "object.h"
#include "safe_map.h"
#include "UniquePtr.h"
+#include "utf.h"
+#include "utils.h"
#include "zip_archive.h"
namespace art {
diff --git a/src/dex_instruction.cc b/src/dex_instruction.cc
index d3aa238..55f6eca 100644
--- a/src/dex_instruction.cc
+++ b/src/dex_instruction.cc
@@ -17,6 +17,7 @@
#include "dex_instruction.h"
#include "dex_file.h"
+#include "utils.h"
#include <iomanip>
namespace art {
diff --git a/src/exception_test.cc b/src/exception_test.cc
index 58e6533..240bf95 100644
--- a/src/exception_test.cc
+++ b/src/exception_test.cc
@@ -18,6 +18,8 @@
#include "common_test.h"
#include "dex_file.h"
#include "gtest/gtest.h"
+#include "mirror/object_array-inl.h"
+#include "mirror/stack_trace_element.h"
#include "runtime.h"
#include "scoped_thread_state_change.h"
#include "sirt_ref.h"
@@ -32,8 +34,8 @@
CommonTest::SetUp();
ScopedObjectAccess soa(Thread::Current());
- SirtRef<ClassLoader> class_loader(soa.Self(),
- soa.Decode<ClassLoader*>(LoadDex("ExceptionHandle")));
+ SirtRef<mirror::ClassLoader> class_loader(soa.Self(),
+ soa.Decode<mirror::ClassLoader*>(LoadDex("ExceptionHandle")));
my_klass_ = class_linker_->FindClass("LExceptionHandle;", class_loader.get());
ASSERT_TRUE(my_klass_ != NULL);
class_linker_->EnsureInitialized(my_klass_, false, true);
@@ -90,11 +92,11 @@
std::vector<uint16_t> fake_vmap_table_data_;
std::vector<uint8_t> fake_gc_map_;
- AbstractMethod* method_f_;
- AbstractMethod* method_g_;
+ mirror::AbstractMethod* method_f_;
+ mirror::AbstractMethod* method_g_;
private:
- Class* my_klass_;
+ mirror::Class* my_klass_;
};
TEST_F(ExceptionTest, FindCatchHandler) {
@@ -193,8 +195,8 @@
ASSERT_TRUE(internal != NULL);
jobjectArray ste_array = Thread::InternalStackTraceToStackTraceElementArray(env, internal);
ASSERT_TRUE(ste_array != NULL);
- ObjectArray<StackTraceElement>* trace_array =
- soa.Decode<ObjectArray<StackTraceElement>*>(ste_array);
+ mirror::ObjectArray<mirror::StackTraceElement>* trace_array =
+ soa.Decode<mirror::ObjectArray<mirror::StackTraceElement>*>(ste_array);
ASSERT_TRUE(trace_array != NULL);
ASSERT_TRUE(trace_array->Get(0) != NULL);
diff --git a/src/gc/atomic_stack.h b/src/gc/atomic_stack.h
index cd1781d..0197bce 100644
--- a/src/gc/atomic_stack.h
+++ b/src/gc/atomic_stack.h
@@ -101,11 +101,11 @@
}
T* Begin() {
- return const_cast<Object**>(begin_ + front_index_);
+ return const_cast<mirror::Object**>(begin_ + front_index_);
}
T* End() {
- return const_cast<Object**>(begin_ + back_index_);
+ return const_cast<mirror::Object**>(begin_ + back_index_);
}
size_t Capacity() const {
@@ -159,6 +159,8 @@
DISALLOW_COPY_AND_ASSIGN(AtomicStack);
};
+typedef AtomicStack<mirror::Object*> ObjectStack;
+
} // namespace art
#endif // ART_SRC_MARK_STACK_H_
diff --git a/src/gc/card_table-inl.h b/src/gc/card_table-inl.h
new file mode 100644
index 0000000..13590b7
--- /dev/null
+++ b/src/gc/card_table-inl.h
@@ -0,0 +1,209 @@
+/*
+ * Copyright (C) 2011 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_GC_CARDTABLE_INL_H_
+#define ART_SRC_GC_CARDTABLE_INL_H_
+
+#include "base/logging.h"
+#include "card_table.h"
+#include "cutils/atomic-inline.h"
+#include "space_bitmap.h"
+#include "utils.h"
+
+namespace art {
+
+static inline bool byte_cas(byte old_value, byte new_value, byte* address) {
+ // Little endian means most significant byte is on the left.
+ const size_t shift = reinterpret_cast<uintptr_t>(address) % sizeof(uintptr_t);
+ // Align the address down.
+ address -= shift;
+ int32_t* word_address = reinterpret_cast<int32_t*>(address);
+ // Word with the byte we are trying to cas cleared.
+ const int32_t cur_word = *word_address & ~(0xFF << shift);
+ const int32_t old_word = cur_word | (static_cast<int32_t>(old_value) << shift);
+ const int32_t new_word = cur_word | (static_cast<int32_t>(new_value) << shift);
+ bool success = android_atomic_cas(old_word, new_word, word_address) == 0;
+ return success;
+}
+
+template <typename Visitor, typename FingerVisitor>
+inline void CardTable::Scan(SpaceBitmap* bitmap, byte* scan_begin, byte* scan_end,
+ const Visitor& visitor, const FingerVisitor& finger_visitor,
+ const byte minimum_age) const {
+ DCHECK(bitmap->HasAddress(scan_begin));
+ DCHECK(bitmap->HasAddress(scan_end - 1)); // scan_end is the byte after the last byte we scan.
+ byte* card_cur = CardFromAddr(scan_begin);
+ byte* card_end = CardFromAddr(scan_end);
+ CheckCardValid(card_cur);
+ CheckCardValid(card_end);
+
+ // Handle any unaligned cards at the start.
+ while (!IsAligned<sizeof(word)>(card_cur) && card_cur < card_end) {
+ if (*card_cur >= minimum_age) {
+ uintptr_t start = reinterpret_cast<uintptr_t>(AddrFromCard(card_cur));
+ uintptr_t end = start + kCardSize;
+ bitmap->VisitMarkedRange(start, end, visitor, finger_visitor);
+ }
+ ++card_cur;
+ }
+
+ byte* aligned_end = card_end -
+ (reinterpret_cast<uintptr_t>(card_end) & (sizeof(uintptr_t) - 1));
+
+ // Now we have the words, we can send these to be processed in parallel.
+ uintptr_t* word_cur = reinterpret_cast<uintptr_t*>(card_cur);
+ uintptr_t* word_end = reinterpret_cast<uintptr_t*>(aligned_end);
+
+ // TODO: Parallelize
+ while (word_cur < word_end) {
+ // Find the first dirty card.
+ while (*word_cur == 0 && word_cur < word_end) {
+ word_cur++;
+ }
+ if (word_cur >= word_end) {
+ break;
+ }
+ uintptr_t start_word = *word_cur;
+ for (size_t i = 0; i < sizeof(uintptr_t); ++i) {
+ if ((start_word & 0xFF) >= minimum_age) {
+ byte* card = reinterpret_cast<byte*>(word_cur) + i;
+ const byte card_byte = *card;
+ DCHECK(card_byte == (start_word & 0xFF) || card_byte == kCardDirty)
+ << "card " << static_cast<size_t>(card_byte) << " word " << (start_word & 0xFF);
+ uintptr_t start = reinterpret_cast<uintptr_t>(AddrFromCard(card));
+ uintptr_t end = start + kCardSize;
+ bitmap->VisitMarkedRange(start, end, visitor, finger_visitor);
+ }
+ start_word >>= 8;
+ }
+ ++word_cur;
+ }
+
+ // Handle any unaligned cards at the end.
+ card_cur = reinterpret_cast<byte*>(word_end);
+ while (card_cur < card_end) {
+ if (*card_cur >= minimum_age) {
+ uintptr_t start = reinterpret_cast<uintptr_t>(AddrFromCard(card_cur));
+ uintptr_t end = start + kCardSize;
+ bitmap->VisitMarkedRange(start, end, visitor, finger_visitor);
+ }
+ ++card_cur;
+ }
+}
+
+/*
+ * Visitor is expected to take in a card and return the new value. When a value is modified, the
+ * modify visitor is called.
+ * visitor: The visitor which modifies the cards. Returns the new value for a card given an old
+ * value.
+ * modified: Whenever the visitor modifies a card, this visitor is called on the card. Enables
+ * us to know which cards got cleared.
+ */
+template <typename Visitor, typename ModifiedVisitor>
+inline void CardTable::ModifyCardsAtomic(byte* scan_begin, byte* scan_end, const Visitor& visitor,
+ const ModifiedVisitor& modified) {
+ byte* card_cur = CardFromAddr(scan_begin);
+ byte* card_end = CardFromAddr(scan_end);
+ CheckCardValid(card_cur);
+ CheckCardValid(card_end);
+
+ // Handle any unaligned cards at the start.
+ while (!IsAligned<sizeof(word)>(card_cur) && card_cur < card_end) {
+ byte expected, new_value;
+ do {
+ expected = *card_cur;
+ new_value = visitor(expected);
+ } while (expected != new_value && UNLIKELY(!byte_cas(expected, new_value, card_cur)));
+ if (expected != new_value) {
+ modified(card_cur, expected, new_value);
+ }
+ ++card_cur;
+ }
+
+ // Handle unaligned cards at the end.
+ while (!IsAligned<sizeof(word)>(card_end) && card_end > card_cur) {
+ --card_end;
+ byte expected, new_value;
+ do {
+ expected = *card_end;
+ new_value = visitor(expected);
+ } while (expected != new_value && UNLIKELY(!byte_cas(expected, new_value, card_end)));
+ if (expected != new_value) {
+ modified(card_cur, expected, new_value);
+ }
+ }
+
+ // Now we have the words, we can process words in parallel.
+ uintptr_t* word_cur = reinterpret_cast<uintptr_t*>(card_cur);
+ uintptr_t* word_end = reinterpret_cast<uintptr_t*>(card_end);
+ uintptr_t expected_word;
+ uintptr_t new_word;
+
+ // TODO: Parallelize.
+ while (word_cur < word_end) {
+ while ((expected_word = *word_cur) != 0) {
+ new_word =
+ (visitor((expected_word >> 0) & 0xFF) << 0) |
+ (visitor((expected_word >> 8) & 0xFF) << 8) |
+ (visitor((expected_word >> 16) & 0xFF) << 16) |
+ (visitor((expected_word >> 24) & 0xFF) << 24);
+ if (new_word == expected_word) {
+ // No need to do a cas.
+ break;
+ }
+ if (LIKELY(android_atomic_cas(expected_word, new_word,
+ reinterpret_cast<int32_t*>(word_cur)) == 0)) {
+ for (size_t i = 0; i < sizeof(uintptr_t); ++i) {
+ const byte expected_byte = (expected_word >> (8 * i)) & 0xFF;
+ const byte new_byte = (new_word >> (8 * i)) & 0xFF;
+ if (expected_byte != new_byte) {
+ modified(reinterpret_cast<byte*>(word_cur) + i, expected_byte, new_byte);
+ }
+ }
+ break;
+ }
+ }
+ ++word_cur;
+ }
+}
+
+inline void* CardTable::AddrFromCard(const byte *card_addr) const {
+ DCHECK(IsValidCard(card_addr))
+ << " card_addr: " << reinterpret_cast<const void*>(card_addr)
+ << " begin: " << reinterpret_cast<void*>(mem_map_->Begin() + offset_)
+ << " end: " << reinterpret_cast<void*>(mem_map_->End());
+ uintptr_t offset = card_addr - biased_begin_;
+ return reinterpret_cast<void*>(offset << kCardShift);
+}
+
+inline byte* CardTable::CardFromAddr(const void *addr) const {
+ byte *card_addr = biased_begin_ + (reinterpret_cast<uintptr_t>(addr) >> kCardShift);
+ // Sanity check the caller was asking for address covered by the card table
+ DCHECK(IsValidCard(card_addr)) << "addr: " << addr
+ << " card_addr: " << reinterpret_cast<void*>(card_addr);
+ return card_addr;
+}
+
+inline void CardTable::CheckCardValid(byte* card) const {
+ DCHECK(IsValidCard(card))
+ << " card_addr: " << reinterpret_cast<const void*>(card)
+ << " begin: " << reinterpret_cast<void*>(mem_map_->Begin() + offset_)
+ << " end: " << reinterpret_cast<void*>(mem_map_->End());
+}
+
+} // namespace art
+
+#endif // ART_SRC_GC_CARDTABLE_INL_H_
diff --git a/src/gc/card_table.cc b/src/gc/card_table.cc
index f27777b..4331270 100644
--- a/src/gc/card_table.cc
+++ b/src/gc/card_table.cc
@@ -19,6 +19,7 @@
#include <dynamic_annotations.h>
#include "base/logging.h"
+#include "gc/card_table-inl.h"
#include "heap.h"
#include "heap_bitmap.h"
#include "runtime.h"
diff --git a/src/gc/card_table.h b/src/gc/card_table.h
index 8f1bc92..842fcc3 100644
--- a/src/gc/card_table.h
+++ b/src/gc/card_table.h
@@ -17,19 +17,18 @@
#ifndef ART_SRC_GC_CARDTABLE_H_
#define ART_SRC_GC_CARDTABLE_H_
-#include "base/logging.h"
#include "globals.h"
+#include "locks.h"
#include "mem_map.h"
-#include "space_bitmap.h"
#include "UniquePtr.h"
-#include "utils.h"
namespace art {
-
+namespace mirror {
+class Object;
+} // namespace mirror
class Heap;
class ContinuousSpace;
class SpaceBitmap;
-class Object;
// Maintain a card table from the the write barrier. All writes of
// non-NULL values to heap addresses should go through an entry in
@@ -50,12 +49,12 @@
}
// Is the object on a dirty card?
- bool IsDirty(const Object* obj) const {
+ bool IsDirty(const mirror::Object* obj) const {
return GetCard(obj) == kCardDirty;
}
// Return the state of the card at an address.
- byte GetCard(const Object* obj) const {
+ byte GetCard(const mirror::Object* obj) const {
return *CardFromAddr(obj);
}
@@ -88,71 +87,7 @@
*/
template <typename Visitor, typename ModifiedVisitor>
void ModifyCardsAtomic(byte* scan_begin, byte* scan_end, const Visitor& visitor,
- const ModifiedVisitor& modified = VoidFunctor()) {
- byte* card_cur = CardFromAddr(scan_begin);
- byte* card_end = CardFromAddr(scan_end);
- CheckCardValid(card_cur);
- CheckCardValid(card_end);
-
- // Handle any unaligned cards at the start.
- while (!IsAligned<sizeof(word)>(card_cur) && card_cur < card_end) {
- byte expected, new_value;
- do {
- expected = *card_cur;
- new_value = visitor(expected);
- } while (expected != new_value && UNLIKELY(byte_cas(expected, new_value, card_cur) != 0));
- if (expected != new_value) {
- modified(card_cur, expected, new_value);
- }
- ++card_cur;
- }
-
- // Handle unaligned cards at the end.
- while (!IsAligned<sizeof(word)>(card_end) && card_end > card_cur) {
- --card_end;
- byte expected, new_value;
- do {
- expected = *card_end;
- new_value = visitor(expected);
- } while (expected != new_value && UNLIKELY(byte_cas(expected, new_value, card_end) != 0));
- if (expected != new_value) {
- modified(card_cur, expected, new_value);
- }
- }
-
- // Now we have the words, we can process words in parallel.
- uintptr_t* word_cur = reinterpret_cast<uintptr_t*>(card_cur);
- uintptr_t* word_end = reinterpret_cast<uintptr_t*>(card_end);
- uintptr_t expected_word;
- uintptr_t new_word;
-
- // TODO: Parallelize.
- while (word_cur < word_end) {
- while ((expected_word = *word_cur) != 0) {
- new_word =
- (visitor((expected_word >> 0) & 0xFF) << 0) |
- (visitor((expected_word >> 8) & 0xFF) << 8) |
- (visitor((expected_word >> 16) & 0xFF) << 16) |
- (visitor((expected_word >> 24) & 0xFF) << 24);
- if (new_word == expected_word) {
- // No need to do a cas.
- break;
- }
- if (LIKELY(android_atomic_cas(expected_word, new_word,
- reinterpret_cast<int32_t*>(word_cur)) == 0)) {
- for (size_t i = 0; i < sizeof(uintptr_t); ++i) {
- const byte expected_byte = (expected_word >> (8 * i)) & 0xFF;
- const byte new_byte = (new_word >> (8 * i)) & 0xFF;
- if (expected_byte != new_byte) {
- modified(reinterpret_cast<byte*>(word_cur) + i, expected_byte, new_byte);
- }
- }
- break;
- }
- }
- ++word_cur;
- }
- }
+ const ModifiedVisitor& modified);
// For every dirty at least minumum age between begin and end invoke the visitor with the
// specified argument.
@@ -161,67 +96,7 @@
const Visitor& visitor, const FingerVisitor& finger_visitor,
const byte minimum_age = kCardDirty) const
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DCHECK(bitmap->HasAddress(scan_begin));
- DCHECK(bitmap->HasAddress(scan_end - 1)); // scan_end is the byte after the last byte we scan.
- byte* card_cur = CardFromAddr(scan_begin);
- byte* card_end = CardFromAddr(scan_end);
- CheckCardValid(card_cur);
- CheckCardValid(card_end);
-
- // Handle any unaligned cards at the start.
- while (!IsAligned<sizeof(word)>(card_cur) && card_cur < card_end) {
- if (*card_cur >= minimum_age) {
- uintptr_t start = reinterpret_cast<uintptr_t>(AddrFromCard(card_cur));
- uintptr_t end = start + kCardSize;
- bitmap->VisitMarkedRange(start, end, visitor, finger_visitor);
- }
- ++card_cur;
- }
-
- byte* aligned_end = card_end -
- (reinterpret_cast<uintptr_t>(card_end) & (sizeof(uintptr_t) - 1));
-
- // Now we have the words, we can send these to be processed in parallel.
- uintptr_t* word_cur = reinterpret_cast<uintptr_t*>(card_cur);
- uintptr_t* word_end = reinterpret_cast<uintptr_t*>(aligned_end);
-
- // TODO: Parallelize
- while (word_cur < word_end) {
- // Find the first dirty card.
- while (*word_cur == 0 && word_cur < word_end) {
- word_cur++;
- }
- if (word_cur >= word_end) {
- break;
- }
- uintptr_t start_word = *word_cur;
- for (size_t i = 0; i < sizeof(uintptr_t); ++i) {
- if ((start_word & 0xFF) >= minimum_age) {
- byte* card = reinterpret_cast<byte*>(word_cur) + i;
- const byte card_byte = *card;
- DCHECK(card_byte == (start_word & 0xFF) || card_byte == kCardDirty)
- << "card " << static_cast<size_t>(card_byte) << " word " << (start_word & 0xFF);
- uintptr_t start = reinterpret_cast<uintptr_t>(AddrFromCard(card));
- uintptr_t end = start + kCardSize;
- bitmap->VisitMarkedRange(start, end, visitor, finger_visitor);
- }
- start_word >>= 8;
- }
- ++word_cur;
- }
-
- // Handle any unaligned cards at the end.
- card_cur = reinterpret_cast<byte*>(word_end);
- while (card_cur < card_end) {
- if (*card_cur >= minimum_age) {
- uintptr_t start = reinterpret_cast<uintptr_t>(AddrFromCard(card_cur));
- uintptr_t end = start + kCardSize;
- bitmap->VisitMarkedRange(start, end, visitor, finger_visitor);
- }
- ++card_cur;
- }
- }
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Assertion used to check the given address is covered by the card table
void CheckAddrIsInCardTable(const byte* addr) const;
@@ -233,40 +108,14 @@
void ClearSpaceCards(ContinuousSpace* space);
// Returns the first address in the heap which maps to this card.
- void* AddrFromCard(const byte *card_addr) const {
- DCHECK(IsValidCard(card_addr))
- << " card_addr: " << reinterpret_cast<const void*>(card_addr)
- << " begin: " << reinterpret_cast<void*>(mem_map_->Begin() + offset_)
- << " end: " << reinterpret_cast<void*>(mem_map_->End());
- uintptr_t offset = card_addr - biased_begin_;
- return reinterpret_cast<void*>(offset << kCardShift);
- }
+ void* AddrFromCard(const byte *card_addr) const;
// Returns the address of the relevant byte in the card table, given an address on the heap.
- byte* CardFromAddr(const void *addr) const {
- byte *card_addr = biased_begin_ + (reinterpret_cast<uintptr_t>(addr) >> kCardShift);
- // Sanity check the caller was asking for address covered by the card table
- DCHECK(IsValidCard(card_addr)) << "addr: " << addr
- << " card_addr: " << reinterpret_cast<void*>(card_addr);
- return card_addr;
- }
+ byte* CardFromAddr(const void *addr) const;
bool AddrIsInCardTable(const void* addr) const;
private:
- static int byte_cas(byte old_value, byte new_value, byte* address) {
- // Little endian means most significant byte is on the left.
- const size_t shift = reinterpret_cast<uintptr_t>(address) % sizeof(uintptr_t);
- // Align the address down.
- address -= shift;
- int32_t* word_address = reinterpret_cast<int32_t*>(address);
- // Word with the byte we are trying to cas cleared.
- const int32_t cur_word = *word_address & ~(0xFF << shift);
- const int32_t old_word = cur_word | (static_cast<int32_t>(old_value) << shift);
- const int32_t new_word = cur_word | (static_cast<int32_t>(new_value) << shift);
- return android_atomic_cas(old_word, new_word, word_address);
- }
-
CardTable(MemMap* begin, byte* biased_begin, size_t offset);
// Returns true iff the card table address is within the bounds of the card table.
@@ -276,12 +125,7 @@
return card_addr >= begin && card_addr < end;
}
- void CheckCardValid(byte* card) const {
- DCHECK(IsValidCard(card))
- << " card_addr: " << reinterpret_cast<const void*>(card)
- << " begin: " << reinterpret_cast<void*>(mem_map_->Begin() + offset_)
- << " end: " << reinterpret_cast<void*>(mem_map_->End());
- }
+ void CheckCardValid(byte* card) const;
// Verifies that all gray objects are on a dirty card.
void VerifyCardTable();
diff --git a/src/gc/garbage_collector.cc b/src/gc/garbage_collector.cc
index bcc7b63..fbcdbaf 100644
--- a/src/gc/garbage_collector.cc
+++ b/src/gc/garbage_collector.cc
@@ -15,6 +15,7 @@
*/
#include "garbage_collector.h"
+#include "thread.h"
#include "thread_list.h"
namespace art {
diff --git a/src/gc/garbage_collector.h b/src/gc/garbage_collector.h
index 9ddf45f..a1014c2 100644
--- a/src/gc/garbage_collector.h
+++ b/src/gc/garbage_collector.h
@@ -14,11 +14,13 @@
* limitations under the License.
*/
-#ifndef ART_SRC_GC_GARBAGE_COLLECTR_H_
-#define ART_SRC_GC_GARBAGE_COLLECTR_H_
+#ifndef ART_SRC_GC_GARBAGE_COLLECTOR_H_
+#define ART_SRC_GC_GARBAGE_COLLECTOR_H_
#include "locks.h"
-#include "utils.h"
+
+#include <stdint.h>
+#include <vector>
namespace art {
@@ -56,7 +58,7 @@
void RegisterPause(uint64_t nano_length);
protected:
- // The initial phase. Done with mutators upaused.
+ // The initial phase. Done without mutators paused.
virtual void InitializePhase() = 0;
// Mark all reachable objects, done concurrently.
@@ -68,7 +70,7 @@
// Called with mutators running.
virtual void ReclaimPhase() = 0;
- // Called after the GC is finished. Done with mutators upaused.
+ // Called after the GC is finished. Done without mutators paused.
virtual void FinishPhase() = 0;
Heap* heap_;
@@ -78,4 +80,4 @@
} // namespace art
-#endif // ART_SRC_GC_GARBAGE_COLLECTR_H_
+#endif // ART_SRC_GC_GARBAGE_COLLECTOR_H_
diff --git a/src/gc/gc_type.h b/src/gc/gc_type.h
new file mode 100644
index 0000000..908f038
--- /dev/null
+++ b/src/gc/gc_type.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2011 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_GC_GC_TYPE_H_
+#define ART_SRC_GC_GC_TYPE_H_
+
+namespace art {
+
+// The ordering of the enum matters, it is used to determine which GCs are run first.
+enum GcType {
+ // No Gc
+ kGcTypeNone,
+ // Sticky mark bits "generational" GC.
+ kGcTypeSticky,
+ // Partial GC, over only the alloc space.
+ kGcTypePartial,
+ // Full GC
+ kGcTypeFull,
+ // Number of different Gc types.
+ kGcTypeMax,
+};
+std::ostream& operator<<(std::ostream& os, const GcType& policy);
+
+} // namespace art
+
+#endif // ART_SRC_GC_GC_TYPE_H_
diff --git a/src/gc/heap_bitmap-inl.h b/src/gc/heap_bitmap-inl.h
new file mode 100644
index 0000000..2811183
--- /dev/null
+++ b/src/gc/heap_bitmap-inl.h
@@ -0,0 +1,36 @@
+/*
+ * 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_GC_HEAP_BITMAP_INL_H_
+#define ART_SRC_GC_HEAP_BITMAP_INL_H_
+
+#include "heap_bitmap.h"
+
+namespace art {
+
+template <typename Visitor>
+inline void HeapBitmap::Visit(const Visitor& visitor) {
+ // TODO: C++0x auto
+ for (Bitmaps::iterator it = bitmaps_.begin(); it != bitmaps_.end(); ++it) {
+ SpaceBitmap* bitmap = *it;
+ bitmap->VisitMarkedRange(bitmap->HeapBegin(), bitmap->HeapLimit(), visitor, VoidFunctor());
+ }
+ large_objects_->Visit(visitor);
+}
+
+} // namespace art
+
+#endif // ART_SRC_GC_HEAP_BITMAP_INL_H_
diff --git a/src/gc/heap_bitmap.h b/src/gc/heap_bitmap.h
index 42c4166..87e0848 100644
--- a/src/gc/heap_bitmap.h
+++ b/src/gc/heap_bitmap.h
@@ -14,96 +14,91 @@
* limitations under the License.
*/
-#ifndef ART_SRC_HEAP_BITMAP_H_
-#define ART_SRC_HEAP_BITMAP_H_
+#ifndef ART_SRC_GC_HEAP_BITMAP_H_
+#define ART_SRC_GC_HEAP_BITMAP_H_
+#include "locks.h"
#include "space_bitmap.h"
namespace art {
- class Heap;
- class SpaceBitmap;
+class Heap;
- class HeapBitmap {
- public:
- bool Test(const Object* obj) SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) {
- SpaceBitmap* bitmap = GetSpaceBitmap(obj);
- if (LIKELY(bitmap != NULL)) {
- return bitmap->Test(obj);
- } else {
- return large_objects_->Test(obj);
+class HeapBitmap {
+ public:
+ bool Test(const mirror::Object* obj) SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) {
+ SpaceBitmap* bitmap = GetSpaceBitmap(obj);
+ if (LIKELY(bitmap != NULL)) {
+ return bitmap->Test(obj);
+ } else {
+ return large_objects_->Test(obj);
+ }
+ }
+
+ void Clear(const mirror::Object* obj)
+ EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) {
+ SpaceBitmap* bitmap = GetSpaceBitmap(obj);
+ if (LIKELY(bitmap != NULL)) {
+ bitmap->Clear(obj);
+ } else {
+ large_objects_->Clear(obj);
+ }
+ }
+
+ void Set(const mirror::Object* obj)
+ EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) {
+ SpaceBitmap* bitmap = GetSpaceBitmap(obj);
+ if (LIKELY(bitmap != NULL)) {
+ bitmap->Set(obj);
+ } else {
+ large_objects_->Set(obj);
+ }
+ }
+
+ SpaceBitmap* GetSpaceBitmap(const mirror::Object* obj) {
+ // TODO: C++0x auto
+ for (Bitmaps::iterator it = bitmaps_.begin(); it != bitmaps_.end(); ++it) {
+ if ((*it)->HasAddress(obj)) {
+ return *it;
}
}
+ return NULL;
+ }
- void Clear(const Object* obj)
- EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) {
- SpaceBitmap* bitmap = GetSpaceBitmap(obj);
- if (LIKELY(bitmap != NULL)) {
- bitmap->Clear(obj);
- } else {
- large_objects_->Clear(obj);
- }
- }
+ void Walk(SpaceBitmap::Callback* callback, void* arg)
+ SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
- void Set(const Object* obj)
- EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) {
- SpaceBitmap* bitmap = GetSpaceBitmap(obj);
- if (LIKELY(bitmap != NULL)) {
- bitmap->Set(obj);
- } else {
- large_objects_->Set(obj);
- }
- }
+ template <typename Visitor>
+ void Visit(const Visitor& visitor)
+ EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- SpaceBitmap* GetSpaceBitmap(const Object* obj) {
- // TODO: C++0x auto
- for (Bitmaps::iterator it = bitmaps_.begin(); it != bitmaps_.end(); ++it) {
- if ((*it)->HasAddress(obj)) {
- return *it;
- }
- }
- return NULL;
- }
+ // Find and replace a bitmap pointer, this is used by for the bitmap swapping in the GC.
+ void ReplaceBitmap(SpaceBitmap* old_bitmap, SpaceBitmap* new_bitmap)
+ EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
- void Walk(SpaceBitmap::Callback* callback, void* arg)
- SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
+ HeapBitmap(Heap* heap);
- template <typename Visitor>
- void Visit(const Visitor& visitor)
- EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) {
- // TODO: C++0x auto
- for (Bitmaps::iterator it = bitmaps_.begin(); it != bitmaps_.end(); ++it) {
- SpaceBitmap* bitmap = *it;
- bitmap->VisitMarkedRange(bitmap->HeapBegin(), bitmap->HeapLimit(), visitor, VoidFunctor());
- }
- large_objects_->Visit(visitor);
- }
+ inline SpaceSetMap* GetLargeObjects() const {
+ return large_objects_;
+ }
- // Find and replace a bitmap pointer, this is used by for the bitmap swapping in the GC.
- void ReplaceBitmap(SpaceBitmap* old_bitmap, SpaceBitmap* new_bitmap)
- EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
+ void SetLargeObjects(SpaceSetMap* large_objects);
- HeapBitmap(Heap* heap);
+ private:
- inline SpaceSetMap* GetLargeObjects() const {
- return large_objects_;
- }
+ const Heap* const heap_;
- void SetLargeObjects(SpaceSetMap* large_objects);
+ void AddSpaceBitmap(SpaceBitmap* bitmap);
- private:
+ typedef std::vector<SpaceBitmap*> Bitmaps;
+ Bitmaps bitmaps_;
- const Heap* const heap_;
+ // Large object sets.
+ SpaceSetMap* large_objects_;
- void AddSpaceBitmap(SpaceBitmap* bitmap);
+ friend class Heap;
+};
- typedef std::vector<SpaceBitmap*> Bitmaps;
- Bitmaps bitmaps_;
-
- // Large object sets.
- SpaceSetMap* large_objects_;
-
- friend class Heap;
- };
} // namespace art
-#endif // ART_SRC_HEAP_BITMAP_H_
+#endif // ART_SRC_GC_HEAP_BITMAP_H_
diff --git a/src/gc/large_object_space.cc b/src/gc/large_object_space.cc
index 1b93e5d..69320fa 100644
--- a/src/gc/large_object_space.cc
+++ b/src/gc/large_object_space.cc
@@ -22,6 +22,7 @@
#include "image.h"
#include "os.h"
#include "space_bitmap.h"
+#include "thread.h"
#include "utils.h"
namespace art {
@@ -58,13 +59,13 @@
return new LargeObjectMapSpace(name);
}
-Object* LargeObjectMapSpace::Alloc(Thread* self, size_t num_bytes) {
+mirror::Object* LargeObjectMapSpace::Alloc(Thread* self, size_t num_bytes) {
MemMap* mem_map = MemMap::MapAnonymous("allocation", NULL, num_bytes, PROT_READ | PROT_WRITE);
if (mem_map == NULL) {
return NULL;
}
MutexLock mu(self, lock_);
- Object* obj = reinterpret_cast<Object*>(mem_map->Begin());
+ mirror::Object* obj = reinterpret_cast<mirror::Object*>(mem_map->Begin());
large_objects_.push_back(obj);
mem_maps_.Put(obj, mem_map);
size_t allocation_size = mem_map->Size();
@@ -75,7 +76,7 @@
return obj;
}
-size_t LargeObjectMapSpace::Free(Thread* self, Object* ptr) {
+size_t LargeObjectMapSpace::Free(Thread* self, mirror::Object* ptr) {
MutexLock mu(self, lock_);
MemMaps::iterator found = mem_maps_.find(ptr);
CHECK(found != mem_maps_.end()) << "Attempted to free large object which was not live";
@@ -88,14 +89,14 @@
return allocation_size;
}
-size_t LargeObjectMapSpace::AllocationSize(const Object* obj) {
+size_t LargeObjectMapSpace::AllocationSize(const mirror::Object* obj) {
MutexLock mu(Thread::Current(), lock_);
- MemMaps::iterator found = mem_maps_.find(const_cast<Object*>(obj));
+ MemMaps::iterator found = mem_maps_.find(const_cast<mirror::Object*>(obj));
CHECK(found != mem_maps_.end()) << "Attempted to get size of a large object which is not live";
return found->second->Size();
}
-size_t LargeObjectSpace::FreeList(Thread* self, size_t num_ptrs, Object** ptrs) {
+size_t LargeObjectSpace::FreeList(Thread* self, size_t num_ptrs, mirror::Object** ptrs) {
size_t total = 0;
for (size_t i = 0; i < num_ptrs; ++i) {
if (kDebugSpaces) {
@@ -115,9 +116,9 @@
}
}
-bool LargeObjectMapSpace::Contains(const Object* obj) const {
+bool LargeObjectMapSpace::Contains(const mirror::Object* obj) const {
MutexLock mu(Thread::Current(), lock_);
- return mem_maps_.find(const_cast<Object*>(obj)) != mem_maps_.end();
+ return mem_maps_.find(const_cast<mirror::Object*>(obj)) != mem_maps_.end();
}
FreeListSpace* FreeListSpace::Create(const std::string& name, byte* requested_begin, size_t size) {
@@ -191,7 +192,7 @@
}
}
-size_t FreeListSpace::Free(Thread* self, Object* obj) {
+size_t FreeListSpace::Free(Thread* self, mirror::Object* obj) {
MutexLock mu(self, lock_);
CHECK(Contains(obj));
// Check adjacent chunks to see if we need to combine.
@@ -220,7 +221,7 @@
return allocation_size;
}
-bool FreeListSpace::Contains(const Object* obj) const {
+bool FreeListSpace::Contains(const mirror::Object* obj) const {
return mem_map_->HasAddress(obj);
}
@@ -228,13 +229,13 @@
return chunk + chunk->GetSize() / kAlignment;
}
-size_t FreeListSpace::AllocationSize(const Object* obj) {
- Chunk* chunk = ChunkFromAddr(const_cast<Object*>(obj));
+size_t FreeListSpace::AllocationSize(const mirror::Object* obj) {
+ Chunk* chunk = ChunkFromAddr(const_cast<mirror::Object*>(obj));
CHECK(!chunk->IsFree());
return chunk->GetSize();
}
-Object* FreeListSpace::Alloc(Thread* self, size_t num_bytes) {
+mirror::Object* FreeListSpace::Alloc(Thread* self, size_t num_bytes) {
MutexLock mu(self, lock_);
num_bytes = RoundUp(num_bytes, kAlignment);
Chunk temp;
@@ -261,7 +262,7 @@
total_objects_allocated_++;
num_bytes_allocated_ += num_bytes;
total_bytes_allocated_ += num_bytes;
- return reinterpret_cast<Object*>(addr);
+ return reinterpret_cast<mirror::Object*>(addr);
}
void FreeListSpace::Dump(std::ostream& os) const{
diff --git a/src/gc/large_object_space.h b/src/gc/large_object_space.h
index 979fce6..c34dbcc 100644
--- a/src/gc/large_object_space.h
+++ b/src/gc/large_object_space.h
@@ -18,8 +18,13 @@
#define ART_SRC_GC_LARGE_OBJECT_SPACE_H_
#include "space.h"
+#include "safe_map.h"
+
+#include <set>
+#include <vector>
namespace art {
+class SpaceSetMap;
class LargeObjectSpace : public DiscontinuousSpace, public AllocSpace {
public:
@@ -64,7 +69,7 @@
return total_objects_allocated_;
}
- size_t FreeList(Thread* self, size_t num_ptrs, Object** ptrs);
+ size_t FreeList(Thread* self, size_t num_ptrs, mirror::Object** ptrs);
protected:
@@ -90,19 +95,19 @@
static LargeObjectMapSpace* Create(const std::string& name);
// Return the storage space required by obj.
- virtual size_t AllocationSize(const Object* obj);
- virtual Object* Alloc(Thread* self, size_t num_bytes);
- size_t Free(Thread* self, Object* ptr);
+ virtual size_t AllocationSize(const mirror::Object* obj);
+ virtual mirror::Object* Alloc(Thread* self, size_t num_bytes);
+ size_t Free(Thread* self, mirror::Object* ptr);
virtual void Walk(DlMallocSpace::WalkCallback, void* arg);
- virtual bool Contains(const Object* obj) const;
+ virtual bool Contains(const mirror::Object* obj) const;
private:
LargeObjectMapSpace(const std::string& name);
virtual ~LargeObjectMapSpace() {}
// Used to ensure mutual exclusion when the allocation spaces data structures are being modified.
mutable Mutex lock_;
- std::vector<Object*> large_objects_;
- typedef SafeMap<Object*, MemMap*> MemMaps;
+ std::vector<mirror::Object*> large_objects_;
+ typedef SafeMap<mirror::Object*, MemMap*> MemMaps;
MemMaps mem_maps_;
};
@@ -111,10 +116,10 @@
virtual ~FreeListSpace();
static FreeListSpace* Create(const std::string& name, byte* requested_begin, size_t capacity);
- size_t AllocationSize(const Object* obj);
- Object* Alloc(Thread* self, size_t num_bytes);
- size_t Free(Thread* self, Object* obj);
- bool Contains(const Object* obj) const;
+ size_t AllocationSize(const mirror::Object* obj);
+ mirror::Object* Alloc(Thread* self, size_t num_bytes);
+ size_t Free(Thread* self, mirror::Object* obj);
+ bool Contains(const mirror::Object* obj) const;
void Walk(DlMallocSpace::WalkCallback callback, void* arg);
// Address at which the space begins
diff --git a/src/gc/mark_sweep-inl.h b/src/gc/mark_sweep-inl.h
new file mode 100644
index 0000000..7265023
--- /dev/null
+++ b/src/gc/mark_sweep-inl.h
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2011 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_GC_MARK_SWEEP_INL_H_
+#define ART_SRC_GC_MARK_SWEEP_INL_H_
+
+#include "heap.h"
+#include "mirror/class.h"
+#include "mirror/field.h"
+#include "mirror/object_array.h"
+
+namespace art {
+
+template <typename MarkVisitor>
+inline void MarkSweep::ScanObjectVisit(const mirror::Object* obj, const MarkVisitor& visitor) {
+ DCHECK(obj != NULL);
+ if (kIsDebugBuild && !IsMarked(obj)) {
+ heap_->DumpSpaces();
+ LOG(FATAL) << "Scanning unmarked object " << obj;
+ }
+ mirror::Class* klass = obj->GetClass();
+ DCHECK(klass != NULL);
+ if (klass == java_lang_Class_) {
+ DCHECK_EQ(klass->GetClass(), java_lang_Class_);
+ if (kCountScannedTypes) {
+ ++class_count_;
+ }
+ VisitClassReferences(klass, obj, visitor);
+ } else if (klass->IsArrayClass()) {
+ if (kCountScannedTypes) {
+ ++array_count_;
+ }
+ visitor(obj, klass, mirror::Object::ClassOffset(), false);
+ if (klass->IsObjectArrayClass()) {
+ VisitObjectArrayReferences(obj->AsObjectArray<mirror::Object>(), visitor);
+ }
+ } else {
+ if (kCountScannedTypes) {
+ ++other_count_;
+ }
+ VisitOtherReferences(klass, obj, visitor);
+ if (UNLIKELY(klass->IsReferenceClass())) {
+ DelayReferenceReferent(const_cast<mirror::Object*>(obj));
+ }
+ }
+}
+
+template <typename Visitor>
+inline void MarkSweep::VisitObjectReferences(const mirror::Object* obj, const Visitor& visitor)
+ SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_,
+ Locks::mutator_lock_) {
+ DCHECK(obj != NULL);
+ DCHECK(obj->GetClass() != NULL);
+
+ mirror::Class* klass = obj->GetClass();
+ DCHECK(klass != NULL);
+ if (klass == mirror::Class::GetJavaLangClass()) {
+ DCHECK_EQ(klass->GetClass(), mirror::Class::GetJavaLangClass());
+ VisitClassReferences(klass, obj, visitor);
+ } else {
+ if (klass->IsArrayClass()) {
+ visitor(obj, klass, mirror::Object::ClassOffset(), false);
+ if (klass->IsObjectArrayClass()) {
+ VisitObjectArrayReferences(obj->AsObjectArray<mirror::Object>(), visitor);
+ }
+ } else {
+ VisitOtherReferences(klass, obj, visitor);
+ }
+ }
+}
+
+template <typename Visitor>
+inline void MarkSweep::VisitInstanceFieldsReferences(const mirror::Class* klass,
+ const mirror::Object* obj,
+ const Visitor& visitor)
+ SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_) {
+ DCHECK(obj != NULL);
+ DCHECK(klass != NULL);
+ VisitFieldsReferences(obj, klass->GetReferenceInstanceOffsets(), false, visitor);
+}
+
+template <typename Visitor>
+inline void MarkSweep::VisitClassReferences(const mirror::Class* klass, const mirror::Object* obj,
+ const Visitor& visitor)
+ SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_) {
+ VisitInstanceFieldsReferences(klass, obj, visitor);
+ VisitStaticFieldsReferences(obj->AsClass(), visitor);
+}
+
+template <typename Visitor>
+inline void MarkSweep::VisitStaticFieldsReferences(const mirror::Class* klass,
+ const Visitor& visitor)
+ SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_) {
+ DCHECK(klass != NULL);
+ VisitFieldsReferences(klass, klass->GetReferenceStaticOffsets(), true, visitor);
+}
+
+template <typename Visitor>
+inline void MarkSweep::VisitFieldsReferences(const mirror::Object* obj, uint32_t ref_offsets,
+ bool is_static, const Visitor& visitor) {
+ if (LIKELY(ref_offsets != CLASS_WALK_SUPER)) {
+ // Found a reference offset bitmap. Mark the specified offsets.
+ while (ref_offsets != 0) {
+ size_t right_shift = CLZ(ref_offsets);
+ MemberOffset field_offset = CLASS_OFFSET_FROM_CLZ(right_shift);
+ const mirror::Object* ref = obj->GetFieldObject<const mirror::Object*>(field_offset, false);
+ visitor(obj, ref, field_offset, is_static);
+ ref_offsets &= ~(CLASS_HIGH_BIT >> right_shift);
+ }
+ } else {
+ // There is no reference offset bitmap. In the non-static case,
+ // walk up the class inheritance hierarchy and find reference
+ // offsets the hard way. In the static case, just consider this
+ // class.
+ for (const mirror::Class* klass = is_static ? obj->AsClass() : obj->GetClass();
+ klass != NULL;
+ klass = is_static ? NULL : klass->GetSuperClass()) {
+ size_t num_reference_fields = (is_static
+ ? klass->NumReferenceStaticFields()
+ : klass->NumReferenceInstanceFields());
+ for (size_t i = 0; i < num_reference_fields; ++i) {
+ mirror::Field* field = (is_static ? klass->GetStaticField(i)
+ : klass->GetInstanceField(i));
+ MemberOffset field_offset = field->GetOffset();
+ const mirror::Object* ref = obj->GetFieldObject<const mirror::Object*>(field_offset, false);
+ visitor(obj, ref, field_offset, is_static);
+ }
+ }
+ }
+}
+
+template <typename Visitor>
+inline void MarkSweep::VisitObjectArrayReferences(const mirror::ObjectArray<mirror::Object>* array,
+ const Visitor& visitor) {
+ const int32_t length = array->GetLength();
+ for (int32_t i = 0; i < length; ++i) {
+ const mirror::Object* element = array->GetWithoutChecks(i);
+ const size_t width = sizeof(mirror::Object*);
+ MemberOffset offset = MemberOffset(i * width + mirror::Array::DataOffset(width).Int32Value());
+ visitor(array, element, offset, false);
+ }
+}
+
+} // namespace art
+
+#endif // ART_SRC_GC_MARK_SWEEP_INL_H_
diff --git a/src/gc/mark_sweep.cc b/src/gc/mark_sweep.cc
index 7c52c83..40102b2 100644
--- a/src/gc/mark_sweep.cc
+++ b/src/gc/mark_sweep.cc
@@ -25,22 +25,32 @@
#include "base/logging.h"
#include "base/macros.h"
#include "card_table.h"
-#include "class_loader.h"
-#include "dex_cache.h"
+#include "card_table-inl.h"
#include "heap.h"
#include "indirect_reference_table.h"
#include "intern_table.h"
#include "jni_internal.h"
#include "large_object_space.h"
#include "monitor.h"
-#include "object.h"
+#include "mark_sweep-inl.h"
+#include "mirror/class-inl.h"
+#include "mirror/class_loader.h"
+#include "mirror/dex_cache.h"
+#include "mirror/field.h"
+#include "mirror/field-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array.h"
+#include "mirror/object_array-inl.h"
#include "runtime.h"
#include "space.h"
+#include "space_bitmap-inl.h"
#include "timing_logger.h"
#include "thread.h"
#include "thread_list.h"
#include "verifier/method_verifier.h"
+using namespace art::mirror;
+
namespace art {
// Performance options.
@@ -186,7 +196,7 @@
timings_.AddSplit("ReMarkRoots");
// Scan dirty objects, this is only required if we are not doing concurrent GC.
- RecursiveMarkDirtyObjects();
+ RecursiveMarkDirtyObjects(CardTable::kCardDirty);
}
ProcessReferences(self);
@@ -700,7 +710,7 @@
Runtime::Current()->VisitRoots(ReMarkObjectVisitor, this);
}
-void MarkSweep::SweepJniWeakGlobals(Heap::IsMarkedTester is_marked, void* arg) {
+void MarkSweep::SweepJniWeakGlobals(IsMarkedTester is_marked, void* arg) {
JavaVMExt* vm = Runtime::Current()->GetJavaVM();
MutexLock mu(Thread::Current(), vm->weak_globals_lock);
IndirectReferenceTable* table = &vm->weak_globals;
diff --git a/src/gc/mark_sweep.h b/src/gc/mark_sweep.h
index 3581d98..0d43bee 100644
--- a/src/gc/mark_sweep.h
+++ b/src/gc/mark_sweep.h
@@ -14,28 +14,38 @@
* limitations under the License.
*/
-#ifndef ART_SRC_MARK_SWEEP_H_
-#define ART_SRC_MARK_SWEEP_H_
+#ifndef ART_SRC_GC_MARK_SWEEP_H_
+#define ART_SRC_GC_MARK_SWEEP_H_
-#include "atomic_stack.h"
+#include "atomic_integer.h"
#include "base/macros.h"
+#include "base/mutex.h"
#include "garbage_collector.h"
-#include "heap_bitmap.h"
-#include "object.h"
+#include "gc_type.h"
#include "offsets.h"
+#include "root_visitor.h"
+#include "timing_logger.h"
+#include "UniquePtr.h"
namespace art {
-
+namespace mirror {
+class Class;
+class Object;
+template<class T> class ObjectArray;
+}
+template <typename T> class AtomicStack;
class Barrier;
class CheckObjectVisitor;
-class Class;
+class ContinuousSpace;
class Heap;
class MarkIfReachesAllocspaceVisitor;
class ModUnionClearCardVisitor;
class ModUnionVisitor;
class ModUnionTableBitmap;
-class Object;
-class TimingLogger;
+typedef AtomicStack<mirror::Object*> ObjectStack;
+class SpaceBitmap;
+class StackVisitor;
+class Thread;
class MarkStackChunk;
class MarkSweep : public GarbageCollector {
@@ -79,7 +89,9 @@
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
// Verify that image roots point to only marked objects within the alloc space.
- void VerifyImageRoots() EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
+ void VerifyImageRoots()
+ EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Builds a mark stack and recursively mark until it empties.
void RecursiveMark()
@@ -88,8 +100,8 @@
// Make a space immune, immune spaces are assumed to have all live objects marked.
void ImmuneSpace(ContinuousSpace* space)
- EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);;
+ EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Bind the live bits to the mark bits of bitmaps based on the gc type.
virtual void BindBitmaps()
@@ -102,7 +114,7 @@
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
// Builds a mark stack with objects on dirty cards and recursively mark until it empties.
- void RecursiveMarkDirtyObjects(byte minimum_age = CardTable::kCardDirty)
+ void RecursiveMarkDirtyObjects(byte minimum_age)
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -130,61 +142,31 @@
virtual void SwapBitmaps() EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
void SwapLargeObjects() EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
- Object* GetClearedReferences() {
+ mirror::Object* GetClearedReferences() {
return cleared_reference_list_;
}
// Proxy for external access to ScanObject.
- void ScanRoot(const Object* obj)
+ void ScanRoot(const mirror::Object* obj)
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Blackens an object.
- void ScanObject(const Object* obj)
+ void ScanObject(const mirror::Object* obj)
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ // TODO: enable thread safety analysis when in use by multiple worker threads.
template <typename MarkVisitor>
- void ScanObjectVisit(const Object* obj, const MarkVisitor& visitor)
- NO_THREAD_SAFETY_ANALYSIS {
- DCHECK(obj != NULL);
- if (kIsDebugBuild && !IsMarked(obj)) {
- heap_->DumpSpaces();
- LOG(FATAL) << "Scanning unmarked object " << obj;
- }
- Class* klass = obj->GetClass();
- DCHECK(klass != NULL);
- if (klass == java_lang_Class_) {
- DCHECK_EQ(klass->GetClass(), java_lang_Class_);
- if (kCountScannedTypes) {
- ++class_count_;
- }
- VisitClassReferences(klass, obj, visitor);
- } else if (klass->IsArrayClass()) {
- if (kCountScannedTypes) {
- ++array_count_;
- }
- visitor(obj, klass, Object::ClassOffset(), false);
- if (klass->IsObjectArrayClass()) {
- VisitObjectArrayReferences(obj->AsObjectArray<Object>(), visitor);
- }
- } else {
- if (kCountScannedTypes) {
- ++other_count_;
- }
- VisitOtherReferences(klass, obj, visitor);
- if (UNLIKELY(klass->IsReferenceClass())) {
- DelayReferenceReferent(const_cast<Object*>(obj));
- }
- }
- }
+ void ScanObjectVisit(const mirror::Object* obj, const MarkVisitor& visitor)
+ NO_THREAD_SAFETY_ANALYSIS;
- void SetFinger(Object* new_finger) {
+ void SetFinger(mirror::Object* new_finger) {
finger_ = new_finger;
}
void DisableFinger() {
- SetFinger(reinterpret_cast<Object*>(~static_cast<uintptr_t>(0)));
+ SetFinger(reinterpret_cast<mirror::Object*>(~static_cast<uintptr_t>(0)));
}
size_t GetFreedBytes() const {
@@ -212,7 +194,7 @@
}
// Everything inside the immune range is assumed to be marked.
- void SetImmuneRange(Object* begin, Object* end);
+ void SetImmuneRange(mirror::Object* begin, mirror::Object* end);
void SweepSystemWeaks()
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
@@ -221,52 +203,33 @@
void SweepSystemWeaksArray(ObjectStack* allocations)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
- static bool VerifyIsLiveCallback(const Object* obj, void* arg)
+ static bool VerifyIsLiveCallback(const mirror::Object* obj, void* arg)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
void VerifySystemWeaks()
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
// Verify that an object is live, either in a live bitmap or in the allocation stack.
- void VerifyIsLive(const Object* obj)
+ void VerifyIsLive(const mirror::Object* obj)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
template <typename Visitor>
- static void VisitObjectReferences(const Object* obj, const Visitor& visitor)
+ static void VisitObjectReferences(const mirror::Object* obj, const Visitor& visitor)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_,
- Locks::mutator_lock_) {
- DCHECK(obj != NULL);
- DCHECK(obj->GetClass() != NULL);
+ Locks::mutator_lock_);
- Class* klass = obj->GetClass();
- DCHECK(klass != NULL);
- if (klass == Class::GetJavaLangClass()) {
- DCHECK_EQ(klass->GetClass(), Class::GetJavaLangClass());
- VisitClassReferences(klass, obj, visitor);
- } else {
- if (klass->IsArrayClass()) {
- visitor(obj, klass, Object::ClassOffset(), false);
- if (klass->IsObjectArrayClass()) {
- VisitObjectArrayReferences(obj->AsObjectArray<Object>(), visitor);
- }
- } else {
- VisitOtherReferences(klass, obj, visitor);
- }
- }
- }
-
- static void MarkObjectCallback(const Object* root, void* arg)
+ static void MarkObjectCallback(const mirror::Object* root, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
- static void MarkRootParallelCallback(const Object* root, void* arg);
+ static void MarkRootParallelCallback(const mirror::Object* root, void* arg);
// Marks an object.
- void MarkObject(const Object* obj)
+ void MarkObject(const mirror::Object* obj)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
- void MarkRoot(const Object* obj)
+ void MarkRoot(const mirror::Object* obj)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
@@ -277,45 +240,46 @@
protected:
// Returns true if the object has its bit set in the mark bitmap.
- bool IsMarked(const Object* object) const;
+ bool IsMarked(const mirror::Object* object) const;
- static bool IsMarkedCallback(const Object* object, void* arg)
+ static bool IsMarkedCallback(const mirror::Object* object, void* arg)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
- static bool IsMarkedArrayCallback(const Object* object, void* arg)
+ static bool IsMarkedArrayCallback(const mirror::Object* object, void* arg)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
- static void ReMarkObjectVisitor(const Object* root, void* arg)
+ static void ReMarkObjectVisitor(const mirror::Object* root, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
- static void VerifyImageRootVisitor(Object* root, void* arg)
+ static void VerifyImageRootVisitor(mirror::Object* root, void* arg)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_,
Locks::mutator_lock_);
- void MarkObjectNonNull(const Object* obj, bool check_finger)
+ void MarkObjectNonNull(const mirror::Object* obj, bool check_finger)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
- void MarkObjectNonNullParallel(const Object* obj, bool check_finger);
+ void MarkObjectNonNullParallel(const mirror::Object* obj, bool check_finger);
- bool MarkLargeObject(const Object* obj)
+ bool MarkLargeObject(const mirror::Object* obj)
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
// Returns true if we need to add obj to a mark stack.
- bool MarkObjectParallel(const Object* obj) NO_THREAD_SAFETY_ANALYSIS;
+ bool MarkObjectParallel(const mirror::Object* obj) NO_THREAD_SAFETY_ANALYSIS;
- static void SweepCallback(size_t num_ptrs, Object** ptrs, void* arg)
+ static void SweepCallback(size_t num_ptrs, mirror::Object** ptrs, void* arg)
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
// Special sweep for zygote that just marks objects / dirties cards.
- static void ZygoteSweepCallback(size_t num_ptrs, Object** ptrs, void* arg)
+ static void ZygoteSweepCallback(size_t num_ptrs, mirror::Object** ptrs, void* arg)
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
- void CheckReference(const Object* obj, const Object* ref, MemberOffset offset, bool is_static)
+ void CheckReference(const mirror::Object* obj, const mirror::Object* ref, MemberOffset offset,
+ bool is_static)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
- void CheckObject(const Object* obj)
+ void CheckObject(const mirror::Object* obj)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
// Verify the roots of the heap and print out information related to any invalid roots.
@@ -326,90 +290,41 @@
// Expand mark stack to 2x its current size. Thread safe.
void ExpandMarkStack();
- static void VerifyRootCallback(const Object* root, void* arg, size_t vreg,
+ static void VerifyRootCallback(const mirror::Object* root, void* arg, size_t vreg,
const StackVisitor *visitor);
- void VerifyRoot(const Object* root, size_t vreg, const StackVisitor* visitor)
+ void VerifyRoot(const mirror::Object* root, size_t vreg, const StackVisitor* visitor)
NO_THREAD_SAFETY_ANALYSIS;
template <typename Visitor>
- static void VisitInstanceFieldsReferences(const Class* klass, const Object* obj,
+ static void VisitInstanceFieldsReferences(const mirror::Class* klass, const mirror::Object* obj,
const Visitor& visitor)
- SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_) {
- DCHECK(obj != NULL);
- DCHECK(klass != NULL);
- VisitFieldsReferences(obj, klass->GetReferenceInstanceOffsets(), false, visitor);
- }
+ SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
// Visit the header, static field references, and interface pointers of a class object.
template <typename Visitor>
- static void VisitClassReferences(const Class* klass, const Object* obj,
+ static void VisitClassReferences(const mirror::Class* klass, const mirror::Object* obj,
const Visitor& visitor)
- SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_) {
- VisitInstanceFieldsReferences(klass, obj, visitor);
- VisitStaticFieldsReferences(obj->AsClass(), visitor);
- }
+ SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
template <typename Visitor>
- static void VisitStaticFieldsReferences(const Class* klass, const Visitor& visitor)
- SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_) {
- DCHECK(klass != NULL);
- VisitFieldsReferences(klass, klass->GetReferenceStaticOffsets(), true, visitor);
- }
+ static void VisitStaticFieldsReferences(const mirror::Class* klass, const Visitor& visitor)
+ SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
template <typename Visitor>
- static void VisitFieldsReferences(const Object* obj, uint32_t ref_offsets, bool is_static,
- const Visitor& visitor)
- SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_) {
- if (LIKELY(ref_offsets != CLASS_WALK_SUPER)) {
- // Found a reference offset bitmap. Mark the specified offsets.
- while (ref_offsets != 0) {
- size_t right_shift = CLZ(ref_offsets);
- MemberOffset field_offset = CLASS_OFFSET_FROM_CLZ(right_shift);
- const Object* ref = obj->GetFieldObject<const Object*>(field_offset, false);
- visitor(obj, ref, field_offset, is_static);
- ref_offsets &= ~(CLASS_HIGH_BIT >> right_shift);
- }
- } else {
- // There is no reference offset bitmap. In the non-static case,
- // walk up the class inheritance hierarchy and find reference
- // offsets the hard way. In the static case, just consider this
- // class.
- for (const Class* klass = is_static ? obj->AsClass() : obj->GetClass();
- klass != NULL;
- klass = is_static ? NULL : klass->GetSuperClass()) {
- size_t num_reference_fields = (is_static
- ? klass->NumReferenceStaticFields()
- : klass->NumReferenceInstanceFields());
- for (size_t i = 0; i < num_reference_fields; ++i) {
- Field* field = (is_static
- ? klass->GetStaticField(i)
- : klass->GetInstanceField(i));
- MemberOffset field_offset = field->GetOffset();
- const Object* ref = obj->GetFieldObject<const Object*>(field_offset, false);
- visitor(obj, ref, field_offset, is_static);
- }
- }
- }
- }
+ static void VisitFieldsReferences(const mirror::Object* obj, uint32_t ref_offsets, bool is_static,
+ const Visitor& visitor)
+ SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
// Visit all of the references in an object array.
template <typename Visitor>
- static void VisitObjectArrayReferences(const ObjectArray<Object>* array,
+ static void VisitObjectArrayReferences(const mirror::ObjectArray<mirror::Object>* array,
const Visitor& visitor)
- SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_) {
- const int32_t length = array->GetLength();
- for (int32_t i = 0; i < length; ++i) {
- const Object* element = array->GetWithoutChecks(i);
- const size_t width = sizeof(Object*);
- MemberOffset offset = MemberOffset(i * width + Array::DataOffset(width).Int32Value());
- visitor(array, element, offset, false);
- }
- }
+ SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
// Visits the header and field references of a data object.
template <typename Visitor>
- static void VisitOtherReferences(const Class* klass, const Object* obj,
+ static void VisitOtherReferences(const mirror::Class* klass, const mirror::Object* obj,
const Visitor& visitor)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_) {
return VisitInstanceFieldsReferences(klass, obj, visitor);
@@ -421,7 +336,7 @@
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Schedules an unmarked object for reference processing.
- void DelayReferenceReferent(Object* reference)
+ void DelayReferenceReferent(mirror::Object* reference)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
// Recursively blackens objects on the mark stack.
@@ -433,25 +348,25 @@
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void EnqueueFinalizerReferences(Object** ref)
+ void EnqueueFinalizerReferences(mirror::Object** ref)
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void PreserveSomeSoftReferences(Object** ref)
+ void PreserveSomeSoftReferences(mirror::Object** ref)
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void ClearWhiteReferences(Object** list)
+ void ClearWhiteReferences(mirror::Object** list)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
- void ProcessReferences(Object** soft_references, bool clear_soft_references,
- Object** weak_references,
- Object** finalizer_references,
- Object** phantom_references)
+ void ProcessReferences(mirror::Object** soft_references, bool clear_soft_references,
+ mirror::Object** weak_references,
+ mirror::Object** finalizer_references,
+ mirror::Object** phantom_references)
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void SweepJniWeakGlobals(Heap::IsMarkedTester is_marked, void* arg)
+ void SweepJniWeakGlobals(IsMarkedTester is_marked, void* arg)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
// Whether or not we count how many of each type of object were scanned.
@@ -461,21 +376,21 @@
SpaceBitmap* current_mark_bitmap_;
// Cache java.lang.Class for optimization.
- Class* java_lang_Class_;
+ mirror::Class* java_lang_Class_;
ObjectStack* mark_stack_;
- Object* finger_;
+ mirror::Object* finger_;
// Immune range, every object inside the immune range is assumed to be marked.
- Object* immune_begin_;
- Object* immune_end_;
+ mirror::Object* immune_begin_;
+ mirror::Object* immune_end_;
- Object* soft_reference_list_;
- Object* weak_reference_list_;
- Object* finalizer_reference_list_;
- Object* phantom_reference_list_;
- Object* cleared_reference_list_;
+ mirror::Object* soft_reference_list_;
+ mirror::Object* weak_reference_list_;
+ mirror::Object* finalizer_reference_list_;
+ mirror::Object* phantom_reference_list_;
+ mirror::Object* cleared_reference_list_;
AtomicInteger freed_bytes_;
AtomicInteger freed_objects_;
@@ -529,4 +444,4 @@
} // namespace art
-#endif // ART_SRC_MARK_SWEEP_H_
+#endif // ART_SRC_GC_MARK_SWEEP_H_
diff --git a/src/gc/mod_union_table-inl.h b/src/gc/mod_union_table-inl.h
new file mode 100644
index 0000000..c1c69fb
--- /dev/null
+++ b/src/gc/mod_union_table-inl.h
@@ -0,0 +1,64 @@
+/*
+ * 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_GC_MOD_UNION_TABLE_INL_H_
+#define ART_SRC_GC_MOD_UNION_TABLE_INL_H_
+
+#include "mod_union_table.h"
+
+namespace art {
+
+template <typename Implementation>
+class ModUnionTableToZygoteAllocspace : public Implementation {
+public:
+ ModUnionTableToZygoteAllocspace(Heap* heap) : Implementation(heap) {
+ }
+
+ bool AddReference(const mirror::Object* /* obj */, const mirror::Object* ref) {
+ const Spaces& spaces = Implementation::GetHeap()->GetSpaces();
+ for (Spaces::const_iterator it = spaces.begin(); it != spaces.end(); ++it) {
+ if ((*it)->Contains(ref)) {
+ return (*it)->IsAllocSpace();
+ }
+ }
+ // Assume it points to a large object.
+ // TODO: Check.
+ return true;
+ }
+};
+
+template <typename Implementation>
+class ModUnionTableToAllocspace : public Implementation {
+public:
+ ModUnionTableToAllocspace(Heap* heap) : Implementation(heap) {
+ }
+
+ bool AddReference(const mirror::Object* /* obj */, const mirror::Object* ref) {
+ const Spaces& spaces = Implementation::GetHeap()->GetSpaces();
+ for (Spaces::const_iterator it = spaces.begin(); it != spaces.end(); ++it) {
+ if ((*it)->Contains(ref)) {
+ return (*it)->GetGcRetentionPolicy() == kGcRetentionPolicyAlwaysCollect;
+ }
+ }
+ // Assume it points to a large object.
+ // TODO: Check.
+ return true;
+ }
+};
+
+} // namespace art
+
+#endif // ART_SRC_GC_MOD_UNION_TABLE_INL_H_
diff --git a/src/gc/mod_union_table.cc b/src/gc/mod_union_table.cc
index 8953c5a..da950bb 100644
--- a/src/gc/mod_union_table.cc
+++ b/src/gc/mod_union_table.cc
@@ -17,12 +17,22 @@
#include "mod_union_table.h"
#include "base/stl_util.h"
+#include "card_table-inl.h"
#include "heap.h"
#include "heap_bitmap.h"
#include "mark_sweep.h"
+#include "mark_sweep-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/class-inl.h"
+#include "mirror/field-inl.h"
+#include "mirror/object_array-inl.h"
#include "space.h"
+#include "space_bitmap-inl.h"
+#include "thread.h"
#include "UniquePtr.h"
+using namespace art::mirror;
+
namespace art {
class MarkIfReachesAllocspaceVisitor {
@@ -260,7 +270,7 @@
// TODO: Fixme when anotatalysis works with visitors.
void operator ()(const Object* obj, const Object* ref, const MemberOffset& /* offset */,
bool /* is_static */) const
- SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) {
+ SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_) {
Heap* heap = mod_union_table_->GetHeap();
if (ref != NULL && mod_union_table_->AddReference(obj, ref) &&
references_.find(ref) == references_.end()) {
diff --git a/src/gc/mod_union_table.h b/src/gc/mod_union_table.h
index f3da41c..23c0a51 100644
--- a/src/gc/mod_union_table.h
+++ b/src/gc/mod_union_table.h
@@ -14,23 +14,30 @@
* limitations under the License.
*/
-#ifndef ART_SRC_MOD_UNION_TABLE_H_
-#define ART_SRC_MOD_UNION_TABLE_H_
+#ifndef ART_SRC_GC_MOD_UNION_TABLE_H_
+#define ART_SRC_GC_MOD_UNION_TABLE_H_
-#include "heap.h"
+#include "globals.h"
#include "safe_map.h"
-#include "space.h"
+
+#include <set>
+#include <vector>
namespace art {
-
+namespace mirror {
+class Object;
+}
+class ContinuousSpace;
class Heap;
class HeapBitmap;
+class MarkSweep;
class Space;
+class SpaceBitmap;
// Base class
class ModUnionTable {
public:
- typedef std::vector<const Object*> ReferenceArray;
+ typedef std::vector<const mirror::Object*> ReferenceArray;
typedef std::set<byte*> ClearedCards;
ModUnionTable(Heap* heap) : heap_(heap) {
@@ -118,7 +125,7 @@
void Verify() EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
// Function that tells whether or not to add a reference to the table.
- virtual bool AddReference(const Object* obj, const Object* ref) = 0;
+ virtual bool AddReference(const mirror::Object* obj, const mirror::Object* ref) = 0;
protected:
// Cleared card array, used to update the mod-union table.
@@ -155,44 +162,6 @@
ClearedCards cleared_cards_;
};
-template <typename Implementation>
-class ModUnionTableToZygoteAllocspace : public Implementation {
-public:
- ModUnionTableToZygoteAllocspace(Heap* heap) : Implementation(heap) {
- }
-
- bool AddReference(const Object* /* obj */, const Object* ref) {
- const Spaces& spaces = Implementation::GetHeap()->GetSpaces();
- for (Spaces::const_iterator it = spaces.begin(); it != spaces.end(); ++it) {
- if ((*it)->Contains(ref)) {
- return (*it)->IsAllocSpace();
- }
- }
- // Assume it points to a large object.
- // TODO: Check.
- return true;
- }
-};
-
-template <typename Implementation>
-class ModUnionTableToAllocspace : public Implementation {
-public:
- ModUnionTableToAllocspace(Heap* heap) : Implementation(heap) {
- }
-
- bool AddReference(const Object* /* obj */, const Object* ref) {
- const Spaces& spaces = Implementation::GetHeap()->GetSpaces();
- for (Spaces::const_iterator it = spaces.begin(); it != spaces.end(); ++it) {
- if ((*it)->Contains(ref)) {
- return (*it)->GetGcRetentionPolicy() == kGcRetentionPolicyAlwaysCollect;
- }
- }
- // Assume it points to a large object.
- // TODO: Check.
- return true;
- }
-};
-
} // namespace art
-#endif // ART_SRC_MOD_UNION_TABLE_H_
+#endif // ART_SRC_GC_MOD_UNION_TABLE_H_
diff --git a/src/gc/partial_mark_sweep.cc b/src/gc/partial_mark_sweep.cc
index 64f09ff..f9c1787 100644
--- a/src/gc/partial_mark_sweep.cc
+++ b/src/gc/partial_mark_sweep.cc
@@ -14,32 +14,38 @@
* limitations under the License.
*/
+#include "partial_mark_sweep.h"
+
+#include "heap.h"
#include "large_object_space.h"
#include "partial_mark_sweep.h"
#include "space.h"
+#include "thread.h"
namespace art {
- PartialMarkSweep::PartialMarkSweep(Heap* heap, bool is_concurrent)
- : MarkSweep(heap, is_concurrent) {
- cumulative_timings_.SetName(GetName());
- }
- PartialMarkSweep::~PartialMarkSweep() {
+PartialMarkSweep::PartialMarkSweep(Heap* heap, bool is_concurrent)
+ : MarkSweep(heap, is_concurrent) {
+ cumulative_timings_.SetName(GetName());
+}
- }
+PartialMarkSweep::~PartialMarkSweep() {
- void PartialMarkSweep::BindBitmaps() {
- MarkSweep::BindBitmaps();
+}
- Spaces& spaces = GetHeap()->GetSpaces();
- WriterMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_);
- // For partial GCs we need to bind the bitmap of the zygote space so that all objects in the
- // zygote space are viewed as marked.
- for (Spaces::iterator it = spaces.begin(); it != spaces.end(); ++it) {
- ContinuousSpace* space = *it;
- if (space->GetGcRetentionPolicy() == kGcRetentionPolicyFullCollect) {
- ImmuneSpace(space);
- }
+void PartialMarkSweep::BindBitmaps() {
+ MarkSweep::BindBitmaps();
+
+ Spaces& spaces = GetHeap()->GetSpaces();
+ WriterMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_);
+ // For partial GCs we need to bind the bitmap of the zygote space so that all objects in the
+ // zygote space are viewed as marked.
+ for (Spaces::iterator it = spaces.begin(); it != spaces.end(); ++it) {
+ ContinuousSpace* space = *it;
+ if (space->GetGcRetentionPolicy() == kGcRetentionPolicyFullCollect) {
+ ImmuneSpace(space);
}
}
+}
+
} // namespace art
diff --git a/src/gc/partial_mark_sweep.h b/src/gc/partial_mark_sweep.h
index 80a1563..64c0bcd 100644
--- a/src/gc/partial_mark_sweep.h
+++ b/src/gc/partial_mark_sweep.h
@@ -14,27 +14,14 @@
* limitations under the License.
*/
-#ifndef ART_SRC_PARTIAL_MARK_SWEEP_H_
-#define ART_SRC_PARTIAL_MARK_SWEEP_H_
+#ifndef ART_SRC_GC_PARTIAL_MARK_SWEEP_H_
+#define ART_SRC_GC_PARTIAL_MARK_SWEEP_H_
#include "locks.h"
#include "mark_sweep.h"
-#include "utils.h"
namespace art {
-class Barrier;
-class CheckObjectVisitor;
-class Class;
-class Heap;
-class MarkIfReachesAllocspaceVisitor;
-class ModUnionClearCardVisitor;
-class ModUnionVisitor;
-class ModUnionTableBitmap;
-class Object;
-class TimingLogger;
-class MarkStackChunk;
-
class PartialMarkSweep : public MarkSweep {
public:
virtual GcType GetGcType() const {
@@ -53,4 +40,4 @@
} // namespace art
-#endif // ART_SRC_PARTIAL_MARK_SWEEP_H_
+#endif // ART_SRC_GC_PARTIAL_MARK_SWEEP_H_
diff --git a/src/gc/space.cc b/src/gc/space.cc
index 04f932d..9db84f2 100644
--- a/src/gc/space.cc
+++ b/src/gc/space.cc
@@ -19,10 +19,16 @@
#include "base/logging.h"
#include "base/stl_util.h"
#include "base/unix_file/fd_file.h"
+#include "card_table.h"
#include "dlmalloc.h"
#include "image.h"
+#include "mirror/array.h"
+#include "mirror/abstract_method.h"
#include "os.h"
+#include "runtime.h"
#include "space_bitmap.h"
+#include "space_bitmap-inl.h"
+#include "thread.h"
#include "UniquePtr.h"
#include "utils.h"
@@ -204,12 +210,12 @@
mark_bitmap_->SetName(temp_name);
}
-Object* DlMallocSpace::AllocWithoutGrowthLocked(size_t num_bytes) {
+mirror::Object* DlMallocSpace::AllocWithoutGrowthLocked(size_t num_bytes) {
if (kDebugSpaces) {
num_bytes += sizeof(word);
}
- Object* result = reinterpret_cast<Object*>(mspace_calloc(mspace_, 1, num_bytes));
+ mirror::Object* result = reinterpret_cast<mirror::Object*>(mspace_calloc(mspace_, 1, num_bytes));
if (kDebugSpaces && result != NULL) {
CHECK(Contains(result)) << "Allocation (" << reinterpret_cast<void*>(result)
<< ") not in bounds of allocation space " << *this;
@@ -225,18 +231,18 @@
return result;
}
-Object* DlMallocSpace::Alloc(Thread* self, size_t num_bytes) {
+mirror::Object* DlMallocSpace::Alloc(Thread* self, size_t num_bytes) {
MutexLock mu(self, lock_);
return AllocWithoutGrowthLocked(num_bytes);
}
-Object* DlMallocSpace::AllocWithGrowth(Thread* self, size_t num_bytes) {
+mirror::Object* DlMallocSpace::AllocWithGrowth(Thread* self, size_t num_bytes) {
MutexLock mu(self, lock_);
// Grow as much as possible within the mspace.
size_t max_allowed = Capacity();
mspace_set_footprint_limit(mspace_, max_allowed);
// Try the allocation.
- Object* result = AllocWithoutGrowthLocked(num_bytes);
+ mirror::Object* result = AllocWithoutGrowthLocked(num_bytes);
// Shrink back down as small as possible.
size_t footprint = mspace_footprint(mspace_);
mspace_set_footprint_limit(mspace_, footprint);
@@ -301,7 +307,7 @@
return alloc_space;
}
-size_t DlMallocSpace::Free(Thread* self, Object* ptr) {
+size_t DlMallocSpace::Free(Thread* self, mirror::Object* ptr) {
MutexLock mu(self, lock_);
if (kDebugSpaces) {
CHECK(ptr != NULL);
@@ -317,13 +323,13 @@
return bytes_freed;
}
-size_t DlMallocSpace::FreeList(Thread* self, size_t num_ptrs, Object** ptrs) {
+size_t DlMallocSpace::FreeList(Thread* self, size_t num_ptrs, mirror::Object** ptrs) {
DCHECK(ptrs != NULL);
// Don't need the lock to calculate the size of the freed pointers.
size_t bytes_freed = 0;
for (size_t i = 0; i < num_ptrs; i++) {
- Object* ptr = ptrs[i];
+ mirror::Object* ptr = ptrs[i];
const size_t look_ahead = 8;
if (kPrefetchDuringDlMallocFreeList && i + look_ahead < num_ptrs) {
// The head of chunk for the allocation is sizeof(size_t) behind the allocation.
@@ -397,12 +403,12 @@
}
// Virtual functions can't get inlined.
-inline size_t DlMallocSpace::InternalAllocationSize(const Object* obj) {
+inline size_t DlMallocSpace::InternalAllocationSize(const mirror::Object* obj) {
return mspace_usable_size(const_cast<void*>(reinterpret_cast<const void*>(obj))) +
kChunkOverhead;
}
-size_t DlMallocSpace::AllocationSize(const Object* obj) {
+size_t DlMallocSpace::AllocationSize(const mirror::Object* obj) {
return InternalAllocationSize(obj);
}
@@ -504,29 +510,29 @@
DCHECK_EQ(0, memcmp(&image_header, map->Begin(), sizeof(ImageHeader)));
Runtime* runtime = Runtime::Current();
- Object* jni_stub_array = image_header.GetImageRoot(ImageHeader::kJniStubArray);
- runtime->SetJniDlsymLookupStub(down_cast<ByteArray*>(jni_stub_array));
+ mirror::Object* jni_stub_array = image_header.GetImageRoot(ImageHeader::kJniStubArray);
+ runtime->SetJniDlsymLookupStub(down_cast<mirror::ByteArray*>(jni_stub_array));
- Object* ame_stub_array = image_header.GetImageRoot(ImageHeader::kAbstractMethodErrorStubArray);
- runtime->SetAbstractMethodErrorStubArray(down_cast<ByteArray*>(ame_stub_array));
+ mirror::Object* ame_stub_array = image_header.GetImageRoot(ImageHeader::kAbstractMethodErrorStubArray);
+ runtime->SetAbstractMethodErrorStubArray(down_cast<mirror::ByteArray*>(ame_stub_array));
- Object* resolution_stub_array =
+ mirror::Object* resolution_stub_array =
image_header.GetImageRoot(ImageHeader::kStaticResolutionStubArray);
runtime->SetResolutionStubArray(
- down_cast<ByteArray*>(resolution_stub_array), Runtime::kStaticMethod);
+ down_cast<mirror::ByteArray*>(resolution_stub_array), Runtime::kStaticMethod);
resolution_stub_array = image_header.GetImageRoot(ImageHeader::kUnknownMethodResolutionStubArray);
runtime->SetResolutionStubArray(
- down_cast<ByteArray*>(resolution_stub_array), Runtime::kUnknownMethod);
+ down_cast<mirror::ByteArray*>(resolution_stub_array), Runtime::kUnknownMethod);
- Object* resolution_method = image_header.GetImageRoot(ImageHeader::kResolutionMethod);
- runtime->SetResolutionMethod(down_cast<AbstractMethod*>(resolution_method));
+ mirror::Object* resolution_method = image_header.GetImageRoot(ImageHeader::kResolutionMethod);
+ runtime->SetResolutionMethod(down_cast<mirror::AbstractMethod*>(resolution_method));
- Object* callee_save_method = image_header.GetImageRoot(ImageHeader::kCalleeSaveMethod);
- runtime->SetCalleeSaveMethod(down_cast<AbstractMethod*>(callee_save_method), Runtime::kSaveAll);
+ mirror::Object* callee_save_method = image_header.GetImageRoot(ImageHeader::kCalleeSaveMethod);
+ runtime->SetCalleeSaveMethod(down_cast<mirror::AbstractMethod*>(callee_save_method), Runtime::kSaveAll);
callee_save_method = image_header.GetImageRoot(ImageHeader::kRefsOnlySaveMethod);
- runtime->SetCalleeSaveMethod(down_cast<AbstractMethod*>(callee_save_method), Runtime::kRefsOnly);
+ runtime->SetCalleeSaveMethod(down_cast<mirror::AbstractMethod*>(callee_save_method), Runtime::kRefsOnly);
callee_save_method = image_header.GetImageRoot(ImageHeader::kRefsAndArgsSaveMethod);
- runtime->SetCalleeSaveMethod(down_cast<AbstractMethod*>(callee_save_method), Runtime::kRefsAndArgs);
+ runtime->SetCalleeSaveMethod(down_cast<mirror::AbstractMethod*>(callee_save_method), Runtime::kRefsAndArgs);
ImageSpace* space = new ImageSpace(image_file_name, map.release());
if (VLOG_IS_ON(heap) || VLOG_IS_ON(startup)) {
@@ -548,7 +554,7 @@
byte* end = End();
while (current < end) {
DCHECK_ALIGNED(current, kObjectAlignment);
- const Object* obj = reinterpret_cast<const Object*>(current);
+ const mirror::Object* obj = reinterpret_cast<const mirror::Object*>(current);
live_bitmap->Set(obj);
current += RoundUp(obj->SizeOf(), kObjectAlignment);
}
diff --git a/src/gc/space.h b/src/gc/space.h
index 2ed4988..d2bcd53 100644
--- a/src/gc/space.h
+++ b/src/gc/space.h
@@ -31,10 +31,12 @@
static const bool kDebugSpaces = kIsDebugBuild;
+namespace mirror {
+class Object;
+} // namespace mirror
class DlMallocSpace;
class ImageSpace;
class LargeObjectSpace;
-class Object;
class SpaceBitmap;
enum GcRetentionPolicy {
@@ -57,7 +59,7 @@
public:
virtual bool CanAllocateInto() const = 0;
virtual bool IsCompactible() const = 0;
- virtual bool Contains(const Object* obj) const = 0;
+ virtual bool Contains(const mirror::Object* obj) const = 0;
virtual SpaceType GetType() const = 0;
virtual GcRetentionPolicy GetGcRetentionPolicy() const = 0;
virtual std::string GetName() const = 0;
@@ -108,16 +110,16 @@
virtual uint64_t GetTotalObjectsAllocated() const = 0;
// Allocate num_bytes without allowing growth.
- virtual Object* Alloc(Thread* self, size_t num_bytes) = 0;
+ virtual mirror::Object* Alloc(Thread* self, size_t num_bytes) = 0;
// Return the storage space required by obj.
- virtual size_t AllocationSize(const Object* obj) = 0;
+ virtual size_t AllocationSize(const mirror::Object* obj) = 0;
// Returns how many bytes were freed.
- virtual size_t Free(Thread* self, Object* ptr) = 0;
+ virtual size_t Free(Thread* self, mirror::Object* ptr) = 0;
// Returns how many bytes were freed.
- virtual size_t FreeList(Thread* self, size_t num_ptrs, Object** ptrs) = 0;
+ virtual size_t FreeList(Thread* self, size_t num_ptrs, mirror::Object** ptrs) = 0;
protected:
AllocSpace() {}
@@ -149,12 +151,12 @@
virtual SpaceBitmap* GetMarkBitmap() const = 0;
// Is object within this space?
- bool HasAddress(const Object* obj) const {
+ bool HasAddress(const mirror::Object* obj) const {
const byte* byte_ptr = reinterpret_cast<const byte*>(obj);
return Begin() <= byte_ptr && byte_ptr < End();
}
- virtual bool Contains(const Object* obj) const {
+ virtual bool Contains(const mirror::Object* obj) const {
return HasAddress(obj);
}
@@ -188,7 +190,7 @@
class DiscontinuousSpace : public virtual Space {
public:
// Is object within this space?
- virtual bool Contains(const Object* obj) const = 0;
+ virtual bool Contains(const mirror::Object* obj) const = 0;
virtual std::string GetName() const {
return name_;
@@ -267,15 +269,15 @@
size_t capacity, byte* requested_begin);
// Allocate num_bytes without allowing the underlying mspace to grow.
- virtual Object* AllocWithGrowth(Thread* self, size_t num_bytes);
+ virtual mirror::Object* AllocWithGrowth(Thread* self, size_t num_bytes);
// Allocate num_bytes allowing the underlying mspace to grow.
- virtual Object* Alloc(Thread* self, size_t num_bytes);
+ virtual mirror::Object* Alloc(Thread* self, size_t num_bytes);
// Return the storage space required by obj.
- virtual size_t AllocationSize(const Object* obj);
- virtual size_t Free(Thread* self, Object* ptr);
- virtual size_t FreeList(Thread* self, size_t num_ptrs, Object** ptrs);
+ virtual size_t AllocationSize(const mirror::Object* obj);
+ virtual size_t Free(Thread* self, mirror::Object* ptr);
+ virtual size_t FreeList(Thread* self, size_t num_ptrs, mirror::Object** ptrs);
void* MoreCore(intptr_t increment);
@@ -353,8 +355,8 @@
}
private:
- size_t InternalAllocationSize(const Object* obj);
- Object* AllocWithoutGrowthLocked(size_t num_bytes) EXCLUSIVE_LOCKS_REQUIRED(lock_);
+ size_t InternalAllocationSize(const mirror::Object* obj);
+ mirror::Object* AllocWithoutGrowthLocked(size_t num_bytes) EXCLUSIVE_LOCKS_REQUIRED(lock_);
UniquePtr<SpaceBitmap> live_bitmap_;
UniquePtr<SpaceBitmap> mark_bitmap_;
diff --git a/src/gc/space_bitmap-inl.h b/src/gc/space_bitmap-inl.h
new file mode 100644
index 0000000..e1fdd29
--- /dev/null
+++ b/src/gc/space_bitmap-inl.h
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2008 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_GC_SPACE_BITMAP_INL_H_
+#define ART_SRC_GC_SPACE_BITMAP_INL_H_
+
+#include "base/logging.h"
+#include "cutils/atomic.h"
+
+namespace art {
+
+inline bool SpaceBitmap::AtomicTestAndSet(const mirror::Object* obj) {
+ uintptr_t addr = reinterpret_cast<uintptr_t>(obj);
+ DCHECK_GE(addr, heap_begin_);
+ const uintptr_t offset = addr - heap_begin_;
+ const size_t index = OffsetToIndex(offset);
+ const word mask = OffsetToMask(offset);
+ word* const address = &bitmap_begin_[index];
+ DCHECK_LT(index, bitmap_size_ / kWordSize) << " bitmap_size_ = " << bitmap_size_;
+ word old_word;
+ do {
+ old_word = *address;
+ // Fast path: The bit is already set.
+ if ((old_word & mask) != 0) {
+ return true;
+ }
+ } while (UNLIKELY(android_atomic_cas(old_word, old_word | mask, address) != 0));
+ return false;
+}
+
+inline bool SpaceBitmap::Test(const mirror::Object* obj) const {
+ uintptr_t addr = reinterpret_cast<uintptr_t>(obj);
+ DCHECK(HasAddress(obj)) << obj;
+ DCHECK(bitmap_begin_ != NULL);
+ DCHECK_GE(addr, heap_begin_);
+ const uintptr_t offset = addr - heap_begin_;
+ return (bitmap_begin_[OffsetToIndex(offset)] & OffsetToMask(offset)) != 0;
+}
+
+template <typename Visitor, typename FingerVisitor>
+void SpaceBitmap::VisitMarkedRange(uintptr_t visit_begin, uintptr_t visit_end,
+ const Visitor& visitor,
+ const FingerVisitor& finger_visitor) const {
+ DCHECK_LT(visit_begin, visit_end);
+
+ const size_t word_span = kAlignment * kBitsPerWord; // Equals IndexToOffset(1).
+ const size_t bit_index_start = (visit_begin - heap_begin_) / kAlignment;
+ const size_t bit_index_end = (visit_end - heap_begin_ - 1) / kAlignment;
+
+ size_t word_start = bit_index_start / kBitsPerWord;
+ size_t word_end = bit_index_end / kBitsPerWord;
+ DCHECK_LT(word_end * kWordSize, Size());
+
+ // Trim off left_bits of left bits.
+ size_t edge_word = bitmap_begin_[word_start];
+
+ // Handle bits on the left first as a special case
+ size_t left_bits = bit_index_start & (kBitsPerWord - 1);
+ if (left_bits != 0) {
+ edge_word &= (1 << (kBitsPerWord - left_bits)) - 1;
+ }
+
+ // If word_start == word_end then handle this case at the same place we handle the right edge.
+ if (edge_word != 0 && word_start < word_end) {
+ uintptr_t ptr_base = IndexToOffset(word_start) + heap_begin_;
+ finger_visitor(reinterpret_cast<void*>(ptr_base + word_span));
+ do {
+ const size_t shift = CLZ(edge_word);
+ mirror::Object* obj = reinterpret_cast<mirror::Object*>(ptr_base + shift * kAlignment);
+ visitor(obj);
+ edge_word ^= static_cast<size_t>(kWordHighBitMask) >> shift;
+ } while (edge_word != 0);
+ }
+ word_start++;
+
+ for (size_t i = word_start; i < word_end; i++) {
+ size_t w = bitmap_begin_[i];
+ if (w != 0) {
+ uintptr_t ptr_base = IndexToOffset(i) + heap_begin_;
+ finger_visitor(reinterpret_cast<void*>(ptr_base + word_span));
+ do {
+ const size_t shift = CLZ(w);
+ mirror::Object* obj = reinterpret_cast<mirror::Object*>(ptr_base + shift * kAlignment);
+ visitor(obj);
+ w ^= static_cast<size_t>(kWordHighBitMask) >> shift;
+ } while (w != 0);
+ }
+ }
+
+ // Handle the right edge, and also the left edge if both edges are on the same word.
+ size_t right_bits = bit_index_end & (kBitsPerWord - 1);
+
+ // If word_start == word_end then we need to use the word which we removed the left bits.
+ if (word_start <= word_end) {
+ edge_word = bitmap_begin_[word_end];
+ }
+
+ // Bits that we trim off the right.
+ edge_word &= ~((static_cast<size_t>(kWordHighBitMask) >> right_bits) - 1);
+ uintptr_t ptr_base = IndexToOffset(word_end) + heap_begin_;
+ finger_visitor(reinterpret_cast<void*>(ptr_base + word_span));
+ while (edge_word != 0) {
+ const size_t shift = CLZ(edge_word);
+ mirror::Object* obj = reinterpret_cast<mirror::Object*>(ptr_base + shift * kAlignment);
+ visitor(obj);
+ edge_word ^= static_cast<size_t>(kWordHighBitMask) >> shift;
+ }
+}
+
+inline bool SpaceBitmap::Modify(const mirror::Object* obj, bool do_set) {
+ uintptr_t addr = reinterpret_cast<uintptr_t>(obj);
+ DCHECK_GE(addr, heap_begin_);
+ const uintptr_t offset = addr - heap_begin_;
+ const size_t index = OffsetToIndex(offset);
+ const word mask = OffsetToMask(offset);
+ DCHECK_LT(index, bitmap_size_ / kWordSize) << " bitmap_size_ = " << bitmap_size_;
+ word* address = &bitmap_begin_[index];
+ word old_word = *address;
+ if (do_set) {
+ *address = old_word | mask;
+ } else {
+ *address = old_word & ~mask;
+ }
+ return (old_word & mask) != 0;
+}
+} // namespace art
+
+#endif // ART_SRC_GC_SPACE_BITMAP_INL_H_
diff --git a/src/gc/space_bitmap.cc b/src/gc/space_bitmap.cc
index 25fa672..d90c090 100644
--- a/src/gc/space_bitmap.cc
+++ b/src/gc/space_bitmap.cc
@@ -17,6 +17,11 @@
#include "heap_bitmap.h"
#include "base/logging.h"
+#include "mirror/class-inl.h"
+#include "mirror/field-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
+#include "space_bitmap-inl.h"
#include "UniquePtr.h"
#include "utils.h"
@@ -32,7 +37,7 @@
void SpaceSetMap::Walk(SpaceBitmap::Callback* callback, void* arg) {
for (Objects::iterator it = contained_.begin(); it != contained_.end(); ++it) {
- callback(const_cast<Object*>(*it), arg);
+ callback(const_cast<mirror::Object*>(*it), arg);
}
}
@@ -98,7 +103,7 @@
uintptr_t ptr_base = IndexToOffset(i) + heap_begin_;
do {
const size_t shift = CLZ(w);
- Object* obj = reinterpret_cast<Object*>(ptr_base + shift * kAlignment);
+ mirror::Object* obj = reinterpret_cast<mirror::Object*>(ptr_base + shift * kAlignment);
(*callback)(obj, arg);
w ^= static_cast<size_t>(kWordHighBitMask) >> shift;
} while (w != 0);
@@ -127,10 +132,10 @@
return;
}
- // TODO: rewrite the callbacks to accept a std::vector<Object*> rather than a Object**?
+ // TODO: rewrite the callbacks to accept a std::vector<mirror::Object*> rather than a mirror::Object**?
const size_t buffer_size = kWordSize * kBitsPerWord;
- Object* pointer_buf[buffer_size];
- Object** pb = &pointer_buf[0];
+ mirror::Object* pointer_buf[buffer_size];
+ mirror::Object** pb = &pointer_buf[0];
size_t start = OffsetToIndex(sweep_begin - live_bitmap.heap_begin_);
size_t end = OffsetToIndex(sweep_end - live_bitmap.heap_begin_ - 1);
CHECK_LT(end, live_bitmap.Size() / kWordSize);
@@ -143,7 +148,7 @@
do {
const size_t shift = CLZ(garbage);
garbage ^= static_cast<size_t>(kWordHighBitMask) >> shift;
- *pb++ = reinterpret_cast<Object*>(ptr_base + shift * kAlignment);
+ *pb++ = reinterpret_cast<mirror::Object*>(ptr_base + shift * kAlignment);
} while (garbage != 0);
// Make sure that there are always enough slots available for an
// entire word of one bits.
@@ -161,32 +166,32 @@
} // namespace art
// Support needed for in order traversal
-#include "object.h"
+#include "mirror/object.h"
#include "object_utils.h"
namespace art {
-static void WalkFieldsInOrder(SpaceBitmap* visited, SpaceBitmap::Callback* callback, Object* obj,
+static void WalkFieldsInOrder(SpaceBitmap* visited, SpaceBitmap::Callback* callback, mirror::Object* obj,
void* arg);
// Walk instance fields of the given Class. Separate function to allow recursion on the super
// class.
-static void WalkInstanceFields(SpaceBitmap* visited, SpaceBitmap::Callback* callback, Object* obj,
- Class* klass, void* arg)
+static void WalkInstanceFields(SpaceBitmap* visited, SpaceBitmap::Callback* callback, mirror::Object* obj,
+ mirror::Class* klass, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// Visit fields of parent classes first.
- Class* super = klass->GetSuperClass();
+ mirror::Class* super = klass->GetSuperClass();
if (super != NULL) {
WalkInstanceFields(visited, callback, obj, super, arg);
}
// Walk instance fields
- ObjectArray<Field>* fields = klass->GetIFields();
+ mirror::ObjectArray<mirror::Field>* fields = klass->GetIFields();
if (fields != NULL) {
for (int32_t i = 0; i < fields->GetLength(); i++) {
- Field* field = fields->Get(i);
+ mirror::Field* field = fields->Get(i);
FieldHelper fh(field);
if (!fh.IsPrimitiveType()) {
- Object* value = field->GetObj(obj);
+ mirror::Object* value = field->GetObj(obj);
if (value != NULL) {
WalkFieldsInOrder(visited, callback, value, arg);
}
@@ -196,7 +201,7 @@
}
// For an unvisited object, visit it then all its children found via fields.
-static void WalkFieldsInOrder(SpaceBitmap* visited, SpaceBitmap::Callback* callback, Object* obj,
+static void WalkFieldsInOrder(SpaceBitmap* visited, SpaceBitmap::Callback* callback, mirror::Object* obj,
void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (visited->Test(obj)) {
@@ -206,17 +211,17 @@
(*callback)(obj, arg);
visited->Set(obj);
// Walk instance fields of all objects
- Class* klass = obj->GetClass();
+ mirror::Class* klass = obj->GetClass();
WalkInstanceFields(visited, callback, obj, klass, arg);
// Walk static fields of a Class
if (obj->IsClass()) {
- ObjectArray<Field>* fields = klass->GetSFields();
+ mirror::ObjectArray<mirror::Field>* fields = klass->GetSFields();
if (fields != NULL) {
for (int32_t i = 0; i < fields->GetLength(); i++) {
- Field* field = fields->Get(i);
+ mirror::Field* field = fields->Get(i);
FieldHelper fh(field);
if (!fh.IsPrimitiveType()) {
- Object* value = field->GetObj(NULL);
+ mirror::Object* value = field->GetObj(NULL);
if (value != NULL) {
WalkFieldsInOrder(visited, callback, value, arg);
}
@@ -225,10 +230,10 @@
}
} else if (obj->IsObjectArray()) {
// Walk elements of an object array
- ObjectArray<Object>* obj_array = obj->AsObjectArray<Object>();
+ mirror::ObjectArray<mirror::Object>* obj_array = obj->AsObjectArray<mirror::Object>();
int32_t length = obj_array->GetLength();
for (int32_t i = 0; i < length; i++) {
- Object* value = obj_array->Get(i);
+ mirror::Object* value = obj_array->Get(i);
if (value != NULL) {
WalkFieldsInOrder(visited, callback, value, arg);
}
@@ -251,7 +256,7 @@
uintptr_t ptr_base = IndexToOffset(i) + heap_begin_;
while (w != 0) {
const size_t shift = CLZ(w);
- Object* obj = reinterpret_cast<Object*>(ptr_base + shift * kAlignment);
+ mirror::Object* obj = reinterpret_cast<mirror::Object*>(ptr_base + shift * kAlignment);
WalkFieldsInOrder(visited.get(), callback, obj, arg);
w ^= static_cast<size_t>(kWordHighBitMask) >> shift;
}
diff --git a/src/gc/space_bitmap.h b/src/gc/space_bitmap.h
index dd2f47d..6bc06d6 100644
--- a/src/gc/space_bitmap.h
+++ b/src/gc/space_bitmap.h
@@ -14,35 +14,33 @@
* limitations under the License.
*/
-#ifndef ART_SRC_SPACE_BITMAP_H_
-#define ART_SRC_SPACE_BITMAP_H_
+#ifndef ART_SRC_GC_SPACE_BITMAP_H_
+#define ART_SRC_GC_SPACE_BITMAP_H_
+
+#include "locks.h"
+#include "globals.h"
+#include "mem_map.h"
+#include "UniquePtr.h"
#include <limits.h>
#include <set>
#include <stdint.h>
#include <vector>
-#include "base/logging.h"
-#include "cutils/atomic.h"
-#include "cutils/atomic-inline.h"
-#include "UniquePtr.h"
-#include "globals.h"
-#include "mem_map.h"
-#include "utils.h"
-
namespace art {
-
+namespace mirror {
class Object;
+} // namespace mirror
class SpaceBitmap {
public:
static const size_t kAlignment = 8;
- typedef void Callback(Object* obj, void* arg);
+ typedef void Callback(mirror::Object* obj, void* arg);
- typedef void ScanCallback(Object* obj, void* finger, void* arg);
+ typedef void ScanCallback(mirror::Object* obj, void* finger, void* arg);
- typedef void SweepCallback(size_t ptr_count, Object** ptrs, void* arg);
+ typedef void SweepCallback(size_t ptr_count, mirror::Object** ptrs, void* arg);
// Initialize a HeapBitmap so that it points to a bitmap large enough to cover a heap at
// heap_begin of heap_capacity bytes, where objects are guaranteed to be kAlignment-aligned.
@@ -66,44 +64,20 @@
return static_cast<uintptr_t>(kWordHighBitMask) >> ((offset_ / kAlignment) % kBitsPerWord);
}
- inline bool Set(const Object* obj) {
+ inline bool Set(const mirror::Object* obj) {
return Modify(obj, true);
}
- inline bool Clear(const Object* obj) {
+ inline bool Clear(const mirror::Object* obj) {
return Modify(obj, false);
}
// Returns true if the object was previously marked.
- inline bool AtomicTestAndSet(const Object* obj) {
- uintptr_t addr = reinterpret_cast<uintptr_t>(obj);
- DCHECK_GE(addr, heap_begin_);
- const uintptr_t offset = addr - heap_begin_;
- const size_t index = OffsetToIndex(offset);
- const word mask = OffsetToMask(offset);
- word* const address = &bitmap_begin_[index];
- DCHECK_LT(index, bitmap_size_ / kWordSize) << " bitmap_size_ = " << bitmap_size_;
- word old_word;
- do {
- old_word = *address;
- // Fast path: The bit is already set.
- if ((old_word & mask) != 0) {
- return true;
- }
- } while (UNLIKELY(android_atomic_cas(old_word, old_word | mask, address) != 0));
- return false;
- }
+ bool AtomicTestAndSet(const mirror::Object* obj);
void Clear();
- inline bool Test(const Object* obj) const {
- uintptr_t addr = reinterpret_cast<uintptr_t>(obj);
- DCHECK(HasAddress(obj)) << obj;
- DCHECK(bitmap_begin_ != NULL);
- DCHECK_GE(addr, heap_begin_);
- const uintptr_t offset = addr - heap_begin_;
- return (bitmap_begin_[OffsetToIndex(offset)] & OffsetToMask(offset)) != 0;
- }
+ bool Test(const mirror::Object* obj) const;
// Return true iff <obj> is within the range of pointers that this bitmap could potentially cover,
// even if a bit has not been set for it.
@@ -123,7 +97,7 @@
: bitmap_(bitmap) {
}
- void operator ()(Object* obj) const {
+ void operator ()(mirror::Object* obj) const {
bitmap_->Clear(obj);
}
private:
@@ -133,86 +107,21 @@
template <typename Visitor>
void VisitRange(uintptr_t visit_begin, uintptr_t visit_end, const Visitor& visitor) const {
for (; visit_begin < visit_end; visit_begin += kAlignment ) {
- visitor(reinterpret_cast<Object*>(visit_begin));
+ visitor(reinterpret_cast<mirror::Object*>(visit_begin));
}
}
template <typename Visitor, typename FingerVisitor>
void VisitMarkedRange(uintptr_t visit_begin, uintptr_t visit_end,
const Visitor& visitor, const FingerVisitor& finger_visitor) const
- EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) {
- DCHECK_LT(visit_begin, visit_end);
-
- const size_t word_span = kAlignment * kBitsPerWord; // Equals IndexToOffset(1).
- const size_t bit_index_start = (visit_begin - heap_begin_) / kAlignment;
- const size_t bit_index_end = (visit_end - heap_begin_ - 1) / kAlignment;
-
- size_t word_start = bit_index_start / kBitsPerWord;
- size_t word_end = bit_index_end / kBitsPerWord;
- DCHECK_LT(word_end * kWordSize, Size());
-
- // Trim off left_bits of left bits.
- size_t edge_word = bitmap_begin_[word_start];
-
- // Handle bits on the left first as a special case
- size_t left_bits = bit_index_start & (kBitsPerWord - 1);
- if (left_bits != 0) {
- edge_word &= (1 << (kBitsPerWord - left_bits)) - 1;
- }
-
- // If word_start == word_end then handle this case at the same place we handle the right edge.
- if (edge_word != 0 && word_start < word_end) {
- uintptr_t ptr_base = IndexToOffset(word_start) + heap_begin_;
- finger_visitor(reinterpret_cast<void*>(ptr_base + word_span));
- do {
- const size_t shift = CLZ(edge_word);
- Object* obj = reinterpret_cast<Object*>(ptr_base + shift * kAlignment);
- visitor(obj);
- edge_word ^= static_cast<size_t>(kWordHighBitMask) >> shift;
- } while (edge_word != 0);
- }
- word_start++;
-
- for (size_t i = word_start; i < word_end; i++) {
- size_t w = bitmap_begin_[i];
- if (w != 0) {
- uintptr_t ptr_base = IndexToOffset(i) + heap_begin_;
- finger_visitor(reinterpret_cast<void*>(ptr_base + word_span));
- do {
- const size_t shift = CLZ(w);
- Object* obj = reinterpret_cast<Object*>(ptr_base + shift * kAlignment);
- visitor(obj);
- w ^= static_cast<size_t>(kWordHighBitMask) >> shift;
- } while (w != 0);
- }
- }
-
- // Handle the right edge, and also the left edge if both edges are on the same word.
- size_t right_bits = bit_index_end & (kBitsPerWord - 1);
-
- // If word_start == word_end then we need to use the word which we removed the left bits.
- if (word_start <= word_end) {
- edge_word = bitmap_begin_[word_end];
- }
-
- // Bits that we trim off the right.
- edge_word &= ~((static_cast<size_t>(kWordHighBitMask) >> right_bits) - 1);
- uintptr_t ptr_base = IndexToOffset(word_end) + heap_begin_;
- finger_visitor(reinterpret_cast<void*>(ptr_base + word_span));
- while (edge_word != 0) {
- const size_t shift = CLZ(edge_word);
- Object* obj = reinterpret_cast<Object*>(ptr_base + shift * kAlignment);
- visitor(obj);
- edge_word ^= static_cast<size_t>(kWordHighBitMask) >> shift;
- }
- }
+ EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void Walk(Callback* callback, void* arg)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
void InOrderWalk(Callback* callback, void* arg)
- SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_, Locks::mutator_lock_);
static void SweepWalk(const SpaceBitmap& live,
const SpaceBitmap& mark,
@@ -251,7 +160,7 @@
std::string GetName() const;
void SetName(const std::string& name);
- const void* GetObjectWordAddress(const Object* obj) const {
+ const void* GetObjectWordAddress(const mirror::Object* obj) const {
uintptr_t addr = reinterpret_cast<uintptr_t>(obj);
const uintptr_t offset = addr - heap_begin_;
const size_t index = OffsetToIndex(offset);
@@ -265,22 +174,7 @@
heap_begin_(reinterpret_cast<uintptr_t>(heap_begin)),
name_(name) {}
- inline bool Modify(const Object* obj, bool do_set) {
- uintptr_t addr = reinterpret_cast<uintptr_t>(obj);
- DCHECK_GE(addr, heap_begin_);
- const uintptr_t offset = addr - heap_begin_;
- const size_t index = OffsetToIndex(offset);
- const word mask = OffsetToMask(offset);
- DCHECK_LT(index, bitmap_size_ / kWordSize) << " bitmap_size_ = " << bitmap_size_;
- word* address = &bitmap_begin_[index];
- word old_word = *address;
- if (do_set) {
- *address = old_word | mask;
- } else {
- *address = old_word & ~mask;
- }
- return (old_word & mask) != 0;
- }
+ bool Modify(const mirror::Object* obj, bool do_set);
// Backing storage for bitmap.
UniquePtr<MemMap> mem_map_;
@@ -302,17 +196,17 @@
// Like a bitmap except it keeps track of objects using sets.
class SpaceSetMap {
public:
- typedef std::set<const Object*> Objects;
+ typedef std::set<const mirror::Object*> Objects;
bool IsEmpty() const {
return contained_.empty();
}
- inline void Set(const Object* obj) {
+ inline void Set(const mirror::Object* obj) {
contained_.insert(obj);
}
- inline void Clear(const Object* obj) {
+ inline void Clear(const mirror::Object* obj) {
Objects::iterator found = contained_.find(obj);
if (found != contained_.end()) {
contained_.erase(found);
@@ -323,7 +217,7 @@
contained_.clear();
}
- inline bool Test(const Object* obj) const {
+ inline bool Test(const mirror::Object* obj) const {
return contained_.find(obj) != contained_.end();
}
@@ -357,4 +251,4 @@
} // namespace art
-#endif // ART_SRC_SPACE_BITMAP_H_
+#endif // ART_SRC_GC_SPACE_BITMAP_H_
diff --git a/src/gc/space_bitmap_test.cc b/src/gc/space_bitmap_test.cc
index a2f1afc..5a829e4 100644
--- a/src/gc/space_bitmap_test.cc
+++ b/src/gc/space_bitmap_test.cc
@@ -19,6 +19,7 @@
#include "common_test.h"
#include "dlmalloc.h"
#include "globals.h"
+#include "space_bitmap-inl.h"
#include "UniquePtr.h"
#include <stdint.h>
@@ -39,20 +40,20 @@
class BitmapVerify {
public:
- BitmapVerify(SpaceBitmap* bitmap, const Object* begin, const Object* end)
+ BitmapVerify(SpaceBitmap* bitmap, const mirror::Object* begin, const mirror::Object* end)
: bitmap_(bitmap),
begin_(begin),
end_(end) {}
- void operator ()(const Object* obj) {
+ void operator ()(const mirror::Object* obj) {
EXPECT_TRUE(obj >= begin_);
EXPECT_TRUE(obj <= end_);
EXPECT_TRUE(bitmap_->Test(obj) == ((reinterpret_cast<uintptr_t>(obj) & 0xF) != 0));
}
SpaceBitmap* bitmap_;
- const Object* begin_;
- const Object* end_;
+ const mirror::Object* begin_;
+ const mirror::Object* end_;
};
TEST_F(SpaceBitmapTest, ScanRange) {
@@ -65,7 +66,8 @@
// Set all the odd bits in the first BitsPerWord * 3 to one.
for (size_t j = 0;j < kBitsPerWord * 3; ++j) {
- const Object* obj = reinterpret_cast<Object*>(heap_begin + j * SpaceBitmap::kAlignment);
+ const mirror::Object* obj =
+ reinterpret_cast<mirror::Object*>(heap_begin + j * SpaceBitmap::kAlignment);
if (reinterpret_cast<uintptr_t>(obj) & 0xF) {
space_bitmap->Set(obj);
}
@@ -75,9 +77,11 @@
// This handles all the cases, having runs which start and end on the same word, and different
// words.
for (size_t i = 0; i < static_cast<size_t>(kBitsPerWord); ++i) {
- Object* start = reinterpret_cast<Object*>(heap_begin + i * SpaceBitmap::kAlignment);
+ mirror::Object* start =
+ reinterpret_cast<mirror::Object*>(heap_begin + i * SpaceBitmap::kAlignment);
for (size_t j = 0; j < static_cast<size_t>(kBitsPerWord * 2); ++j) {
- Object* end = reinterpret_cast<Object*>(heap_begin + (i + j) * SpaceBitmap::kAlignment);
+ mirror::Object* end =
+ reinterpret_cast<mirror::Object*>(heap_begin + (i + j) * SpaceBitmap::kAlignment);
BitmapVerify(space_bitmap.get(), start, end);
}
}
diff --git a/src/gc/space_test.cc b/src/gc/space_test.cc
index 2e03eae..372ec77 100644
--- a/src/gc/space_test.cc
+++ b/src/gc/space_test.cc
@@ -83,23 +83,23 @@
Thread* self = Thread::Current();
// Succeeds, fits without adjusting the footprint limit.
- Object* ptr1 = space->Alloc(self, 1 * MB);
+ mirror::Object* ptr1 = space->Alloc(self, 1 * MB);
EXPECT_TRUE(ptr1 != NULL);
// Fails, requires a higher footprint limit.
- Object* ptr2 = space->Alloc(self, 8 * MB);
+ mirror::Object* ptr2 = space->Alloc(self, 8 * MB);
EXPECT_TRUE(ptr2 == NULL);
// Succeeds, adjusts the footprint.
- Object* ptr3 = space->AllocWithGrowth(self, 8 * MB);
+ mirror::Object* ptr3 = space->AllocWithGrowth(self, 8 * MB);
EXPECT_TRUE(ptr3 != NULL);
// Fails, requires a higher footprint limit.
- Object* ptr4 = space->Alloc(self, 8 * MB);
+ mirror::Object* ptr4 = space->Alloc(self, 8 * MB);
EXPECT_TRUE(ptr4 == NULL);
// Also fails, requires a higher allowed footprint.
- Object* ptr5 = space->AllocWithGrowth(self, 8 * MB);
+ mirror::Object* ptr5 = space->AllocWithGrowth(self, 8 * MB);
EXPECT_TRUE(ptr5 == NULL);
// Release some memory.
@@ -151,23 +151,23 @@
Runtime::Current()->GetHeap()->AddSpace(space);
// Succeeds, fits without adjusting the footprint limit.
- Object* ptr1 = space->Alloc(self, 1 * MB);
+ mirror::Object* ptr1 = space->Alloc(self, 1 * MB);
EXPECT_TRUE(ptr1 != NULL);
// Fails, requires a higher footprint limit.
- Object* ptr2 = space->Alloc(self, 8 * MB);
+ mirror::Object* ptr2 = space->Alloc(self, 8 * MB);
EXPECT_TRUE(ptr2 == NULL);
// Succeeds, adjusts the footprint.
- Object* ptr3 = space->AllocWithGrowth(self, 8 * MB);
+ mirror::Object* ptr3 = space->AllocWithGrowth(self, 8 * MB);
EXPECT_TRUE(ptr3 != NULL);
// Fails, requires a higher footprint limit.
- Object* ptr4 = space->Alloc(self, 8 * MB);
+ mirror::Object* ptr4 = space->Alloc(self, 8 * MB);
EXPECT_TRUE(ptr4 == NULL);
// Also fails, requires a higher allowed footprint.
- Object* ptr5 = space->AllocWithGrowth(self, 8 * MB);
+ mirror::Object* ptr5 = space->AllocWithGrowth(self, 8 * MB);
EXPECT_TRUE(ptr5 == NULL);
// Release some memory.
@@ -194,7 +194,7 @@
Thread* self = Thread::Current();
// Succeeds, fits without adjusting the max allowed footprint.
- Object* lots_of_objects[1024];
+ mirror::Object* lots_of_objects[1024];
for (size_t i = 0; i < arraysize(lots_of_objects); i++) {
lots_of_objects[i] = space->Alloc(self, 16);
EXPECT_TRUE(lots_of_objects[i] != NULL);
@@ -252,7 +252,7 @@
// Fill the space with lots of small objects up to the growth limit
size_t max_objects = (growth_limit / (object_size > 0 ? object_size : 8)) + 1;
- UniquePtr<Object*[]> lots_of_objects(new Object*[max_objects]);
+ UniquePtr<mirror::Object*[]> lots_of_objects(new mirror::Object*[max_objects]);
size_t last_object = 0; // last object for which allocation succeeded
size_t amount_allocated = 0; // amount of space allocated
Thread* self = Thread::Current();
@@ -269,7 +269,7 @@
alloc_size = 8;
}
}
- Object* object;
+ mirror::Object* object;
if (round <= 1) {
object = space->Alloc(self, alloc_size);
} else {
@@ -326,7 +326,7 @@
// Free some objects
for (size_t i = 0; i < last_object; i += free_increment) {
- Object* object = lots_of_objects.get()[i];
+ mirror::Object* object = lots_of_objects.get()[i];
if (object == NULL) {
continue;
}
@@ -347,7 +347,7 @@
}
// All memory was released, try a large allocation to check freed memory is being coalesced
- Object* large_object;
+ mirror::Object* large_object;
size_t three_quarters_space = (growth_limit / 2) + (growth_limit / 4);
if (round <= 1) {
large_object = space->Alloc(self, three_quarters_space);
diff --git a/src/gc/sticky_mark_sweep.cc b/src/gc/sticky_mark_sweep.cc
index 23196fd..988d4e7 100644
--- a/src/gc/sticky_mark_sweep.cc
+++ b/src/gc/sticky_mark_sweep.cc
@@ -14,47 +14,51 @@
* limitations under the License.
*/
+#include "heap.h"
#include "large_object_space.h"
#include "space.h"
#include "sticky_mark_sweep.h"
+#include "thread.h"
namespace art {
- StickyMarkSweep::StickyMarkSweep(Heap* heap, bool is_concurrent)
- : PartialMarkSweep(heap, is_concurrent) {
- cumulative_timings_.SetName(GetName());
- }
- StickyMarkSweep::~StickyMarkSweep() {
+StickyMarkSweep::StickyMarkSweep(Heap* heap, bool is_concurrent)
+ : PartialMarkSweep(heap, is_concurrent) {
+ cumulative_timings_.SetName(GetName());
+}
- }
+StickyMarkSweep::~StickyMarkSweep() {
- void StickyMarkSweep::BindBitmaps() {
- PartialMarkSweep::BindBitmaps();
+}
- Spaces& spaces = GetHeap()->GetSpaces();
- WriterMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_);
- // For sticky GC, we want to bind the bitmaps of both the zygote space and the alloc space.
- // This lets us start with the mark bitmap of the previous garbage collection as the current
- // mark bitmap of the alloc space. After the sticky GC finishes, we then unbind the bitmaps,
- // making it so that the live bitmap of the alloc space is contains the newly marked objects
- // from the sticky GC.
- for (Spaces::iterator it = spaces.begin(); it != spaces.end(); ++it) {
- if ((*it)->GetGcRetentionPolicy() == kGcRetentionPolicyAlwaysCollect) {
- BindLiveToMarkBitmap(*it);
- }
+void StickyMarkSweep::BindBitmaps() {
+ PartialMarkSweep::BindBitmaps();
+
+ Spaces& spaces = GetHeap()->GetSpaces();
+ WriterMutexLock mu(Thread::Current(), *Locks::heap_bitmap_lock_);
+ // For sticky GC, we want to bind the bitmaps of both the zygote space and the alloc space.
+ // This lets us start with the mark bitmap of the previous garbage collection as the current
+ // mark bitmap of the alloc space. After the sticky GC finishes, we then unbind the bitmaps,
+ // making it so that the live bitmap of the alloc space is contains the newly marked objects
+ // from the sticky GC.
+ for (Spaces::iterator it = spaces.begin(); it != spaces.end(); ++it) {
+ if ((*it)->GetGcRetentionPolicy() == kGcRetentionPolicyAlwaysCollect) {
+ BindLiveToMarkBitmap(*it);
}
-
- GetHeap()->GetLargeObjectsSpace()->CopyLiveToMarked();
}
- void StickyMarkSweep::MarkReachableObjects() {
- DisableFinger();
- RecursiveMarkDirtyObjects(CardTable::kCardDirty - 1);
- }
+ GetHeap()->GetLargeObjectsSpace()->CopyLiveToMarked();
+}
- void StickyMarkSweep::Sweep(TimingLogger& timings, bool swap_bitmaps) {
- ObjectStack* live_stack = GetHeap()->GetLiveStack();
- SweepArray(timings_, live_stack, false);
- timings_.AddSplit("SweepArray");
- }
+void StickyMarkSweep::MarkReachableObjects() {
+ DisableFinger();
+ RecursiveMarkDirtyObjects(CardTable::kCardDirty - 1);
+}
+
+void StickyMarkSweep::Sweep(TimingLogger& timings, bool swap_bitmaps) {
+ ObjectStack* live_stack = GetHeap()->GetLiveStack();
+ SweepArray(timings_, live_stack, false);
+ timings_.AddSplit("SweepArray");
+}
+
} // namespace art
diff --git a/src/gc/sticky_mark_sweep.h b/src/gc/sticky_mark_sweep.h
index 8396bbe..41ab0cc 100644
--- a/src/gc/sticky_mark_sweep.h
+++ b/src/gc/sticky_mark_sweep.h
@@ -14,28 +14,15 @@
* limitations under the License.
*/
-#ifndef ART_SRC_STICKY_MARK_SWEEP_H_
-#define ART_SRC_STICKY_MARK_SWEEP_H_
+#ifndef ART_SRC_GC_STICKY_MARK_SWEEP_H_
+#define ART_SRC_GC_STICKY_MARK_SWEEP_H_
#include "base/macros.h"
#include "locks.h"
#include "partial_mark_sweep.h"
-#include "utils.h"
namespace art {
-class Barrier;
-class CheckObjectVisitor;
-class Class;
-class Heap;
-class MarkIfReachesAllocspaceVisitor;
-class ModUnionClearCardVisitor;
-class ModUnionVisitor;
-class ModUnionTableBitmap;
-class Object;
-class TimingLogger;
-class MarkStackChunk;
-
class StickyMarkSweep : public PartialMarkSweep {
public:
virtual GcType GetGcType() const {
@@ -60,4 +47,4 @@
} // namespace art
-#endif // ART_SRC_STICKY_MARK_SWEEP_H_
+#endif // ART_SRC_GC_STICKY_MARK_SWEEP_H_
diff --git a/src/heap.cc b/src/heap.cc
index 805d63c..5c96dec 100644
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -27,15 +27,24 @@
#include "debugger.h"
#include "gc/atomic_stack.h"
#include "gc/card_table.h"
+#include "gc/card_table-inl.h"
#include "gc/heap_bitmap.h"
+#include "gc/heap_bitmap-inl.h"
#include "gc/large_object_space.h"
#include "gc/mark_sweep.h"
+#include "gc/mark_sweep-inl.h"
#include "gc/partial_mark_sweep.h"
+#include "gc/space_bitmap-inl.h"
#include "gc/sticky_mark_sweep.h"
#include "gc/mod_union_table.h"
+#include "gc/mod_union_table-inl.h"
#include "gc/space.h"
#include "image.h"
-#include "object.h"
+#include "mirror/class-inl.h"
+#include "mirror/field-inl.h"
+#include "mirror/object.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
#include "object_utils.h"
#include "os.h"
#include "ScopedLocalRef.h"
@@ -431,7 +440,7 @@
delete gc_complete_lock_;
}
-ContinuousSpace* Heap::FindSpaceFromObject(const Object* obj) const {
+ContinuousSpace* Heap::FindSpaceFromObject(const mirror::Object* obj) const {
// TODO: C++0x auto
for (Spaces::const_iterator it = spaces_.begin(); it != spaces_.end(); ++it) {
if ((*it)->Contains(obj)) {
@@ -465,13 +474,13 @@
}
}
-Object* Heap::AllocObject(Thread* self, Class* c, size_t byte_count) {
- DCHECK(c == NULL || (c->IsClassClass() && byte_count >= sizeof(Class)) ||
+mirror::Object* Heap::AllocObject(Thread* self, mirror::Class* c, size_t byte_count) {
+ DCHECK(c == NULL || (c->IsClassClass() && byte_count >= sizeof(mirror::Class)) ||
(c->IsVariableSize() || c->GetObjectSize() == byte_count) ||
strlen(ClassHelper(c).GetDescriptor()) == 0);
- DCHECK_GE(byte_count, sizeof(Object));
+ DCHECK_GE(byte_count, sizeof(mirror::Object));
- Object* obj = NULL;
+ mirror::Object* obj = NULL;
size_t size = 0;
uint64_t allocation_start = 0;
if (measure_allocation_time_) {
@@ -513,7 +522,7 @@
// concurrent_start_bytes_.
concurrent_start_bytes_ = std::numeric_limits<size_t>::max();
// The SirtRef is necessary since the calls in RequestConcurrentGC are a safepoint.
- SirtRef<Object> ref(self, obj);
+ SirtRef<mirror::Object> ref(self, obj);
RequestConcurrentGC(self);
}
VerifyObject(obj);
@@ -547,7 +556,7 @@
return NULL;
}
-bool Heap::IsHeapAddress(const Object* obj) {
+bool Heap::IsHeapAddress(const mirror::Object* obj) {
// Note: we deliberately don't take the lock here, and mustn't test anything that would
// require taking the lock.
if (obj == NULL) {
@@ -566,7 +575,7 @@
return large_object_space_->Contains(obj);
}
-bool Heap::IsLiveObjectLocked(const Object* obj) {
+bool Heap::IsLiveObjectLocked(const mirror::Object* obj) {
Locks::heap_bitmap_lock_->AssertReaderHeld(Thread::Current());
return IsHeapAddress(obj) && GetLiveBitmap()->Test(obj);
}
@@ -596,7 +605,7 @@
}
}
-void Heap::VerifyObjectBody(const Object* obj) {
+void Heap::VerifyObjectBody(const mirror::Object* obj) {
if (!IsAligned<kObjectAlignment>(obj)) {
LOG(FATAL) << "Object isn't aligned: " << obj;
}
@@ -618,8 +627,8 @@
// Ignore early dawn of the universe verifications
if (!VERIFY_OBJECT_FAST && GetObjectsAllocated() > 10) {
const byte* raw_addr = reinterpret_cast<const byte*>(obj) +
- Object::ClassOffset().Int32Value();
- const Class* c = *reinterpret_cast<Class* const *>(raw_addr);
+ mirror::Object::ClassOffset().Int32Value();
+ const mirror::Class* c = *reinterpret_cast<mirror::Class* const *>(raw_addr);
if (c == NULL) {
LOG(FATAL) << "Null class in object: " << obj;
} else if (!IsAligned<kObjectAlignment>(c)) {
@@ -630,15 +639,15 @@
// Check obj.getClass().getClass() == obj.getClass().getClass().getClass()
// Note: we don't use the accessors here as they have internal sanity checks
// that we don't want to run
- raw_addr = reinterpret_cast<const byte*>(c) + Object::ClassOffset().Int32Value();
- const Class* c_c = *reinterpret_cast<Class* const *>(raw_addr);
- raw_addr = reinterpret_cast<const byte*>(c_c) + Object::ClassOffset().Int32Value();
- const Class* c_c_c = *reinterpret_cast<Class* const *>(raw_addr);
+ raw_addr = reinterpret_cast<const byte*>(c) + mirror::Object::ClassOffset().Int32Value();
+ const mirror::Class* c_c = *reinterpret_cast<mirror::Class* const *>(raw_addr);
+ raw_addr = reinterpret_cast<const byte*>(c_c) + mirror::Object::ClassOffset().Int32Value();
+ const mirror::Class* c_c_c = *reinterpret_cast<mirror::Class* const *>(raw_addr);
CHECK_EQ(c_c, c_c_c);
}
}
-void Heap::VerificationCallback(Object* obj, void* arg) {
+void Heap::VerificationCallback(mirror::Object* obj, void* arg) {
DCHECK(obj != NULL);
reinterpret_cast<Heap*>(arg)->VerifyObjectBody(obj);
}
@@ -648,7 +657,7 @@
GetLiveBitmap()->Walk(Heap::VerificationCallback, this);
}
-void Heap::RecordAllocation(size_t size, Object* obj) {
+void Heap::RecordAllocation(size_t size, mirror::Object* obj) {
DCHECK(obj != NULL);
DCHECK_GT(size, 0u);
num_bytes_allocated_ += size;
@@ -687,7 +696,7 @@
}
}
-Object* Heap::TryToAllocate(Thread* self, AllocSpace* space, size_t alloc_size, bool grow) {
+mirror::Object* Heap::TryToAllocate(Thread* self, AllocSpace* space, size_t alloc_size, bool grow) {
// Should we try to use a CAS here and fix up num_bytes_allocated_ later with AllocationSize?
if (num_bytes_allocated_ + alloc_size > max_allowed_footprint_) {
// max_allowed_footprint_ <= growth_limit_ so it is safe to check in here.
@@ -711,13 +720,13 @@
return space->Alloc(self, alloc_size);
}
-Object* Heap::Allocate(Thread* self, AllocSpace* space, size_t alloc_size) {
+mirror::Object* Heap::Allocate(Thread* self, AllocSpace* space, size_t alloc_size) {
// 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(self->GetState(), kRunnable);
self->AssertThreadSuspensionIsAllowable();
- Object* ptr = TryToAllocate(self, space, alloc_size, false);
+ mirror::Object* ptr = TryToAllocate(self, space, alloc_size, false);
if (ptr != NULL) {
return ptr;
}
@@ -838,14 +847,14 @@
class InstanceCounter {
public:
- InstanceCounter(const std::vector<Class*>& classes, bool use_is_assignable_from, uint64_t* counts)
+ InstanceCounter(const std::vector<mirror::Class*>& classes, bool use_is_assignable_from, uint64_t* counts)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
: classes_(classes), use_is_assignable_from_(use_is_assignable_from), counts_(counts) {
}
- void operator()(const Object* o) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ void operator()(const mirror::Object* o) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
for (size_t i = 0; i < classes_.size(); ++i) {
- const Class* instance_class = o->GetClass();
+ const mirror::Class* instance_class = o->GetClass();
if (use_is_assignable_from_) {
if (instance_class != NULL && classes_[i]->IsAssignableFrom(instance_class)) {
++counts_[i];
@@ -859,14 +868,14 @@
}
private:
- const std::vector<Class*>& classes_;
+ const std::vector<mirror::Class*>& classes_;
bool use_is_assignable_from_;
uint64_t* const counts_;
DISALLOW_COPY_AND_ASSIGN(InstanceCounter);
};
-void Heap::CountInstances(const std::vector<Class*>& classes, bool use_is_assignable_from,
+void Heap::CountInstances(const std::vector<mirror::Class*>& classes, bool use_is_assignable_from,
uint64_t* counts) {
// We only want reachable instances, so do a GC. This also ensures that the alloc stack
// is empty, so the live bitmap is the only place we need to look.
@@ -882,29 +891,30 @@
class InstanceCollector {
public:
- InstanceCollector(Class* c, int32_t max_count, std::vector<Object*>& instances)
+ InstanceCollector(mirror::Class* c, int32_t max_count, std::vector<mirror::Object*>& instances)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
: class_(c), max_count_(max_count), instances_(instances) {
}
- void operator()(const Object* o) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- const Class* instance_class = o->GetClass();
+ void operator()(const mirror::Object* o) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ const mirror::Class* instance_class = o->GetClass();
if (instance_class == class_) {
if (max_count_ == 0 || instances_.size() < max_count_) {
- instances_.push_back(const_cast<Object*>(o));
+ instances_.push_back(const_cast<mirror::Object*>(o));
}
}
}
private:
- Class* class_;
+ mirror::Class* class_;
uint32_t max_count_;
- std::vector<Object*>& instances_;
+ std::vector<mirror::Object*>& instances_;
DISALLOW_COPY_AND_ASSIGN(InstanceCollector);
};
-void Heap::GetInstances(Class* c, int32_t max_count, std::vector<Object*>& instances) {
+void Heap::GetInstances(mirror::Class* c, int32_t max_count,
+ std::vector<mirror::Object*>& instances) {
// We only want reachable instances, so do a GC. This also ensures that the alloc stack
// is empty, so the live bitmap is the only place we need to look.
Thread* self = Thread::Current();
@@ -919,7 +929,8 @@
class ReferringObjectsFinder {
public:
- ReferringObjectsFinder(Object* object, int32_t max_count, std::vector<Object*>& referring_objects)
+ ReferringObjectsFinder(mirror::Object* object, int32_t max_count,
+ std::vector<mirror::Object*>& referring_objects)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
: object_(object), max_count_(max_count), referring_objects_(referring_objects) {
}
@@ -927,27 +938,28 @@
// For bitmap Visit.
// TODO: Fix lock analysis to not use NO_THREAD_SAFETY_ANALYSIS, requires support for
// annotalysis on visitors.
- void operator()(const Object* o) const NO_THREAD_SAFETY_ANALYSIS {
+ void operator()(const mirror::Object* o) const NO_THREAD_SAFETY_ANALYSIS {
MarkSweep::VisitObjectReferences(o, *this);
}
// For MarkSweep::VisitObjectReferences.
- void operator ()(const Object* referrer, const Object* object, const MemberOffset&, bool) const {
+ void operator ()(const mirror::Object* referrer, const mirror::Object* object,
+ const MemberOffset&, bool) const {
if (object == object_ && (max_count_ == 0 || referring_objects_.size() < max_count_)) {
- referring_objects_.push_back(const_cast<Object*>(referrer));
+ referring_objects_.push_back(const_cast<mirror::Object*>(referrer));
}
}
private:
- Object* object_;
+ mirror::Object* object_;
uint32_t max_count_;
- std::vector<Object*>& referring_objects_;
+ std::vector<mirror::Object*>& referring_objects_;
DISALLOW_COPY_AND_ASSIGN(ReferringObjectsFinder);
};
-void Heap::GetReferringObjects(Object* o, int32_t max_count,
- std::vector<Object*>& referring_objects) {
+void Heap::GetReferringObjects(mirror::Object* o, int32_t max_count,
+ std::vector<mirror::Object*>& referring_objects) {
// We only want reachable instances, so do a GC. This also ensures that the alloc stack
// is empty, so the live bitmap is the only place we need to look.
Thread* self = Thread::Current();
@@ -1026,9 +1038,9 @@
}
void Heap::MarkAllocStack(SpaceBitmap* bitmap, SpaceSetMap* large_objects, ObjectStack* stack) {
- Object** limit = stack->End();
- for (Object** it = stack->Begin(); it != limit; ++it) {
- const Object* obj = *it;
+ mirror::Object** limit = stack->End();
+ for (mirror::Object** it = stack->Begin(); it != limit; ++it) {
+ const mirror::Object* obj = *it;
DCHECK(obj != NULL);
if (LIKELY(bitmap->HasAddress(obj))) {
bitmap->Set(obj);
@@ -1039,9 +1051,9 @@
}
void Heap::UnMarkAllocStack(SpaceBitmap* bitmap, SpaceSetMap* large_objects, ObjectStack* stack) {
- Object** limit = stack->End();
- for (Object** it = stack->Begin(); it != limit; ++it) {
- const Object* obj = *it;
+ mirror::Object** limit = stack->End();
+ for (mirror::Object** it = stack->Begin(); it != limit; ++it) {
+ const mirror::Object* obj = *it;
DCHECK(obj != NULL);
if (LIKELY(bitmap->HasAddress(obj))) {
bitmap->Clear(obj);
@@ -1187,8 +1199,8 @@
timings.AddSplit("MarkImageToAllocSpaceReferences");
}
-void Heap::RootMatchesObjectVisitor(const Object* root, void* arg) {
- Object* obj = reinterpret_cast<Object*>(arg);
+void Heap::RootMatchesObjectVisitor(const mirror::Object* root, void* arg) {
+ mirror::Object* obj = reinterpret_cast<mirror::Object*>(arg);
if (root == obj) {
LOG(INFO) << "Object " << obj << " is a root";
}
@@ -1196,7 +1208,7 @@
class ScanVisitor {
public:
- void operator ()(const Object* obj) const {
+ void operator ()(const mirror::Object* obj) const {
LOG(INFO) << "Would have rescanned object " << obj;
}
};
@@ -1212,8 +1224,9 @@
// TODO: Fix lock analysis to not use NO_THREAD_SAFETY_ANALYSIS, requires support for smarter
// analysis.
- void operator ()(const Object* obj, const Object* ref, const MemberOffset& /* offset */,
- bool /* is_static */) const NO_THREAD_SAFETY_ANALYSIS {
+ void operator ()(const mirror::Object* obj, const mirror::Object* ref,
+ const MemberOffset& /* offset */, bool /* is_static */) const
+ NO_THREAD_SAFETY_ANALYSIS {
// Verify that the reference is live.
if (ref != NULL && !IsLive(ref)) {
CardTable* card_table = heap_->GetCardTable();
@@ -1260,7 +1273,7 @@
}
}
- bool IsLive(const Object* obj) const NO_THREAD_SAFETY_ANALYSIS {
+ bool IsLive(const mirror::Object* obj) const NO_THREAD_SAFETY_ANALYSIS {
if (heap_->GetLiveBitmap()->Test(obj)) {
return true;
}
@@ -1284,7 +1297,7 @@
}
- void operator ()(const Object* obj) const
+ void operator ()(const mirror::Object* obj) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, Locks::heap_bitmap_lock_) {
VerifyReferenceVisitor visitor(heap_, const_cast<bool*>(&failed_));
MarkSweep::VisitObjectReferences(obj, visitor);
@@ -1328,8 +1341,8 @@
// TODO: Fix lock analysis to not use NO_THREAD_SAFETY_ANALYSIS, requires support for
// annotalysis on visitors.
- void operator ()(const Object* obj, const Object* ref, const MemberOffset& offset,
- bool is_static) const NO_THREAD_SAFETY_ANALYSIS {
+ void operator ()(const mirror::Object* obj, const mirror::Object* ref, const MemberOffset& offset,
+ bool is_static) const NO_THREAD_SAFETY_ANALYSIS {
// Filter out class references since changing an object's class does not mark the card as dirty.
// Also handles large objects, since the only reference they hold is a class reference.
if (ref != NULL && !ref->IsClass()) {
@@ -1355,12 +1368,13 @@
// Print which field of the object is dead.
if (!obj->IsObjectArray()) {
- const Class* klass = is_static ? obj->AsClass() : obj->GetClass();
+ const mirror::Class* klass = is_static ? obj->AsClass() : obj->GetClass();
CHECK(klass != NULL);
- const ObjectArray<Field>* fields = is_static ? klass->GetSFields() : klass->GetIFields();
+ const mirror::ObjectArray<mirror::Field>* fields = is_static ? klass->GetSFields()
+ : klass->GetIFields();
CHECK(fields != NULL);
for (int32_t i = 0; i < fields->GetLength(); ++i) {
- const Field* cur = fields->Get(i);
+ const mirror::Field* cur = fields->Get(i);
if (cur->GetOffset().Int32Value() == offset.Int32Value()) {
LOG(ERROR) << (is_static ? "Static " : "") << "field in the live stack is "
<< PrettyField(cur);
@@ -1368,7 +1382,8 @@
}
}
} else {
- const ObjectArray<Object>* object_array = obj->AsObjectArray<Object>();
+ const mirror::ObjectArray<mirror::Object>* object_array =
+ obj->AsObjectArray<mirror::Object>();
for (int32_t i = 0; i < object_array->GetLength(); ++i) {
if (object_array->Get(i) == ref) {
LOG(ERROR) << (is_static ? "Static " : "") << "obj[" << i << "] = ref";
@@ -1395,7 +1410,7 @@
}
- void operator ()(const Object* obj) const
+ void operator ()(const mirror::Object* obj) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_, Locks::heap_bitmap_lock_) {
VerifyReferenceCardVisitor visitor(heap_, const_cast<bool*>(&failed_));
MarkSweep::VisitObjectReferences(obj, visitor);
@@ -1419,7 +1434,7 @@
GetLiveBitmap()->Visit(visitor);
// We can verify objects in the live stack since none of these should reference dead objects.
- for (Object** it = live_stack_->Begin(); it != live_stack_->End(); ++it) {
+ for (mirror::Object** it = live_stack_->Begin(); it != live_stack_->End(); ++it) {
visitor(*it);
}
@@ -1636,34 +1651,36 @@
CHECK_NE(finalizer_reference_zombie_offset_.Uint32Value(), 0U);
}
-Object* Heap::GetReferenceReferent(Object* reference) {
+mirror::Object* Heap::GetReferenceReferent(mirror::Object* reference) {
DCHECK(reference != NULL);
DCHECK_NE(reference_referent_offset_.Uint32Value(), 0U);
- return reference->GetFieldObject<Object*>(reference_referent_offset_, true);
+ return reference->GetFieldObject<mirror::Object*>(reference_referent_offset_, true);
}
-void Heap::ClearReferenceReferent(Object* reference) {
+void Heap::ClearReferenceReferent(mirror::Object* reference) {
DCHECK(reference != NULL);
DCHECK_NE(reference_referent_offset_.Uint32Value(), 0U);
reference->SetFieldObject(reference_referent_offset_, NULL, true);
}
// Returns true if the reference object has not yet been enqueued.
-bool Heap::IsEnqueuable(const Object* ref) {
+bool Heap::IsEnqueuable(const mirror::Object* ref) {
DCHECK(ref != NULL);
- const Object* queue = ref->GetFieldObject<Object*>(reference_queue_offset_, false);
- const Object* queue_next = ref->GetFieldObject<Object*>(reference_queueNext_offset_, false);
+ const mirror::Object* queue =
+ ref->GetFieldObject<mirror::Object*>(reference_queue_offset_, false);
+ const mirror::Object* queue_next =
+ ref->GetFieldObject<mirror::Object*>(reference_queueNext_offset_, false);
return (queue != NULL) && (queue_next == NULL);
}
-void Heap::EnqueueReference(Object* ref, Object** cleared_reference_list) {
+void Heap::EnqueueReference(mirror::Object* ref, mirror::Object** cleared_reference_list) {
DCHECK(ref != NULL);
- CHECK(ref->GetFieldObject<Object*>(reference_queue_offset_, false) != NULL);
- CHECK(ref->GetFieldObject<Object*>(reference_queueNext_offset_, false) == NULL);
+ CHECK(ref->GetFieldObject<mirror::Object*>(reference_queue_offset_, false) != NULL);
+ CHECK(ref->GetFieldObject<mirror::Object*>(reference_queueNext_offset_, false) == NULL);
EnqueuePendingReference(ref, cleared_reference_list);
}
-void Heap::EnqueuePendingReference(Object* ref, Object** list) {
+void Heap::EnqueuePendingReference(mirror::Object* ref, mirror::Object** list) {
DCHECK(ref != NULL);
DCHECK(list != NULL);
@@ -1673,17 +1690,19 @@
ref->SetFieldObject(reference_pendingNext_offset_, ref, false);
*list = ref;
} else {
- Object* head = (*list)->GetFieldObject<Object*>(reference_pendingNext_offset_, false);
+ mirror::Object* head =
+ (*list)->GetFieldObject<mirror::Object*>(reference_pendingNext_offset_, false);
ref->SetFieldObject(reference_pendingNext_offset_, head, false);
(*list)->SetFieldObject(reference_pendingNext_offset_, ref, false);
}
}
-Object* Heap::DequeuePendingReference(Object** list) {
+mirror::Object* Heap::DequeuePendingReference(mirror::Object** list) {
DCHECK(list != NULL);
DCHECK(*list != NULL);
- Object* head = (*list)->GetFieldObject<Object*>(reference_pendingNext_offset_, false);
- Object* ref;
+ mirror::Object* head = (*list)->GetFieldObject<mirror::Object*>(reference_pendingNext_offset_,
+ false);
+ mirror::Object* ref;
// Note: the following code is thread-safe because it is only called from ProcessReferences which
// is single threaded.
@@ -1691,7 +1710,8 @@
ref = *list;
*list = NULL;
} else {
- Object* next = head->GetFieldObject<Object*>(reference_pendingNext_offset_, false);
+ mirror::Object* next = head->GetFieldObject<mirror::Object*>(reference_pendingNext_offset_,
+ false);
(*list)->SetFieldObject(reference_pendingNext_offset_, next, false);
ref = head;
}
@@ -1699,7 +1719,7 @@
return ref;
}
-void Heap::AddFinalizerReference(Thread* self, Object* object) {
+void Heap::AddFinalizerReference(Thread* self, mirror::Object* object) {
ScopedObjectAccess soa(self);
JValue args[1];
args[0].SetL(object);
@@ -1731,7 +1751,7 @@
return concurrent_min_free_;
}
-void Heap::EnqueueClearedReferences(Object** cleared) {
+void Heap::EnqueueClearedReferences(mirror::Object** cleared) {
DCHECK(cleared != NULL);
if (*cleared != NULL) {
// When a runtime isn't started there are no reference queues to care about so ignore.
diff --git a/src/heap.h b/src/heap.h
index b7fc34d..9981f83 100644
--- a/src/heap.h
+++ b/src/heap.h
@@ -24,6 +24,7 @@
#include "atomic_integer.h"
#include "gc/atomic_stack.h"
#include "gc/card_table.h"
+#include "gc/gc_type.h"
#include "gc/heap_bitmap.h"
#include "globals.h"
#include "gtest/gtest.h"
@@ -39,9 +40,11 @@
#define VERIFY_OBJECT_FAST 1
namespace art {
-
-class AllocSpace;
+namespace mirror {
class Class;
+class Object;
+} // namespace mirror
+class AllocSpace;
class ConditionVariable;
class DlMallocSpace;
class GarbageCollector;
@@ -51,14 +54,12 @@
class MarkSweep;
class ModUnionTable;
class Mutex;
-class Object;
class Space;
class SpaceTest;
class StackVisitor;
class Thread;
class TimingLogger;
-typedef AtomicStack<Object*> ObjectStack;
typedef std::vector<ContinuousSpace*> Spaces;
class AgeCardVisitor {
@@ -72,21 +73,6 @@
}
};
-// The ordering of the enum matters, it is used to determine which GCs are run first.
-enum GcType {
- // No Gc
- kGcTypeNone,
- // Sticky mark bits "generational" GC.
- kGcTypeSticky,
- // Partial GC, over only the alloc space.
- kGcTypePartial,
- // Full GC
- kGcTypeFull,
- // Number of different Gc types.
- kGcTypeMax,
-};
-std::ostream& operator<<(std::ostream& os, const GcType& policy);
-
enum GcCause {
kGcCauseForAlloc,
kGcCauseBackground,
@@ -107,11 +93,6 @@
// Used so that we don't overflow the allocation time atomic integer.
static const size_t kTimeAdjust = 1024;
- typedef void (RootVisitor)(const Object* root, void* arg);
- typedef void (VerifyRootVisitor)(const Object* root, void* arg, size_t vreg,
- const StackVisitor* visitor);
- typedef bool (IsMarkedTester)(const Object* object, void* arg);
-
// Create a heap with the requested sizes. The possible empty
// image_file_names names specify Spaces to load based on
// ImageWriter output.
@@ -122,19 +103,19 @@
~Heap();
// Allocates and initializes storage for an object instance.
- Object* AllocObject(Thread* self, Class* klass, size_t num_bytes)
+ mirror::Object* AllocObject(Thread* self, mirror::Class* klass, size_t num_bytes)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Check sanity of given reference. Requires the heap lock.
#if VERIFY_OBJECT_ENABLED
- void VerifyObject(const Object* o);
+ void VerifyObject(const mirror::Object* o);
#else
- void VerifyObject(const Object*) {}
+ void VerifyObject(const mirror::Object*) {}
#endif
// Check sanity of all live references. Requires the heap lock.
void VerifyHeap() LOCKS_EXCLUDED(Locks::heap_bitmap_lock_);
- static void RootMatchesObjectVisitor(const Object* root, void* arg);
+ static void RootMatchesObjectVisitor(const mirror::Object* root, void* arg);
bool VerifyHeapReferences()
EXCLUSIVE_LOCKS_REQUIRED(Locks::heap_bitmap_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -145,11 +126,11 @@
// A weaker test than IsLiveObject or VerifyObject that doesn't require the heap lock,
// and doesn't abort on error, allowing the caller to report more
// meaningful diagnostics.
- bool IsHeapAddress(const Object* obj);
+ bool IsHeapAddress(const mirror::Object* obj);
// Returns true if 'obj' is a live heap object, false otherwise (including for invalid addresses).
// Requires the heap lock to be held.
- bool IsLiveObjectLocked(const Object* obj)
+ bool IsLiveObjectLocked(const mirror::Object* obj)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
// Initiates an explicit garbage collection.
@@ -169,16 +150,16 @@
// Implements VMDebug.countInstancesOfClass and JDWP VM_InstanceCount.
// The boolean decides whether to use IsAssignableFrom or == when comparing classes.
- void CountInstances(const std::vector<Class*>& classes, bool use_is_assignable_from,
+ void CountInstances(const std::vector<mirror::Class*>& classes, bool use_is_assignable_from,
uint64_t* counts)
LOCKS_EXCLUDED(Locks::heap_bitmap_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Implements JDWP RT_Instances.
- void GetInstances(Class* c, int32_t max_count, std::vector<Object*>& instances)
+ void GetInstances(mirror::Class* c, int32_t max_count, std::vector<mirror::Object*>& instances)
LOCKS_EXCLUDED(Locks::heap_bitmap_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Implements JDWP OR_ReferringObjects.
- void GetReferringObjects(Object* o, int32_t max_count, std::vector<Object*>& referring_objects)
+ void GetReferringObjects(mirror::Object* o, int32_t max_count, std::vector<mirror::Object*>& referring_objects)
LOCKS_EXCLUDED(Locks::heap_bitmap_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -218,15 +199,15 @@
MemberOffset reference_pendingNext_offset,
MemberOffset finalizer_reference_zombie_offset);
- Object* GetReferenceReferent(Object* reference);
- void ClearReferenceReferent(Object* reference) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ mirror::Object* GetReferenceReferent(mirror::Object* reference);
+ void ClearReferenceReferent(mirror::Object* reference) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Returns true if the reference object has not yet been enqueued.
- bool IsEnqueuable(const Object* ref);
- void EnqueueReference(Object* ref, Object** list) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void EnqueuePendingReference(Object* ref, Object** list)
+ bool IsEnqueuable(const mirror::Object* ref);
+ void EnqueueReference(mirror::Object* ref, mirror::Object** list) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void EnqueuePendingReference(mirror::Object* ref, mirror::Object** list)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Object* DequeuePendingReference(Object** list) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ mirror::Object* DequeuePendingReference(mirror::Object** list) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
MemberOffset GetReferencePendingNextOffset() {
DCHECK_NE(reference_pendingNext_offset_.Uint32Value(), 0U);
@@ -257,12 +238,12 @@
// Must be called if a field of an Object in the heap changes, and before any GC safe-point.
// The call is not needed if NULL is stored in the field.
- void WriteBarrierField(const Object* dst, MemberOffset /*offset*/, const Object* /*new_value*/) {
+ void WriteBarrierField(const mirror::Object* dst, MemberOffset /*offset*/, const mirror::Object* /*new_value*/) {
card_table_->MarkCard(dst);
}
// Write barrier for array operations that update many field positions
- void WriteBarrierArray(const Object* dst, int /*start_offset*/,
+ void WriteBarrierArray(const mirror::Object* dst, int /*start_offset*/,
size_t /*length TODO: element_count or byte_count?*/) {
card_table_->MarkCard(dst);
}
@@ -271,7 +252,7 @@
return card_table_.get();
}
- void AddFinalizerReference(Thread* self, Object* object);
+ void AddFinalizerReference(Thread* self, mirror::Object* object);
size_t GetBytesAllocated() const;
size_t GetObjectsAllocated() const;
@@ -293,7 +274,7 @@
// Functions for getting the bitmap which corresponds to an object's address.
// This is probably slow, TODO: use better data structure like binary tree .
- ContinuousSpace* FindSpaceFromObject(const Object*) const;
+ ContinuousSpace* FindSpaceFromObject(const mirror::Object*) const;
void DumpForSigQuit(std::ostream& os);
@@ -354,22 +335,22 @@
private:
// Allocates uninitialized storage. Passing in a null space tries to place the object in the
// large object space.
- Object* Allocate(Thread* self, AllocSpace* space, size_t num_bytes)
+ mirror::Object* Allocate(Thread* self, AllocSpace* space, size_t num_bytes)
LOCKS_EXCLUDED(Locks::thread_suspend_count_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Try to allocate a number of bytes, this function never does any GCs.
- Object* TryToAllocate(Thread* self, AllocSpace* space, size_t alloc_size, bool grow)
+ mirror::Object* TryToAllocate(Thread* self, AllocSpace* space, size_t alloc_size, bool grow)
LOCKS_EXCLUDED(Locks::thread_suspend_count_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Pushes a list of cleared references out to the managed heap.
- void EnqueueClearedReferences(Object** cleared_references);
+ void EnqueueClearedReferences(mirror::Object** cleared_references);
void RequestHeapTrim() LOCKS_EXCLUDED(Locks::runtime_shutdown_lock_);
void RequestConcurrentGC(Thread* self) LOCKS_EXCLUDED(Locks::runtime_shutdown_lock_);
- void RecordAllocation(size_t size, Object* object)
+ void RecordAllocation(size_t size, mirror::Object* object)
LOCKS_EXCLUDED(GlobalSynchronization::heap_bitmap_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -395,9 +376,9 @@
// No thread saftey analysis since we call this everywhere and it is impossible to find a proper
// lock ordering for it.
- void VerifyObjectBody(const Object *obj) NO_THREAD_SAFETY_ANALYSIS;
+ void VerifyObjectBody(const mirror::Object *obj) NO_THREAD_SAFETY_ANALYSIS;
- static void VerificationCallback(Object* obj, void* arg)
+ static void VerificationCallback(mirror::Object* obj, void* arg)
SHARED_LOCKS_REQUIRED(GlobalSychronization::heap_bitmap_lock_);
// Swap the allocation stack with the live stack.
diff --git a/src/heap_test.cc b/src/heap_test.cc
index 6db7416..79cc835 100644
--- a/src/heap_test.cc
+++ b/src/heap_test.cc
@@ -15,6 +15,11 @@
*/
#include "common_test.h"
+#include "gc/card_table-inl.h"
+#include "gc/space_bitmap-inl.h"
+#include "mirror/class-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
#include "sirt_ref.h"
namespace art {
@@ -37,12 +42,12 @@
ScopedObjectAccess soa(Thread::Current());
// garbage is created during ClassLinker::Init
- Class* c = class_linker_->FindSystemClass("[Ljava/lang/Object;");
+ mirror::Class* c = class_linker_->FindSystemClass("[Ljava/lang/Object;");
for (size_t i = 0; i < 1024; ++i) {
- SirtRef<ObjectArray<Object> > array(soa.Self(),
- ObjectArray<Object>::Alloc(soa.Self(), c, 2048));
+ SirtRef<mirror::ObjectArray<mirror::Object> > array(soa.Self(),
+ mirror::ObjectArray<mirror::Object>::Alloc(soa.Self(), c, 2048));
for (size_t j = 0; j < 2048; ++j) {
- array->Set(j, String::AllocFromModifiedUtf8(soa.Self(), "hello, world!"));
+ array->Set(j, mirror::String::AllocFromModifiedUtf8(soa.Self(), "hello, world!"));
}
}
}
@@ -53,7 +58,7 @@
byte* heap_begin = reinterpret_cast<byte*>(0x1000);
const size_t heap_capacity = SpaceBitmap::kAlignment * (sizeof(intptr_t) * 8 + 1);
UniquePtr<SpaceBitmap> bitmap(SpaceBitmap::Create("test-bitmap", heap_begin, heap_capacity));
- bitmap->Set(reinterpret_cast<const Object*>(&heap_begin[heap_capacity - SpaceBitmap::kAlignment]));
+ bitmap->Set(reinterpret_cast<const mirror::Object*>(&heap_begin[heap_capacity - SpaceBitmap::kAlignment]));
}
} // namespace art
diff --git a/src/hprof/hprof.cc b/src/hprof/hprof.cc
index c0e73bc..e0a4c05 100644
--- a/src/hprof/hprof.cc
+++ b/src/hprof/hprof.cc
@@ -44,7 +44,11 @@
#include "debugger.h"
#include "globals.h"
#include "heap.h"
-#include "object.h"
+#include "mirror/class.h"
+#include "mirror/class-inl.h"
+#include "mirror/field.h"
+#include "mirror/field-inl.h"
+#include "mirror/object-inl.h"
#include "object_utils.h"
#include "os.h"
#include "safe_map.h"
@@ -165,8 +169,8 @@
typedef HprofId HprofStringId;
typedef HprofId HprofObjectId;
typedef HprofId HprofClassObjectId;
-typedef std::set<Class*> ClassSet;
-typedef std::set<Class*>::iterator ClassSetIterator;
+typedef std::set<mirror::Class*> ClassSet;
+typedef std::set<mirror::Class*>::iterator ClassSetIterator;
typedef SafeMap<std::string, size_t> StringMap;
typedef SafeMap<std::string, size_t>::iterator StringMapIterator;
@@ -480,14 +484,14 @@
}
private:
- static void RootVisitor(const Object* obj, void* arg)
+ static void RootVisitor(const mirror::Object* obj, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
CHECK(arg != NULL);
Hprof* hprof = reinterpret_cast<Hprof*>(arg);
hprof->VisitRoot(obj);
}
- static void HeapBitmapCallback(Object* obj, void* arg)
+ static void HeapBitmapCallback(mirror::Object* obj, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
CHECK(obj != NULL);
CHECK(arg != NULL);
@@ -495,9 +499,9 @@
hprof->DumpHeapObject(obj);
}
- void VisitRoot(const Object* obj) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void VisitRoot(const mirror::Object* obj) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- int DumpHeapObject(Object* obj) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ int DumpHeapObject(mirror::Object* obj) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void Finish() {
}
@@ -507,7 +511,7 @@
uint32_t nextSerialNumber = 1;
for (ClassSetIterator it = classes_.begin(); it != classes_.end(); ++it) {
- const Class* c = *it;
+ const mirror::Class* c = *it;
CHECK(c != NULL);
int err = current_record_.StartNewRecord(header_fp_, HPROF_TAG_LOAD_CLASS, HPROF_TIME);
@@ -567,9 +571,9 @@
current_heap_ = HPROF_HEAP_DEFAULT;
}
- int MarkRootObject(const Object* obj, jobject jniObj);
+ int MarkRootObject(const mirror::Object* obj, jobject jniObj);
- HprofClassObjectId LookupClassId(Class* c)
+ HprofClassObjectId LookupClassId(mirror::Class* c)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (c == NULL) {
// c is the superclass of java.lang.Object or a primitive
@@ -577,7 +581,7 @@
}
std::pair<ClassSetIterator, bool> result = classes_.insert(c);
- const Class* present = *result.first;
+ const mirror::Class* present = *result.first;
// Make sure that we've assigned a string ID for this class' name
LookupClassNameId(c);
@@ -586,7 +590,7 @@
return (HprofStringId) present;
}
- HprofStringId LookupStringId(String* string) {
+ HprofStringId LookupStringId(mirror::String* string) {
return LookupStringId(string->ToModifiedUtf8());
}
@@ -604,7 +608,7 @@
return id;
}
- HprofStringId LookupClassNameId(const Class* c)
+ HprofStringId LookupClassNameId(const mirror::Class* c)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return LookupStringId(PrettyDescriptor(c));
}
@@ -740,7 +744,7 @@
// something when ctx->gc_scan_state_ is non-zero, which is usually
// only true when marking the root set or unreachable
// objects. Used to add rootset references to obj.
-int Hprof::MarkRootObject(const Object* obj, jobject jniObj) {
+int Hprof::MarkRootObject(const mirror::Object* obj, jobject jniObj) {
HprofRecord* rec = ¤t_record_;
HprofHeapTag heapTag = (HprofHeapTag)gc_scan_state_;
@@ -823,11 +827,11 @@
return 0;
}
-static int StackTraceSerialNumber(const Object* /*obj*/) {
+static int StackTraceSerialNumber(const mirror::Object* /*obj*/) {
return HPROF_NULL_STACK_TRACE;
}
-int Hprof::DumpHeapObject(Object* obj) {
+int Hprof::DumpHeapObject(mirror::Object* obj) {
HprofRecord* rec = ¤t_record_;
HprofHeapId desiredHeap = false ? HPROF_HEAP_ZYGOTE : HPROF_HEAP_APP; // TODO: zygote objects?
@@ -859,7 +863,7 @@
current_heap_ = desiredHeap;
}
- Class* c = obj->GetClass();
+ mirror::Class* c = obj->GetClass();
if (c == NULL) {
// This object will bother HprofReader, because it has a NULL
// class, so just don't dump it. It could be
@@ -867,7 +871,7 @@
// allocated which hasn't been initialized yet.
} else {
if (obj->IsClass()) {
- Class* thisClass = obj->AsClass();
+ mirror::Class* thisClass = obj->AsClass();
// obj is a ClassObject.
size_t sFieldCount = thisClass->NumStaticFields();
if (sFieldCount != 0) {
@@ -896,7 +900,7 @@
if (thisClass->IsClassClass()) {
// ClassObjects have their static fields appended, so aren't all the same size.
// But they're at least this size.
- rec->AddU4(sizeof(Class)); // instance size
+ rec->AddU4(sizeof(mirror::Class)); // instance size
} else if (thisClass->IsArrayClass() || thisClass->IsPrimitive()) {
rec->AddU4(0);
} else {
@@ -917,7 +921,7 @@
rec->AddId(CLASS_STATICS_ID(obj));
for (size_t i = 0; i < sFieldCount; ++i) {
- Field* f = thisClass->GetStaticField(i);
+ mirror::Field* f = thisClass->GetStaticField(i);
fh.ChangeField(f);
size_t size;
@@ -942,14 +946,14 @@
int iFieldCount = thisClass->IsObjectClass() ? 0 : thisClass->NumInstanceFields();
rec->AddU2((uint16_t)iFieldCount);
for (int i = 0; i < iFieldCount; ++i) {
- Field* f = thisClass->GetInstanceField(i);
+ mirror::Field* f = thisClass->GetInstanceField(i);
fh.ChangeField(f);
HprofBasicType t = SignatureToBasicTypeAndSize(fh.GetTypeDescriptor(), NULL);
rec->AddId(LookupStringId(fh.GetName()));
rec->AddU1(t);
}
} else if (c->IsArrayClass()) {
- const Array* aobj = obj->AsArray();
+ const mirror::Array* aobj = obj->AsArray();
uint32_t length = aobj->GetLength();
if (obj->IsObjectArray()) {
@@ -962,7 +966,7 @@
rec->AddId(LookupClassId(c));
// Dump the elements, which are always objects or NULL.
- rec->AddIdList((const HprofObjectId*)aobj->GetRawData(sizeof(Object*)), length);
+ rec->AddIdList((const HprofObjectId*)aobj->GetRawData(sizeof(mirror::Object*)), length);
} else {
size_t size;
HprofBasicType t = PrimitiveToBasicTypeAndSize(c->GetComponentType()->GetPrimitiveType(), &size);
@@ -1000,12 +1004,12 @@
// Write the instance data; fields for this class, followed by super class fields,
// and so on. Don't write the klass or monitor fields of Object.class.
- const Class* sclass = c;
+ const mirror::Class* sclass = c;
FieldHelper fh;
while (!sclass->IsObjectClass()) {
int ifieldCount = sclass->NumInstanceFields();
for (int i = 0; i < ifieldCount; ++i) {
- Field* f = sclass->GetInstanceField(i);
+ mirror::Field* f = sclass->GetInstanceField(i);
fh.ChangeField(f);
size_t size;
SignatureToBasicTypeAndSize(fh.GetTypeDescriptor(), &size);
@@ -1034,7 +1038,7 @@
return 0;
}
-void Hprof::VisitRoot(const Object* obj) {
+void Hprof::VisitRoot(const mirror::Object* obj) {
uint32_t threadId = 0; // TODO
/*RootType*/ size_t type = 0; // TODO
diff --git a/src/image.cc b/src/image.cc
index a190f10..8eeb772 100644
--- a/src/image.cc
+++ b/src/image.cc
@@ -16,9 +16,47 @@
#include "image.h"
+#include "mirror/object_array.h"
+#include "mirror/object_array-inl.h"
+#include "utils.h"
+
namespace art {
const byte ImageHeader::kImageMagic[] = { 'a', 'r', 't', '\n' };
const byte ImageHeader::kImageVersion[] = { '0', '0', '2', '\0' };
+ImageHeader::ImageHeader(uint32_t image_begin,
+ uint32_t image_roots,
+ uint32_t oat_checksum,
+ uint32_t oat_file_begin,
+ uint32_t oat_data_begin,
+ uint32_t oat_data_end,
+ uint32_t oat_file_end)
+ : image_begin_(image_begin),
+ oat_checksum_(oat_checksum),
+ oat_file_begin_(oat_file_begin),
+ oat_data_begin_(oat_data_begin),
+ oat_data_end_(oat_data_end),
+ oat_file_end_(oat_file_end),
+ image_roots_(image_roots) {
+ CHECK_EQ(image_begin, RoundUp(image_begin, kPageSize));
+ CHECK_EQ(oat_file_begin, RoundUp(oat_file_begin, kPageSize));
+ CHECK_EQ(oat_data_begin, RoundUp(oat_data_begin, kPageSize));
+ CHECK_LT(image_begin, image_roots);
+ CHECK_LT(image_roots, oat_file_begin);
+ CHECK_LE(oat_file_begin, oat_data_begin);
+ CHECK_LT(oat_data_begin, oat_data_end);
+ CHECK_LE(oat_data_end, oat_file_end);
+ memcpy(magic_, kImageMagic, sizeof(kImageMagic));
+ memcpy(version_, kImageVersion, sizeof(kImageVersion));
+}
+
+mirror::Object* ImageHeader::GetImageRoot(ImageRoot image_root) const {
+ return GetImageRoots()->Get(image_root);
+}
+
+mirror::ObjectArray<mirror::Object>* ImageHeader::GetImageRoots() const {
+ return reinterpret_cast<mirror::ObjectArray<mirror::Object>*>(image_roots_);
+}
+
} // namespace art
diff --git a/src/image.h b/src/image.h
index f38f04b..6501328 100644
--- a/src/image.h
+++ b/src/image.h
@@ -20,7 +20,7 @@
#include <string.h>
#include "globals.h"
-#include "object.h"
+#include "mirror/object.h"
namespace art {
@@ -35,25 +35,7 @@
uint32_t oat_file_begin,
uint32_t oat_data_begin,
uint32_t oat_data_end,
- uint32_t oat_file_end)
- : image_begin_(image_begin),
- oat_checksum_(oat_checksum),
- oat_file_begin_(oat_file_begin),
- oat_data_begin_(oat_data_begin),
- oat_data_end_(oat_data_end),
- oat_file_end_(oat_file_end),
- image_roots_(image_roots) {
- CHECK_EQ(image_begin, RoundUp(image_begin, kPageSize));
- CHECK_EQ(oat_file_begin, RoundUp(oat_file_begin, kPageSize));
- CHECK_EQ(oat_data_begin, RoundUp(oat_data_begin, kPageSize));
- CHECK_LT(image_begin, image_roots);
- CHECK_LT(image_roots, oat_file_begin);
- CHECK_LE(oat_file_begin, oat_data_begin);
- CHECK_LT(oat_data_begin, oat_data_end);
- CHECK_LE(oat_data_end, oat_file_end);
- memcpy(magic_, kImageMagic, sizeof(kImageMagic));
- memcpy(version_, kImageVersion, sizeof(kImageVersion));
- }
+ uint32_t oat_file_end);
bool IsValid() const {
if (memcmp(magic_, kImageMagic, sizeof(kImageMagic) != 0)) {
@@ -113,15 +95,11 @@
kImageRootsMax,
};
- Object* GetImageRoot(ImageRoot image_root) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return GetImageRoots()->Get(image_root);
- }
+ mirror::Object* GetImageRoot(ImageRoot image_root) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
private:
- ObjectArray<Object>* GetImageRoots() const {
- return reinterpret_cast<ObjectArray<Object>*>(image_roots_);
- }
+ mirror::ObjectArray<mirror::Object>* GetImageRoots() const;
static const byte kImageMagic[4];
static const byte kImageVersion[4];
diff --git a/src/image_test.cc b/src/image_test.cc
index 89e3a05..ed6426b 100644
--- a/src/image_test.cc
+++ b/src/image_test.cc
@@ -54,7 +54,7 @@
for (size_t i = 0; i < java_lang_dex_file_->NumClassDefs(); ++i) {
const DexFile::ClassDef& class_def = java_lang_dex_file_->GetClassDef(i);
const char* descriptor = java_lang_dex_file_->GetClassDescriptor(class_def);
- Class* klass = class_linker_->FindSystemClass(descriptor);
+ mirror::Class* klass = class_linker_->FindSystemClass(descriptor);
EXPECT_TRUE(klass != NULL) << descriptor;
}
}
@@ -139,7 +139,7 @@
for (size_t i = 0; i < dex->NumClassDefs(); ++i) {
const DexFile::ClassDef& class_def = dex->GetClassDef(i);
const char* descriptor = dex->GetClassDescriptor(class_def);
- Class* klass = class_linker_->FindSystemClass(descriptor);
+ mirror::Class* klass = class_linker_->FindSystemClass(descriptor);
EXPECT_TRUE(klass != NULL) << descriptor;
EXPECT_LT(image_begin, reinterpret_cast<byte*>(klass)) << descriptor;
EXPECT_LT(reinterpret_cast<byte*>(klass), image_end) << descriptor;
diff --git a/src/image_writer.cc b/src/image_writer.cc
index fc88cbb..dc19d72 100644
--- a/src/image_writer.cc
+++ b/src/image_writer.cc
@@ -23,19 +23,25 @@
#include "base/logging.h"
#include "base/unix_file/fd_file.h"
#include "class_linker.h"
-#include "class_loader.h"
#include "compiled_method.h"
#include "compiler.h"
-#include "dex_cache.h"
+#include "gc/card_table-inl.h"
#include "gc/large_object_space.h"
#include "gc/space.h"
#include "globals.h"
#include "heap.h"
#include "image.h"
#include "intern_table.h"
+#include "mirror/array-inl.h"
+#include "mirror/class-inl.h"
+#include "mirror/class_loader.h"
+#include "mirror/dex_cache.h"
+#include "mirror/field-inl.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
#include "oat.h"
#include "oat_file.h"
-#include "object.h"
#include "object_utils.h"
#include "runtime.h"
#include "scoped_thread_state_change.h"
@@ -43,6 +49,8 @@
#include "UniquePtr.h"
#include "utils.h"
+using namespace art::mirror;
+
namespace art {
bool ImageWriter::Write(const std::string& image_filename,
@@ -442,7 +450,7 @@
DCHECK_LT(offset + n, image_writer->image_->Size());
memcpy(dst, src, n);
Object* copy = reinterpret_cast<Object*>(dst);
- copy->monitor_ = 0; // We may have inflated the lock during compilation.
+ copy->SetField32(Object::MonitorOffset(), 0, false); // We may have inflated the lock during compilation.
image_writer->FixupObject(obj, copy);
}
@@ -476,13 +484,13 @@
// Every type of method can have an invoke stub
uint32_t invoke_stub_offset = orig->GetOatInvokeStubOffset();
const byte* invoke_stub = GetOatAddress(invoke_stub_offset);
- copy->invoke_stub_ = reinterpret_cast<AbstractMethod::InvokeStub*>(const_cast<byte*>(invoke_stub));
+ copy->SetInvokeStub(reinterpret_cast<AbstractMethod::InvokeStub*>(const_cast<byte*>(invoke_stub)));
if (orig->IsAbstract()) {
// Abstract methods are pointed to a stub that will throw AbstractMethodError if they are called
ByteArray* orig_ame_stub_array_ = Runtime::Current()->GetAbstractMethodErrorStubArray();
ByteArray* copy_ame_stub_array_ = down_cast<ByteArray*>(GetImageAddress(orig_ame_stub_array_));
- copy->code_ = copy_ame_stub_array_->GetData();
+ copy->SetCode(copy_ame_stub_array_->GetData());
return;
}
@@ -492,7 +500,7 @@
Runtime::Current()->GetResolutionStubArray(Runtime::kUnknownMethod);
CHECK(orig->GetCode() == orig_res_stub_array_->GetData());
ByteArray* copy_res_stub_array_ = down_cast<ByteArray*>(GetImageAddress(orig_res_stub_array_));
- copy->code_ = copy_res_stub_array_->GetData();
+ copy->SetCode(copy_res_stub_array_->GetData());
return;
}
@@ -511,27 +519,27 @@
if (code == NULL) {
code = GetOatAddress(code_offset);
}
- copy->code_ = code;
+ copy->SetCode(code);
if (orig->IsNative()) {
// The native method's pointer is directed to a stub to lookup via dlsym.
// Note this is not the code_ pointer, that is handled above.
ByteArray* orig_jni_stub_array_ = Runtime::Current()->GetJniDlsymLookupStub();
ByteArray* copy_jni_stub_array_ = down_cast<ByteArray*>(GetImageAddress(orig_jni_stub_array_));
- copy->native_method_ = copy_jni_stub_array_->GetData();
+ copy->SetNativeMethod(copy_jni_stub_array_->GetData());
} else {
// normal (non-abstract non-native) methods have mapping tables to relocate
uint32_t mapping_table_off = orig->GetOatMappingTableOffset();
const byte* mapping_table = GetOatAddress(mapping_table_off);
- copy->mapping_table_ = reinterpret_cast<const uint32_t*>(mapping_table);
+ copy->SetMappingTable(reinterpret_cast<const uint32_t*>(mapping_table));
uint32_t vmap_table_offset = orig->GetOatVmapTableOffset();
const byte* vmap_table = GetOatAddress(vmap_table_offset);
- copy->vmap_table_ = reinterpret_cast<const uint16_t*>(vmap_table);
+ copy->SetVmapTable(reinterpret_cast<const uint16_t*>(vmap_table));
uint32_t native_gc_map_offset = orig->GetOatNativeGcMapOffset();
const byte* native_gc_map = GetOatAddress(native_gc_map_offset);
- copy->native_gc_map_ = reinterpret_cast<const uint8_t*>(native_gc_map);
+ copy->SetNativeGcMap(reinterpret_cast<const uint8_t*>(native_gc_map));
}
}
diff --git a/src/image_writer.h b/src/image_writer.h
index 64bac2e..eff9ffb 100644
--- a/src/image_writer.h
+++ b/src/image_writer.h
@@ -24,10 +24,9 @@
#include <string>
#include "compiler.h"
-#include "dex_cache.h"
#include "mem_map.h"
#include "oat_file.h"
-#include "object.h"
+#include "mirror/dex_cache.h"
#include "os.h"
#include "safe_map.h"
#include "gc/space.h"
@@ -59,7 +58,7 @@
bool AllocMemory();
// we use the lock word to store the offset of the object in the image
- void AssignImageOffset(Object* object)
+ void AssignImageOffset(mirror::Object* object)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(object != NULL);
SetImageOffset(object, image_end_);
@@ -67,35 +66,35 @@
DCHECK_LT(image_end_, image_->Size());
}
- void SetImageOffset(Object* object, size_t offset) {
+ void SetImageOffset(mirror::Object* object, size_t offset) {
DCHECK(object != NULL);
DCHECK_NE(offset, 0U);
DCHECK(!IsImageOffsetAssigned(object));
offsets_.Put(object, offset);
}
- size_t IsImageOffsetAssigned(const Object* object) const {
+ size_t IsImageOffsetAssigned(const mirror::Object* object) const {
DCHECK(object != NULL);
return offsets_.find(object) != offsets_.end();
}
- size_t GetImageOffset(const Object* object) const {
+ size_t GetImageOffset(const mirror::Object* object) const {
DCHECK(object != NULL);
DCHECK(IsImageOffsetAssigned(object));
return offsets_.find(object)->second;
}
- Object* GetImageAddress(const Object* object) const {
+ mirror::Object* GetImageAddress(const mirror::Object* object) const {
if (object == NULL) {
return NULL;
}
- return reinterpret_cast<Object*>(image_begin_ + GetImageOffset(object));
+ return reinterpret_cast<mirror::Object*>(image_begin_ + GetImageOffset(object));
}
- Object* GetLocalAddress(const Object* object) const {
+ mirror::Object* GetLocalAddress(const mirror::Object* object) const {
size_t offset = GetImageOffset(object);
byte* dst = image_->Begin() + offset;
- return reinterpret_cast<Object*>(dst);
+ return reinterpret_cast<mirror::Object*>(dst);
}
const byte* GetOatAddress(uint32_t offset) const {
@@ -106,50 +105,52 @@
return oat_data_begin_ + offset;
}
- bool IsImageClass(const Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ bool IsImageClass(const mirror::Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void DumpImageClasses();
void ComputeLazyFieldsForImageClasses()
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- static bool ComputeLazyFieldsForClassesVisitor(Class* klass, void* arg)
+ static bool ComputeLazyFieldsForClassesVisitor(mirror::Class* klass, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Wire dex cache resolved strings to strings in the image to avoid runtime resolution
void ComputeEagerResolvedStrings();
- static void ComputeEagerResolvedStringsCallback(Object* obj, void* arg)
+ static void ComputeEagerResolvedStringsCallback(mirror::Object* obj, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void PruneNonImageClasses() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- static bool NonImageClassesVisitor(Class* c, void* arg)
+ static bool NonImageClassesVisitor(mirror::Class* c, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void CheckNonImageClassesRemoved();
- static void CheckNonImageClassesRemovedCallback(Object* obj, void* arg)
+ static void CheckNonImageClassesRemovedCallback(mirror::Object* obj, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void CalculateNewObjectOffsets(size_t oat_loaded_size, size_t oat_data_offset)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- ObjectArray<Object>* CreateImageRoots() const
+ mirror::ObjectArray<mirror::Object>* CreateImageRoots() const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- static void CalculateNewObjectOffsetsCallback(Object* obj, void* arg)
+ static void CalculateNewObjectOffsetsCallback(mirror::Object* obj, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void CopyAndFixupObjects();
- static void CopyAndFixupObjectsCallback(Object* obj, void* arg)
+ static void CopyAndFixupObjectsCallback(mirror::Object* obj, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void FixupClass(const Class* orig, Class* copy)
+ void FixupClass(const mirror::Class* orig, mirror::Class* copy)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void FixupMethod(const AbstractMethod* orig, AbstractMethod* copy)
+ void FixupMethod(const mirror::AbstractMethod* orig, mirror::AbstractMethod* copy)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void FixupObject(const Object* orig, Object* copy)
+ void FixupObject(const mirror::Object* orig, mirror::Object* copy)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void FixupObjectArray(const ObjectArray<Object>* orig, ObjectArray<Object>* copy)
+ void FixupObjectArray(const mirror::ObjectArray<mirror::Object>* orig,
+ mirror::ObjectArray<mirror::Object>* copy)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void FixupInstanceFields(const Object* orig, Object* copy)
+ void FixupInstanceFields(const mirror::Object* orig, mirror::Object* copy)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void FixupStaticFields(const Class* orig, Class* copy)
+ void FixupStaticFields(const mirror::Class* orig, mirror::Class* copy)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void FixupFields(const Object* orig, Object* copy, uint32_t ref_offsets, bool is_static)
+ void FixupFields(const mirror::Object* orig, mirror::Object* copy, uint32_t ref_offsets,
+ bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void PatchOatCodeAndMethods(const Compiler& compiler)
@@ -157,7 +158,7 @@
void SetPatchLocation(const Compiler::PatchInformation* patch, uint32_t value)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- SafeMap<const Object*, size_t> offsets_;
+ SafeMap<const mirror::Object*, size_t> offsets_;
// oat file with code for this image
OatFile* oat_file_;
@@ -178,7 +179,7 @@
const byte* oat_data_begin_;
// DexCaches seen while scanning for fixing up CodeAndDirectMethods
- typedef std::set<DexCache*> Set;
+ typedef std::set<mirror::DexCache*> Set;
Set dex_caches_;
};
diff --git a/src/indirect_reference_table.cc b/src/indirect_reference_table.cc
index 9bb6edc..720380a 100644
--- a/src/indirect_reference_table.cc
+++ b/src/indirect_reference_table.cc
@@ -40,9 +40,9 @@
CHECK_LE(initialCount, maxCount);
CHECK_NE(desiredKind, kSirtOrInvalid);
- table_ = reinterpret_cast<const Object**>(malloc(initialCount * sizeof(const Object*)));
+ table_ = reinterpret_cast<const mirror::Object**>(malloc(initialCount * sizeof(const mirror::Object*)));
CHECK(table_ != NULL);
- memset(table_, 0xd1, initialCount * sizeof(const Object*));
+ memset(table_, 0xd1, initialCount * sizeof(const mirror::Object*));
slot_data_ = reinterpret_cast<IndirectRefSlot*>(calloc(initialCount, sizeof(IndirectRefSlot)));
CHECK(slot_data_ != NULL);
@@ -63,7 +63,7 @@
// Make sure that the entry at "idx" is correctly paired with "iref".
bool IndirectReferenceTable::CheckEntry(const char* what, IndirectRef iref, int idx) const {
- const Object* obj = table_[idx];
+ const mirror::Object* obj = table_[idx];
IndirectRef checkRef = ToIndirectRef(obj, idx);
if (checkRef != iref) {
LOG(ERROR) << "JNI ERROR (app bug): attempt to " << what
@@ -75,7 +75,7 @@
return true;
}
-IndirectRef IndirectReferenceTable::Add(uint32_t cookie, const Object* obj) {
+IndirectRef IndirectReferenceTable::Add(uint32_t cookie, const mirror::Object* obj) {
IRTSegmentState prevState;
prevState.all = cookie;
size_t topIndex = segment_state_.parts.topIndex;
@@ -101,7 +101,7 @@
}
DCHECK_GT(newSize, alloc_entries_);
- table_ = reinterpret_cast<const Object**>(realloc(table_, newSize * sizeof(const Object*)));
+ table_ = reinterpret_cast<const mirror::Object**>(realloc(table_, newSize * sizeof(const mirror::Object*)));
slot_data_ = reinterpret_cast<IndirectRefSlot*>(realloc(slot_data_,
newSize * sizeof(IndirectRefSlot)));
if (table_ == NULL || slot_data_ == NULL) {
@@ -126,7 +126,7 @@
if (numHoles > 0) {
DCHECK_GT(topIndex, 1U);
// Find the first hole; likely to be near the end of the list.
- const Object** pScan = &table_[topIndex - 1];
+ const mirror::Object** pScan = &table_[topIndex - 1];
DCHECK(*pScan != NULL);
while (*--pScan != NULL) {
DCHECK_GE(pScan, table_ + prevState.parts.topIndex);
@@ -194,7 +194,7 @@
return true;
}
-static int Find(Object* direct_pointer, int bottomIndex, int topIndex, const Object** table) {
+static int Find(mirror::Object* direct_pointer, int bottomIndex, int topIndex, const mirror::Object** table) {
for (int i = bottomIndex; i < topIndex; ++i) {
if (table[i] == direct_pointer) {
return i;
@@ -203,7 +203,7 @@
return -1;
}
-bool IndirectReferenceTable::ContainsDirectPointer(Object* direct_pointer) const {
+bool IndirectReferenceTable::ContainsDirectPointer(mirror::Object* direct_pointer) const {
return Find(direct_pointer, 0, segment_state_.parts.topIndex, table_) != -1;
}
@@ -234,7 +234,7 @@
return true;
}
if (GetIndirectRefKind(iref) == kSirtOrInvalid && vm->work_around_app_jni_bugs) {
- Object* direct_pointer = reinterpret_cast<Object*>(iref);
+ mirror::Object* direct_pointer = reinterpret_cast<mirror::Object*>(iref);
idx = Find(direct_pointer, bottomIndex, topIndex, table_);
if (idx == -1) {
LOG(WARNING) << "trying to work around app JNI bugs, but didn't find " << iref << " in table!";
@@ -308,7 +308,7 @@
return true;
}
-void IndirectReferenceTable::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
+void IndirectReferenceTable::VisitRoots(RootVisitor* visitor, void* arg) {
typedef IndirectReferenceTable::iterator It; // TODO: C++0x auto
for (It it = begin(), end = this->end(); it != end; ++it) {
visitor(**it, arg);
@@ -317,7 +317,7 @@
void IndirectReferenceTable::Dump(std::ostream& os) const {
os << kind_ << " table dump:\n";
- std::vector<const Object*> entries(table_, table_ + Capacity());
+ std::vector<const mirror::Object*> entries(table_, table_ + Capacity());
// Remove NULLs.
for (int i = entries.size() - 1; i >= 0; --i) {
if (entries[i] == NULL) {
diff --git a/src/indirect_reference_table.h b/src/indirect_reference_table.h
index cd358e9..e09043d 100644
--- a/src/indirect_reference_table.h
+++ b/src/indirect_reference_table.h
@@ -23,11 +23,13 @@
#include <string>
#include "base/logging.h"
-#include "heap.h"
+#include "offsets.h"
+#include "root_visitor.h"
namespace art {
-
+namespace mirror {
class Object;
+} // namespace mirror
/*
* Maintain a table of indirect references. Used for local/global JNI
@@ -98,8 +100,8 @@
typedef void* IndirectRef;
// Magic failure values; must not pass Heap::ValidateObject() or Heap::IsHeapAddress().
-static Object* const kInvalidIndirectRefObject = reinterpret_cast<Object*>(0xdead4321);
-static Object* const kClearedJniWeakGlobal = reinterpret_cast<Object*>(0xdead1234);
+static mirror::Object* const kInvalidIndirectRefObject = reinterpret_cast<mirror::Object*>(0xdead4321);
+static mirror::Object* const kClearedJniWeakGlobal = reinterpret_cast<mirror::Object*>(0xdead1234);
/*
* Indirect reference kind, used as the two low bits of IndirectRef.
@@ -128,7 +130,7 @@
static const size_t kIRTPrevCount = 4;
struct IndirectRefSlot {
uint32_t serial;
- const Object* previous[kIRTPrevCount];
+ const mirror::Object* previous[kIRTPrevCount];
};
/* use as initial value for "cookie", and when table has only one segment */
@@ -204,7 +206,7 @@
class IrtIterator {
public:
- explicit IrtIterator(const Object** table, size_t i, size_t capacity)
+ explicit IrtIterator(const mirror::Object** table, size_t i, size_t capacity)
: table_(table), i_(i), capacity_(capacity) {
SkipNullsAndTombstones();
}
@@ -215,7 +217,7 @@
return *this;
}
- const Object** operator*() {
+ const mirror::Object** operator*() {
return &table_[i_];
}
@@ -231,7 +233,7 @@
}
}
- const Object** table_;
+ const mirror::Object** table_;
size_t i_;
size_t capacity_;
};
@@ -258,7 +260,7 @@
* Returns NULL if the table is full (max entries reached, or alloc
* failed during expansion).
*/
- IndirectRef Add(uint32_t cookie, const Object* obj)
+ IndirectRef Add(uint32_t cookie, const mirror::Object* obj)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
/*
@@ -266,7 +268,7 @@
*
* Returns kInvalidIndirectRefObject if iref is invalid.
*/
- const Object* Get(IndirectRef iref) const {
+ const mirror::Object* Get(IndirectRef iref) const {
if (!GetChecked(iref)) {
return kInvalidIndirectRefObject;
}
@@ -274,7 +276,7 @@
}
// TODO: remove when we remove work_around_app_jni_bugs support.
- bool ContainsDirectPointer(Object* direct_pointer) const;
+ bool ContainsDirectPointer(mirror::Object* direct_pointer) const;
/*
* Remove an existing entry.
@@ -307,7 +309,7 @@
return iterator(table_, Capacity(), Capacity());
}
- void VisitRoots(Heap::RootVisitor* visitor, void* arg);
+ void VisitRoots(RootVisitor* visitor, void* arg);
uint32_t GetSegmentState() const {
return segment_state_.all;
@@ -334,7 +336,7 @@
* The object pointer itself is subject to relocation in some GC
* implementations, so we shouldn't really be using it here.
*/
- IndirectRef ToIndirectRef(const Object* /*o*/, uint32_t tableIndex) const {
+ IndirectRef ToIndirectRef(const mirror::Object* /*o*/, uint32_t tableIndex) const {
DCHECK_LT(tableIndex, 65536U);
uint32_t serialChunk = slot_data_[tableIndex].serial;
uint32_t uref = serialChunk << 20 | (tableIndex << 2) | kind_;
@@ -347,7 +349,7 @@
* We advance the serial number, invalidating any outstanding references to
* this slot.
*/
- void UpdateSlotAdd(const Object* obj, int slot) {
+ void UpdateSlotAdd(const mirror::Object* obj, int slot) {
if (slot_data_ != NULL) {
IndirectRefSlot* pSlot = &slot_data_[slot];
pSlot->serial++;
@@ -363,7 +365,7 @@
IRTSegmentState segment_state_;
/* bottom of the stack */
- const Object** table_;
+ const mirror::Object** table_;
/* bit mask, ORed into all irefs */
IndirectRefKind kind_;
/* extended debugging info */
diff --git a/src/indirect_reference_table_test.cc b/src/indirect_reference_table_test.cc
index b5a05ec..bd2890c 100644
--- a/src/indirect_reference_table_test.cc
+++ b/src/indirect_reference_table_test.cc
@@ -47,15 +47,15 @@
static const size_t kTableMax = 20;
IndirectReferenceTable irt(kTableInitial, kTableMax, kGlobal);
- Class* c = class_linker_->FindSystemClass("Ljava/lang/Object;");
+ mirror::Class* c = class_linker_->FindSystemClass("Ljava/lang/Object;");
ASSERT_TRUE(c != NULL);
- Object* obj0 = c->AllocObject(soa.Self());
+ mirror::Object* obj0 = c->AllocObject(soa.Self());
ASSERT_TRUE(obj0 != NULL);
- Object* obj1 = c->AllocObject(soa.Self());
+ mirror::Object* obj1 = c->AllocObject(soa.Self());
ASSERT_TRUE(obj1 != NULL);
- Object* obj2 = c->AllocObject(soa.Self());
+ mirror::Object* obj2 = c->AllocObject(soa.Self());
ASSERT_TRUE(obj2 != NULL);
- Object* obj3 = c->AllocObject(soa.Self());
+ mirror::Object* obj3 = c->AllocObject(soa.Self());
ASSERT_TRUE(obj3 != NULL);
const uint32_t cookie = IRT_FIRST_SEGMENT;
diff --git a/src/instrumentation.cc b/src/instrumentation.cc
index 065758d..e3d4d28 100644
--- a/src/instrumentation.cc
+++ b/src/instrumentation.cc
@@ -21,7 +21,10 @@
#include "base/unix_file/fd_file.h"
#include "class_linker.h"
#include "debugger.h"
-#include "dex_cache.h"
+#include "mirror/class-inl.h"
+#include "mirror/dex_cache.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object_array-inl.h"
#if !defined(ART_USE_LLVM_COMPILER)
#include "oat/runtime/oat_support_entrypoints.h"
#endif
@@ -34,18 +37,18 @@
namespace art {
-static bool InstallStubsClassVisitor(Class* klass, void*)
+static bool InstallStubsClassVisitor(mirror::Class* klass, void*)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
- AbstractMethod* method = klass->GetDirectMethod(i);
+ mirror::AbstractMethod* method = klass->GetDirectMethod(i);
if (instrumentation->GetSavedCodeFromMap(method) == NULL) {
instrumentation->SaveAndUpdateCode(method);
}
}
for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
- AbstractMethod* method = klass->GetVirtualMethod(i);
+ mirror::AbstractMethod* method = klass->GetVirtualMethod(i);
if (instrumentation->GetSavedCodeFromMap(method) == NULL) {
instrumentation->SaveAndUpdateCode(method);
}
@@ -53,18 +56,18 @@
return true;
}
-static bool UninstallStubsClassVisitor(Class* klass, void*)
+static bool UninstallStubsClassVisitor(mirror::Class* klass, void*)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
- AbstractMethod* method = klass->GetDirectMethod(i);
+ mirror::AbstractMethod* method = klass->GetDirectMethod(i);
if (instrumentation->GetSavedCodeFromMap(method) != NULL) {
instrumentation->ResetSavedCode(method);
}
}
for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
- AbstractMethod* method = klass->GetVirtualMethod(i);
+ mirror::AbstractMethod* method = klass->GetVirtualMethod(i);
if (instrumentation->GetSavedCodeFromMap(method) != NULL) {
instrumentation->ResetSavedCode(method);
}
@@ -83,7 +86,7 @@
if (GetCurrentQuickFrame() == NULL) {
return true; // Ignore shadow frames.
}
- AbstractMethod* m = GetMethod();
+ mirror::AbstractMethod* m = GetMethod();
if (m == NULL) {
return true; // Ignore upcalls.
}
@@ -125,7 +128,7 @@
if (self_->IsInstrumentationStackEmpty()) {
return false; // Stop.
}
- AbstractMethod* m = GetMethod();
+ mirror::AbstractMethod* m = GetMethod();
if (m == NULL) {
return true; // Ignore upcalls.
}
@@ -171,16 +174,16 @@
Runtime::Current()->GetThreadList()->ForEach(InstrumentationRestoreStack, NULL);
}
-void Instrumentation::AddSavedCodeToMap(const AbstractMethod* method, const void* code) {
+void Instrumentation::AddSavedCodeToMap(const mirror::AbstractMethod* method, const void* code) {
saved_code_map_.Put(method, code);
}
-void Instrumentation::RemoveSavedCodeFromMap(const AbstractMethod* method) {
+void Instrumentation::RemoveSavedCodeFromMap(const mirror::AbstractMethod* method) {
saved_code_map_.erase(method);
}
-const void* Instrumentation::GetSavedCodeFromMap(const AbstractMethod* method) {
- typedef SafeMap<const AbstractMethod*, const void*>::const_iterator It; // TODO: C++0x auto
+const void* Instrumentation::GetSavedCodeFromMap(const mirror::AbstractMethod* method) {
+ typedef SafeMap<const mirror::AbstractMethod*, const void*>::const_iterator It; // TODO: C++0x auto
It it = saved_code_map_.find(method);
if (it == saved_code_map_.end()) {
return NULL;
@@ -189,7 +192,7 @@
}
}
-void Instrumentation::SaveAndUpdateCode(AbstractMethod* method) {
+void Instrumentation::SaveAndUpdateCode(mirror::AbstractMethod* method) {
#if defined(ART_USE_LLVM_COMPILER)
UNUSED(method);
UNIMPLEMENTED(FATAL);
@@ -201,7 +204,7 @@
#endif
}
-void Instrumentation::ResetSavedCode(AbstractMethod* method) {
+void Instrumentation::ResetSavedCode(mirror::AbstractMethod* method) {
CHECK(GetSavedCodeFromMap(method) != NULL);
method->SetCode(GetSavedCodeFromMap(method));
RemoveSavedCodeFromMap(method);
@@ -223,7 +226,7 @@
uint32_t InstrumentationMethodUnwindFromCode(Thread* self) {
Trace* trace = Runtime::Current()->GetInstrumentation()->GetTrace();
InstrumentationStackFrame instrumentation_frame = self->PopInstrumentationStackFrame();
- AbstractMethod* method = instrumentation_frame.method_;
+ mirror::AbstractMethod* method = instrumentation_frame.method_;
uint32_t lr = instrumentation_frame.return_pc_;
trace->LogMethodTraceEvent(self, method, Trace::kMethodTraceUnwind);
diff --git a/src/instrumentation.h b/src/instrumentation.h
index 00060ce..fb49bf8 100644
--- a/src/instrumentation.h
+++ b/src/instrumentation.h
@@ -17,29 +17,27 @@
#ifndef ART_SRC_INSTRUMENTATION_H_
#define ART_SRC_INSTRUMENTATION_H_
-#include <ostream>
-#include <set>
-#include <string>
-
#include "base/macros.h"
-#include "globals.h"
#include "safe_map.h"
-#include "trace.h"
-#include "UniquePtr.h"
+
+#include <stdint.h>
namespace art {
+namespace mirror {
class AbstractMethod;
+}
class Thread;
+class Trace;
uint32_t InstrumentationMethodUnwindFromCode(Thread* self);
struct InstrumentationStackFrame {
InstrumentationStackFrame() : method_(NULL), return_pc_(0), frame_id_(0) {}
- InstrumentationStackFrame(AbstractMethod* method, uintptr_t return_pc, size_t frame_id)
+ InstrumentationStackFrame(mirror::AbstractMethod* method, uintptr_t return_pc, size_t frame_id)
: method_(method), return_pc_(return_pc), frame_id_(frame_id) {
}
- AbstractMethod* method_;
+ mirror::AbstractMethod* method_;
uintptr_t return_pc_;
size_t frame_id_;
};
@@ -55,20 +53,20 @@
// Restores original code for each method and fixes the return values of each thread's stack.
void UninstallStubs() LOCKS_EXCLUDED(Locks::thread_list_lock_);
- const void* GetSavedCodeFromMap(const AbstractMethod* method);
- void SaveAndUpdateCode(AbstractMethod* method);
- void ResetSavedCode(AbstractMethod* method);
+ const void* GetSavedCodeFromMap(const mirror::AbstractMethod* method);
+ void SaveAndUpdateCode(mirror::AbstractMethod* method);
+ void ResetSavedCode(mirror::AbstractMethod* method);
Trace* GetTrace() const;
void SetTrace(Trace* trace);
void RemoveTrace();
private:
- void AddSavedCodeToMap(const AbstractMethod* method, const void* code);
- void RemoveSavedCodeFromMap(const AbstractMethod* method);
+ void AddSavedCodeToMap(const mirror::AbstractMethod* method, const void* code);
+ void RemoveSavedCodeFromMap(const mirror::AbstractMethod* method);
// Maps a method to its original code pointer.
- SafeMap<const AbstractMethod*, const void*> saved_code_map_;
+ SafeMap<const mirror::AbstractMethod*, const void*> saved_code_map_;
Trace* trace_;
diff --git a/src/intern_table.cc b/src/intern_table.cc
index 817ce1e..fa3c075 100644
--- a/src/intern_table.cc
+++ b/src/intern_table.cc
@@ -16,6 +16,8 @@
#include "intern_table.h"
+#include "mirror/string.h"
+#include "thread.h"
#include "UniquePtr.h"
#include "utf.h"
@@ -36,7 +38,7 @@
<< image_strong_interns_.size() << " image strong\n";
}
-void InternTable::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
+void InternTable::VisitRoots(RootVisitor* visitor, void* arg) {
MutexLock mu(Thread::Current(), intern_table_lock_);
typedef Table::const_iterator It; // TODO: C++0x auto
for (It it = strong_interns_.begin(), end = strong_interns_.end(); it != end; ++it) {
@@ -46,11 +48,11 @@
// Note: we deliberately don't visit the weak_interns_ table and the immutable image roots.
}
-String* InternTable::Lookup(Table& table, String* s, uint32_t hash_code) {
+mirror::String* InternTable::Lookup(Table& table, mirror::String* s, uint32_t hash_code) {
intern_table_lock_.AssertHeld(Thread::Current());
typedef Table::const_iterator It; // TODO: C++0x auto
for (It it = table.find(hash_code), end = table.end(); it != end; ++it) {
- String* existing_string = it->second;
+ mirror::String* existing_string = it->second;
if (existing_string->Equals(s)) {
return existing_string;
}
@@ -58,18 +60,18 @@
return NULL;
}
-String* InternTable::Insert(Table& table, String* s, uint32_t hash_code) {
+mirror::String* InternTable::Insert(Table& table, mirror::String* s, uint32_t hash_code) {
intern_table_lock_.AssertHeld(Thread::Current());
table.insert(std::make_pair(hash_code, s));
return s;
}
-void InternTable::RegisterStrong(String* s) {
+void InternTable::RegisterStrong(mirror::String* s) {
MutexLock mu(Thread::Current(), intern_table_lock_);
Insert(image_strong_interns_, s, s->GetHashCode());
}
-void InternTable::Remove(Table& table, const String* s, uint32_t hash_code) {
+void InternTable::Remove(Table& table, const mirror::String* s, uint32_t hash_code) {
intern_table_lock_.AssertHeld(Thread::Current());
typedef Table::iterator It; // TODO: C++0x auto
for (It it = table.find(hash_code), end = table.end(); it != end; ++it) {
@@ -80,7 +82,7 @@
}
}
-String* InternTable::Insert(String* s, bool is_strong) {
+mirror::String* InternTable::Insert(mirror::String* s, bool is_strong) {
MutexLock mu(Thread::Current(), intern_table_lock_);
DCHECK(s != NULL);
@@ -88,12 +90,12 @@
if (is_strong) {
// Check the strong table for a match.
- String* strong = Lookup(strong_interns_, s, hash_code);
+ mirror::String* strong = Lookup(strong_interns_, s, hash_code);
if (strong != NULL) {
return strong;
}
// Check the image table for a match.
- String* image = Lookup(image_strong_interns_, s, hash_code);
+ mirror::String* image = Lookup(image_strong_interns_, s, hash_code);
if (image != NULL) {
return image;
}
@@ -102,7 +104,7 @@
Dirty();
// There is no match in the strong table, check the weak table.
- String* weak = Lookup(weak_interns_, s, hash_code);
+ mirror::String* weak = Lookup(weak_interns_, s, hash_code);
if (weak != NULL) {
// A match was found in the weak table. Promote to the strong table.
Remove(weak_interns_, weak, hash_code);
@@ -114,17 +116,17 @@
}
// Check the strong table for a match.
- String* strong = Lookup(strong_interns_, s, hash_code);
+ mirror::String* strong = Lookup(strong_interns_, s, hash_code);
if (strong != NULL) {
return strong;
}
// Check the image table for a match.
- String* image = Lookup(image_strong_interns_, s, hash_code);
+ mirror::String* image = Lookup(image_strong_interns_, s, hash_code);
if (image != NULL) {
return image;
}
// Check the weak table for a match.
- String* weak = Lookup(weak_interns_, s, hash_code);
+ mirror::String* weak = Lookup(weak_interns_, s, hash_code);
if (weak != NULL) {
return weak;
}
@@ -132,39 +134,39 @@
return Insert(weak_interns_, s, hash_code);
}
-String* InternTable::InternStrong(int32_t utf16_length, const char* utf8_data) {
- return InternStrong(String::AllocFromModifiedUtf8(Thread::Current(), utf16_length, utf8_data));
+mirror::String* InternTable::InternStrong(int32_t utf16_length, const char* utf8_data) {
+ return InternStrong(mirror::String::AllocFromModifiedUtf8(Thread::Current(), utf16_length, utf8_data));
}
-String* InternTable::InternStrong(const char* utf8_data) {
- return InternStrong(String::AllocFromModifiedUtf8(Thread::Current(), utf8_data));
+mirror::String* InternTable::InternStrong(const char* utf8_data) {
+ return InternStrong(mirror::String::AllocFromModifiedUtf8(Thread::Current(), utf8_data));
}
-String* InternTable::InternStrong(String* s) {
+mirror::String* InternTable::InternStrong(mirror::String* s) {
if (s == NULL) {
return NULL;
}
return Insert(s, true);
}
-String* InternTable::InternWeak(String* s) {
+mirror::String* InternTable::InternWeak(mirror::String* s) {
if (s == NULL) {
return NULL;
}
return Insert(s, false);
}
-bool InternTable::ContainsWeak(String* s) {
+bool InternTable::ContainsWeak(mirror::String* s) {
MutexLock mu(Thread::Current(), intern_table_lock_);
- const String* found = Lookup(weak_interns_, s, s->GetHashCode());
+ const mirror::String* found = Lookup(weak_interns_, s, s->GetHashCode());
return found == s;
}
-void InternTable::SweepInternTableWeaks(Heap::IsMarkedTester is_marked, void* arg) {
+void InternTable::SweepInternTableWeaks(IsMarkedTester is_marked, void* arg) {
MutexLock mu(Thread::Current(), intern_table_lock_);
typedef Table::iterator It; // TODO: C++0x auto
for (It it = weak_interns_.begin(), end = weak_interns_.end(); it != end;) {
- Object* object = it->second;
+ mirror::Object* object = it->second;
if (!is_marked(object, arg)) {
weak_interns_.erase(it++);
} else {
diff --git a/src/intern_table.h b/src/intern_table.h
index 06a2b89..3018317 100644
--- a/src/intern_table.h
+++ b/src/intern_table.h
@@ -17,14 +17,15 @@
#ifndef ART_SRC_INTERN_TABLE_H_
#define ART_SRC_INTERN_TABLE_H_
-#include <iosfwd>
-
#include "base/mutex.h"
-#include "heap.h"
-#include "object.h"
-#include "safe_map.h"
+#include "root_visitor.h"
+
+#include <map>
namespace art {
+namespace mirror {
+class String;
+} // namespace mirror
/**
* Used to intern strings.
@@ -41,31 +42,31 @@
InternTable();
// Interns a potentially new string in the 'strong' table. (See above.)
- String* InternStrong(int32_t utf16_length, const char* utf8_data)
+ mirror::String* InternStrong(int32_t utf16_length, const char* utf8_data)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Interns a potentially new string in the 'strong' table. (See above.)
- String* InternStrong(const char* utf8_data)
+ mirror::String* InternStrong(const char* utf8_data)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Interns a potentially new string in the 'strong' table. (See above.)
- String* InternStrong(String* s) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ mirror::String* InternStrong(mirror::String* s) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Interns a potentially new string in the 'weak' table. (See above.)
- String* InternWeak(String* s) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ mirror::String* InternWeak(mirror::String* s) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Register a String trusting that it is safe to intern.
// Used when reinitializing InternTable from an image.
- void RegisterStrong(String* s) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void RegisterStrong(mirror::String* s) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void SweepInternTableWeaks(Heap::IsMarkedTester is_marked, void* arg)
+ void SweepInternTableWeaks(IsMarkedTester is_marked, void* arg)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
- bool ContainsWeak(String* s) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ bool ContainsWeak(mirror::String* s) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
size_t Size() const;
- void VisitRoots(Heap::RootVisitor* visitor, void* arg);
+ void VisitRoots(RootVisitor* visitor, void* arg);
void DumpForSigQuit(std::ostream& os) const;
@@ -75,15 +76,15 @@
}
private:
- typedef std::multimap<int32_t, String*> Table;
+ typedef std::multimap<int32_t, mirror::String*> Table;
- String* Insert(String* s, bool is_strong)
+ mirror::String* Insert(mirror::String* s, bool is_strong)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- String* Lookup(Table& table, String* s, uint32_t hash_code)
+ mirror::String* Lookup(Table& table, mirror::String* s, uint32_t hash_code)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- String* Insert(Table& table, String* s, uint32_t hash_code);
- void Remove(Table& table, const String* s, uint32_t hash_code);
+ mirror::String* Insert(Table& table, mirror::String* s, uint32_t hash_code);
+ void Remove(Table& table, const mirror::String* s, uint32_t hash_code);
mutable Mutex intern_table_lock_;
bool is_dirty_;
diff --git a/src/intern_table_test.cc b/src/intern_table_test.cc
index ee9165e..f6b040d 100644
--- a/src/intern_table_test.cc
+++ b/src/intern_table_test.cc
@@ -17,7 +17,7 @@
#include "intern_table.h"
#include "common_test.h"
-#include "object.h"
+#include "mirror/object.h"
#include "sirt_ref.h"
namespace art {
@@ -27,10 +27,10 @@
TEST_F(InternTableTest, Intern) {
ScopedObjectAccess soa(Thread::Current());
InternTable intern_table;
- SirtRef<String> foo_1(soa.Self(), intern_table.InternStrong(3, "foo"));
- SirtRef<String> foo_2(soa.Self(), intern_table.InternStrong(3, "foo"));
- SirtRef<String> foo_3(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "foo"));
- SirtRef<String> bar(soa.Self(), intern_table.InternStrong(3, "bar"));
+ SirtRef<mirror::String> foo_1(soa.Self(), intern_table.InternStrong(3, "foo"));
+ SirtRef<mirror::String> foo_2(soa.Self(), intern_table.InternStrong(3, "foo"));
+ SirtRef<mirror::String> foo_3(soa.Self(), mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo"));
+ SirtRef<mirror::String> bar(soa.Self(), intern_table.InternStrong(3, "bar"));
EXPECT_TRUE(foo_1->Equals("foo"));
EXPECT_TRUE(foo_2->Equals("foo"));
EXPECT_TRUE(foo_3->Equals("foo"));
@@ -47,7 +47,7 @@
InternTable t;
EXPECT_EQ(0U, t.Size());
t.InternStrong(3, "foo");
- SirtRef<String> foo(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "foo"));
+ SirtRef<mirror::String> foo(soa.Self(), mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo"));
t.InternWeak(foo.get());
EXPECT_EQ(1U, t.Size());
t.InternStrong(3, "bar");
@@ -56,9 +56,9 @@
class TestPredicate {
public:
- bool IsMarked(const Object* s) const {
+ bool IsMarked(const mirror::Object* s) const {
bool erased = false;
- typedef std::vector<const String*>::iterator It; // TODO: C++0x auto
+ typedef std::vector<const mirror::String*>::iterator It; // TODO: C++0x auto
for (It it = expected_.begin(), end = expected_.end(); it != end; ++it) {
if (*it == s) {
expected_.erase(it);
@@ -70,7 +70,7 @@
return false;
}
- void Expect(const String* s) {
+ void Expect(const mirror::String* s) {
expected_.push_back(s);
}
@@ -79,10 +79,10 @@
}
private:
- mutable std::vector<const String*> expected_;
+ mutable std::vector<const mirror::String*> expected_;
};
-bool IsMarked(const Object* object, void* arg) {
+bool IsMarked(const mirror::Object* object, void* arg) {
return reinterpret_cast<TestPredicate*>(arg)->IsMarked(object);
}
@@ -91,10 +91,12 @@
InternTable t;
t.InternStrong(3, "foo");
t.InternStrong(3, "bar");
- SirtRef<String> hello(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "hello"));
- SirtRef<String> world(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "world"));
- SirtRef<String> s0(soa.Self(), t.InternWeak(hello.get()));
- SirtRef<String> s1(soa.Self(), t.InternWeak(world.get()));
+ SirtRef<mirror::String> hello(soa.Self(),
+ mirror::String::AllocFromModifiedUtf8(soa.Self(), "hello"));
+ SirtRef<mirror::String> world(soa.Self(),
+ mirror::String::AllocFromModifiedUtf8(soa.Self(), "world"));
+ SirtRef<mirror::String> s0(soa.Self(), t.InternWeak(hello.get()));
+ SirtRef<mirror::String> s1(soa.Self(), t.InternWeak(world.get()));
EXPECT_EQ(4U, t.Size());
@@ -110,7 +112,8 @@
EXPECT_EQ(2U, t.Size());
// Just check that we didn't corrupt the map.
- SirtRef<String> still_here(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "still here"));
+ SirtRef<mirror::String> still_here(soa.Self(),
+ mirror::String::AllocFromModifiedUtf8(soa.Self(), "still here"));
t.InternWeak(still_here.get());
EXPECT_EQ(3U, t.Size());
}
@@ -120,9 +123,9 @@
{
// Strongs are never weak.
InternTable t;
- SirtRef<String> interned_foo_1(soa.Self(), t.InternStrong(3, "foo"));
+ SirtRef<mirror::String> interned_foo_1(soa.Self(), t.InternStrong(3, "foo"));
EXPECT_FALSE(t.ContainsWeak(interned_foo_1.get()));
- SirtRef<String> interned_foo_2(soa.Self(), t.InternStrong(3, "foo"));
+ SirtRef<mirror::String> interned_foo_2(soa.Self(), t.InternStrong(3, "foo"));
EXPECT_FALSE(t.ContainsWeak(interned_foo_2.get()));
EXPECT_EQ(interned_foo_1.get(), interned_foo_2.get());
}
@@ -130,11 +133,13 @@
{
// Weaks are always weak.
InternTable t;
- SirtRef<String> foo_1(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "foo"));
- SirtRef<String> foo_2(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "foo"));
+ SirtRef<mirror::String> foo_1(soa.Self(),
+ mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo"));
+ SirtRef<mirror::String> foo_2(soa.Self(),
+ mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo"));
EXPECT_NE(foo_1.get(), foo_2.get());
- SirtRef<String> interned_foo_1(soa.Self(), t.InternWeak(foo_1.get()));
- SirtRef<String> interned_foo_2(soa.Self(), t.InternWeak(foo_2.get()));
+ SirtRef<mirror::String> interned_foo_1(soa.Self(), t.InternWeak(foo_1.get()));
+ SirtRef<mirror::String> interned_foo_2(soa.Self(), t.InternWeak(foo_2.get()));
EXPECT_TRUE(t.ContainsWeak(interned_foo_2.get()));
EXPECT_EQ(interned_foo_1.get(), interned_foo_2.get());
}
@@ -142,10 +147,10 @@
{
// A weak can be promoted to a strong.
InternTable t;
- SirtRef<String> foo(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "foo"));
- SirtRef<String> interned_foo_1(soa.Self(), t.InternWeak(foo.get()));
+ SirtRef<mirror::String> foo(soa.Self(), mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo"));
+ SirtRef<mirror::String> interned_foo_1(soa.Self(), t.InternWeak(foo.get()));
EXPECT_TRUE(t.ContainsWeak(interned_foo_1.get()));
- SirtRef<String> interned_foo_2(soa.Self(), t.InternStrong(3, "foo"));
+ SirtRef<mirror::String> interned_foo_2(soa.Self(), t.InternStrong(3, "foo"));
EXPECT_FALSE(t.ContainsWeak(interned_foo_2.get()));
EXPECT_EQ(interned_foo_1.get(), interned_foo_2.get());
}
@@ -153,10 +158,11 @@
{
// Interning a weak after a strong gets you the strong.
InternTable t;
- SirtRef<String> interned_foo_1(soa.Self(), t.InternStrong(3, "foo"));
+ SirtRef<mirror::String> interned_foo_1(soa.Self(), t.InternStrong(3, "foo"));
EXPECT_FALSE(t.ContainsWeak(interned_foo_1.get()));
- SirtRef<String> foo(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), "foo"));
- SirtRef<String> interned_foo_2(soa.Self(), t.InternWeak(foo.get()));
+ SirtRef<mirror::String> foo(soa.Self(),
+ mirror::String::AllocFromModifiedUtf8(soa.Self(), "foo"));
+ SirtRef<mirror::String> interned_foo_2(soa.Self(), t.InternWeak(foo.get()));
EXPECT_FALSE(t.ContainsWeak(interned_foo_2.get()));
EXPECT_EQ(interned_foo_1.get(), interned_foo_2.get());
}
diff --git a/src/interpreter/interpreter.cc b/src/interpreter/interpreter.cc
index 820348e..65729c9 100644
--- a/src/interpreter/interpreter.cc
+++ b/src/interpreter/interpreter.cc
@@ -19,18 +19,28 @@
#include <math.h>
#include "base/logging.h"
+#include "class_linker-inl.h"
#include "common_throws.h"
#include "debugger.h"
#include "dex_instruction.h"
+#include "gc/card_table-inl.h"
#include "invoke_arg_array_builder.h"
#include "nth_caller_visitor.h"
-#include "object.h"
+#include "mirror/class.h"
+#include "mirror/class-inl.h"
+#include "mirror/field-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 "object_utils.h"
#include "runtime_support.h"
#include "ScopedLocalRef.h"
#include "scoped_thread_state_change.h"
#include "thread.h"
+using namespace art::mirror;
+
namespace art {
namespace interpreter {
diff --git a/src/interpreter/interpreter.h b/src/interpreter/interpreter.h
index 6990458..eee13dc 100644
--- a/src/interpreter/interpreter.h
+++ b/src/interpreter/interpreter.h
@@ -21,18 +21,20 @@
#include "locks.h"
namespace art {
-
+namespace mirror {
class AbstractMethod;
+class Object;
+} // namespace mirror
+
union JValue;
class MethodHelper;
-class Object;
class ShadowFrame;
class Thread;
namespace interpreter {
-extern void EnterInterpreterFromInvoke(Thread* self, AbstractMethod* method, Object* receiver,
- JValue* args, JValue* result)
+extern void EnterInterpreterFromInvoke(Thread* self, mirror::AbstractMethod* method,
+ mirror::Object* receiver, JValue* args, JValue* result)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
extern JValue EnterInterpreterFromDeoptimize(Thread* self, ShadowFrame& shadow_frame,
diff --git a/src/invoke_arg_array_builder.h b/src/invoke_arg_array_builder.h
index 16eedfe..19c42ac 100644
--- a/src/invoke_arg_array_builder.h
+++ b/src/invoke_arg_array_builder.h
@@ -17,7 +17,7 @@
#ifndef ART_SRC_INVOKE_ARG_ARRAY_BUILDER_H_
#define ART_SRC_INVOKE_ARG_ARRAY_BUILDER_H_
-#include "object.h"
+#include "mirror/object.h"
#include "scoped_thread_state_change.h"
namespace art {
@@ -31,7 +31,7 @@
} else if (ch == 'L') {
// Argument is a reference or an array. The shorty descriptor
// does not distinguish between these types.
- num_bytes += sizeof(Object*);
+ num_bytes += sizeof(mirror::Object*);
} else {
num_bytes += 4;
}
@@ -78,7 +78,7 @@
arg_array_[offset].SetF(va_arg(ap, jdouble));
break;
case 'L':
- arg_array_[offset].SetL(soa.Decode<Object*>(va_arg(ap, jobject)));
+ arg_array_[offset].SetL(soa.Decode<mirror::Object*>(va_arg(ap, jobject)));
break;
case 'D':
arg_array_[offset].SetD(va_arg(ap, jdouble));
@@ -113,7 +113,7 @@
arg_array_[offset].SetF(args[offset].f);
break;
case 'L':
- arg_array_[offset].SetL(soa.Decode<Object*>(args[offset].l));
+ arg_array_[offset].SetL(soa.Decode<mirror::Object*>(args[offset].l));
break;
case 'D':
arg_array_[offset].SetD(args[offset].d);
diff --git a/src/jdwp/jdwp.h b/src/jdwp/jdwp.h
index 6cac0f6..71bae08 100644
--- a/src/jdwp/jdwp.h
+++ b/src/jdwp/jdwp.h
@@ -30,8 +30,9 @@
struct iovec;
namespace art {
-
+namespace mirror {
class AbstractMethod;
+} // namespace mirror
class Thread;
namespace JDWP {
diff --git a/src/jdwp/jdwp_event.cc b/src/jdwp/jdwp_event.cc
index ba2d8d2..71e91d4 100644
--- a/src/jdwp/jdwp_event.cc
+++ b/src/jdwp/jdwp_event.cc
@@ -28,6 +28,7 @@
#include "jdwp/jdwp_expand_buf.h"
#include "jdwp/jdwp_handler.h"
#include "jdwp/jdwp_priv.h"
+#include "thread.h"
/*
General notes:
diff --git a/src/jdwp/jdwp_handler.cc b/src/jdwp/jdwp_handler.cc
index cb13695..aa5a8a0 100644
--- a/src/jdwp/jdwp_handler.cc
+++ b/src/jdwp/jdwp_handler.cc
@@ -42,6 +42,9 @@
#include "jdwp/jdwp_event.h"
#include "jdwp/jdwp_expand_buf.h"
#include "jdwp/jdwp_priv.h"
+#include "runtime.h"
+#include "thread.h"
+#include "UniquePtr.h"
namespace art {
diff --git a/src/jni_compiler_test.cc b/src/jni_compiler_test.cc
index 16976d4..4ed7898 100644
--- a/src/jni_compiler_test.cc
+++ b/src/jni_compiler_test.cc
@@ -21,6 +21,11 @@
#include "indirect_reference_table.h"
#include "jni_internal.h"
#include "mem_map.h"
+#include "mirror/class.h"
+#include "mirror/class_loader.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object_array-inl.h"
+#include "mirror/stack_trace_element.h"
#include "runtime.h"
#include "ScopedLocalRef.h"
#include "scoped_thread_state_change.h"
@@ -43,8 +48,9 @@
const char* method_name, const char* method_sig) {
ScopedObjectAccess soa(Thread::Current());
// Compile the native method before starting the runtime
- Class* c = class_linker_->FindClass("LMyClassNatives;", soa.Decode<ClassLoader*>(class_loader));
- AbstractMethod* method;
+ mirror::Class* c = class_linker_->FindClass("LMyClassNatives;",
+ soa.Decode<mirror::ClassLoader*>(class_loader));
+ mirror::AbstractMethod* method;
if (direct) {
method = c->FindDirectMethod(method_name, method_sig);
} else {
@@ -141,7 +147,7 @@
ScopedObjectAccess soa(Thread::Current());
std::string reason;
ASSERT_TRUE(
- Runtime::Current()->GetJavaVM()->LoadNativeLibrary("", soa.Decode<ClassLoader*>(class_loader_),
+ Runtime::Current()->GetJavaVM()->LoadNativeLibrary("", soa.Decode<mirror::ClassLoader*>(class_loader_),
reason)) << reason;
jint result = env_->CallNonvirtualIntMethod(jobj_, jklass_, jmethod_, 24);
@@ -155,7 +161,7 @@
ScopedObjectAccess soa(Thread::Current());
std::string reason;
ASSERT_TRUE(
- Runtime::Current()->GetJavaVM()->LoadNativeLibrary("", soa.Decode<ClassLoader*>(class_loader_),
+ Runtime::Current()->GetJavaVM()->LoadNativeLibrary("", soa.Decode<mirror::ClassLoader*>(class_loader_),
reason)) << reason;
jint result = env_->CallStaticIntMethod(jklass_, jmethod_, 42);
@@ -548,15 +554,15 @@
// Build stack trace
jobject internal = Thread::Current()->CreateInternalStackTrace(soa);
jobjectArray ste_array = Thread::InternalStackTraceToStackTraceElementArray(env, internal);
- ObjectArray<StackTraceElement>* trace_array =
- soa.Decode<ObjectArray<StackTraceElement>*>(ste_array);
+ mirror::ObjectArray<mirror::StackTraceElement>* trace_array =
+ soa.Decode<mirror::ObjectArray<mirror::StackTraceElement>*>(ste_array);
EXPECT_TRUE(trace_array != NULL);
EXPECT_EQ(11, trace_array->GetLength());
// Check stack trace entries have expected values
for (int32_t i = 0; i < trace_array->GetLength(); ++i) {
EXPECT_EQ(-2, trace_array->Get(i)->GetLineNumber());
- StackTraceElement* ste = trace_array->Get(i);
+ mirror::StackTraceElement* ste = trace_array->Get(i);
EXPECT_STREQ("MyClassNatives.java", ste->GetFileName()->ToModifiedUtf8().c_str());
EXPECT_STREQ("MyClassNatives", ste->GetDeclaringClass()->ToModifiedUtf8().c_str());
EXPECT_STREQ("fooI", ste->GetMethodName()->ToModifiedUtf8().c_str());
@@ -601,7 +607,7 @@
// Add 10 local references
ScopedObjectAccess soa(env);
for (int i = 0; i < 10; i++) {
- soa.AddLocalReference<jobject>(soa.Decode<Object*>(thisObj));
+ soa.AddLocalReference<jobject>(soa.Decode<mirror::Object*>(thisObj));
}
return x+1;
}
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 84b5144..0ee4c21 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -27,19 +27,28 @@
#include "base/stl_util.h"
#include "base/stringpiece.h"
#include "class_linker.h"
-#include "class_loader.h"
+#include "gc/card_table-inl.h"
#include "invoke_arg_array_builder.h"
#include "jni.h"
-#include "object.h"
+#include "mirror/class-inl.h"
+#include "mirror/class_loader.h"
+#include "mirror/field-inl.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
+#include "mirror/throwable.h"
#include "object_utils.h"
#include "runtime.h"
#include "safe_map.h"
#include "scoped_thread_state_change.h"
#include "ScopedLocalRef.h"
#include "thread.h"
+#include "utf.h"
#include "UniquePtr.h"
#include "well_known_classes.h"
+using namespace art::mirror;
+
namespace art {
static const size_t kMonitorsInitial = 32; // Arbitrary.
@@ -2533,6 +2542,11 @@
stacked_local_ref_cookies.pop_back();
}
+Offset JNIEnvExt::SegmentStateOffset() {
+ return Offset(OFFSETOF_MEMBER(JNIEnvExt, locals) +
+ IndirectReferenceTable::SegmentStateOffset().Int32Value());
+}
+
// JNI Invocation interface.
extern "C" jint JNI_CreateJavaVM(JavaVM** p_vm, void** p_env, void* vm_args) {
@@ -2860,7 +2874,7 @@
return native_method;
}
-void JavaVMExt::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
+void JavaVMExt::VisitRoots(RootVisitor* visitor, void* arg) {
Thread* self = Thread::Current();
{
MutexLock mu(self, globals_lock);
diff --git a/src/jni_internal.h b/src/jni_internal.h
index 6b597ec..9b773f3 100644
--- a/src/jni_internal.h
+++ b/src/jni_internal.h
@@ -21,9 +21,9 @@
#include "base/macros.h"
#include "base/mutex.h"
-#include "heap.h"
#include "indirect_reference_table.h"
#include "reference_table.h"
+#include "root_visitor.h"
#include "runtime.h"
#include <iosfwd>
@@ -37,12 +37,13 @@
RegisterNativeMethods(env, jni_class_name, gMethods, arraysize(gMethods))
namespace art {
-
+namespace mirror {
+class AbstractMethod;
class ClassLoader;
class Field;
+}
union JValue;
class Libraries;
-class AbstractMethod;
class ScopedObjectAccess;
class Thread;
@@ -54,7 +55,8 @@
JValue InvokeWithJValues(const ScopedObjectAccess&, jobject obj, jmethodID mid, jvalue* args)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-JValue InvokeWithJValues(const ScopedObjectAccess&, Object* receiver, AbstractMethod* m, JValue* args)
+JValue InvokeWithJValues(const ScopedObjectAccess&, mirror::Object* receiver,
+ mirror::AbstractMethod* m, JValue* args)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
int ThrowNewException(JNIEnv* env, jclass exception_class, const char* msg, jobject cause);
@@ -69,14 +71,15 @@
* Returns 'true' on success. On failure, sets 'detail' to a
* human-readable description of the error.
*/
- bool LoadNativeLibrary(const std::string& path, ClassLoader* class_loader, std::string& detail)
+ bool LoadNativeLibrary(const std::string& path, mirror::ClassLoader* class_loader,
+ std::string& detail)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
/**
* Returns a pointer to the code for the native method 'm', found
* using dlsym(3) on every native library that's been loaded so far.
*/
- void* FindCodeForNativeMethod(AbstractMethod* m)
+ void* FindCodeForNativeMethod(mirror::AbstractMethod* m)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void DumpForSigQuit(std::ostream& os);
@@ -86,7 +89,7 @@
void SetCheckJniEnabled(bool enabled);
- void VisitRoots(Heap::RootVisitor*, void*);
+ void VisitRoots(RootVisitor*, void*);
Runtime* runtime;
@@ -135,10 +138,7 @@
void PushFrame(int capacity);
void PopFrame();
- static Offset SegmentStateOffset() {
- return Offset(OFFSETOF_MEMBER(JNIEnvExt, locals) +
- IndirectReferenceTable::SegmentStateOffset().Int32Value());
- }
+ static Offset SegmentStateOffset();
static Offset LocalRefCookieOffset() {
return Offset(OFFSETOF_MEMBER(JNIEnvExt, local_ref_cookie));
diff --git a/src/jni_internal_test.cc b/src/jni_internal_test.cc
index 7201233..a945ba6 100644
--- a/src/jni_internal_test.cc
+++ b/src/jni_internal_test.cc
@@ -20,6 +20,8 @@
#include <cmath>
#include "common_test.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object_array-inl.h"
#include "ScopedLocalRef.h"
#include "sirt_ref.h"
@@ -70,15 +72,17 @@
CommonTest::TearDown();
}
- AbstractMethod::InvokeStub* DoCompile(AbstractMethod*& method, Object*& receiver, bool is_static,
- const char* method_name, const char* method_signature)
+ mirror::AbstractMethod::InvokeStub* DoCompile(mirror::AbstractMethod*& method,
+ mirror::Object*& receiver,
+ bool is_static, const char* method_name,
+ const char* method_signature)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
const char* class_name = is_static ? "StaticLeafMethods" : "NonStaticLeafMethods";
jobject jclass_loader(LoadDex(class_name));
Thread* self = Thread::Current();
- SirtRef<ClassLoader>
+ SirtRef<mirror::ClassLoader>
class_loader(self,
- ScopedObjectAccessUnchecked(self).Decode<ClassLoader*>(jclass_loader));
+ ScopedObjectAccessUnchecked(self).Decode<mirror::ClassLoader*>(jclass_loader));
if (is_static) {
CompileDirectMethod(class_loader.get(), class_name, method_name, method_signature);
} else {
@@ -87,7 +91,7 @@
CompileVirtualMethod(class_loader.get(), class_name, method_name, method_signature);
}
- Class* c = class_linker_->FindClass(DotToDescriptor(class_name).c_str(), class_loader.get());
+ mirror::Class* c = class_linker_->FindClass(DotToDescriptor(class_name).c_str(), class_loader.get());
CHECK(c != NULL);
method = is_static ? c->FindDirectMethod(method_name, method_signature)
@@ -96,24 +100,25 @@
receiver = (is_static ? NULL : c->AllocObject(self));
- AbstractMethod::InvokeStub* stub = method->GetInvokeStub();
+ mirror::AbstractMethod::InvokeStub* stub = method->GetInvokeStub();
CHECK(stub != NULL);
return stub;
}
void InvokeNopMethod(bool is_static) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* method;
- Object* receiver;
- AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "nop", "()V");
+ mirror::AbstractMethod* method;
+ mirror::Object* receiver;
+ mirror::AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "nop", "()V");
(*stub)(method, receiver, Thread::Current(), NULL, NULL);
}
void InvokeIdentityByteMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* method;
- Object* receiver;
- AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "identity", "(B)B");
+ mirror::AbstractMethod* method;
+ mirror::Object* receiver;
+ mirror::AbstractMethod::InvokeStub* stub =
+ DoCompile(method, receiver, is_static, "identity", "(B)B");
JValue args[1];
JValue result;
@@ -141,9 +146,10 @@
void InvokeIdentityIntMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* method;
- Object* receiver;
- AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "identity", "(I)I");
+ mirror::AbstractMethod* method;
+ mirror::Object* receiver;
+ mirror::AbstractMethod::InvokeStub* stub =
+ DoCompile(method, receiver, is_static, "identity", "(I)I");
JValue args[1];
JValue result;
@@ -171,9 +177,10 @@
void InvokeIdentityDoubleMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* method;
- Object* receiver;
- AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "identity", "(D)D");
+ mirror::AbstractMethod* method;
+ mirror::Object* receiver;
+ mirror::AbstractMethod::InvokeStub* stub =
+ DoCompile(method, receiver, is_static, "identity", "(D)D");
JValue args[1];
JValue result;
@@ -201,9 +208,10 @@
void InvokeSumIntIntMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* method;
- Object* receiver;
- AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(II)I");
+ mirror::AbstractMethod* method;
+ mirror::Object* receiver;
+ mirror::AbstractMethod::InvokeStub* stub =
+ DoCompile(method, receiver, is_static, "sum", "(II)I");
JValue result;
result.SetI(-1);
@@ -240,9 +248,10 @@
void InvokeSumIntIntIntMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* method;
- Object* receiver;
- AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(III)I");
+ mirror::AbstractMethod* method;
+ mirror::Object* receiver;
+ mirror::AbstractMethod::InvokeStub* stub =
+ DoCompile(method, receiver, is_static, "sum", "(III)I");
JValue result;
result.SetI(-1);
@@ -284,9 +293,10 @@
void InvokeSumIntIntIntIntMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* method;
- Object* receiver;
- AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(IIII)I");
+ mirror::AbstractMethod* method;
+ mirror::Object* receiver;
+ mirror::AbstractMethod::InvokeStub* stub =
+ DoCompile(method, receiver, is_static, "sum", "(IIII)I");
JValue result;
result.SetI(-1);
@@ -333,9 +343,10 @@
void InvokeSumIntIntIntIntIntMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* method;
- Object* receiver;
- AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(IIIII)I");
+ mirror::AbstractMethod* method;
+ mirror::Object* receiver;
+ mirror::AbstractMethod::InvokeStub* stub =
+ DoCompile(method, receiver, is_static, "sum", "(IIIII)I");
JValue result;
result.SetI(-1.0);
@@ -387,9 +398,10 @@
void InvokeSumDoubleDoubleMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* method;
- Object* receiver;
- AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(DD)D");
+ mirror::AbstractMethod* method;
+ mirror::Object* receiver;
+ mirror::AbstractMethod::InvokeStub* stub =
+ DoCompile(method, receiver, is_static, "sum", "(DD)D");
JValue args[2];
JValue result;
@@ -427,9 +439,10 @@
void InvokeSumDoubleDoubleDoubleMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* method;
- Object* receiver;
- AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(DDD)D");
+ mirror::AbstractMethod* method;
+ mirror::Object* receiver;
+ mirror::AbstractMethod::InvokeStub* stub =
+ DoCompile(method, receiver, is_static, "sum", "(DDD)D");
JValue args[3];
JValue result;
@@ -458,9 +471,10 @@
void InvokeSumDoubleDoubleDoubleDoubleMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* method;
- Object* receiver;
- AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(DDDD)D");
+ mirror::AbstractMethod* method;
+ mirror::Object* receiver;
+ mirror::AbstractMethod::InvokeStub* stub =
+ DoCompile(method, receiver, is_static, "sum", "(DDDD)D");
JValue args[4];
JValue result;
@@ -492,9 +506,10 @@
void InvokeSumDoubleDoubleDoubleDoubleDoubleMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* method;
- Object* receiver;
- AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(DDDDD)D");
+ mirror::AbstractMethod* method;
+ mirror::Object* receiver;
+ mirror::AbstractMethod::InvokeStub* stub =
+ DoCompile(method, receiver, is_static, "sum", "(DDDDD)D");
JValue args[5];
JValue result;
@@ -1270,7 +1285,7 @@
jobject outer;
jobject inner1, inner2;
ScopedObjectAccess soa(env_);
- Object* inner2_direct_pointer;
+ mirror::Object* inner2_direct_pointer;
{
env_->PushLocalFrame(4);
outer = env_->NewLocalRef(original);
@@ -1279,7 +1294,7 @@
env_->PushLocalFrame(4);
inner1 = env_->NewLocalRef(outer);
inner2 = env_->NewStringUTF("survivor");
- inner2_direct_pointer = soa.Decode<Object*>(inner2);
+ inner2_direct_pointer = soa.Decode<mirror::Object*>(inner2);
env_->PopLocalFrame(inner2);
}
@@ -1393,16 +1408,17 @@
TEST_F(JniInternalTest, StaticMainMethod) {
ScopedObjectAccess soa(Thread::Current());
jobject jclass_loader = LoadDex("Main");
- SirtRef<ClassLoader> class_loader(soa.Self(), soa.Decode<ClassLoader*>(jclass_loader));
+ SirtRef<mirror::ClassLoader>
+ class_loader(soa.Self(), soa.Decode<mirror::ClassLoader*>(jclass_loader));
CompileDirectMethod(class_loader.get(), "Main", "main", "([Ljava/lang/String;)V");
- Class* klass = class_linker_->FindClass("LMain;", class_loader.get());
+ mirror::Class* klass = class_linker_->FindClass("LMain;", class_loader.get());
ASSERT_TRUE(klass != NULL);
- AbstractMethod* method = klass->FindDirectMethod("main", "([Ljava/lang/String;)V");
+ mirror::AbstractMethod* method = klass->FindDirectMethod("main", "([Ljava/lang/String;)V");
ASSERT_TRUE(method != NULL);
- AbstractMethod::InvokeStub* stub = method->GetInvokeStub();
+ mirror::AbstractMethod::InvokeStub* stub = method->GetInvokeStub();
JValue args[1];
args[0].SetL(NULL);
diff --git a/src/jobject_comparator.cc b/src/jobject_comparator.cc
index edd0727..738a186 100644
--- a/src/jobject_comparator.cc
+++ b/src/jobject_comparator.cc
@@ -16,7 +16,9 @@
#include "jobject_comparator.h"
-#include "object.h"
+#include "mirror/array-inl.h"
+#include "mirror/class.h"
+#include "mirror/object-inl.h"
#include "scoped_thread_state_change.h"
namespace art {
@@ -29,8 +31,8 @@
return false;
}
ScopedObjectAccess soa(Thread::Current());
- Object* obj1 = soa.Decode<Object*>(jobj1);
- Object* obj2 = soa.Decode<Object*>(jobj2);
+ mirror::Object* obj1 = soa.Decode<mirror::Object*>(jobj1);
+ mirror::Object* obj2 = soa.Decode<mirror::Object*>(jobj2);
if (obj1 == NULL) {
return true;
} else if (obj2 == NULL) {
diff --git a/src/jvalue.h b/src/jvalue.h
index a7a1795..fa85937 100644
--- a/src/jvalue.h
+++ b/src/jvalue.h
@@ -20,8 +20,9 @@
#include "base/macros.h"
namespace art {
-
+namespace mirror {
class Object;
+} // namespace mirror
union PACKED(4) JValue {
// We default initialize JValue instances to all-zeros.
@@ -47,8 +48,8 @@
int64_t GetJ() const { return j; }
void SetJ(int64_t new_j) { j = new_j; }
- Object* GetL() const { return l; }
- void SetL(Object* new_l) { l = new_l; }
+ mirror::Object* GetL() const { return l; }
+ void SetL(mirror::Object* new_l) { l = new_l; }
int16_t GetS() const { return s; }
void SetS(int16_t new_s) {
@@ -67,7 +68,7 @@
int64_t j;
float f;
double d;
- Object* l;
+ mirror::Object* l;
};
} // namespace art
diff --git a/src/mirror/abstract_method-inl.h b/src/mirror/abstract_method-inl.h
new file mode 100644
index 0000000..efb7c03
--- /dev/null
+++ b/src/mirror/abstract_method-inl.h
@@ -0,0 +1,184 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_METHOD_INL_H_
+#define ART_SRC_MIRROR_METHOD_INL_H_
+
+#include "abstract_method.h"
+
+#include "array.h"
+#include "dex_file.h"
+#include "runtime.h"
+
+namespace art {
+namespace mirror {
+
+inline Class* AbstractMethod::GetDeclaringClass() const {
+ Class* result = GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, declaring_class_), false);
+ DCHECK(result != NULL) << this;
+ DCHECK(result->IsIdxLoaded() || result->IsErroneous()) << this;
+ return result;
+}
+
+inline void AbstractMethod::SetDeclaringClass(Class *new_declaring_class) {
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, declaring_class_), new_declaring_class, false);
+}
+
+inline uint32_t AbstractMethod::GetAccessFlags() const {
+ DCHECK(GetDeclaringClass()->IsIdxLoaded() || GetDeclaringClass()->IsErroneous());
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, access_flags_), false);
+}
+
+inline uint16_t AbstractMethod::GetMethodIndex() const {
+ DCHECK(GetDeclaringClass()->IsResolved() || GetDeclaringClass()->IsErroneous());
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_index_), false);
+}
+
+inline uint32_t AbstractMethod::GetDexMethodIndex() const {
+ DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_dex_index_), false);
+}
+
+inline uint32_t AbstractMethod::GetCodeSize() const {
+ DCHECK(!IsRuntimeMethod() && !IsProxyMethod()) << PrettyMethod(this);
+ uintptr_t code = reinterpret_cast<uintptr_t>(GetCode());
+ if (code == 0) {
+ return 0;
+ }
+ // TODO: make this Thumb2 specific
+ code &= ~0x1;
+ return reinterpret_cast<uint32_t*>(code)[-1];
+}
+
+inline bool AbstractMethod::CheckIncompatibleClassChange(InvokeType type) {
+ switch (type) {
+ case kStatic:
+ return !IsStatic();
+ case kDirect:
+ return !IsDirect() || IsStatic();
+ case kVirtual: {
+ Class* methods_class = GetDeclaringClass();
+ return IsDirect() || (methods_class->IsInterface() && !IsMiranda());
+ }
+ case kSuper:
+ return false; // TODO: appropriate checks for call to super class.
+ case kInterface: {
+ Class* methods_class = GetDeclaringClass();
+ return IsDirect() || !(methods_class->IsInterface() || methods_class->IsObjectClass());
+ }
+ default:
+ LOG(FATAL) << "Unreachable - invocation type: " << type;
+ return true;
+ }
+}
+
+inline void AbstractMethod::AssertPcIsWithinCode(uintptr_t pc) const {
+ if (!kIsDebugBuild) {
+ return;
+ }
+ if (IsNative() || IsRuntimeMethod() || IsProxyMethod()) {
+ return;
+ }
+ Runtime* runtime = Runtime::Current();
+ if (GetCode() == runtime->GetResolutionStubArray(Runtime::kStaticMethod)->GetData()) {
+ return;
+ }
+ DCHECK(IsWithinCode(pc))
+ << PrettyMethod(this)
+ << " pc=" << std::hex << pc
+ << " code=" << GetCode()
+ << " size=" << GetCodeSize();
+}
+
+inline uint32_t AbstractMethod::GetOatCodeOffset() const {
+ DCHECK(!Runtime::Current()->IsStarted());
+ return reinterpret_cast<uint32_t>(GetCode());
+}
+
+inline void AbstractMethod::SetOatCodeOffset(uint32_t code_offset) {
+ DCHECK(!Runtime::Current()->IsStarted());
+ SetCode(reinterpret_cast<void*>(code_offset));
+}
+
+inline uint32_t AbstractMethod::GetOatMappingTableOffset() const {
+ DCHECK(!Runtime::Current()->IsStarted());
+ return reinterpret_cast<uint32_t>(GetMappingTableRaw());
+}
+
+inline void AbstractMethod::SetOatMappingTableOffset(uint32_t mapping_table_offset) {
+ DCHECK(!Runtime::Current()->IsStarted());
+ SetMappingTable(reinterpret_cast<const uint32_t*>(mapping_table_offset));
+}
+
+inline uint32_t AbstractMethod::GetOatVmapTableOffset() const {
+ DCHECK(!Runtime::Current()->IsStarted());
+ return reinterpret_cast<uint32_t>(GetVmapTableRaw());
+}
+
+inline void AbstractMethod::SetOatVmapTableOffset(uint32_t vmap_table_offset) {
+ DCHECK(!Runtime::Current()->IsStarted());
+ SetVmapTable(reinterpret_cast<uint16_t*>(vmap_table_offset));
+}
+
+inline void AbstractMethod::SetOatNativeGcMapOffset(uint32_t gc_map_offset) {
+ DCHECK(!Runtime::Current()->IsStarted());
+ SetNativeGcMap(reinterpret_cast<uint8_t*>(gc_map_offset));
+}
+
+inline uint32_t AbstractMethod::GetOatNativeGcMapOffset() const {
+ DCHECK(!Runtime::Current()->IsStarted());
+ return reinterpret_cast<uint32_t>(GetNativeGcMap());
+}
+
+inline uint32_t AbstractMethod::GetOatInvokeStubOffset() const {
+ DCHECK(!Runtime::Current()->IsStarted());
+ return reinterpret_cast<uint32_t>(GetInvokeStub());
+}
+
+inline void AbstractMethod::SetOatInvokeStubOffset(uint32_t invoke_stub_offset) {
+ DCHECK(!Runtime::Current()->IsStarted());
+ SetInvokeStub(reinterpret_cast<InvokeStub*>(invoke_stub_offset));
+}
+
+inline bool AbstractMethod::IsRuntimeMethod() const {
+ return GetDexMethodIndex() == DexFile::kDexNoIndex16;
+}
+
+inline bool AbstractMethod::IsCalleeSaveMethod() const {
+ if (!IsRuntimeMethod()) {
+ return false;
+ }
+ Runtime* runtime = Runtime::Current();
+ bool result = false;
+ for (int i = 0; i < Runtime::kLastCalleeSaveType; i++) {
+ if (this == runtime->GetCalleeSaveMethod(Runtime::CalleeSaveType(i))) {
+ result = true;
+ break;
+ }
+ }
+ return result;
+}
+
+inline bool AbstractMethod::IsResolutionMethod() const {
+ bool result = this == Runtime::Current()->GetResolutionMethod();
+ // Check that if we do think it is phony it looks like the resolution method.
+ DCHECK(!result || IsRuntimeMethod());
+ return result;
+}
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_METHOD_INL_H_
diff --git a/src/mirror/abstract_method.cc b/src/mirror/abstract_method.cc
new file mode 100644
index 0000000..4641941
--- /dev/null
+++ b/src/mirror/abstract_method.cc
@@ -0,0 +1,376 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+#include "abstract_method.h"
+
+#include "abstract_method-inl.h"
+#include "class-inl.h"
+#include "base/stringpiece.h"
+#include "gc/card_table-inl.h"
+#include "interpreter/interpreter.h"
+#include "jni_internal.h"
+#include "object-inl.h"
+#include "object_array.h"
+#include "object_array-inl.h"
+#include "string.h"
+#include "object_utils.h"
+
+namespace art {
+namespace mirror {
+
+// TODO: get global references for these
+Class* AbstractMethod::java_lang_reflect_Constructor_ = NULL;
+Class* AbstractMethod::java_lang_reflect_Method_ = NULL;
+
+InvokeType AbstractMethod::GetInvokeType() const {
+ // TODO: kSuper?
+ if (GetDeclaringClass()->IsInterface()) {
+ return kInterface;
+ } else if (IsStatic()) {
+ return kStatic;
+ } else if (IsDirect()) {
+ return kDirect;
+ } else {
+ return kVirtual;
+ }
+}
+
+void AbstractMethod::SetClasses(Class* java_lang_reflect_Constructor, Class* java_lang_reflect_Method) {
+ CHECK(java_lang_reflect_Constructor_ == NULL);
+ CHECK(java_lang_reflect_Constructor != NULL);
+ java_lang_reflect_Constructor_ = java_lang_reflect_Constructor;
+
+ CHECK(java_lang_reflect_Method_ == NULL);
+ CHECK(java_lang_reflect_Method != NULL);
+ java_lang_reflect_Method_ = java_lang_reflect_Method;
+}
+
+void AbstractMethod::ResetClasses() {
+ CHECK(java_lang_reflect_Constructor_ != NULL);
+ java_lang_reflect_Constructor_ = NULL;
+
+ CHECK(java_lang_reflect_Method_ != NULL);
+ java_lang_reflect_Method_ = NULL;
+}
+
+ObjectArray<String>* AbstractMethod::GetDexCacheStrings() const {
+ return GetFieldObject<ObjectArray<String>*>(
+ OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_strings_), false);
+}
+
+void AbstractMethod::SetDexCacheStrings(ObjectArray<String>* new_dex_cache_strings) {
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_strings_),
+ new_dex_cache_strings, false);
+}
+
+ObjectArray<AbstractMethod>* AbstractMethod::GetDexCacheResolvedMethods() const {
+ return GetFieldObject<ObjectArray<AbstractMethod>*>(
+ OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_methods_), false);
+}
+
+void AbstractMethod::SetDexCacheResolvedMethods(ObjectArray<AbstractMethod>* new_dex_cache_methods) {
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_methods_),
+ new_dex_cache_methods, false);
+}
+
+ObjectArray<Class>* AbstractMethod::GetDexCacheResolvedTypes() const {
+ return GetFieldObject<ObjectArray<Class>*>(
+ OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_types_), false);
+}
+
+void AbstractMethod::SetDexCacheResolvedTypes(ObjectArray<Class>* new_dex_cache_classes) {
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_types_),
+ new_dex_cache_classes, false);
+}
+
+ObjectArray<StaticStorageBase>* AbstractMethod::GetDexCacheInitializedStaticStorage() const {
+ return GetFieldObject<ObjectArray<StaticStorageBase>*>(
+ OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_initialized_static_storage_),
+ false);
+}
+
+void AbstractMethod::SetDexCacheInitializedStaticStorage(ObjectArray<StaticStorageBase>* new_value) {
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_initialized_static_storage_),
+ new_value, false);
+}
+
+size_t AbstractMethod::NumArgRegisters(const StringPiece& shorty) {
+ CHECK_LE(1, shorty.length());
+ uint32_t num_registers = 0;
+ for (int i = 1; i < shorty.length(); ++i) {
+ char ch = shorty[i];
+ if (ch == 'D' || ch == 'J') {
+ num_registers += 2;
+ } else {
+ num_registers += 1;
+ }
+ }
+ return num_registers;
+}
+
+bool AbstractMethod::IsProxyMethod() const {
+ return GetDeclaringClass()->IsProxyClass();
+}
+
+AbstractMethod* AbstractMethod::FindOverriddenMethod() const {
+ if (IsStatic()) {
+ return NULL;
+ }
+ Class* declaring_class = GetDeclaringClass();
+ Class* super_class = declaring_class->GetSuperClass();
+ uint16_t method_index = GetMethodIndex();
+ ObjectArray<AbstractMethod>* super_class_vtable = super_class->GetVTable();
+ AbstractMethod* result = NULL;
+ // Did this method override a super class method? If so load the result from the super class'
+ // vtable
+ if (super_class_vtable != NULL && method_index < super_class_vtable->GetLength()) {
+ result = super_class_vtable->Get(method_index);
+ } else {
+ // Method didn't override superclass method so search interfaces
+ if (IsProxyMethod()) {
+ result = GetDexCacheResolvedMethods()->Get(GetDexMethodIndex());
+ CHECK_EQ(result,
+ Runtime::Current()->GetClassLinker()->FindMethodForProxy(GetDeclaringClass(), this));
+ } else {
+ MethodHelper mh(this);
+ MethodHelper interface_mh;
+ IfTable* iftable = GetDeclaringClass()->GetIfTable();
+ for (size_t i = 0; i < iftable->Count() && result == NULL; i++) {
+ Class* interface = iftable->GetInterface(i);
+ for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
+ AbstractMethod* interface_method = interface->GetVirtualMethod(j);
+ interface_mh.ChangeMethod(interface_method);
+ if (mh.HasSameNameAndSignature(&interface_mh)) {
+ result = interface_method;
+ break;
+ }
+ }
+ }
+ }
+ }
+#ifndef NDEBUG
+ MethodHelper result_mh(result);
+ DCHECK(result == NULL || MethodHelper(this).HasSameNameAndSignature(&result_mh));
+#endif
+ return result;
+}
+
+static const void* GetOatCode(const AbstractMethod* m)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ Runtime* runtime = Runtime::Current();
+ const void* code = m->GetCode();
+ // Peel off any method tracing trampoline.
+ if (runtime->IsMethodTracingActive() && runtime->GetInstrumentation()->GetSavedCodeFromMap(m) != NULL) {
+ code = runtime->GetInstrumentation()->GetSavedCodeFromMap(m);
+ }
+ // Peel off any resolution stub.
+ if (code == runtime->GetResolutionStubArray(Runtime::kStaticMethod)->GetData()) {
+ code = runtime->GetClassLinker()->GetOatCodeFor(m);
+ }
+ return code;
+}
+
+uintptr_t AbstractMethod::NativePcOffset(const uintptr_t pc) const {
+ return pc - reinterpret_cast<uintptr_t>(GetOatCode(this));
+}
+
+// Find the lowest-address native safepoint pc for a given dex pc
+uintptr_t AbstractMethod::ToFirstNativeSafepointPc(const uint32_t dex_pc) const {
+#if !defined(ART_USE_LLVM_COMPILER)
+ const uint32_t* mapping_table = GetPcToDexMappingTable();
+ if (mapping_table == NULL) {
+ DCHECK(IsNative() || IsCalleeSaveMethod() || IsProxyMethod()) << PrettyMethod(this);
+ return DexFile::kDexNoIndex; // Special no mapping case
+ }
+ size_t mapping_table_length = GetPcToDexMappingTableLength();
+ for (size_t i = 0; i < mapping_table_length; i += 2) {
+ if (mapping_table[i + 1] == dex_pc) {
+ return mapping_table[i] + reinterpret_cast<uintptr_t>(GetOatCode(this));
+ }
+ }
+ LOG(FATAL) << "Failed to find native offset for dex pc 0x" << std::hex << dex_pc
+ << " in " << PrettyMethod(this);
+ return 0;
+#else
+ // Compiler LLVM doesn't use the machine pc, we just use dex pc instead.
+ return static_cast<uint32_t>(dex_pc);
+#endif
+}
+
+uint32_t AbstractMethod::ToDexPc(const uintptr_t pc) const {
+#if !defined(ART_USE_LLVM_COMPILER)
+ const uint32_t* mapping_table = GetPcToDexMappingTable();
+ if (mapping_table == NULL) {
+ DCHECK(IsNative() || IsCalleeSaveMethod() || IsProxyMethod()) << PrettyMethod(this);
+ return DexFile::kDexNoIndex; // Special no mapping case
+ }
+ size_t mapping_table_length = GetPcToDexMappingTableLength();
+ uint32_t sought_offset = pc - reinterpret_cast<uintptr_t>(GetOatCode(this));
+ for (size_t i = 0; i < mapping_table_length; i += 2) {
+ if (mapping_table[i] == sought_offset) {
+ return mapping_table[i + 1];
+ }
+ }
+ LOG(ERROR) << "Failed to find Dex offset for PC offset " << reinterpret_cast<void*>(sought_offset)
+ << "(PC " << reinterpret_cast<void*>(pc) << ") in " << PrettyMethod(this);
+ return DexFile::kDexNoIndex;
+#else
+ // Compiler LLVM doesn't use the machine pc, we just use dex pc instead.
+ return static_cast<uint32_t>(pc);
+#endif
+}
+
+uintptr_t AbstractMethod::ToNativePc(const uint32_t dex_pc) const {
+ const uint32_t* mapping_table = GetDexToPcMappingTable();
+ if (mapping_table == NULL) {
+ DCHECK_EQ(dex_pc, 0U);
+ return 0; // Special no mapping/pc == 0 case
+ }
+ size_t mapping_table_length = GetDexToPcMappingTableLength();
+ for (size_t i = 0; i < mapping_table_length; i += 2) {
+ uint32_t map_offset = mapping_table[i];
+ uint32_t map_dex_offset = mapping_table[i + 1];
+ if (map_dex_offset == dex_pc) {
+ return reinterpret_cast<uintptr_t>(GetOatCode(this)) + map_offset;
+ }
+ }
+ LOG(FATAL) << "Looking up Dex PC not contained in method, 0x" << std::hex << dex_pc
+ << " in " << PrettyMethod(this);
+ return 0;
+}
+
+uint32_t AbstractMethod::FindCatchBlock(Class* exception_type, uint32_t dex_pc) const {
+ MethodHelper mh(this);
+ const DexFile::CodeItem* code_item = mh.GetCodeItem();
+ // Iterate over the catch handlers associated with dex_pc
+ for (CatchHandlerIterator it(*code_item, dex_pc); it.HasNext(); it.Next()) {
+ uint16_t iter_type_idx = it.GetHandlerTypeIndex();
+ // Catch all case
+ if (iter_type_idx == DexFile::kDexNoIndex16) {
+ return it.GetHandlerAddress();
+ }
+ // Does this catch exception type apply?
+ Class* iter_exception_type = mh.GetDexCacheResolvedType(iter_type_idx);
+ if (iter_exception_type == NULL) {
+ // The verifier should take care of resolving all exception classes early
+ LOG(WARNING) << "Unresolved exception class when finding catch block: "
+ << mh.GetTypeDescriptorFromTypeIdx(iter_type_idx);
+ } else if (iter_exception_type->IsAssignableFrom(exception_type)) {
+ return it.GetHandlerAddress();
+ }
+ }
+ // Handler not found
+ return DexFile::kDexNoIndex;
+}
+
+void AbstractMethod::Invoke(Thread* self, Object* receiver, JValue* args, JValue* result) {
+ if (kIsDebugBuild) {
+ self->AssertThreadSuspensionIsAllowable();
+ CHECK_EQ(kRunnable, self->GetState());
+ }
+
+ // Push a transition back into managed code onto the linked list in thread.
+ ManagedStack fragment;
+ self->PushManagedStackFragment(&fragment);
+
+ // Call the invoke stub associated with the method.
+ // Pass everything as arguments.
+ AbstractMethod::InvokeStub* stub = GetInvokeStub();
+
+ if (UNLIKELY(!Runtime::Current()->IsStarted())){
+ LOG(INFO) << "Not invoking " << PrettyMethod(this) << " for a runtime that isn't started";
+ if (result != NULL) {
+ result->SetJ(0);
+ }
+ } else {
+ bool interpret = self->ReadFlag(kEnterInterpreter) && !IsNative() && !IsProxyMethod();
+ const bool kLogInvocationStartAndReturn = false;
+ if (!interpret && GetCode() != NULL && stub != NULL) {
+ if (kLogInvocationStartAndReturn) {
+ LOG(INFO) << StringPrintf("Invoking '%s' code=%p stub=%p",
+ PrettyMethod(this).c_str(), GetCode(), stub);
+ }
+ (*stub)(this, receiver, self, args, result);
+ if (kLogInvocationStartAndReturn) {
+ LOG(INFO) << StringPrintf("Returned '%s' code=%p stub=%p",
+ PrettyMethod(this).c_str(), GetCode(), stub);
+ }
+ } else {
+ const bool kInterpretMethodsWithNoCode = false;
+ if (interpret || kInterpretMethodsWithNoCode) {
+ if (kLogInvocationStartAndReturn) {
+ LOG(INFO) << "Interpreting " << PrettyMethod(this) << "'";
+ }
+ art::interpreter::EnterInterpreterFromInvoke(self, this, receiver, args, result);
+ if (kLogInvocationStartAndReturn) {
+ LOG(INFO) << "Returned '" << PrettyMethod(this) << "'";
+ }
+ } else {
+ LOG(INFO) << "Not invoking '" << PrettyMethod(this)
+ << "' code=" << reinterpret_cast<const void*>(GetCode())
+ << " stub=" << reinterpret_cast<void*>(stub);
+ if (result != NULL) {
+ result->SetJ(0);
+ }
+ }
+ }
+ }
+
+ // Pop transition.
+ self->PopManagedStackFragment(fragment);
+}
+
+bool AbstractMethod::IsRegistered() const {
+ void* native_method = GetFieldPtr<void*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_method_), false);
+ CHECK(native_method != NULL);
+ void* jni_stub = Runtime::Current()->GetJniDlsymLookupStub()->GetData();
+ return native_method != jni_stub;
+}
+
+void AbstractMethod::RegisterNative(Thread* self, const void* native_method) {
+ DCHECK(Thread::Current() == self);
+ CHECK(IsNative()) << PrettyMethod(this);
+ CHECK(native_method != NULL) << PrettyMethod(this);
+ if (!self->GetJniEnv()->vm->work_around_app_jni_bugs) {
+ SetNativeMethod(native_method);
+ } else {
+ // We've been asked to associate this method with the given native method but are working
+ // around JNI bugs, that include not giving Object** SIRT references to native methods. Direct
+ // the native method to runtime support and store the target somewhere runtime support will
+ // find it.
+#if defined(__arm__) && !defined(ART_USE_LLVM_COMPILER)
+ SetNativeMethod(native_method);
+#else
+ UNIMPLEMENTED(FATAL);
+#endif
+ SetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_gc_map_),
+ reinterpret_cast<const uint8_t*>(native_method), false);
+ }
+}
+
+void AbstractMethod::UnregisterNative(Thread* self) {
+ CHECK(IsNative()) << PrettyMethod(this);
+ // restore stub to lookup native pointer via dlsym
+ RegisterNative(self, Runtime::Current()->GetJniDlsymLookupStub()->GetData());
+}
+
+void AbstractMethod::SetNativeMethod(const void* native_method) {
+ SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_method_),
+ native_method, false);
+}
+
+} // namespace mirror
+} // namespace art
diff --git a/src/mirror/abstract_method.h b/src/mirror/abstract_method.h
new file mode 100644
index 0000000..1d57abb
--- /dev/null
+++ b/src/mirror/abstract_method.h
@@ -0,0 +1,524 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_METHOD_H_
+#define ART_SRC_MIRROR_METHOD_H_
+
+#include "class.h"
+#include "invoke_type.h"
+#include "locks.h"
+#include "modifiers.h"
+#include "object.h"
+
+namespace art {
+
+struct AbstractMethodOffsets;
+struct ConstructorMethodOffsets;
+union JValue;
+struct MethodClassOffsets;
+struct MethodOffsets;
+class StringPiece;
+
+namespace mirror {
+
+class StaticStorageBase;
+
+// C++ mirror of java.lang.reflect.Method and java.lang.reflect.Constructor
+class MANAGED AbstractMethod : public Object {
+ public:
+ // A function that invokes a method with an array of its arguments.
+ typedef void InvokeStub(const AbstractMethod* method,
+ Object* obj,
+ Thread* thread,
+ JValue* args,
+ JValue* result);
+
+ Class* GetDeclaringClass() const;
+
+ void SetDeclaringClass(Class *new_declaring_class) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static MemberOffset DeclaringClassOffset() {
+ return MemberOffset(OFFSETOF_MEMBER(AbstractMethod, declaring_class_));
+ }
+
+ uint32_t GetAccessFlags() const;
+
+ void SetAccessFlags(uint32_t new_access_flags) {
+ SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, access_flags_), new_access_flags, false);
+ }
+
+ // Approximate what kind of method call would be used for this method.
+ InvokeType GetInvokeType() const;
+
+ // Returns true if the method is declared public.
+ bool IsPublic() const {
+ return (GetAccessFlags() & kAccPublic) != 0;
+ }
+
+ // Returns true if the method is declared private.
+ bool IsPrivate() const {
+ return (GetAccessFlags() & kAccPrivate) != 0;
+ }
+
+ // Returns true if the method is declared static.
+ bool IsStatic() const {
+ return (GetAccessFlags() & kAccStatic) != 0;
+ }
+
+ // Returns true if the method is a constructor.
+ bool IsConstructor() const {
+ return (GetAccessFlags() & kAccConstructor) != 0;
+ }
+
+ // Returns true if the method is static, private, or a constructor.
+ bool IsDirect() const {
+ return IsDirect(GetAccessFlags());
+ }
+
+ static bool IsDirect(uint32_t access_flags) {
+ return (access_flags & (kAccStatic | kAccPrivate | kAccConstructor)) != 0;
+ }
+
+ // Returns true if the method is declared synchronized.
+ bool IsSynchronized() const {
+ uint32_t synchonized = kAccSynchronized | kAccDeclaredSynchronized;
+ return (GetAccessFlags() & synchonized) != 0;
+ }
+
+ bool IsFinal() const {
+ return (GetAccessFlags() & kAccFinal) != 0;
+ }
+
+ bool IsMiranda() const {
+ return (GetAccessFlags() & kAccMiranda) != 0;
+ }
+
+ bool IsNative() const {
+ return (GetAccessFlags() & kAccNative) != 0;
+ }
+
+ bool IsAbstract() const {
+ return (GetAccessFlags() & kAccAbstract) != 0;
+ }
+
+ bool IsSynthetic() const {
+ return (GetAccessFlags() & kAccSynthetic) != 0;
+ }
+
+ bool IsProxyMethod() const;
+
+ bool CheckIncompatibleClassChange(InvokeType type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ uint16_t GetMethodIndex() const;
+
+ size_t GetVtableIndex() const {
+ return GetMethodIndex();
+ }
+
+ void SetMethodIndex(uint16_t new_method_index) {
+ SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_index_), new_method_index, false);
+ }
+
+ static MemberOffset MethodIndexOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_index_);
+ }
+
+ uint32_t GetCodeItemOffset() const {
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, code_item_offset_), false);
+ }
+
+ void SetCodeItemOffset(uint32_t new_code_off) {
+ SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, code_item_offset_), new_code_off, false);
+ }
+
+ // Number of 32bit registers that would be required to hold all the arguments
+ static size_t NumArgRegisters(const StringPiece& shorty);
+
+ uint32_t GetDexMethodIndex() const;
+
+ void SetDexMethodIndex(uint32_t new_idx) {
+ SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_dex_index_), new_idx, false);
+ }
+
+ ObjectArray<String>* GetDexCacheStrings() const;
+ void SetDexCacheStrings(ObjectArray<String>* new_dex_cache_strings)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static MemberOffset DexCacheStringsOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_strings_);
+ }
+
+ static MemberOffset DexCacheResolvedMethodsOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_methods_);
+ }
+
+ static MemberOffset DexCacheResolvedTypesOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_types_);
+ }
+
+ static MemberOffset DexCacheInitializedStaticStorageOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod,
+ dex_cache_initialized_static_storage_);
+ }
+
+ ObjectArray<AbstractMethod>* GetDexCacheResolvedMethods() const;
+ void SetDexCacheResolvedMethods(ObjectArray<AbstractMethod>* new_dex_cache_methods)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ ObjectArray<Class>* GetDexCacheResolvedTypes() const;
+ void SetDexCacheResolvedTypes(ObjectArray<Class>* new_dex_cache_types)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ ObjectArray<StaticStorageBase>* GetDexCacheInitializedStaticStorage() const;
+ void SetDexCacheInitializedStaticStorage(ObjectArray<StaticStorageBase>* new_value)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Find the method that this method overrides
+ AbstractMethod* FindOverriddenMethod() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ void Invoke(Thread* self, Object* receiver, JValue* args, JValue* result)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ const void* GetCode() const {
+ return GetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, code_), false);
+ }
+
+ void SetCode(const void* code) {
+ SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, code_), code, false);
+ }
+
+ uint32_t GetCodeSize() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ bool IsWithinCode(uintptr_t pc) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ uintptr_t code = reinterpret_cast<uintptr_t>(GetCode());
+ if (code == 0) {
+ return pc == 0;
+ }
+ /*
+ * During a stack walk, a return PC may point to the end of the code + 1
+ * (in the case that the last instruction is a call that isn't expected to
+ * return. Thus, we check <= code + GetCodeSize().
+ */
+ return (code <= pc && pc <= code + GetCodeSize());
+ }
+
+ void AssertPcIsWithinCode(uintptr_t pc) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ uint32_t GetOatCodeOffset() const;
+
+ void SetOatCodeOffset(uint32_t code_offset);
+
+ static MemberOffset GetCodeOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, code_);
+ }
+
+ const uint32_t* GetMappingTable() const {
+ const uint32_t* map = GetMappingTableRaw();
+ if (map == NULL) {
+ return map;
+ }
+ return map + 1;
+ }
+
+ uint32_t GetPcToDexMappingTableLength() const {
+ const uint32_t* map = GetMappingTableRaw();
+ if (map == NULL) {
+ return 0;
+ }
+ return map[2];
+ }
+
+ const uint32_t* GetPcToDexMappingTable() const {
+ const uint32_t* map = GetMappingTableRaw();
+ if (map == NULL) {
+ return map;
+ }
+ return map + 3;
+ }
+
+
+ uint32_t GetDexToPcMappingTableLength() const {
+ const uint32_t* map = GetMappingTableRaw();
+ if (map == NULL) {
+ return 0;
+ }
+ return map[1] - map[2];
+ }
+
+ const uint32_t* GetDexToPcMappingTable() const {
+ const uint32_t* map = GetMappingTableRaw();
+ if (map == NULL) {
+ return map;
+ }
+ return map + 3 + map[2];
+ }
+
+
+ const uint32_t* GetMappingTableRaw() const {
+ return GetFieldPtr<const uint32_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, mapping_table_), false);
+ }
+
+ void SetMappingTable(const uint32_t* mapping_table) {
+ SetFieldPtr<const uint32_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, mapping_table_),
+ mapping_table, false);
+ }
+
+ uint32_t GetOatMappingTableOffset() const;
+
+ void SetOatMappingTableOffset(uint32_t mapping_table_offset);
+
+ // Callers should wrap the uint16_t* in a VmapTable instance for convenient access.
+ const uint16_t* GetVmapTableRaw() const {
+ return GetFieldPtr<const uint16_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, vmap_table_), false);
+ }
+
+ void SetVmapTable(const uint16_t* vmap_table) {
+ SetFieldPtr<const uint16_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, vmap_table_), vmap_table, false);
+ }
+
+ uint32_t GetOatVmapTableOffset() const;
+
+ void SetOatVmapTableOffset(uint32_t vmap_table_offset);
+
+ const uint8_t* GetNativeGcMap() const {
+ return GetFieldPtr<uint8_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_gc_map_), false);
+ }
+ void SetNativeGcMap(const uint8_t* data) {
+ SetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_gc_map_), data,
+ false);
+ }
+
+ // When building the oat need a convenient place to stuff the offset of the native GC map.
+ void SetOatNativeGcMapOffset(uint32_t gc_map_offset);
+ uint32_t GetOatNativeGcMapOffset() const;
+
+ size_t GetFrameSizeInBytes() const {
+ DCHECK_EQ(sizeof(size_t), sizeof(uint32_t));
+ size_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, frame_size_in_bytes_), false);
+ DCHECK_LE(static_cast<size_t>(kStackAlignment), result);
+ return result;
+ }
+
+ void SetFrameSizeInBytes(size_t new_frame_size_in_bytes) {
+ DCHECK_EQ(sizeof(size_t), sizeof(uint32_t));
+ SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, frame_size_in_bytes_),
+ new_frame_size_in_bytes, false);
+ }
+
+ size_t GetReturnPcOffsetInBytes() const {
+ return GetFrameSizeInBytes() - kPointerSize;
+ }
+
+ bool IsRegistered() const;
+
+ void RegisterNative(Thread* self, const void* native_method)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ void UnregisterNative(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static MemberOffset NativeMethodOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_method_);
+ }
+
+ const void* GetNativeMethod() const {
+ return reinterpret_cast<const void*>(GetField32(NativeMethodOffset(), false));
+ }
+
+ void SetNativeMethod(const void*);
+
+ // Native to managed invocation stub entry point
+ InvokeStub* GetInvokeStub() const {
+ InvokeStub* result = GetFieldPtr<InvokeStub*>(
+ OFFSET_OF_OBJECT_MEMBER(AbstractMethod, invoke_stub_), false);
+ // TODO: DCHECK(result != NULL); should be ahead of time compiled
+ return result;
+ }
+
+ void SetInvokeStub(InvokeStub* invoke_stub) {
+ SetFieldPtr<InvokeStub*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, invoke_stub_),
+ invoke_stub, false);
+ }
+
+ uint32_t GetInvokeStubSize() const {
+ uintptr_t invoke_stub = reinterpret_cast<uintptr_t>(GetInvokeStub());
+ if (invoke_stub == 0) {
+ return 0;
+ }
+ // TODO: make this Thumb2 specific
+ invoke_stub &= ~0x1;
+ return reinterpret_cast<const uint32_t*>(invoke_stub)[-1];
+ }
+
+ uint32_t GetOatInvokeStubOffset() const;
+ void SetOatInvokeStubOffset(uint32_t invoke_stub_offset);
+
+ static MemberOffset GetInvokeStubOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, invoke_stub_);
+ }
+
+ static MemberOffset GetMethodIndexOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_index_);
+ }
+
+ uint32_t GetCoreSpillMask() const {
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, core_spill_mask_), false);
+ }
+
+ void SetCoreSpillMask(uint32_t core_spill_mask) {
+ // Computed during compilation
+ SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, core_spill_mask_), core_spill_mask, false);
+ }
+
+ uint32_t GetFpSpillMask() const {
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, fp_spill_mask_), false);
+ }
+
+ void SetFpSpillMask(uint32_t fp_spill_mask) {
+ // Computed during compilation
+ SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, fp_spill_mask_), fp_spill_mask, false);
+ }
+
+ // Is this a CalleSaveMethod or ResolutionMethod and therefore doesn't adhere to normal
+ // conventions for a method of managed code. Returns false for Proxy methods.
+ bool IsRuntimeMethod() const;
+
+ // Is this a hand crafted method used for something like describing callee saves?
+ bool IsCalleeSaveMethod() const;
+
+ bool IsResolutionMethod() const;
+
+ uintptr_t NativePcOffset(const uintptr_t pc) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Converts a native PC to a dex PC.
+ uint32_t ToDexPc(const uintptr_t pc) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Converts a dex PC to a native PC.
+ uintptr_t ToNativePc(const uint32_t dex_pc) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Converts a dex PC to the first corresponding safepoint PC.
+ uintptr_t ToFirstNativeSafepointPc(const uint32_t dex_pc)
+ const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Find the catch block for the given exception type and dex_pc
+ uint32_t FindCatchBlock(Class* exception_type, uint32_t dex_pc) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static void SetClasses(Class* java_lang_reflect_Constructor, Class* java_lang_reflect_Method);
+
+ static Class* GetConstructorClass() {
+ return java_lang_reflect_Constructor_;
+ }
+
+ static Class* GetMethodClass() {
+ return java_lang_reflect_Method_;
+ }
+
+ static void ResetClasses();
+
+ protected:
+ // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
+ // The class we are a part of
+ Class* declaring_class_;
+
+ // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
+ ObjectArray<StaticStorageBase>* dex_cache_initialized_static_storage_;
+
+ // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
+ ObjectArray<AbstractMethod>* dex_cache_resolved_methods_;
+
+ // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
+ ObjectArray<Class>* dex_cache_resolved_types_;
+
+ // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
+ ObjectArray<String>* dex_cache_strings_;
+
+ // Access flags; low 16 bits are defined by spec.
+ uint32_t access_flags_;
+
+ // Compiled code associated with this method for callers from managed code.
+ // May be compiled managed code or a bridge for invoking a native method.
+ const void* code_;
+
+ // Offset to the CodeItem.
+ uint32_t code_item_offset_;
+
+ // Architecture-dependent register spill mask
+ uint32_t core_spill_mask_;
+
+ // Architecture-dependent register spill mask
+ uint32_t fp_spill_mask_;
+
+ // Total size in bytes of the frame
+ size_t frame_size_in_bytes_;
+
+ // Garbage collection map of native PC offsets to reference bitmaps.
+ const uint8_t* native_gc_map_;
+
+ // Native invocation stub entry point for calling from native to managed code.
+ InvokeStub* invoke_stub_;
+
+ // Mapping from native pc to dex pc
+ const uint32_t* mapping_table_;
+
+ // Index into method_ids of the dex file associated with this method
+ uint32_t method_dex_index_;
+
+ // For concrete virtual methods, this is the offset of the method in Class::vtable_.
+ //
+ // For abstract methods in an interface class, this is the offset of the method in
+ // "iftable_->Get(n)->GetMethodArray()".
+ //
+ // For static and direct methods this is the index in the direct methods table.
+ uint32_t method_index_;
+
+ // The target native method registered with this method
+ const void* native_method_;
+
+ // When a register is promoted into a register, the spill mask holds which registers hold dex
+ // registers. The first promoted register's corresponding dex register is vmap_table_[1], the Nth
+ // is vmap_table_[N]. vmap_table_[0] holds the length of the table.
+ const uint16_t* vmap_table_;
+
+ static Class* java_lang_reflect_Constructor_;
+ static Class* java_lang_reflect_Method_;
+
+ friend struct art::AbstractMethodOffsets; // for verifying offset information
+ friend struct art::ConstructorMethodOffsets; // for verifying offset information
+ friend struct art::MethodOffsets; // for verifying offset information
+ DISALLOW_IMPLICIT_CONSTRUCTORS(AbstractMethod);
+};
+
+class MANAGED Method : public AbstractMethod {
+
+};
+
+class MANAGED Constructor : public AbstractMethod {
+
+};
+
+class MANAGED AbstractMethodClass : public Class {
+ private:
+ Object* ORDER_BY_SIGNATURE_;
+ friend struct art::MethodClassOffsets; // for verifying offset information
+ DISALLOW_IMPLICIT_CONSTRUCTORS(AbstractMethodClass);
+};
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_METHOD_H_
diff --git a/src/mirror/array-inl.h b/src/mirror/array-inl.h
new file mode 100644
index 0000000..b7f212f
--- /dev/null
+++ b/src/mirror/array-inl.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_ARRAY_INL_H_
+#define ART_SRC_MIRROR_ARRAY_INL_H_
+
+#include "array.h"
+
+#include "class.h"
+
+namespace art {
+namespace mirror {
+
+inline size_t Array::SizeOf() const {
+ // This is safe from overflow because the array was already allocated, so we know it's sane.
+ size_t component_size = GetClass()->GetComponentSize();
+ int32_t component_count = GetLength();
+ size_t header_size = sizeof(Object) + (component_size == sizeof(int64_t) ? 8 : 4);
+ size_t data_size = component_count * component_size;
+ return header_size + data_size;
+}
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_ARRAY_INL_H_
diff --git a/src/mirror/array.cc b/src/mirror/array.cc
new file mode 100644
index 0000000..103efa3
--- /dev/null
+++ b/src/mirror/array.cc
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+#include "array.h"
+
+#include "class.h"
+#include "class-inl.h"
+#include "gc/card_table-inl.h"
+#include "object-inl.h"
+#include "object_array.h"
+#include "object_array-inl.h"
+#include "object_utils.h"
+#include "sirt_ref.h"
+#include "thread.h"
+#include "utils.h"
+
+namespace art {
+namespace mirror {
+
+Array* Array::Alloc(Thread* self, Class* array_class, int32_t component_count,
+ size_t component_size) {
+ DCHECK(array_class != NULL);
+ DCHECK_GE(component_count, 0);
+ DCHECK(array_class->IsArrayClass());
+
+ size_t header_size = sizeof(Object) + (component_size == sizeof(int64_t) ? 8 : 4);
+ size_t data_size = component_count * component_size;
+ size_t size = header_size + data_size;
+
+ // Check for overflow and throw OutOfMemoryError if this was an unreasonable request.
+ size_t component_shift = sizeof(size_t) * 8 - 1 - CLZ(component_size);
+ if (data_size >> component_shift != size_t(component_count) || size < data_size) {
+ self->ThrowNewExceptionF("Ljava/lang/OutOfMemoryError;",
+ "%s of length %d would overflow",
+ PrettyDescriptor(array_class).c_str(), component_count);
+ return NULL;
+ }
+
+ Heap* heap = Runtime::Current()->GetHeap();
+ Array* array = down_cast<Array*>(heap->AllocObject(self, array_class, size));
+ if (array != NULL) {
+ DCHECK(array->IsArrayInstance());
+ array->SetLength(component_count);
+ }
+ return array;
+}
+
+Array* Array::Alloc(Thread* self, Class* array_class, int32_t component_count) {
+ DCHECK(array_class->IsArrayClass());
+ return Alloc(self, array_class, component_count, array_class->GetComponentSize());
+}
+
+// Create a multi-dimensional array of Objects or primitive types.
+//
+// We have to generate the names for X[], X[][], X[][][], and so on. The
+// easiest way to deal with that is to create the full name once and then
+// subtract pieces off. Besides, we want to start with the outermost
+// piece and work our way in.
+// Recursively create an array with multiple dimensions. Elements may be
+// Objects or primitive types.
+static Array* RecursiveCreateMultiArray(Thread* self, Class* array_class, int current_dimension,
+ IntArray* dimensions)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ int32_t array_length = dimensions->Get(current_dimension);
+ SirtRef<Array> new_array(self, Array::Alloc(self, array_class, array_length));
+ if (UNLIKELY(new_array.get() == NULL)) {
+ CHECK(self->IsExceptionPending());
+ return NULL;
+ }
+ if ((current_dimension + 1) < dimensions->GetLength()) {
+ // Create a new sub-array in every element of the array.
+ for (int32_t i = 0; i < array_length; i++) {
+ Array* sub_array = RecursiveCreateMultiArray(self, array_class->GetComponentType(),
+ current_dimension + 1, dimensions);
+ if (UNLIKELY(sub_array == NULL)) {
+ CHECK(self->IsExceptionPending());
+ return NULL;
+ }
+ new_array->AsObjectArray<Array>()->Set(i, sub_array);
+ }
+ }
+ return new_array.get();
+}
+
+Array* Array::CreateMultiArray(Thread* self, Class* element_class, IntArray* dimensions) {
+ // Verify dimensions.
+ //
+ // The caller is responsible for verifying that "dimArray" is non-null
+ // and has a length > 0 and <= 255.
+ int num_dimensions = dimensions->GetLength();
+ DCHECK_GT(num_dimensions, 0);
+ DCHECK_LE(num_dimensions, 255);
+
+ for (int i = 0; i < num_dimensions; i++) {
+ int dimension = dimensions->Get(i);
+ if (UNLIKELY(dimension < 0)) {
+ self->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;",
+ "Dimension %d: %d", i, dimension);
+ return NULL;
+ }
+ }
+
+ // Generate the full name of the array class.
+ std::string descriptor(num_dimensions, '[');
+ descriptor += ClassHelper(element_class).GetDescriptor();
+
+ // Find/generate the array class.
+ ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+ Class* array_class = class_linker->FindClass(descriptor.c_str(), element_class->GetClassLoader());
+ if (UNLIKELY(array_class == NULL)) {
+ CHECK(self->IsExceptionPending());
+ return NULL;
+ }
+ // create the array
+ Array* new_array = RecursiveCreateMultiArray(self, array_class, 0, dimensions);
+ if (UNLIKELY(new_array == NULL)) {
+ CHECK(self->IsExceptionPending());
+ return NULL;
+ }
+ return new_array;
+}
+
+bool Array::ThrowArrayIndexOutOfBoundsException(int32_t index) const {
+ Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
+ "length=%i; index=%i", length_, index);
+ return false;
+}
+
+bool Array::ThrowArrayStoreException(Object* object) const {
+ Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;",
+ "%s cannot be stored in an array of type %s",
+ PrettyTypeOf(object).c_str(), PrettyTypeOf(this).c_str());
+ return false;
+}
+
+template<typename T>
+PrimitiveArray<T>* PrimitiveArray<T>::Alloc(Thread* self, size_t length) {
+ DCHECK(array_class_ != NULL);
+ Array* raw_array = Array::Alloc(self, array_class_, length, sizeof(T));
+ return down_cast<PrimitiveArray<T>*>(raw_array);
+}
+
+template <typename T> Class* PrimitiveArray<T>::array_class_ = NULL;
+
+// Explicitly instantiate all the primitive array types.
+template class PrimitiveArray<uint8_t>; // BooleanArray
+template class PrimitiveArray<int8_t>; // ByteArray
+template class PrimitiveArray<uint16_t>; // CharArray
+template class PrimitiveArray<double>; // DoubleArray
+template class PrimitiveArray<float>; // FloatArray
+template class PrimitiveArray<int32_t>; // IntArray
+template class PrimitiveArray<int64_t>; // LongArray
+template class PrimitiveArray<int16_t>; // ShortArray
+
+} // namespace mirror
+} // namespace art
diff --git a/src/mirror/array.h b/src/mirror/array.h
new file mode 100644
index 0000000..8da906f
--- /dev/null
+++ b/src/mirror/array.h
@@ -0,0 +1,148 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_ARRAY_H_
+#define ART_SRC_MIRROR_ARRAY_H_
+
+#include "object.h"
+
+namespace art {
+namespace mirror {
+
+class MANAGED Array : public Object {
+ public:
+ // A convenience for code that doesn't know the component size,
+ // and doesn't want to have to work it out itself.
+ static Array* Alloc(Thread* self, Class* array_class, int32_t component_count)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static Array* Alloc(Thread* self, Class* array_class, int32_t component_count,
+ size_t component_size)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static Array* CreateMultiArray(Thread* self, Class* element_class, IntArray* dimensions)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ size_t SizeOf() const;
+
+ int32_t GetLength() const {
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(Array, length_), false);
+ }
+
+ void SetLength(int32_t length) {
+ CHECK_GE(length, 0);
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Array, length_), length, false);
+ }
+
+ static MemberOffset LengthOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(Array, length_);
+ }
+
+ static MemberOffset DataOffset(size_t component_size) {
+ if (component_size != sizeof(int64_t)) {
+ return OFFSET_OF_OBJECT_MEMBER(Array, first_element_);
+ } else {
+ // Align longs and doubles.
+ return MemberOffset(OFFSETOF_MEMBER(Array, first_element_) + 4);
+ }
+ }
+
+ void* GetRawData(size_t component_size) {
+ intptr_t data = reinterpret_cast<intptr_t>(this) + DataOffset(component_size).Int32Value();
+ return reinterpret_cast<void*>(data);
+ }
+
+ const void* GetRawData(size_t component_size) const {
+ intptr_t data = reinterpret_cast<intptr_t>(this) + DataOffset(component_size).Int32Value();
+ return reinterpret_cast<const void*>(data);
+ }
+
+ protected:
+ bool IsValidIndex(int32_t index) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ if (UNLIKELY(index < 0 || index >= GetLength())) {
+ return ThrowArrayIndexOutOfBoundsException(index);
+ }
+ return true;
+ }
+
+ protected:
+ bool ThrowArrayIndexOutOfBoundsException(int32_t index) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ bool ThrowArrayStoreException(Object* object) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ private:
+ // The number of array elements.
+ int32_t length_;
+ // Marker for the data (used by generated code)
+ uint32_t first_element_[0];
+
+ DISALLOW_IMPLICIT_CONSTRUCTORS(Array);
+};
+
+template<class T>
+class MANAGED PrimitiveArray : public Array {
+ public:
+ typedef T ElementType;
+
+ static PrimitiveArray<T>* Alloc(Thread* self, size_t length)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ const T* GetData() const {
+ intptr_t data = reinterpret_cast<intptr_t>(this) + DataOffset(sizeof(T)).Int32Value();
+ return reinterpret_cast<T*>(data);
+ }
+
+ T* GetData() {
+ intptr_t data = reinterpret_cast<intptr_t>(this) + DataOffset(sizeof(T)).Int32Value();
+ return reinterpret_cast<T*>(data);
+ }
+
+ T Get(int32_t i) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ if (!IsValidIndex(i)) {
+ return T(0);
+ }
+ return GetData()[i];
+ }
+
+ void Set(int32_t i, T value) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ if (IsValidIndex(i)) {
+ GetData()[i] = value;
+ }
+ }
+
+ static void SetArrayClass(Class* array_class) {
+ CHECK(array_class_ == NULL);
+ CHECK(array_class != NULL);
+ array_class_ = array_class;
+ }
+
+ static void ResetArrayClass() {
+ CHECK(array_class_ != NULL);
+ array_class_ = NULL;
+ }
+
+ private:
+ static Class* array_class_;
+
+ DISALLOW_IMPLICIT_CONSTRUCTORS(PrimitiveArray);
+};
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_ARRAY_H_
diff --git a/src/mirror/class-inl.h b/src/mirror/class-inl.h
new file mode 100644
index 0000000..7eb8601
--- /dev/null
+++ b/src/mirror/class-inl.h
@@ -0,0 +1,256 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_CLASS_INL_H_
+#define ART_SRC_MIRROR_CLASS_INL_H_
+
+#include "class.h"
+
+#include "abstract_method.h"
+#include "field.h"
+#include "iftable.h"
+#include "object_array.h"
+#include "runtime.h"
+#include "string.h"
+
+namespace art {
+namespace mirror {
+
+inline size_t Class::GetObjectSize() const {
+ CHECK(!IsVariableSize()) << " class=" << PrettyTypeOf(this);
+ DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
+ size_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(Class, object_size_), false);
+ CHECK_GE(result, sizeof(Object)) << " class=" << PrettyTypeOf(this);
+ return result;
+}
+
+inline Class* Class::GetSuperClass() const {
+ // Can only get super class for loaded classes (hack for when runtime is
+ // initializing)
+ DCHECK(IsLoaded() || !Runtime::Current()->IsStarted()) << IsLoaded();
+ return GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Class, super_class_), false);
+}
+
+inline ObjectArray<AbstractMethod>* Class::GetDirectMethods() const {
+ DCHECK(IsLoaded() || IsErroneous());
+ return GetFieldObject<ObjectArray<AbstractMethod>*>(
+ OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_), false);
+}
+
+inline void Class::SetDirectMethods(ObjectArray<AbstractMethod>* new_direct_methods)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ DCHECK(NULL == GetFieldObject<ObjectArray<AbstractMethod>*>(
+ OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_), false));
+ DCHECK_NE(0, new_direct_methods->GetLength());
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_),
+ new_direct_methods, false);
+}
+
+inline AbstractMethod* Class::GetDirectMethod(int32_t i) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ return GetDirectMethods()->Get(i);
+}
+
+inline void Class::SetDirectMethod(uint32_t i, AbstractMethod* f) // TODO: uint16_t
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_){
+ ObjectArray<AbstractMethod>* direct_methods =
+ GetFieldObject<ObjectArray<AbstractMethod>*>(
+ OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_), false);
+ direct_methods->Set(i, f);
+}
+
+// Returns the number of static, private, and constructor methods.
+inline size_t Class::NumDirectMethods() const {
+ return (GetDirectMethods() != NULL) ? GetDirectMethods()->GetLength() : 0;
+}
+
+inline ObjectArray<AbstractMethod>* Class::GetVirtualMethods() const {
+ DCHECK(IsLoaded() || IsErroneous());
+ return GetFieldObject<ObjectArray<AbstractMethod>*>(
+ OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_), false);
+}
+
+inline void Class::SetVirtualMethods(ObjectArray<AbstractMethod>* new_virtual_methods) {
+ // TODO: we reassign virtual methods to grow the table for miranda
+ // methods.. they should really just be assigned once
+ DCHECK_NE(0, new_virtual_methods->GetLength());
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_),
+ new_virtual_methods, false);
+}
+
+inline size_t Class::NumVirtualMethods() const {
+ return (GetVirtualMethods() != NULL) ? GetVirtualMethods()->GetLength() : 0;
+}
+
+inline AbstractMethod* Class::GetVirtualMethod(uint32_t i) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ DCHECK(IsResolved() || IsErroneous());
+ return GetVirtualMethods()->Get(i);
+}
+
+inline AbstractMethod* Class::GetVirtualMethodDuringLinking(uint32_t i) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ DCHECK(IsLoaded() || IsErroneous());
+ return GetVirtualMethods()->Get(i);
+}
+
+inline void Class::SetVirtualMethod(uint32_t i, AbstractMethod* f) // TODO: uint16_t
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ ObjectArray<AbstractMethod>* virtual_methods =
+ GetFieldObject<ObjectArray<AbstractMethod>*>(
+ OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_), false);
+ virtual_methods->Set(i, f);
+}
+
+inline ObjectArray<AbstractMethod>* Class::GetVTable() const {
+ DCHECK(IsResolved() || IsErroneous());
+ return GetFieldObject<ObjectArray<AbstractMethod>*>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
+}
+
+inline ObjectArray<AbstractMethod>* Class::GetVTableDuringLinking() const {
+ DCHECK(IsLoaded() || IsErroneous());
+ return GetFieldObject<ObjectArray<AbstractMethod>*>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
+}
+
+inline void Class::SetVTable(ObjectArray<AbstractMethod>* new_vtable)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), new_vtable, false);
+}
+
+inline AbstractMethod* Class::FindVirtualMethodForVirtual(AbstractMethod* method) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ DCHECK(!method->GetDeclaringClass()->IsInterface());
+ // The argument method may from a super class.
+ // Use the index to a potentially overridden one for this instance's class.
+ return GetVTable()->Get(method->GetMethodIndex());
+}
+
+inline AbstractMethod* Class::FindVirtualMethodForSuper(AbstractMethod* method) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ DCHECK(!method->GetDeclaringClass()->IsInterface());
+ return GetSuperClass()->GetVTable()->Get(method->GetMethodIndex());
+}
+
+inline AbstractMethod* Class::FindVirtualMethodForVirtualOrInterface(AbstractMethod* method) const {
+ if (method->IsDirect()) {
+ return method;
+ }
+ if (method->GetDeclaringClass()->IsInterface()) {
+ return FindVirtualMethodForInterface(method);
+ }
+ return FindVirtualMethodForVirtual(method);
+}
+
+inline IfTable* Class::GetIfTable() const {
+ return GetFieldObject<IfTable*>(OFFSET_OF_OBJECT_MEMBER(Class, iftable_), false);
+}
+
+inline int32_t Class::GetIfTableCount() const {
+ IfTable* iftable = GetIfTable();
+ if (iftable == NULL) {
+ return 0;
+ }
+ return iftable->Count();
+}
+
+inline void Class::SetIfTable(IfTable* new_iftable) {
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, iftable_), new_iftable, false);
+}
+
+inline ObjectArray<Field>* Class::GetIFields() const {
+ DCHECK(IsLoaded() || IsErroneous());
+ return GetFieldObject<ObjectArray<Field>*>(OFFSET_OF_OBJECT_MEMBER(Class, ifields_), false);
+}
+
+inline void Class::SetIFields(ObjectArray<Field>* new_ifields)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ DCHECK(NULL == GetFieldObject<ObjectArray<Field>*>(
+ OFFSET_OF_OBJECT_MEMBER(Class, ifields_), false));
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, ifields_), new_ifields, false);
+}
+
+inline ObjectArray<Field>* Class::GetSFields() const {
+ DCHECK(IsLoaded() || IsErroneous());
+ return GetFieldObject<ObjectArray<Field>*>(OFFSET_OF_OBJECT_MEMBER(Class, sfields_), false);
+}
+
+inline void Class::SetSFields(ObjectArray<Field>* new_sfields)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ DCHECK(NULL == GetFieldObject<ObjectArray<Field>*>(
+ OFFSET_OF_OBJECT_MEMBER(Class, sfields_), false));
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, sfields_), new_sfields, false);
+}
+
+inline size_t Class::NumStaticFields() const {
+ return (GetSFields() != NULL) ? GetSFields()->GetLength() : 0;
+}
+
+inline Field* Class::GetStaticField(uint32_t i) const // TODO: uint16_t
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ return GetSFields()->Get(i);
+}
+
+inline void Class::SetStaticField(uint32_t i, Field* f) // TODO: uint16_t
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ ObjectArray<Field>* sfields= GetFieldObject<ObjectArray<Field>*>(
+ OFFSET_OF_OBJECT_MEMBER(Class, sfields_), false);
+ sfields->Set(i, f);
+}
+
+inline size_t Class::NumInstanceFields() const {
+ return (GetIFields() != NULL) ? GetIFields()->GetLength() : 0;
+}
+
+inline Field* Class::GetInstanceField(uint32_t i) const // TODO: uint16_t
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_){
+ DCHECK_NE(NumInstanceFields(), 0U);
+ return GetIFields()->Get(i);
+}
+
+inline void Class::SetInstanceField(uint32_t i, Field* f) // TODO: uint16_t
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_){
+ ObjectArray<Field>* ifields= GetFieldObject<ObjectArray<Field>*>(
+ OFFSET_OF_OBJECT_MEMBER(Class, ifields_), false);
+ ifields->Set(i, f);
+}
+
+inline void Class::SetVerifyErrorClass(Class* klass) {
+ CHECK(klass != NULL) << PrettyClass(this);
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, verify_error_class_), klass, false);
+}
+
+inline uint32_t Class::GetAccessFlags() const {
+ // Check class is loaded or this is java.lang.String that has a
+ // circularity issue during loading the names of its members
+ DCHECK(IsLoaded() || IsErroneous() ||
+ this == String::GetJavaLangString() ||
+ this == Field::GetJavaLangReflectField() ||
+ this == AbstractMethod::GetConstructorClass() ||
+ this == AbstractMethod::GetMethodClass());
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_), false);
+}
+
+inline String* Class::GetName() const {
+ return GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(Class, name_), false);
+}
+inline void Class::SetName(String* name) {
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, name_), name, false);
+}
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_CLASS_INL_H_
diff --git a/src/mirror/class.cc b/src/mirror/class.cc
new file mode 100644
index 0000000..7f52d17
--- /dev/null
+++ b/src/mirror/class.cc
@@ -0,0 +1,668 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+#include "class.h"
+
+#include "abstract_method-inl.h"
+#include "class-inl.h"
+#include "class_linker.h"
+#include "class_loader.h"
+#include "dex_cache.h"
+#include "field-inl.h"
+#include "gc/card_table-inl.h"
+#include "object-inl.h"
+#include "object_array-inl.h"
+#include "object_utils.h"
+#include "runtime.h"
+#include "sirt_ref.h"
+#include "thread.h"
+#include "throwable.h"
+#include "utils.h"
+#include "well_known_classes.h"
+
+namespace art {
+namespace mirror {
+
+Class* Class::java_lang_Class_ = NULL;
+
+void Class::SetClassClass(Class* java_lang_Class) {
+ CHECK(java_lang_Class_ == NULL) << java_lang_Class_ << " " << java_lang_Class;
+ CHECK(java_lang_Class != NULL);
+ java_lang_Class_ = java_lang_Class;
+}
+
+void Class::ResetClass() {
+ CHECK(java_lang_Class_ != NULL);
+ java_lang_Class_ = NULL;
+}
+
+void Class::SetStatus(Status new_status) {
+ CHECK(new_status > GetStatus() || new_status == kStatusError || !Runtime::Current()->IsStarted())
+ << PrettyClass(this) << " " << GetStatus() << " -> " << new_status;
+ CHECK(sizeof(Status) == sizeof(uint32_t)) << PrettyClass(this);
+ if (new_status > kStatusResolved) {
+ CHECK_EQ(GetThinLockId(), Thread::Current()->GetThinLockId()) << PrettyClass(this);
+ }
+ if (new_status == kStatusError) {
+ CHECK_NE(GetStatus(), kStatusError) << PrettyClass(this);
+
+ // stash current exception
+ Thread* self = Thread::Current();
+ SirtRef<Throwable> exception(self, self->GetException());
+ CHECK(exception.get() != NULL);
+
+ // clear exception to call FindSystemClass
+ self->ClearException();
+ ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+ Class* eiie_class = class_linker->FindSystemClass("Ljava/lang/ExceptionInInitializerError;");
+ CHECK(!self->IsExceptionPending());
+
+ // only verification errors, not initialization problems, should set a verify error.
+ // this is to ensure that ThrowEarlierClassFailure will throw NoClassDefFoundError in that case.
+ Class* exception_class = exception->GetClass();
+ if (!eiie_class->IsAssignableFrom(exception_class)) {
+ SetVerifyErrorClass(exception_class);
+ }
+
+ // restore exception
+ self->SetException(exception.get());
+ }
+ return SetField32(OFFSET_OF_OBJECT_MEMBER(Class, status_), new_status, false);
+}
+
+DexCache* Class::GetDexCache() const {
+ return GetFieldObject<DexCache*>(OFFSET_OF_OBJECT_MEMBER(Class, dex_cache_), false);
+}
+
+void Class::SetDexCache(DexCache* new_dex_cache) {
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, dex_cache_), new_dex_cache, false);
+}
+
+Object* Class::AllocObject(Thread* self) {
+ DCHECK(!IsArrayClass()) << PrettyClass(this);
+ DCHECK(IsInstantiable()) << PrettyClass(this);
+ // TODO: decide whether we want this check. It currently fails during bootstrap.
+ // DCHECK(!Runtime::Current()->IsStarted() || IsInitializing()) << PrettyClass(this);
+ DCHECK_GE(this->object_size_, sizeof(Object));
+ return Runtime::Current()->GetHeap()->AllocObject(self, this, this->object_size_);
+}
+
+void Class::SetClassSize(size_t new_class_size) {
+ DCHECK_GE(new_class_size, GetClassSize()) << " class=" << PrettyTypeOf(this);
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Class, class_size_), new_class_size, false);
+}
+
+// Return the class' name. The exact format is bizarre, but it's the specified behavior for
+// Class.getName: keywords for primitive types, regular "[I" form for primitive arrays (so "int"
+// but "[I"), and arrays of reference types written between "L" and ";" but with dots rather than
+// slashes (so "java.lang.String" but "[Ljava.lang.String;"). Madness.
+String* Class::ComputeName() {
+ String* name = GetName();
+ if (name != NULL) {
+ return name;
+ }
+ std::string descriptor(ClassHelper(this).GetDescriptor());
+ if ((descriptor[0] != 'L') && (descriptor[0] != '[')) {
+ // The descriptor indicates that this is the class for
+ // a primitive type; special-case the return value.
+ const char* c_name = NULL;
+ switch (descriptor[0]) {
+ case 'Z': c_name = "boolean"; break;
+ case 'B': c_name = "byte"; break;
+ case 'C': c_name = "char"; break;
+ case 'S': c_name = "short"; break;
+ case 'I': c_name = "int"; break;
+ case 'J': c_name = "long"; break;
+ case 'F': c_name = "float"; break;
+ case 'D': c_name = "double"; break;
+ case 'V': c_name = "void"; break;
+ default:
+ LOG(FATAL) << "Unknown primitive type: " << PrintableChar(descriptor[0]);
+ }
+ name = String::AllocFromModifiedUtf8(Thread::Current(), c_name);
+ } else {
+ // Convert the UTF-8 name to a java.lang.String. The name must use '.' to separate package
+ // components.
+ if (descriptor.size() > 2 && descriptor[0] == 'L' && descriptor[descriptor.size() - 1] == ';') {
+ descriptor.erase(0, 1);
+ descriptor.erase(descriptor.size() - 1);
+ }
+ std::replace(descriptor.begin(), descriptor.end(), '/', '.');
+ name = String::AllocFromModifiedUtf8(Thread::Current(), descriptor.c_str());
+ }
+ SetName(name);
+ return name;
+}
+
+void Class::DumpClass(std::ostream& os, int flags) const {
+ if ((flags & kDumpClassFullDetail) == 0) {
+ os << PrettyClass(this);
+ if ((flags & kDumpClassClassLoader) != 0) {
+ os << ' ' << GetClassLoader();
+ }
+ if ((flags & kDumpClassInitialized) != 0) {
+ os << ' ' << GetStatus();
+ }
+ os << "\n";
+ return;
+ }
+
+ Class* super = GetSuperClass();
+ ClassHelper kh(this);
+ os << "----- " << (IsInterface() ? "interface" : "class") << " "
+ << "'" << kh.GetDescriptor() << "' cl=" << GetClassLoader() << " -----\n",
+ os << " objectSize=" << SizeOf() << " "
+ << "(" << (super != NULL ? super->SizeOf() : -1) << " from super)\n",
+ os << StringPrintf(" access=0x%04x.%04x\n",
+ GetAccessFlags() >> 16, GetAccessFlags() & kAccJavaFlagsMask);
+ if (super != NULL) {
+ os << " super='" << PrettyClass(super) << "' (cl=" << super->GetClassLoader() << ")\n";
+ }
+ if (IsArrayClass()) {
+ os << " componentType=" << PrettyClass(GetComponentType()) << "\n";
+ }
+ if (kh.NumDirectInterfaces() > 0) {
+ os << " interfaces (" << kh.NumDirectInterfaces() << "):\n";
+ for (size_t i = 0; i < kh.NumDirectInterfaces(); ++i) {
+ Class* interface = kh.GetDirectInterface(i);
+ const ClassLoader* cl = interface->GetClassLoader();
+ os << StringPrintf(" %2zd: %s (cl=%p)\n", i, PrettyClass(interface).c_str(), cl);
+ }
+ }
+ os << " vtable (" << NumVirtualMethods() << " entries, "
+ << (super != NULL ? super->NumVirtualMethods() : 0) << " in super):\n";
+ for (size_t i = 0; i < NumVirtualMethods(); ++i) {
+ os << StringPrintf(" %2zd: %s\n", i, PrettyMethod(GetVirtualMethodDuringLinking(i)).c_str());
+ }
+ os << " direct methods (" << NumDirectMethods() << " entries):\n";
+ for (size_t i = 0; i < NumDirectMethods(); ++i) {
+ os << StringPrintf(" %2zd: %s\n", i, PrettyMethod(GetDirectMethod(i)).c_str());
+ }
+ if (NumStaticFields() > 0) {
+ os << " static fields (" << NumStaticFields() << " entries):\n";
+ if (IsResolved() || IsErroneous()) {
+ for (size_t i = 0; i < NumStaticFields(); ++i) {
+ os << StringPrintf(" %2zd: %s\n", i, PrettyField(GetStaticField(i)).c_str());
+ }
+ } else {
+ os << " <not yet available>";
+ }
+ }
+ if (NumInstanceFields() > 0) {
+ os << " instance fields (" << NumInstanceFields() << " entries):\n";
+ if (IsResolved() || IsErroneous()) {
+ for (size_t i = 0; i < NumInstanceFields(); ++i) {
+ os << StringPrintf(" %2zd: %s\n", i, PrettyField(GetInstanceField(i)).c_str());
+ }
+ } else {
+ os << " <not yet available>";
+ }
+ }
+}
+
+void Class::SetReferenceInstanceOffsets(uint32_t new_reference_offsets) {
+ if (new_reference_offsets != CLASS_WALK_SUPER) {
+ // Sanity check that the number of bits set in the reference offset bitmap
+ // agrees with the number of references
+ size_t count = 0;
+ for (Class* c = this; c != NULL; c = c->GetSuperClass()) {
+ count += c->NumReferenceInstanceFieldsDuringLinking();
+ }
+ CHECK_EQ((size_t)__builtin_popcount(new_reference_offsets), count);
+ }
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Class, reference_instance_offsets_),
+ new_reference_offsets, false);
+}
+
+void Class::SetReferenceStaticOffsets(uint32_t new_reference_offsets) {
+ if (new_reference_offsets != CLASS_WALK_SUPER) {
+ // Sanity check that the number of bits set in the reference offset bitmap
+ // agrees with the number of references
+ CHECK_EQ((size_t)__builtin_popcount(new_reference_offsets),
+ NumReferenceStaticFieldsDuringLinking());
+ }
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Class, reference_static_offsets_),
+ new_reference_offsets, false);
+}
+
+bool Class::Implements(const Class* klass) const {
+ DCHECK(klass != NULL);
+ DCHECK(klass->IsInterface()) << PrettyClass(this);
+ // All interfaces implemented directly and by our superclass, and
+ // recursively all super-interfaces of those interfaces, are listed
+ // in iftable_, so we can just do a linear scan through that.
+ int32_t iftable_count = GetIfTableCount();
+ IfTable* iftable = GetIfTable();
+ for (int32_t i = 0; i < iftable_count; i++) {
+ if (iftable->GetInterface(i) == klass) {
+ return true;
+ }
+ }
+ return false;
+}
+
+// Determine whether "this" is assignable from "src", where both of these
+// are array classes.
+//
+// Consider an array class, e.g. Y[][], where Y is a subclass of X.
+// Y[][] = Y[][] --> true (identity)
+// X[][] = Y[][] --> true (element superclass)
+// Y = Y[][] --> false
+// Y[] = Y[][] --> false
+// Object = Y[][] --> true (everything is an object)
+// Object[] = Y[][] --> true
+// Object[][] = Y[][] --> true
+// Object[][][] = Y[][] --> false (too many []s)
+// Serializable = Y[][] --> true (all arrays are Serializable)
+// Serializable[] = Y[][] --> true
+// Serializable[][] = Y[][] --> false (unless Y is Serializable)
+//
+// Don't forget about primitive types.
+// Object[] = int[] --> false
+//
+bool Class::IsArrayAssignableFromArray(const Class* src) const {
+ DCHECK(IsArrayClass()) << PrettyClass(this);
+ DCHECK(src->IsArrayClass()) << PrettyClass(src);
+ return GetComponentType()->IsAssignableFrom(src->GetComponentType());
+}
+
+bool Class::IsAssignableFromArray(const Class* src) const {
+ DCHECK(!IsInterface()) << PrettyClass(this); // handled first in IsAssignableFrom
+ DCHECK(src->IsArrayClass()) << PrettyClass(src);
+ if (!IsArrayClass()) {
+ // If "this" is not also an array, it must be Object.
+ // src's super should be java_lang_Object, since it is an array.
+ Class* java_lang_Object = src->GetSuperClass();
+ DCHECK(java_lang_Object != NULL) << PrettyClass(src);
+ DCHECK(java_lang_Object->GetSuperClass() == NULL) << PrettyClass(src);
+ return this == java_lang_Object;
+ }
+ return IsArrayAssignableFromArray(src);
+}
+
+bool Class::IsSubClass(const Class* klass) const {
+ DCHECK(!IsInterface()) << PrettyClass(this);
+ DCHECK(!IsArrayClass()) << PrettyClass(this);
+ const Class* current = this;
+ do {
+ if (current == klass) {
+ return true;
+ }
+ current = current->GetSuperClass();
+ } while (current != NULL);
+ return false;
+}
+
+bool Class::IsInSamePackage(const StringPiece& descriptor1, const StringPiece& descriptor2) {
+ size_t i = 0;
+ while (descriptor1[i] != '\0' && descriptor1[i] == descriptor2[i]) {
+ ++i;
+ }
+ if (descriptor1.find('/', i) != StringPiece::npos ||
+ descriptor2.find('/', i) != StringPiece::npos) {
+ return false;
+ } else {
+ return true;
+ }
+}
+
+bool Class::IsInSamePackage(const Class* that) const {
+ const Class* klass1 = this;
+ const Class* klass2 = that;
+ if (klass1 == klass2) {
+ return true;
+ }
+ // Class loaders must match.
+ if (klass1->GetClassLoader() != klass2->GetClassLoader()) {
+ return false;
+ }
+ // Arrays are in the same package when their element classes are.
+ while (klass1->IsArrayClass()) {
+ klass1 = klass1->GetComponentType();
+ }
+ while (klass2->IsArrayClass()) {
+ klass2 = klass2->GetComponentType();
+ }
+ // Compare the package part of the descriptor string.
+ ClassHelper kh(klass1);
+ std::string descriptor1(kh.GetDescriptor());
+ kh.ChangeClass(klass2);
+ std::string descriptor2(kh.GetDescriptor());
+ return IsInSamePackage(descriptor1, descriptor2);
+}
+
+bool Class::IsClassClass() const {
+ Class* java_lang_Class = GetClass()->GetClass();
+ return this == java_lang_Class;
+}
+
+bool Class::IsStringClass() const {
+ return this == String::GetJavaLangString();
+}
+
+bool Class::IsThrowableClass() const {
+ return WellKnownClasses::ToClass(WellKnownClasses::java_lang_Throwable)->IsAssignableFrom(this);
+}
+
+bool Class::IsFieldClass() const {
+ Class* java_lang_Class = GetClass();
+ Class* java_lang_reflect_Field = java_lang_Class->GetInstanceField(0)->GetClass();
+ return this == java_lang_reflect_Field;
+
+}
+
+bool Class::IsMethodClass() const {
+ return (this == AbstractMethod::GetMethodClass()) ||
+ (this == AbstractMethod::GetConstructorClass());
+
+}
+
+ClassLoader* Class::GetClassLoader() const {
+ return GetFieldObject<ClassLoader*>(OFFSET_OF_OBJECT_MEMBER(Class, class_loader_), false);
+}
+
+void Class::SetClassLoader(ClassLoader* new_class_loader) {
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, class_loader_), new_class_loader, false);
+}
+
+AbstractMethod* Class::FindVirtualMethodForInterface(AbstractMethod* method) const {
+ Class* declaring_class = method->GetDeclaringClass();
+ DCHECK(declaring_class != NULL) << PrettyClass(this);
+ DCHECK(declaring_class->IsInterface()) << PrettyMethod(method);
+ // TODO cache to improve lookup speed
+ int32_t iftable_count = GetIfTableCount();
+ IfTable* iftable = GetIfTable();
+ for (int32_t i = 0; i < iftable_count; i++) {
+ if (iftable->GetInterface(i) == declaring_class) {
+ return iftable->GetMethodArray(i)->Get(method->GetMethodIndex());
+ }
+ }
+ return NULL;
+}
+
+AbstractMethod* Class::FindInterfaceMethod(const StringPiece& name, const StringPiece& signature) const {
+ // Check the current class before checking the interfaces.
+ AbstractMethod* method = FindDeclaredVirtualMethod(name, signature);
+ if (method != NULL) {
+ return method;
+ }
+
+ int32_t iftable_count = GetIfTableCount();
+ IfTable* iftable = GetIfTable();
+ for (int32_t i = 0; i < iftable_count; i++) {
+ method = iftable->GetInterface(i)->FindDeclaredVirtualMethod(name, signature);
+ if (method != NULL) {
+ return method;
+ }
+ }
+ return NULL;
+}
+
+AbstractMethod* Class::FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
+ // Check the current class before checking the interfaces.
+ AbstractMethod* method = FindDeclaredVirtualMethod(dex_cache, dex_method_idx);
+ if (method != NULL) {
+ return method;
+ }
+
+ int32_t iftable_count = GetIfTableCount();
+ IfTable* iftable = GetIfTable();
+ for (int32_t i = 0; i < iftable_count; i++) {
+ method = iftable->GetInterface(i)->FindDeclaredVirtualMethod(dex_cache, dex_method_idx);
+ if (method != NULL) {
+ return method;
+ }
+ }
+ return NULL;
+}
+
+
+AbstractMethod* Class::FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature) const {
+ MethodHelper mh;
+ for (size_t i = 0; i < NumDirectMethods(); ++i) {
+ AbstractMethod* method = GetDirectMethod(i);
+ mh.ChangeMethod(method);
+ if (name == mh.GetName() && signature == mh.GetSignature()) {
+ return method;
+ }
+ }
+ return NULL;
+}
+
+AbstractMethod* Class::FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
+ if (GetDexCache() == dex_cache) {
+ for (size_t i = 0; i < NumDirectMethods(); ++i) {
+ AbstractMethod* method = GetDirectMethod(i);
+ if (method->GetDexMethodIndex() == dex_method_idx) {
+ return method;
+ }
+ }
+ }
+ return NULL;
+}
+
+AbstractMethod* Class::FindDirectMethod(const StringPiece& name, const StringPiece& signature) const {
+ for (const Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) {
+ AbstractMethod* method = klass->FindDeclaredDirectMethod(name, signature);
+ if (method != NULL) {
+ return method;
+ }
+ }
+ return NULL;
+}
+
+AbstractMethod* Class::FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
+ for (const Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) {
+ AbstractMethod* method = klass->FindDeclaredDirectMethod(dex_cache, dex_method_idx);
+ if (method != NULL) {
+ return method;
+ }
+ }
+ return NULL;
+}
+
+AbstractMethod* Class::FindDeclaredVirtualMethod(const StringPiece& name,
+ const StringPiece& signature) const {
+ MethodHelper mh;
+ for (size_t i = 0; i < NumVirtualMethods(); ++i) {
+ AbstractMethod* method = GetVirtualMethod(i);
+ mh.ChangeMethod(method);
+ if (name == mh.GetName() && signature == mh.GetSignature()) {
+ return method;
+ }
+ }
+ return NULL;
+}
+
+AbstractMethod* Class::FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
+ if (GetDexCache() == dex_cache) {
+ for (size_t i = 0; i < NumVirtualMethods(); ++i) {
+ AbstractMethod* method = GetVirtualMethod(i);
+ if (method->GetDexMethodIndex() == dex_method_idx) {
+ return method;
+ }
+ }
+ }
+ return NULL;
+}
+
+AbstractMethod* Class::FindVirtualMethod(const StringPiece& name, const StringPiece& signature) const {
+ for (const Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) {
+ AbstractMethod* method = klass->FindDeclaredVirtualMethod(name, signature);
+ if (method != NULL) {
+ return method;
+ }
+ }
+ return NULL;
+}
+
+AbstractMethod* Class::FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
+ for (const Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) {
+ AbstractMethod* method = klass->FindDeclaredVirtualMethod(dex_cache, dex_method_idx);
+ if (method != NULL) {
+ return method;
+ }
+ }
+ return NULL;
+}
+
+Field* Class::FindDeclaredInstanceField(const StringPiece& name, const StringPiece& type) {
+ // Is the field in this class?
+ // Interfaces are not relevant because they can't contain instance fields.
+ FieldHelper fh;
+ for (size_t i = 0; i < NumInstanceFields(); ++i) {
+ Field* f = GetInstanceField(i);
+ fh.ChangeField(f);
+ if (name == fh.GetName() && type == fh.GetTypeDescriptor()) {
+ return f;
+ }
+ }
+ return NULL;
+}
+
+Field* Class::FindDeclaredInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx) {
+ if (GetDexCache() == dex_cache) {
+ for (size_t i = 0; i < NumInstanceFields(); ++i) {
+ Field* f = GetInstanceField(i);
+ if (f->GetDexFieldIndex() == dex_field_idx) {
+ return f;
+ }
+ }
+ }
+ return NULL;
+}
+
+Field* Class::FindInstanceField(const StringPiece& name, const StringPiece& type) {
+ // Is the field in this class, or any of its superclasses?
+ // Interfaces are not relevant because they can't contain instance fields.
+ for (Class* c = this; c != NULL; c = c->GetSuperClass()) {
+ Field* f = c->FindDeclaredInstanceField(name, type);
+ if (f != NULL) {
+ return f;
+ }
+ }
+ return NULL;
+}
+
+Field* Class::FindInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx) {
+ // Is the field in this class, or any of its superclasses?
+ // Interfaces are not relevant because they can't contain instance fields.
+ for (Class* c = this; c != NULL; c = c->GetSuperClass()) {
+ Field* f = c->FindDeclaredInstanceField(dex_cache, dex_field_idx);
+ if (f != NULL) {
+ return f;
+ }
+ }
+ return NULL;
+}
+
+Field* Class::FindDeclaredStaticField(const StringPiece& name, const StringPiece& type) {
+ DCHECK(type != NULL);
+ FieldHelper fh;
+ for (size_t i = 0; i < NumStaticFields(); ++i) {
+ Field* f = GetStaticField(i);
+ fh.ChangeField(f);
+ if (name == fh.GetName() && type == fh.GetTypeDescriptor()) {
+ return f;
+ }
+ }
+ return NULL;
+}
+
+Field* Class::FindDeclaredStaticField(const DexCache* dex_cache, uint32_t dex_field_idx) {
+ if (dex_cache == GetDexCache()) {
+ for (size_t i = 0; i < NumStaticFields(); ++i) {
+ Field* f = GetStaticField(i);
+ if (f->GetDexFieldIndex() == dex_field_idx) {
+ return f;
+ }
+ }
+ }
+ return NULL;
+}
+
+Field* Class::FindStaticField(const StringPiece& name, const StringPiece& type) {
+ // Is the field in this class (or its interfaces), or any of its
+ // superclasses (or their interfaces)?
+ ClassHelper kh;
+ for (Class* k = this; k != NULL; k = k->GetSuperClass()) {
+ // Is the field in this class?
+ Field* f = k->FindDeclaredStaticField(name, type);
+ if (f != NULL) {
+ return f;
+ }
+ // Is this field in any of this class' interfaces?
+ kh.ChangeClass(k);
+ for (uint32_t i = 0; i < kh.NumDirectInterfaces(); ++i) {
+ Class* interface = kh.GetDirectInterface(i);
+ f = interface->FindStaticField(name, type);
+ if (f != NULL) {
+ return f;
+ }
+ }
+ }
+ return NULL;
+}
+
+Field* Class::FindStaticField(const DexCache* dex_cache, uint32_t dex_field_idx) {
+ ClassHelper kh;
+ for (Class* k = this; k != NULL; k = k->GetSuperClass()) {
+ // Is the field in this class?
+ Field* f = k->FindDeclaredStaticField(dex_cache, dex_field_idx);
+ if (f != NULL) {
+ return f;
+ }
+ // Is this field in any of this class' interfaces?
+ kh.ChangeClass(k);
+ for (uint32_t i = 0; i < kh.NumDirectInterfaces(); ++i) {
+ Class* interface = kh.GetDirectInterface(i);
+ f = interface->FindStaticField(dex_cache, dex_field_idx);
+ if (f != NULL) {
+ return f;
+ }
+ }
+ }
+ return NULL;
+}
+
+Field* Class::FindField(const StringPiece& name, const StringPiece& type) {
+ // Find a field using the JLS field resolution order
+ ClassHelper kh;
+ for (Class* k = this; k != NULL; k = k->GetSuperClass()) {
+ // Is the field in this class?
+ Field* f = k->FindDeclaredInstanceField(name, type);
+ if (f != NULL) {
+ return f;
+ }
+ f = k->FindDeclaredStaticField(name, type);
+ if (f != NULL) {
+ return f;
+ }
+ // Is this field in any of this class' interfaces?
+ kh.ChangeClass(k);
+ for (uint32_t i = 0; i < kh.NumDirectInterfaces(); ++i) {
+ Class* interface = kh.GetDirectInterface(i);
+ f = interface->FindStaticField(name, type);
+ if (f != NULL) {
+ return f;
+ }
+ }
+ }
+ return NULL;
+}
+
+} // namespace mirror
+} // namespace art
diff --git a/src/mirror/class.h b/src/mirror/class.h
new file mode 100644
index 0000000..843e07c
--- /dev/null
+++ b/src/mirror/class.h
@@ -0,0 +1,866 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_CLASS_H_
+#define ART_SRC_MIRROR_CLASS_H_
+
+#include "modifiers.h"
+#include "object.h"
+#include "primitive.h"
+
+/*
+ * A magic value for refOffsets. Ignore the bits and walk the super
+ * chain when this is the value.
+ * [This is an unlikely "natural" value, since it would be 30 non-ref instance
+ * fields followed by 2 ref instance fields.]
+ */
+#define CLASS_WALK_SUPER ((unsigned int)(3))
+#define CLASS_BITS_PER_WORD (sizeof(unsigned long int) * 8)
+#define CLASS_OFFSET_ALIGNMENT 4
+#define CLASS_HIGH_BIT ((unsigned int)1 << (CLASS_BITS_PER_WORD - 1))
+/*
+ * Given an offset, return the bit number which would encode that offset.
+ * Local use only.
+ */
+#define _CLASS_BIT_NUMBER_FROM_OFFSET(byteOffset) \
+ ((unsigned int)(byteOffset) / \
+ CLASS_OFFSET_ALIGNMENT)
+/*
+ * Is the given offset too large to be encoded?
+ */
+#define CLASS_CAN_ENCODE_OFFSET(byteOffset) \
+ (_CLASS_BIT_NUMBER_FROM_OFFSET(byteOffset) < CLASS_BITS_PER_WORD)
+/*
+ * Return a single bit, encoding the offset.
+ * Undefined if the offset is too large, as defined above.
+ */
+#define CLASS_BIT_FROM_OFFSET(byteOffset) \
+ (CLASS_HIGH_BIT >> _CLASS_BIT_NUMBER_FROM_OFFSET(byteOffset))
+/*
+ * Return an offset, given a bit number as returned from CLZ.
+ */
+#define CLASS_OFFSET_FROM_CLZ(rshift) \
+ MemberOffset((static_cast<int>(rshift) * CLASS_OFFSET_ALIGNMENT))
+
+namespace art {
+
+struct ClassClassOffsets;
+struct ClassOffsets;
+class StringPiece;
+
+namespace mirror {
+
+class ClassLoader;
+class DexCache;
+class Field;
+class IfTable;
+
+// Type for the InitializedStaticStorage table. Currently the Class
+// provides the static storage. However, this might change to an Array
+// to improve image sharing, so we use this type to avoid assumptions
+// on the current storage.
+class MANAGED StaticStorageBase : public Object {
+};
+
+// C++ mirror of java.lang.Class
+class MANAGED Class : public StaticStorageBase {
+ public:
+ // Class Status
+ //
+ // kStatusNotReady: If a Class cannot be found in the class table by
+ // FindClass, it allocates an new one with AllocClass in the
+ // kStatusNotReady and calls LoadClass. Note if it does find a
+ // class, it may not be kStatusResolved and it will try to push it
+ // forward toward kStatusResolved.
+ //
+ // kStatusIdx: LoadClass populates with Class with information from
+ // the DexFile, moving the status to kStatusIdx, indicating that the
+ // Class value in super_class_ has not been populated. The new Class
+ // can then be inserted into the classes table.
+ //
+ // kStatusLoaded: After taking a lock on Class, the ClassLinker will
+ // attempt to move a kStatusIdx class forward to kStatusLoaded by
+ // using ResolveClass to initialize the super_class_ and ensuring the
+ // interfaces are resolved.
+ //
+ // kStatusResolved: Still holding the lock on Class, the ClassLinker
+ // shows linking is complete and fields of the Class populated by making
+ // it kStatusResolved. Java allows circularities of the form where a super
+ // class has a field that is of the type of the sub class. We need to be able
+ // to fully resolve super classes while resolving types for fields.
+ //
+ // kStatusRetryVerificationAtRuntime: The verifier sets a class to
+ // this state if it encounters a soft failure at compile time. This
+ // often happens when there are unresolved classes in other dex
+ // files, and this status marks a class as needing to be verified
+ // again at runtime.
+ //
+ // TODO: Explain the other states
+ enum Status {
+ kStatusError = -1,
+ kStatusNotReady = 0,
+ kStatusIdx = 1, // Loaded, DEX idx in super_class_type_idx_ and interfaces_type_idx_.
+ kStatusLoaded = 2, // DEX idx values resolved.
+ kStatusResolved = 3, // Part of linking.
+ kStatusVerifying = 4, // In the process of being verified.
+ kStatusRetryVerificationAtRuntime = 5, // Compile time verification failed, retry at runtime.
+ kStatusVerifyingAtRuntime = 6, // Retrying verification at runtime.
+ kStatusVerified = 7, // Logically part of linking; done pre-init.
+ kStatusInitializing = 8, // Class init in progress.
+ kStatusInitialized = 9, // Ready to go.
+ };
+
+ Status GetStatus() const {
+ DCHECK_EQ(sizeof(Status), sizeof(uint32_t));
+ return static_cast<Status>(GetField32(OFFSET_OF_OBJECT_MEMBER(Class, status_), false));
+ }
+
+ void SetStatus(Status new_status) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Returns true if the class has failed to link.
+ bool IsErroneous() const {
+ return GetStatus() == kStatusError;
+ }
+
+ // Returns true if the class has been loaded.
+ bool IsIdxLoaded() const {
+ return GetStatus() >= kStatusIdx;
+ }
+
+ // Returns true if the class has been loaded.
+ bool IsLoaded() const {
+ return GetStatus() >= kStatusLoaded;
+ }
+
+ // Returns true if the class has been linked.
+ bool IsResolved() const {
+ return GetStatus() >= kStatusResolved;
+ }
+
+ // Returns true if the class was compile-time verified.
+ bool IsCompileTimeVerified() const {
+ return GetStatus() >= kStatusRetryVerificationAtRuntime;
+ }
+
+ // Returns true if the class has been verified.
+ bool IsVerified() const {
+ return GetStatus() >= kStatusVerified;
+ }
+
+ // Returns true if the class is initializing.
+ bool IsInitializing() const {
+ return GetStatus() >= kStatusInitializing;
+ }
+
+ // Returns true if the class is initialized.
+ bool IsInitialized() const {
+ return GetStatus() == kStatusInitialized;
+ }
+
+ uint32_t GetAccessFlags() const;
+
+ void SetAccessFlags(uint32_t new_access_flags) {
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_), new_access_flags, false);
+ }
+
+ // Returns true if the class is an interface.
+ bool IsInterface() const {
+ return (GetAccessFlags() & kAccInterface) != 0;
+ }
+
+ // Returns true if the class is declared public.
+ bool IsPublic() const {
+ return (GetAccessFlags() & kAccPublic) != 0;
+ }
+
+ // Returns true if the class is declared final.
+ bool IsFinal() const {
+ return (GetAccessFlags() & kAccFinal) != 0;
+ }
+
+ bool IsFinalizable() const {
+ return (GetAccessFlags() & kAccClassIsFinalizable) != 0;
+ }
+
+ void SetFinalizable() {
+ uint32_t flags = GetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_), false);
+ SetAccessFlags(flags | kAccClassIsFinalizable);
+ }
+
+ // Returns true if the class is abstract.
+ bool IsAbstract() const {
+ return (GetAccessFlags() & kAccAbstract) != 0;
+ }
+
+ // Returns true if the class is an annotation.
+ bool IsAnnotation() const {
+ return (GetAccessFlags() & kAccAnnotation) != 0;
+ }
+
+ // Returns true if the class is synthetic.
+ bool IsSynthetic() const {
+ return (GetAccessFlags() & kAccSynthetic) != 0;
+ }
+
+ bool IsReferenceClass() const {
+ return (GetAccessFlags() & kAccClassIsReference) != 0;
+ }
+
+ bool IsWeakReferenceClass() const {
+ return (GetAccessFlags() & kAccClassIsWeakReference) != 0;
+ }
+
+ bool IsSoftReferenceClass() const {
+ return (GetAccessFlags() & kAccReferenceFlagsMask) == kAccClassIsReference;
+ }
+
+ bool IsFinalizerReferenceClass() const {
+ return (GetAccessFlags() & kAccClassIsFinalizerReference) != 0;
+ }
+
+ bool IsPhantomReferenceClass() const {
+ return (GetAccessFlags() & kAccClassIsPhantomReference) != 0;
+ }
+
+
+ String* GetName() const; // Returns the cached name.
+ void SetName(String* name) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); // Sets the cached name.
+ // Computes the name, then sets the cached value.
+ String* ComputeName() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ bool IsProxyClass() const {
+ // Read access flags without using getter as whether something is a proxy can be check in
+ // any loaded state
+ // TODO: switch to a check if the super class is java.lang.reflect.Proxy?
+ uint32_t access_flags = GetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_), false);
+ return (access_flags & kAccClassIsProxy) != 0;
+ }
+
+ Primitive::Type GetPrimitiveType() const {
+ DCHECK_EQ(sizeof(Primitive::Type), sizeof(int32_t));
+ return static_cast<Primitive::Type>(
+ GetField32(OFFSET_OF_OBJECT_MEMBER(Class, primitive_type_), false));
+ }
+
+ void SetPrimitiveType(Primitive::Type new_type) {
+ DCHECK_EQ(sizeof(Primitive::Type), sizeof(int32_t));
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Class, primitive_type_), new_type, false);
+ }
+
+ // Returns true if the class is a primitive type.
+ bool IsPrimitive() const {
+ return GetPrimitiveType() != Primitive::kPrimNot;
+ }
+
+ bool IsPrimitiveBoolean() const {
+ return GetPrimitiveType() == Primitive::kPrimBoolean;
+ }
+
+ bool IsPrimitiveByte() const {
+ return GetPrimitiveType() == Primitive::kPrimByte;
+ }
+
+ bool IsPrimitiveChar() const {
+ return GetPrimitiveType() == Primitive::kPrimChar;
+ }
+
+ bool IsPrimitiveShort() const {
+ return GetPrimitiveType() == Primitive::kPrimShort;
+ }
+
+ bool IsPrimitiveInt() const {
+ return GetPrimitiveType() == Primitive::kPrimInt;
+ }
+
+ bool IsPrimitiveLong() const {
+ return GetPrimitiveType() == Primitive::kPrimLong;
+ }
+
+ bool IsPrimitiveFloat() const {
+ return GetPrimitiveType() == Primitive::kPrimFloat;
+ }
+
+ bool IsPrimitiveDouble() const {
+ return GetPrimitiveType() == Primitive::kPrimDouble;
+ }
+
+ bool IsPrimitiveVoid() const {
+ return GetPrimitiveType() == Primitive::kPrimVoid;
+ }
+
+ bool IsPrimitiveArray() const {
+ return IsArrayClass() && GetComponentType()->IsPrimitive();
+ }
+
+ // Depth of class from java.lang.Object
+ size_t Depth() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ size_t depth = 0;
+ for (Class* klass = this; klass->GetSuperClass() != NULL; klass = klass->GetSuperClass()) {
+ depth++;
+ }
+ return depth;
+ }
+
+ bool IsArrayClass() const {
+ return GetComponentType() != NULL;
+ }
+
+ bool IsClassClass() const;
+
+ bool IsStringClass() const;
+
+ bool IsThrowableClass() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ bool IsFieldClass() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ bool IsMethodClass() const;
+
+ Class* GetComponentType() const {
+ return GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Class, component_type_), false);
+ }
+
+ void SetComponentType(Class* new_component_type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ DCHECK(GetComponentType() == NULL);
+ DCHECK(new_component_type != NULL);
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, component_type_), new_component_type, false);
+ }
+
+ size_t GetComponentSize() const {
+ return Primitive::ComponentSize(GetComponentType()->GetPrimitiveType());
+ }
+
+ bool IsObjectClass() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ return !IsPrimitive() && GetSuperClass() == NULL;
+ }
+ bool IsInstantiable() const {
+ return !IsPrimitive() && !IsInterface() && !IsAbstract();
+ }
+
+ bool IsObjectArrayClass() const {
+ return GetComponentType() != NULL && !GetComponentType()->IsPrimitive();
+ }
+
+ // Creates a raw object instance but does not invoke the default constructor.
+ Object* AllocObject(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ bool IsVariableSize() const {
+ // Classes and arrays vary in size, and so the object_size_ field cannot
+ // be used to get their instance size
+ return IsClassClass() || IsArrayClass();
+ }
+
+ size_t SizeOf() const {
+ DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, class_size_), false);
+ }
+
+ size_t GetClassSize() const {
+ DCHECK_EQ(sizeof(size_t), sizeof(uint32_t));
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, class_size_), false);
+ }
+
+ void SetClassSize(size_t new_class_size)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ size_t GetObjectSize() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ void SetObjectSize(size_t new_object_size) {
+ DCHECK(!IsVariableSize());
+ DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
+ return SetField32(OFFSET_OF_OBJECT_MEMBER(Class, object_size_), new_object_size, false);
+ }
+
+ // Returns true if this class is in the same packages as that class.
+ bool IsInSamePackage(const Class* that) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static bool IsInSamePackage(const StringPiece& descriptor1, const StringPiece& descriptor2);
+
+ // Returns true if this class can access that class.
+ bool CanAccess(Class* that) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ return that->IsPublic() || this->IsInSamePackage(that);
+ }
+
+ // Can this class access a member in the provided class with the provided member access flags?
+ // Note that access to the class isn't checked in case the declaring class is protected and the
+ // method has been exposed by a public sub-class
+ bool CanAccessMember(Class* access_to, uint32_t member_flags) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ // Classes can access all of their own members
+ if (this == access_to) {
+ return true;
+ }
+ // Public members are trivially accessible
+ if (member_flags & kAccPublic) {
+ return true;
+ }
+ // Private members are trivially not accessible
+ if (member_flags & kAccPrivate) {
+ return false;
+ }
+ // Check for protected access from a sub-class, which may or may not be in the same package.
+ if (member_flags & kAccProtected) {
+ if (this->IsSubClass(access_to)) {
+ return true;
+ }
+ }
+ // Allow protected access from other classes in the same package.
+ return this->IsInSamePackage(access_to);
+ }
+
+ bool IsSubClass(const Class* klass) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Can src be assigned to this class? For example, String can be assigned to Object (by an
+ // upcast), however, an Object cannot be assigned to a String as a potentially exception throwing
+ // downcast would be necessary. Similarly for interfaces, a class that implements (or an interface
+ // that extends) another can be assigned to its parent, but not vice-versa. All Classes may assign
+ // to themselves. Classes for primitive types may not assign to each other.
+ bool IsAssignableFrom(const Class* src) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ DCHECK(src != NULL);
+ if (this == src) {
+ // Can always assign to things of the same type.
+ return true;
+ } else if (IsObjectClass()) {
+ // Can assign any reference to java.lang.Object.
+ return !src->IsPrimitive();
+ } else if (IsInterface()) {
+ return src->Implements(this);
+ } else if (src->IsArrayClass()) {
+ return IsAssignableFromArray(src);
+ } else {
+ return !src->IsInterface() && src->IsSubClass(this);
+ }
+ }
+
+ Class* GetSuperClass() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ void SetSuperClass(Class *new_super_class) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ // super class is assigned once, except during class linker initialization
+ Class* old_super_class = GetFieldObject<Class*>(
+ OFFSET_OF_OBJECT_MEMBER(Class, super_class_), false);
+ DCHECK(old_super_class == NULL || old_super_class == new_super_class);
+ DCHECK(new_super_class != NULL);
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, super_class_), new_super_class, false);
+ }
+
+ bool HasSuperClass() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ return GetSuperClass() != NULL;
+ }
+
+ static MemberOffset SuperClassOffset() {
+ return MemberOffset(OFFSETOF_MEMBER(Class, super_class_));
+ }
+
+ ClassLoader* GetClassLoader() const;
+
+ void SetClassLoader(ClassLoader* new_cl) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static MemberOffset DexCacheOffset() {
+ return MemberOffset(OFFSETOF_MEMBER(Class, dex_cache_));
+ }
+
+ enum {
+ kDumpClassFullDetail = 1,
+ kDumpClassClassLoader = (1 << 1),
+ kDumpClassInitialized = (1 << 2),
+ };
+
+ void DumpClass(std::ostream& os, int flags) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ DexCache* GetDexCache() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ void SetDexCache(DexCache* new_dex_cache) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ ObjectArray<AbstractMethod>* GetDirectMethods() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ void SetDirectMethods(ObjectArray<AbstractMethod>* new_direct_methods)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ AbstractMethod* GetDirectMethod(int32_t i) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ void SetDirectMethod(uint32_t i, AbstractMethod* f) // TODO: uint16_t
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Returns the number of static, private, and constructor methods.
+ size_t NumDirectMethods() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ ObjectArray<AbstractMethod>* GetVirtualMethods() const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ void SetVirtualMethods(ObjectArray<AbstractMethod>* new_virtual_methods)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Returns the number of non-inherited virtual methods.
+ size_t NumVirtualMethods() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ AbstractMethod* GetVirtualMethod(uint32_t i) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ AbstractMethod* GetVirtualMethodDuringLinking(uint32_t i) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ void SetVirtualMethod(uint32_t i, AbstractMethod* f) // TODO: uint16_t
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ ObjectArray<AbstractMethod>* GetVTable() const;
+
+ ObjectArray<AbstractMethod>* GetVTableDuringLinking() const;
+
+ void SetVTable(ObjectArray<AbstractMethod>* new_vtable)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static MemberOffset VTableOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(Class, vtable_);
+ }
+
+ // Given a method implemented by this class but potentially from a super class, return the
+ // specific implementation method for this class.
+ AbstractMethod* FindVirtualMethodForVirtual(AbstractMethod* method) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Given a method implemented by this class' super class, return the specific implementation
+ // method for this class.
+ AbstractMethod* FindVirtualMethodForSuper(AbstractMethod* method) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Given a method implemented by this class, but potentially from a
+ // super class or interface, return the specific implementation
+ // method for this class.
+ AbstractMethod* FindVirtualMethodForInterface(AbstractMethod* method) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ AbstractMethod* FindInterfaceMethod(const StringPiece& name, const StringPiece& descriptor) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ AbstractMethod* FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ AbstractMethod* FindVirtualMethodForVirtualOrInterface(AbstractMethod* method) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ AbstractMethod* FindDeclaredVirtualMethod(const StringPiece& name, const StringPiece& signature) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ AbstractMethod* FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ AbstractMethod* FindVirtualMethod(const StringPiece& name, const StringPiece& descriptor) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ AbstractMethod* FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ AbstractMethod* FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ AbstractMethod* FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ AbstractMethod* FindDirectMethod(const StringPiece& name, const StringPiece& signature) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ AbstractMethod* FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ int32_t GetIfTableCount() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ IfTable* GetIfTable() const;
+
+ void SetIfTable(IfTable* new_iftable) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Get instance fields of the class (See also GetSFields).
+ ObjectArray<Field>* GetIFields() const;
+
+ void SetIFields(ObjectArray<Field>* new_ifields) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ size_t NumInstanceFields() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ Field* GetInstanceField(uint32_t i) const // TODO: uint16_t
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ void SetInstanceField(uint32_t i, Field* f) // TODO: uint16_t
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Returns the number of instance fields containing reference types.
+ size_t NumReferenceInstanceFields() const {
+ DCHECK(IsResolved() || IsErroneous());
+ DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_instance_fields_), false);
+ }
+
+ size_t NumReferenceInstanceFieldsDuringLinking() const {
+ DCHECK(IsLoaded() || IsErroneous());
+ DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_instance_fields_), false);
+ }
+
+ void SetNumReferenceInstanceFields(size_t new_num) {
+ DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_instance_fields_), new_num, false);
+ }
+
+ uint32_t GetReferenceInstanceOffsets() const {
+ DCHECK(IsResolved() || IsErroneous());
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, reference_instance_offsets_), false);
+ }
+
+ void SetReferenceInstanceOffsets(uint32_t new_reference_offsets)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Beginning of static field data
+ static MemberOffset FieldsOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(Class, fields_);
+ }
+
+ // Returns the number of static fields containing reference types.
+ size_t NumReferenceStaticFields() const {
+ DCHECK(IsResolved() || IsErroneous());
+ DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_static_fields_), false);
+ }
+
+ size_t NumReferenceStaticFieldsDuringLinking() const {
+ DCHECK(IsLoaded() || IsErroneous());
+ DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_static_fields_), false);
+ }
+
+ void SetNumReferenceStaticFields(size_t new_num) {
+ DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_static_fields_), new_num, false);
+ }
+
+ // Gets the static fields of the class.
+ ObjectArray<Field>* GetSFields() const;
+
+ void SetSFields(ObjectArray<Field>* new_sfields) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ size_t NumStaticFields() const;
+
+ Field* GetStaticField(uint32_t i) const; // TODO: uint16_t
+
+ void SetStaticField(uint32_t i, Field* f); // TODO: uint16_t
+
+ uint32_t GetReferenceStaticOffsets() const {
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, reference_static_offsets_), false);
+ }
+
+ void SetReferenceStaticOffsets(uint32_t new_reference_offsets);
+
+ // Find a static or instance field using the JLS resolution order
+ Field* FindField(const StringPiece& name, const StringPiece& type)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Finds the given instance field in this class or a superclass.
+ Field* FindInstanceField(const StringPiece& name, const StringPiece& type)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Finds the given instance field in this class or a superclass, only searches classes that
+ // have the same dex cache.
+ Field* FindInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ Field* FindDeclaredInstanceField(const StringPiece& name, const StringPiece& type)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ Field* FindDeclaredInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Finds the given static field in this class or a superclass.
+ Field* FindStaticField(const StringPiece& name, const StringPiece& type)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Finds the given static field in this class or superclass, only searches classes that
+ // have the same dex cache.
+ Field* FindStaticField(const DexCache* dex_cache, uint32_t dex_field_idx)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ Field* FindDeclaredStaticField(const StringPiece& name, const StringPiece& type)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ Field* FindDeclaredStaticField(const DexCache* dex_cache, uint32_t dex_field_idx)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ pid_t GetClinitThreadId() const {
+ DCHECK(IsIdxLoaded() || IsErroneous());
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, clinit_thread_id_), false);
+ }
+
+ void SetClinitThreadId(pid_t new_clinit_thread_id) {
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Class, clinit_thread_id_), new_clinit_thread_id, false);
+ }
+
+ Class* GetVerifyErrorClass() const {
+ // DCHECK(IsErroneous());
+ return GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Class, verify_error_class_), false);
+ }
+
+ uint16_t GetDexTypeIndex() const {
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, dex_type_idx_), false);
+ }
+
+ void SetDexTypeIndex(uint16_t type_idx) {
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Class, dex_type_idx_), type_idx, false);
+ }
+
+ static Class* GetJavaLangClass() {
+ DCHECK(java_lang_Class_ != NULL);
+ return java_lang_Class_;
+ }
+
+ // Can't call this SetClass or else gets called instead of Object::SetClass in places.
+ static void SetClassClass(Class* java_lang_Class);
+ static void ResetClass();
+
+ private:
+ void SetVerifyErrorClass(Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ bool Implements(const Class* klass) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ bool IsArrayAssignableFromArray(const Class* klass) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ bool IsAssignableFromArray(const Class* klass) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // defining class loader, or NULL for the "bootstrap" system loader
+ ClassLoader* class_loader_;
+
+ // For array classes, the component class object for instanceof/checkcast
+ // (for String[][][], this will be String[][]). NULL for non-array classes.
+ Class* component_type_;
+
+ // DexCache of resolved constant pool entries (will be NULL for classes generated by the
+ // runtime such as arrays and primitive classes).
+ DexCache* dex_cache_;
+
+ // static, private, and <init> methods
+ ObjectArray<AbstractMethod>* direct_methods_;
+
+ // instance fields
+ //
+ // These describe the layout of the contents of an Object.
+ // Note that only the fields directly declared by this class are
+ // listed in ifields; fields declared by a superclass are listed in
+ // the superclass's Class.ifields.
+ //
+ // All instance fields that refer to objects are guaranteed to be at
+ // the beginning of the field list. num_reference_instance_fields_
+ // specifies the number of reference fields.
+ ObjectArray<Field>* ifields_;
+
+ // The interface table (iftable_) contains pairs of a interface class and an array of the
+ // interface methods. There is one pair per interface supported by this class. That means one
+ // pair for each interface we support directly, indirectly via superclass, or indirectly via a
+ // superinterface. This will be null if neither we nor our superclass implement any interfaces.
+ //
+ // Why we need this: given "class Foo implements Face", declare "Face faceObj = new Foo()".
+ // Invoke faceObj.blah(), where "blah" is part of the Face interface. We can't easily use a
+ // single vtable.
+ //
+ // For every interface a concrete class implements, we create an array of the concrete vtable_
+ // methods for the methods in the interface.
+ IfTable* iftable_;
+
+ // descriptor for the class such as "java.lang.Class" or "[C". Lazily initialized by ComputeName
+ String* name_;
+
+ // Static fields
+ ObjectArray<Field>* sfields_;
+
+ // The superclass, or NULL if this is java.lang.Object, an interface or primitive type.
+ Class* super_class_;
+
+ // If class verify fails, we must return same error on subsequent tries.
+ Class* verify_error_class_;
+
+ // virtual methods defined in this class; invoked through vtable
+ ObjectArray<AbstractMethod>* virtual_methods_;
+
+ // Virtual method table (vtable), for use by "invoke-virtual". The vtable from the superclass is
+ // copied in, and virtual methods from our class either replace those from the super or are
+ // appended. For abstract classes, methods may be created in the vtable that aren't in
+ // virtual_ methods_ for miranda methods.
+ ObjectArray<AbstractMethod>* vtable_;
+
+ // access flags; low 16 bits are defined by VM spec
+ uint32_t access_flags_;
+
+ // Total size of the Class instance; used when allocating storage on gc heap.
+ // See also object_size_.
+ size_t class_size_;
+
+ // tid used to check for recursive <clinit> invocation
+ pid_t clinit_thread_id_;
+
+ // type index from dex file
+ // TODO: really 16bits
+ uint32_t dex_type_idx_;
+
+ // number of instance fields that are object refs
+ size_t num_reference_instance_fields_;
+
+ // number of static fields that are object refs
+ size_t num_reference_static_fields_;
+
+ // Total object size; used when allocating storage on gc heap.
+ // (For interfaces and abstract classes this will be zero.)
+ // See also class_size_.
+ size_t object_size_;
+
+ // primitive type value, or Primitive::kPrimNot (0); set for generated prim classes
+ Primitive::Type primitive_type_;
+
+ // Bitmap of offsets of ifields.
+ uint32_t reference_instance_offsets_;
+
+ // Bitmap of offsets of sfields.
+ uint32_t reference_static_offsets_;
+
+ // state of class initialization
+ Status status_;
+
+ // TODO: ?
+ // initiating class loader list
+ // NOTE: for classes with low serialNumber, these are unused, and the
+ // values are kept in a table in gDvm.
+ // InitiatingLoaderList initiating_loader_list_;
+
+ // Location of first static field.
+ uint32_t fields_[0];
+
+ // java.lang.Class
+ static Class* java_lang_Class_;
+
+ friend struct art::ClassOffsets; // for verifying offset information
+ DISALLOW_IMPLICIT_CONSTRUCTORS(Class);
+};
+
+std::ostream& operator<<(std::ostream& os, const Class::Status& rhs);
+
+class MANAGED ClassClass : public Class {
+ private:
+ int32_t padding_;
+ int64_t serialVersionUID_;
+ friend struct art::ClassClassOffsets; // for verifying offset information
+ DISALLOW_IMPLICIT_CONSTRUCTORS(ClassClass);
+};
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_CLASS_H_
diff --git a/src/class_loader.h b/src/mirror/class_loader.h
similarity index 85%
rename from src/class_loader.h
rename to src/mirror/class_loader.h
index 029c4a2..0d635f1 100644
--- a/src/class_loader.h
+++ b/src/mirror/class_loader.h
@@ -20,10 +20,14 @@
#include <vector>
#include "dex_file.h"
-#include "object.h"
+#include "mirror/object.h"
namespace art {
+struct ClassLoaderOffsets;
+
+namespace mirror {
+
// C++ mirror of java.lang.ClassLoader
class MANAGED ClassLoader : public Object {
private:
@@ -32,10 +36,11 @@
ClassLoader* parent_;
Object* proxyCache_;
- friend struct ClassLoaderOffsets; // for verifying offset information
+ friend struct art::ClassLoaderOffsets; // for verifying offset information
DISALLOW_IMPLICIT_CONSTRUCTORS(ClassLoader);
};
+} // namespace mirror
} // namespace art
#endif // ART_SRC_CLASS_LOADER_H_
diff --git a/src/dex_cache.cc b/src/mirror/dex_cache.cc
similarity index 81%
rename from src/dex_cache.cc
rename to src/mirror/dex_cache.cc
index 98fc932..3009786 100644
--- a/src/dex_cache.cc
+++ b/src/mirror/dex_cache.cc
@@ -14,14 +14,22 @@
* limitations under the License.
*/
+#include "dex_cache.h"
+
+#include "abstract_method-inl.h"
#include "base/logging.h"
#include "class_linker.h"
-#include "dex_cache.h"
#include "heap.h"
+#include "gc/card_table-inl.h"
#include "globals.h"
#include "object.h"
+#include "object-inl.h"
+#include "object_array-inl.h"
+#include "runtime.h"
+#include "string.h"
namespace art {
+namespace mirror {
void DexCache::Init(const DexFile* dex_file,
String* location,
@@ -70,4 +78,17 @@
}
}
+AbstractMethod* DexCache::GetResolvedMethod(uint32_t method_idx) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ AbstractMethod* method = GetResolvedMethods()->Get(method_idx);
+ // Hide resolution trampoline methods from the caller
+ if (method != NULL && method->IsRuntimeMethod()) {
+ DCHECK(method == Runtime::Current()->GetResolutionMethod());
+ return NULL;
+ } else {
+ return method;
+ }
+}
+
+} // namespace mirror
} // namespace art
diff --git a/src/dex_cache.h b/src/mirror/dex_cache.h
similarity index 88%
rename from src/dex_cache.h
rename to src/mirror/dex_cache.h
index ee44856..307588b 100644
--- a/src/dex_cache.h
+++ b/src/mirror/dex_cache.h
@@ -14,22 +14,26 @@
* limitations under the License.
*/
-#ifndef ART_SRC_DEX_CACHE_H_
-#define ART_SRC_DEX_CACHE_H_
+#ifndef ART_SRC_MIRROR_DEX_CACHE_H_
+#define ART_SRC_MIRROR_DEX_CACHE_H_
-#include "base/macros.h"
-#include "dex_file.h"
-#include "globals.h"
+#include "abstract_method.h"
+#include "class.h"
#include "object.h"
+#include "object_array.h"
+#include "string.h"
namespace art {
+struct DexCacheOffsets;
+class DexFile;
+class ImageWriter;
+union JValue;
+
+namespace mirror {
+
class Class;
class Field;
-class ImageWriter;
-class AbstractMethod;
-class String;
-union JValue;
class MANAGED DexCacheClass : public Class {
private:
@@ -107,16 +111,7 @@
}
AbstractMethod* GetResolvedMethod(uint32_t method_idx) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* method = GetResolvedMethods()->Get(method_idx);
- // Hide resolution trampoline methods from the caller
- if (method != NULL && method->GetDexMethodIndex() == DexFile::kDexNoIndex16) {
- DCHECK(method == Runtime::Current()->GetResolutionMethod());
- return NULL;
- } else {
- return method;
- }
- }
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void SetResolvedMethod(uint32_t method_idx, AbstractMethod* resolved)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -177,10 +172,11 @@
ObjectArray<String>* strings_;
uint32_t dex_file_;
- friend struct DexCacheOffsets; // for verifying offset information
+ friend struct art::DexCacheOffsets; // for verifying offset information
DISALLOW_IMPLICIT_CONSTRUCTORS(DexCache);
};
+} // namespace mirror
} // namespace art
-#endif // ART_SRC_DEX_CACHE_H_
+#endif // ART_SRC_MIRROR_DEX_CACHE_H_
diff --git a/src/dex_cache_test.cc b/src/mirror/dex_cache_test.cc
similarity index 96%
rename from src/dex_cache_test.cc
rename to src/mirror/dex_cache_test.cc
index b131e4c..9817660 100644
--- a/src/dex_cache_test.cc
+++ b/src/mirror/dex_cache_test.cc
@@ -18,12 +18,13 @@
#include "common_test.h"
#include "dex_cache.h"
#include "heap.h"
-#include "object.h"
+#include "mirror/object_array-inl.h"
#include "sirt_ref.h"
#include <stdio.h>
namespace art {
+namespace mirror {
class DexCacheTest : public CommonTest {};
@@ -57,4 +58,5 @@
static_cast<uint32_t>(dex_cache->GetInitializedStaticStorage()->GetLength()));
}
+} // namespace mirror
} // namespace art
diff --git a/src/mirror/field-inl.h b/src/mirror/field-inl.h
new file mode 100644
index 0000000..b73cf19
--- /dev/null
+++ b/src/mirror/field-inl.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_FIELD_INL_H_
+#define ART_SRC_MIRROR_FIELD_INL_H_
+
+#include "field.h"
+
+namespace art {
+namespace mirror {
+
+inline Class* Field::GetDeclaringClass() const {
+ Class* result = GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Field, declaring_class_), false);
+ DCHECK(result != NULL);
+ DCHECK(result->IsLoaded() || result->IsErroneous());
+ return result;
+}
+
+inline void Field::SetDeclaringClass(Class *new_declaring_class) {
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Field, declaring_class_), new_declaring_class, false);
+}
+
+inline uint32_t Field::GetAccessFlags() const {
+ DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(Field, access_flags_), false);
+}
+
+inline MemberOffset Field::GetOffset() const {
+ DCHECK(GetDeclaringClass()->IsResolved() || GetDeclaringClass()->IsErroneous());
+ return MemberOffset(GetField32(OFFSET_OF_OBJECT_MEMBER(Field, offset_), false));
+}
+
+inline MemberOffset Field::GetOffsetDuringLinking() const {
+ DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
+ return MemberOffset(GetField32(OFFSET_OF_OBJECT_MEMBER(Field, offset_), false));
+}
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_FIELD_INL_H_
diff --git a/src/mirror/field.cc b/src/mirror/field.cc
new file mode 100644
index 0000000..dab7868
--- /dev/null
+++ b/src/mirror/field.cc
@@ -0,0 +1,223 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+#include "field.h"
+
+#include "field-inl.h"
+#include "gc/card_table-inl.h"
+#include "object-inl.h"
+#include "object_utils.h"
+#include "runtime.h"
+#include "utils.h"
+
+namespace art {
+namespace mirror {
+
+// TODO: get global references for these
+Class* Field::java_lang_reflect_Field_ = NULL;
+
+void Field::SetClass(Class* java_lang_reflect_Field) {
+ CHECK(java_lang_reflect_Field_ == NULL);
+ CHECK(java_lang_reflect_Field != NULL);
+ java_lang_reflect_Field_ = java_lang_reflect_Field;
+}
+
+void Field::ResetClass() {
+ CHECK(java_lang_reflect_Field_ != NULL);
+ java_lang_reflect_Field_ = NULL;
+}
+
+void Field::SetOffset(MemberOffset num_bytes) {
+ DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
+#if 0 // TODO enable later in boot and under !NDEBUG
+ FieldHelper fh(this);
+ Primitive::Type type = fh.GetTypeAsPrimitiveType();
+ if (type == Primitive::kPrimDouble || type == Primitive::kPrimLong) {
+ DCHECK_ALIGNED(num_bytes.Uint32Value(), 8);
+ }
+#endif
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Field, offset_), num_bytes.Uint32Value(), false);
+}
+
+uint32_t Field::Get32(const Object* object) const {
+ DCHECK(object != NULL) << PrettyField(this);
+ DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
+ return object->GetField32(GetOffset(), IsVolatile());
+}
+
+void Field::Set32(Object* object, uint32_t new_value) const {
+ DCHECK(object != NULL) << PrettyField(this);
+ DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
+ object->SetField32(GetOffset(), new_value, IsVolatile());
+}
+
+uint64_t Field::Get64(const Object* object) const {
+ DCHECK(object != NULL) << PrettyField(this);
+ DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
+ return object->GetField64(GetOffset(), IsVolatile());
+}
+
+void Field::Set64(Object* object, uint64_t new_value) const {
+ DCHECK(object != NULL) << PrettyField(this);
+ DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
+ object->SetField64(GetOffset(), new_value, IsVolatile());
+}
+
+Object* Field::GetObj(const Object* object) const {
+ DCHECK(object != NULL) << PrettyField(this);
+ DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
+ return object->GetFieldObject<Object*>(GetOffset(), IsVolatile());
+}
+
+void Field::SetObj(Object* object, const Object* new_value) const {
+ DCHECK(object != NULL) << PrettyField(this);
+ DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
+ object->SetFieldObject(GetOffset(), new_value, IsVolatile());
+}
+
+bool Field::GetBoolean(const Object* object) const {
+ DCHECK_EQ(Primitive::kPrimBoolean, FieldHelper(this).GetTypeAsPrimitiveType())
+ << PrettyField(this);
+ return Get32(object);
+}
+
+void Field::SetBoolean(Object* object, bool z) const {
+ DCHECK_EQ(Primitive::kPrimBoolean, FieldHelper(this).GetTypeAsPrimitiveType())
+ << PrettyField(this);
+ Set32(object, z);
+}
+
+int8_t Field::GetByte(const Object* object) const {
+ DCHECK_EQ(Primitive::kPrimByte, FieldHelper(this).GetTypeAsPrimitiveType())
+ << PrettyField(this);
+ return Get32(object);
+}
+
+void Field::SetByte(Object* object, int8_t b) const {
+ DCHECK_EQ(Primitive::kPrimByte, FieldHelper(this).GetTypeAsPrimitiveType())
+ << PrettyField(this);
+ Set32(object, b);
+}
+
+uint16_t Field::GetChar(const Object* object) const {
+ DCHECK_EQ(Primitive::kPrimChar, FieldHelper(this).GetTypeAsPrimitiveType())
+ << PrettyField(this);
+ return Get32(object);
+}
+
+void Field::SetChar(Object* object, uint16_t c) const {
+ DCHECK_EQ(Primitive::kPrimChar, FieldHelper(this).GetTypeAsPrimitiveType())
+ << PrettyField(this);
+ Set32(object, c);
+}
+
+int16_t Field::GetShort(const Object* object) const {
+ DCHECK_EQ(Primitive::kPrimShort, FieldHelper(this).GetTypeAsPrimitiveType())
+ << PrettyField(this);
+ return Get32(object);
+}
+
+void Field::SetShort(Object* object, int16_t s) const {
+ DCHECK_EQ(Primitive::kPrimShort, FieldHelper(this).GetTypeAsPrimitiveType())
+ << PrettyField(this);
+ Set32(object, s);
+}
+
+int32_t Field::GetInt(const Object* object) const {
+#ifndef NDEBUG
+ Primitive::Type type = FieldHelper(this).GetTypeAsPrimitiveType();
+ CHECK(type == Primitive::kPrimInt || type == Primitive::kPrimFloat) << PrettyField(this);
+#endif
+ return Get32(object);
+}
+
+void Field::SetInt(Object* object, int32_t i) const {
+#ifndef NDEBUG
+ Primitive::Type type = FieldHelper(this).GetTypeAsPrimitiveType();
+ CHECK(type == Primitive::kPrimInt || type == Primitive::kPrimFloat) << PrettyField(this);
+#endif
+ Set32(object, i);
+}
+
+int64_t Field::GetLong(const Object* object) const {
+#ifndef NDEBUG
+ Primitive::Type type = FieldHelper(this).GetTypeAsPrimitiveType();
+ CHECK(type == Primitive::kPrimLong || type == Primitive::kPrimDouble) << PrettyField(this);
+#endif
+ return Get64(object);
+}
+
+void Field::SetLong(Object* object, int64_t j) const {
+#ifndef NDEBUG
+ Primitive::Type type = FieldHelper(this).GetTypeAsPrimitiveType();
+ CHECK(type == Primitive::kPrimLong || type == Primitive::kPrimDouble) << PrettyField(this);
+#endif
+ Set64(object, j);
+}
+
+union Bits {
+ jdouble d;
+ jfloat f;
+ jint i;
+ jlong j;
+};
+
+float Field::GetFloat(const Object* object) const {
+ DCHECK_EQ(Primitive::kPrimFloat, FieldHelper(this).GetTypeAsPrimitiveType())
+ << PrettyField(this);
+ Bits bits;
+ bits.i = Get32(object);
+ return bits.f;
+}
+
+void Field::SetFloat(Object* object, float f) const {
+ DCHECK_EQ(Primitive::kPrimFloat, FieldHelper(this).GetTypeAsPrimitiveType())
+ << PrettyField(this);
+ Bits bits;
+ bits.f = f;
+ Set32(object, bits.i);
+}
+
+double Field::GetDouble(const Object* object) const {
+ DCHECK_EQ(Primitive::kPrimDouble, FieldHelper(this).GetTypeAsPrimitiveType())
+ << PrettyField(this);
+ Bits bits;
+ bits.j = Get64(object);
+ return bits.d;
+}
+
+void Field::SetDouble(Object* object, double d) const {
+ DCHECK_EQ(Primitive::kPrimDouble, FieldHelper(this).GetTypeAsPrimitiveType())
+ << PrettyField(this);
+ Bits bits;
+ bits.d = d;
+ Set64(object, bits.j);
+}
+
+Object* Field::GetObject(const Object* object) const {
+ DCHECK_EQ(Primitive::kPrimNot, FieldHelper(this).GetTypeAsPrimitiveType())
+ << PrettyField(this);
+ return GetObj(object);
+}
+
+void Field::SetObject(Object* object, const Object* l) const {
+ DCHECK_EQ(Primitive::kPrimNot, FieldHelper(this).GetTypeAsPrimitiveType())
+ << PrettyField(this);
+ SetObj(object, l);
+}
+
+} // namespace mirror
+} // namespace art
diff --git a/src/mirror/field.h b/src/mirror/field.h
new file mode 100644
index 0000000..4e7abe8
--- /dev/null
+++ b/src/mirror/field.h
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_FIELD_H_
+#define ART_SRC_MIRROR_FIELD_H_
+
+#include "class.h"
+#include "modifiers.h"
+#include "object.h"
+
+namespace art {
+
+struct FieldClassOffsets;
+struct FieldOffsets;
+
+namespace mirror {
+
+// C++ mirror of java.lang.reflect.Field
+class MANAGED Field : public Object {
+ public:
+ Class* GetDeclaringClass() const;
+
+ void SetDeclaringClass(Class *new_declaring_class) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ uint32_t GetAccessFlags() const;
+
+ void SetAccessFlags(uint32_t new_access_flags) {
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Field, access_flags_), new_access_flags, false);
+ }
+
+ bool IsPublic() const {
+ return (GetAccessFlags() & kAccPublic) != 0;
+ }
+
+ bool IsStatic() const {
+ return (GetAccessFlags() & kAccStatic) != 0;
+ }
+
+ bool IsFinal() const {
+ return (GetAccessFlags() & kAccFinal) != 0;
+ }
+
+ uint32_t GetDexFieldIndex() const {
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(Field, field_dex_idx_), false);
+ }
+
+ void SetDexFieldIndex(uint32_t new_idx) {
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Field, field_dex_idx_), new_idx, false);
+ }
+
+ // Offset to field within an Object
+ MemberOffset GetOffset() const;
+
+ static MemberOffset OffsetOffset() {
+ return MemberOffset(OFFSETOF_MEMBER(Field, offset_));
+ }
+
+ MemberOffset GetOffsetDuringLinking() const;
+
+ void SetOffset(MemberOffset num_bytes);
+
+ // field access, null object for static fields
+ bool GetBoolean(const Object* object) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void SetBoolean(Object* object, bool z) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ int8_t GetByte(const Object* object) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void SetByte(Object* object, int8_t b) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ uint16_t GetChar(const Object* object) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void SetChar(Object* object, uint16_t c) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ int16_t GetShort(const Object* object) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void SetShort(Object* object, int16_t s) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ int32_t GetInt(const Object* object) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void SetInt(Object* object, int32_t i) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ int64_t GetLong(const Object* object) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void SetLong(Object* object, int64_t j) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ float GetFloat(const Object* object) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void SetFloat(Object* object, float f) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ double GetDouble(const Object* object) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void SetDouble(Object* object, double d) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ Object* GetObject(const Object* object) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void SetObject(Object* object, const Object* l) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // raw field accesses
+ uint32_t Get32(const Object* object) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void Set32(Object* object, uint32_t new_value) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ uint64_t Get64(const Object* object) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void Set64(Object* object, uint64_t new_value) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ Object* GetObj(const Object* object) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void SetObj(Object* object, const Object* new_value) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static Class* GetJavaLangReflectField() {
+ DCHECK(java_lang_reflect_Field_ != NULL);
+ return java_lang_reflect_Field_;
+ }
+
+ static void SetClass(Class* java_lang_reflect_Field);
+ static void ResetClass();
+
+ bool IsVolatile() const {
+ return (GetAccessFlags() & kAccVolatile) != 0;
+ }
+
+ private:
+ // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
+ // The class we are a part of
+ Class* declaring_class_;
+
+ uint32_t access_flags_;
+
+ // Dex cache index of field id
+ uint32_t field_dex_idx_;
+
+ // Offset of field within an instance or in the Class' static fields
+ uint32_t offset_;
+
+ static Class* java_lang_reflect_Field_;
+
+ friend struct art::FieldOffsets; // for verifying offset information
+ DISALLOW_IMPLICIT_CONSTRUCTORS(Field);
+};
+
+class MANAGED FieldClass : public Class {
+ private:
+ Object* ORDER_BY_NAME_AND_DECLARING_CLASS_;
+ friend struct art::FieldClassOffsets; // for verifying offset information
+ DISALLOW_IMPLICIT_CONSTRUCTORS(FieldClass);
+};
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_FIELD_H_
diff --git a/src/mirror/iftable-inl.h b/src/mirror/iftable-inl.h
new file mode 100644
index 0000000..72803b8
--- /dev/null
+++ b/src/mirror/iftable-inl.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_IFTABLE_INL_H_
+#define ART_SRC_MIRROR_IFTABLE_INL_H_
+
+#include "iftable.h"
+
+namespace art {
+namespace mirror {
+
+inline void IfTable::SetInterface(int32_t i, Class* interface) {
+ DCHECK(interface != NULL);
+ DCHECK(interface->IsInterface());
+ DCHECK(Get((i * kMax) + kInterface) == NULL);
+ Set((i * kMax) + kInterface, interface);
+}
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_IFTABLE_INL_H_
diff --git a/src/mirror/iftable.h b/src/mirror/iftable.h
new file mode 100644
index 0000000..ffb2e51
--- /dev/null
+++ b/src/mirror/iftable.h
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_IFTABLE_H_
+#define ART_SRC_MIRROR_IFTABLE_H_
+
+#include "object_array.h"
+
+namespace art {
+namespace mirror {
+
+class MANAGED IfTable : public ObjectArray<Object> {
+ public:
+ Class* GetInterface(int32_t i) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ Class* interface = Get((i * kMax) + kInterface)->AsClass();
+ DCHECK(interface != NULL);
+ return interface;
+ }
+
+ void SetInterface(int32_t i, Class* interface) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ ObjectArray<AbstractMethod>* GetMethodArray(int32_t i) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ ObjectArray<AbstractMethod>* method_array =
+ down_cast<ObjectArray<AbstractMethod>*>(Get((i * kMax) + kMethodArray));
+ DCHECK(method_array != NULL);
+ return method_array;
+ }
+
+ size_t GetMethodArrayCount(int32_t i) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ ObjectArray<AbstractMethod>* method_array =
+ down_cast<ObjectArray<AbstractMethod>*>(Get((i * kMax) + kMethodArray));
+ if (method_array == NULL) {
+ return 0;
+ }
+ return method_array->GetLength();
+ }
+
+ void SetMethodArray(int32_t i, ObjectArray<AbstractMethod>* new_ma)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ DCHECK(new_ma != NULL);
+ DCHECK(Get((i * kMax) + kMethodArray) == NULL);
+ Set((i * kMax) + kMethodArray, new_ma);
+ }
+
+ size_t Count() const {
+ return GetLength() / kMax;
+ }
+
+ enum {
+ // Points to the interface class.
+ kInterface = 0,
+ // Method pointers into the vtable, allow fast map from interface method index to concrete
+ // instance method.
+ kMethodArray = 1,
+ kMax = 2,
+ };
+
+ private:
+ DISALLOW_IMPLICIT_CONSTRUCTORS(IfTable);
+};
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_IFTABLE_H_
diff --git a/src/mirror/object-inl.h b/src/mirror/object-inl.h
new file mode 100644
index 0000000..723192d
--- /dev/null
+++ b/src/mirror/object-inl.h
@@ -0,0 +1,181 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_OBJECT_INL_H_
+#define ART_SRC_MIRROR_OBJECT_INL_H_
+
+#include "object.h"
+
+#include "abstract_method.h"
+#include "atomic.h"
+#include "array.h"
+#include "field.h"
+#include "class.h"
+#include "runtime.h"
+
+namespace art {
+namespace mirror {
+
+inline Class* Object::GetClass() const {
+ return GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Object, klass_), false);
+}
+
+inline void Object::SetClass(Class* new_klass) {
+ // new_klass may be NULL prior to class linker initialization
+ // We don't mark the card since the class is guaranteed to be referenced from another location.
+ // Proxy classes are held live by the class loader, and other classes are roots of the class
+ // linker.
+ SetFieldPtr(OFFSET_OF_OBJECT_MEMBER(Object, klass_), new_klass, false, false);
+}
+
+inline bool Object::InstanceOf(const Class* klass) const {
+ DCHECK(klass != NULL);
+ DCHECK(GetClass() != NULL);
+ return klass->IsAssignableFrom(GetClass());
+}
+
+inline bool Object::IsClass() const {
+ Class* java_lang_Class = GetClass()->GetClass();
+ return GetClass() == java_lang_Class;
+}
+
+inline Class* Object::AsClass() {
+ DCHECK(IsClass());
+ return down_cast<Class*>(this);
+}
+
+inline const Class* Object::AsClass() const {
+ DCHECK(IsClass());
+ return down_cast<const Class*>(this);
+}
+
+inline bool Object::IsObjectArray() const {
+ return IsArrayInstance() && !GetClass()->GetComponentType()->IsPrimitive();
+}
+
+template<class T>
+inline ObjectArray<T>* Object::AsObjectArray() {
+ DCHECK(IsObjectArray());
+ return down_cast<ObjectArray<T>*>(this);
+}
+
+template<class T>
+inline const ObjectArray<T>* Object::AsObjectArray() const {
+ DCHECK(IsObjectArray());
+ return down_cast<const ObjectArray<T>*>(this);
+}
+
+inline bool Object::IsArrayInstance() const {
+ return GetClass()->IsArrayClass();
+}
+
+inline bool Object::IsField() const {
+ return GetClass()->IsFieldClass();
+}
+
+inline Field* Object::AsField() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ DCHECK(IsField());
+ return down_cast<Field*>(this);
+}
+
+inline const Field* Object::AsField() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ DCHECK(IsField());
+ return down_cast<const Field*>(this);
+}
+
+inline bool Object::IsMethod() const {
+ return GetClass()->IsMethodClass();
+}
+
+inline AbstractMethod* Object::AsMethod() {
+ DCHECK(IsMethod());
+ return down_cast<AbstractMethod*>(this);
+}
+
+inline const AbstractMethod* Object::AsMethod() const {
+ DCHECK(IsMethod());
+ return down_cast<const AbstractMethod*>(this);
+}
+
+inline bool Object::IsReferenceInstance() const {
+ return GetClass()->IsReferenceClass();
+}
+
+inline bool Object::IsWeakReferenceInstance() const {
+ return GetClass()->IsWeakReferenceClass();
+}
+
+inline bool Object::IsSoftReferenceInstance() const {
+ return GetClass()->IsSoftReferenceClass();
+}
+
+inline bool Object::IsFinalizerReferenceInstance() const {
+ return GetClass()->IsFinalizerReferenceClass();
+}
+
+inline bool Object::IsPhantomReferenceInstance() const {
+ return GetClass()->IsPhantomReferenceClass();
+}
+
+inline size_t Object::SizeOf() const {
+ size_t result;
+ if (IsArrayInstance()) {
+ result = AsArray()->SizeOf();
+ } else if (IsClass()) {
+ result = AsClass()->SizeOf();
+ } else {
+ result = GetClass()->GetObjectSize();
+ }
+ DCHECK(!IsField() || result == sizeof(Field));
+ DCHECK(!IsMethod() || result == sizeof(AbstractMethod));
+ return result;
+}
+
+inline uint64_t Object::GetField64(MemberOffset field_offset, bool is_volatile) const {
+ VerifyObject(this);
+ const byte* raw_addr = reinterpret_cast<const byte*>(this) + field_offset.Int32Value();
+ const int64_t* addr = reinterpret_cast<const int64_t*>(raw_addr);
+ if (UNLIKELY(is_volatile)) {
+ uint64_t result = QuasiAtomic::Read64(addr);
+ ANDROID_MEMBAR_FULL();
+ return result;
+ } else {
+ return *addr;
+ }
+}
+
+inline void Object::SetField64(MemberOffset field_offset, uint64_t new_value, bool is_volatile) {
+ VerifyObject(this);
+ byte* raw_addr = reinterpret_cast<byte*>(this) + field_offset.Int32Value();
+ int64_t* addr = reinterpret_cast<int64_t*>(raw_addr);
+ if (UNLIKELY(is_volatile)) {
+ ANDROID_MEMBAR_STORE();
+ QuasiAtomic::Write64(addr, new_value);
+ // Post-store barrier not required due to use of atomic op or mutex.
+ } else {
+ *addr = new_value;
+ }
+}
+
+inline void Object::WriteBarrierField(const Object* dst, MemberOffset field_offset,
+ const Object* new_value) {
+ Runtime::Current()->GetHeap()->WriteBarrierField(dst, field_offset, new_value);
+}
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_OBJECT_INL_H_
diff --git a/src/mirror/object.cc b/src/mirror/object.cc
new file mode 100644
index 0000000..27a42d3
--- /dev/null
+++ b/src/mirror/object.cc
@@ -0,0 +1,215 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+#include "object.h"
+
+#include "array-inl.h"
+#include "class.h"
+#include "class-inl.h"
+#include "field.h"
+#include "field-inl.h"
+#include "gc/card_table-inl.h"
+#include "heap.h"
+#include "monitor.h"
+#include "object-inl.h"
+#include "object_array.h"
+#include "object_utils.h"
+#include "runtime.h"
+#include "sirt_ref.h"
+#include "throwable.h"
+#include "well_known_classes.h"
+
+namespace art {
+namespace mirror {
+
+Array* Object::AsArray() {
+ DCHECK(IsArrayInstance());
+ return down_cast<Array*>(this);
+}
+
+const Array* Object::AsArray() const {
+ DCHECK(IsArrayInstance());
+ return down_cast<const Array*>(this);
+}
+
+BooleanArray* Object::AsBooleanArray() {
+ DCHECK(GetClass()->IsArrayClass());
+ DCHECK(GetClass()->GetComponentType()->IsPrimitiveBoolean());
+ return down_cast<BooleanArray*>(this);
+}
+
+ByteArray* Object::AsByteArray() {
+ DCHECK(GetClass()->IsArrayClass());
+ DCHECK(GetClass()->GetComponentType()->IsPrimitiveByte());
+ return down_cast<ByteArray*>(this);
+}
+
+CharArray* Object::AsCharArray() {
+ DCHECK(GetClass()->IsArrayClass());
+ DCHECK(GetClass()->GetComponentType()->IsPrimitiveChar());
+ return down_cast<CharArray*>(this);
+}
+
+ShortArray* Object::AsShortArray() {
+ DCHECK(GetClass()->IsArrayClass());
+ DCHECK(GetClass()->GetComponentType()->IsPrimitiveShort());
+ return down_cast<ShortArray*>(this);
+}
+
+IntArray* Object::AsIntArray() {
+ DCHECK(GetClass()->IsArrayClass());
+ DCHECK(GetClass()->GetComponentType()->IsPrimitiveInt() ||
+ GetClass()->GetComponentType()->IsPrimitiveFloat());
+ return down_cast<IntArray*>(this);
+}
+
+LongArray* Object::AsLongArray() {
+ DCHECK(GetClass()->IsArrayClass());
+ DCHECK(GetClass()->GetComponentType()->IsPrimitiveLong() ||
+ GetClass()->GetComponentType()->IsPrimitiveDouble());
+ return down_cast<LongArray*>(this);
+}
+
+String* Object::AsString() {
+ DCHECK(GetClass()->IsStringClass());
+ return down_cast<String*>(this);
+}
+
+Throwable* Object::AsThrowable() {
+ DCHECK(GetClass()->IsThrowableClass());
+ return down_cast<Throwable*>(this);
+}
+
+Object* Object::Clone(Thread* self) {
+ Class* c = GetClass();
+ DCHECK(!c->IsClassClass());
+
+ // Object::SizeOf gets the right size even if we're an array.
+ // Using c->AllocObject() here would be wrong.
+ size_t num_bytes = SizeOf();
+ Heap* heap = Runtime::Current()->GetHeap();
+ SirtRef<Object> copy(self, heap->AllocObject(self, c, num_bytes));
+ if (copy.get() == NULL) {
+ return NULL;
+ }
+
+ // Copy instance data. We assume memcpy copies by words.
+ // TODO: expose and use move32.
+ byte* src_bytes = reinterpret_cast<byte*>(this);
+ byte* dst_bytes = reinterpret_cast<byte*>(copy.get());
+ size_t offset = sizeof(Object);
+ memcpy(dst_bytes + offset, src_bytes + offset, num_bytes - offset);
+
+ // Perform write barriers on copied object references.
+ if (c->IsArrayClass()) {
+ if (!c->GetComponentType()->IsPrimitive()) {
+ const ObjectArray<Object>* array = copy->AsObjectArray<Object>();
+ heap->WriteBarrierArray(copy.get(), 0, array->GetLength());
+ }
+ } else {
+ for (const Class* klass = c; klass != NULL; klass = klass->GetSuperClass()) {
+ size_t num_reference_fields = klass->NumReferenceInstanceFields();
+ for (size_t i = 0; i < num_reference_fields; ++i) {
+ Field* field = klass->GetInstanceField(i);
+ MemberOffset field_offset = field->GetOffset();
+ const Object* ref = copy->GetFieldObject<const Object*>(field_offset, false);
+ heap->WriteBarrierField(copy.get(), field_offset, ref);
+ }
+ }
+ }
+
+ if (c->IsFinalizable()) {
+ heap->AddFinalizerReference(Thread::Current(), copy.get());
+ }
+
+ return copy.get();
+}
+
+uint32_t Object::GetThinLockId() {
+ return Monitor::GetThinLockId(monitor_);
+}
+
+void Object::MonitorEnter(Thread* thread) {
+ Monitor::MonitorEnter(thread, this);
+}
+
+bool Object::MonitorExit(Thread* thread) {
+ return Monitor::MonitorExit(thread, this);
+}
+
+void Object::Notify() {
+ Monitor::Notify(Thread::Current(), this);
+}
+
+void Object::NotifyAll() {
+ Monitor::NotifyAll(Thread::Current(), this);
+}
+
+void Object::Wait() {
+ Monitor::Wait(Thread::Current(), this, 0, 0, true, kWaiting);
+}
+
+void Object::Wait(int64_t ms, int32_t ns) {
+ Monitor::Wait(Thread::Current(), this, ms, ns, true, kTimedWaiting);
+}
+
+#if VERIFY_OBJECT_ENABLED
+void Object::CheckFieldAssignment(MemberOffset field_offset, const Object* new_value) {
+ const Class* c = GetClass();
+ if (Runtime::Current()->GetClassLinker() == NULL ||
+ !Runtime::Current()->GetHeap()->IsObjectValidationEnabled() ||
+ !c->IsResolved()) {
+ return;
+ }
+ for (const Class* cur = c; cur != NULL; cur = cur->GetSuperClass()) {
+ ObjectArray<Field>* fields = cur->GetIFields();
+ if (fields != NULL) {
+ size_t num_ref_ifields = cur->NumReferenceInstanceFields();
+ for (size_t i = 0; i < num_ref_ifields; ++i) {
+ Field* field = fields->Get(i);
+ if (field->GetOffset().Int32Value() == field_offset.Int32Value()) {
+ FieldHelper fh(field);
+ CHECK(fh.GetType()->IsAssignableFrom(new_value->GetClass()));
+ return;
+ }
+ }
+ }
+ }
+ if (c->IsArrayClass()) {
+ // Bounds and assign-ability done in the array setter.
+ return;
+ }
+ if (IsClass()) {
+ ObjectArray<Field>* fields = AsClass()->GetSFields();
+ if (fields != NULL) {
+ size_t num_ref_sfields = AsClass()->NumReferenceStaticFields();
+ for (size_t i = 0; i < num_ref_sfields; ++i) {
+ Field* field = fields->Get(i);
+ if (field->GetOffset().Int32Value() == field_offset.Int32Value()) {
+ FieldHelper fh(field);
+ CHECK(fh.GetType()->IsAssignableFrom(new_value->GetClass()));
+ return;
+ }
+ }
+ }
+ }
+ LOG(FATAL) << "Failed to find field for assignment to " << reinterpret_cast<void*>(this)
+ << " of type " << PrettyDescriptor(c) << " at offset " << field_offset;
+}
+#endif
+
+} // namespace mirror
+} // namespace art
diff --git a/src/mirror/object.h b/src/mirror/object.h
new file mode 100644
index 0000000..e2cedd8
--- /dev/null
+++ b/src/mirror/object.h
@@ -0,0 +1,261 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_OBJECT_H_
+#define ART_SRC_MIRROR_OBJECT_H_
+
+#include "base/casts.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "cutils/atomic-inline.h"
+#include "offsets.h"
+
+namespace art {
+
+class ImageWriter;
+struct ObjectOffsets;
+class Thread;
+
+namespace mirror {
+
+class AbstractMethod;
+class Array;
+class Class;
+class Field;
+template<class T> class ObjectArray;
+template<class T> class PrimitiveArray;
+typedef PrimitiveArray<uint8_t> BooleanArray;
+typedef PrimitiveArray<int8_t> ByteArray;
+typedef PrimitiveArray<uint16_t> CharArray;
+typedef PrimitiveArray<double> DoubleArray;
+typedef PrimitiveArray<float> FloatArray;
+typedef PrimitiveArray<int32_t> IntArray;
+typedef PrimitiveArray<int64_t> LongArray;
+typedef PrimitiveArray<int16_t> ShortArray;
+class String;
+class Throwable;
+
+// Classes shared with the managed side of the world need to be packed so that they don't have
+// extra platform specific padding.
+#define MANAGED PACKED(4)
+
+// Fields within mirror objects aren't accessed directly so that the appropriate amount of
+// handshaking is done with GC (for example, read and write barriers). This macro is used to
+// compute an offset for the Set/Get methods defined in Object that can safely access fields.
+#define OFFSET_OF_OBJECT_MEMBER(type, field) \
+ MemberOffset(OFFSETOF_MEMBER(type, field))
+
+// C++ mirror of java.lang.Object
+class MANAGED Object {
+ public:
+ static MemberOffset ClassOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(Object, klass_);
+ }
+
+ Class* GetClass() const;
+
+ void SetClass(Class* new_klass);
+
+ bool InstanceOf(const Class* klass) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ size_t SizeOf() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ Object* Clone(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ int32_t IdentityHashCode() const {
+ #ifdef MOVING_GARBAGE_COLLECTOR
+ // TODO: we'll need to use the Object's internal concept of identity
+ UNIMPLEMENTED(FATAL);
+ #endif
+ return reinterpret_cast<int32_t>(this);
+ }
+
+ static MemberOffset MonitorOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(Object, monitor_);
+ }
+
+ volatile int32_t* GetRawLockWordAddress() {
+ byte* raw_addr = reinterpret_cast<byte*>(this) +
+ OFFSET_OF_OBJECT_MEMBER(Object, monitor_).Int32Value();
+ int32_t* word_addr = reinterpret_cast<int32_t*>(raw_addr);
+ return const_cast<volatile int32_t*>(word_addr);
+ }
+
+ uint32_t GetThinLockId();
+
+ void MonitorEnter(Thread* thread) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
+ EXCLUSIVE_LOCK_FUNCTION(monitor_lock_);
+
+ bool MonitorExit(Thread* thread) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
+ UNLOCK_FUNCTION(monitor_lock_);
+
+ void Notify() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ void NotifyAll() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ void Wait() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ void Wait(int64_t timeout) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ void Wait(int64_t timeout, int32_t nanos) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ bool IsClass() const;
+
+ Class* AsClass();
+
+ const Class* AsClass() const;
+
+ bool IsObjectArray() const;
+
+ template<class T>
+ ObjectArray<T>* AsObjectArray();
+
+ template<class T>
+ const ObjectArray<T>* AsObjectArray() const;
+
+ bool IsArrayInstance() const;
+
+ Array* AsArray();
+
+ const Array* AsArray() const;
+
+ BooleanArray* AsBooleanArray();
+ ByteArray* AsByteArray();
+ CharArray* AsCharArray();
+ ShortArray* AsShortArray();
+ IntArray* AsIntArray();
+ LongArray* AsLongArray();
+
+ String* AsString();
+
+ Throwable* AsThrowable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ bool IsMethod() const;
+
+ AbstractMethod* AsMethod();
+
+ const AbstractMethod* AsMethod() const;
+
+ bool IsField() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ Field* AsField() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ const Field* AsField() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ bool IsReferenceInstance() const;
+
+ bool IsWeakReferenceInstance() const;
+
+ bool IsSoftReferenceInstance() const;
+
+ bool IsFinalizerReferenceInstance() const;
+
+ bool IsPhantomReferenceInstance() const;
+
+ // Accessors for Java type fields
+ template<class T>
+ T GetFieldObject(MemberOffset field_offset, bool is_volatile) const {
+ T result = reinterpret_cast<T>(GetField32(field_offset, is_volatile));
+ VerifyObject(result);
+ return result;
+ }
+
+ void SetFieldObject(MemberOffset field_offset, const Object* new_value, bool is_volatile,
+ bool this_is_valid = true) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ VerifyObject(new_value);
+ SetField32(field_offset, reinterpret_cast<uint32_t>(new_value), is_volatile, this_is_valid);
+ if (new_value != NULL) {
+ CheckFieldAssignment(field_offset, new_value);
+ WriteBarrierField(this, field_offset, new_value);
+ }
+ }
+
+ uint32_t GetField32(MemberOffset field_offset, bool is_volatile) const {
+ VerifyObject(this);
+ const byte* raw_addr = reinterpret_cast<const byte*>(this) + field_offset.Int32Value();
+ const int32_t* word_addr = reinterpret_cast<const int32_t*>(raw_addr);
+ if (UNLIKELY(is_volatile)) {
+ return android_atomic_acquire_load(word_addr);
+ } else {
+ return *word_addr;
+ }
+ }
+
+ void SetField32(MemberOffset field_offset, uint32_t new_value, bool is_volatile,
+ bool this_is_valid = true) {
+ if (this_is_valid) {
+ VerifyObject(this);
+ }
+ byte* raw_addr = reinterpret_cast<byte*>(this) + field_offset.Int32Value();
+ uint32_t* word_addr = reinterpret_cast<uint32_t*>(raw_addr);
+ if (UNLIKELY(is_volatile)) {
+ /*
+ * TODO: add an android_atomic_synchronization_store() function and
+ * use it in the 32-bit volatile set handlers. On some platforms we
+ * can use a fast atomic instruction and avoid the barriers.
+ */
+ ANDROID_MEMBAR_STORE();
+ *word_addr = new_value;
+ ANDROID_MEMBAR_FULL();
+ } else {
+ *word_addr = new_value;
+ }
+ }
+
+ uint64_t GetField64(MemberOffset field_offset, bool is_volatile) const;
+
+ void SetField64(MemberOffset field_offset, uint64_t new_value, bool is_volatile);
+
+ protected:
+ // Accessors for non-Java type fields
+ template<class T>
+ T GetFieldPtr(MemberOffset field_offset, bool is_volatile) const {
+ return reinterpret_cast<T>(GetField32(field_offset, is_volatile));
+ }
+
+ template<typename T>
+ void SetFieldPtr(MemberOffset field_offset, T new_value, bool is_volatile, bool this_is_valid = true) {
+ SetField32(field_offset, reinterpret_cast<uint32_t>(new_value), is_volatile, this_is_valid);
+ }
+
+ private:
+#if VERIFY_OBJECT_ENABLED
+ static void VerifyObject(const Object* obj);
+ void CheckFieldAssignment(MemberOffset field_offset, const Object* new_value)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+#else
+ static void VerifyObject(const Object*) {}
+ void CheckFieldAssignment(MemberOffset, const Object*)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {}
+#endif
+
+ // Write barrier called post update to a reference bearing field.
+ static void WriteBarrierField(const Object* dst, MemberOffset offset, const Object* new_value);
+
+ Class* klass_;
+
+ uint32_t monitor_;
+
+ friend class art::ImageWriter;
+ friend struct art::ObjectOffsets; // for verifying offset information
+ DISALLOW_IMPLICIT_CONSTRUCTORS(Object);
+};
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_OBJECT_H_
diff --git a/src/mirror/object_array-inl.h b/src/mirror/object_array-inl.h
new file mode 100644
index 0000000..d981428
--- /dev/null
+++ b/src/mirror/object_array-inl.h
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_OBJECT_ARRAY_INL_H_
+#define ART_SRC_MIRROR_OBJECT_ARRAY_INL_H_
+
+#include "object_array.h"
+
+#include "heap.h"
+#include "mirror/class.h"
+#include "mirror/field.h"
+#include "runtime.h"
+
+namespace art {
+namespace mirror {
+
+template<class T>
+inline ObjectArray<T>* ObjectArray<T>::Alloc(Thread* self, Class* object_array_class, int32_t length) {
+ Array* array = Array::Alloc(self, object_array_class, length, sizeof(Object*));
+ if (UNLIKELY(array == NULL)) {
+ return NULL;
+ } else {
+ return array->AsObjectArray<T>();
+ }
+}
+
+template<class T>
+inline T* ObjectArray<T>::Get(int32_t i) const {
+ if (UNLIKELY(!IsValidIndex(i))) {
+ return NULL;
+ }
+ MemberOffset data_offset(DataOffset(sizeof(Object*)).Int32Value() + i * sizeof(Object*));
+ return GetFieldObject<T*>(data_offset, false);
+}
+
+template<class T>
+inline void ObjectArray<T>::Set(int32_t i, T* object) {
+ if (LIKELY(IsValidIndex(i))) {
+ if (object != NULL) {
+ Class* element_class = GetClass()->GetComponentType();
+ if (UNLIKELY(!object->InstanceOf(element_class))) {
+ ThrowArrayStoreException(object);
+ return;
+ }
+ }
+ MemberOffset data_offset(DataOffset(sizeof(Object*)).Int32Value() + i * sizeof(Object*));
+ SetFieldObject(data_offset, object, false);
+ }
+}
+
+template<class T>
+inline void ObjectArray<T>::SetWithoutChecks(int32_t i, T* object) {
+ DCHECK(IsValidIndex(i));
+ MemberOffset data_offset(DataOffset(sizeof(Object*)).Int32Value() + i * sizeof(Object*));
+ SetFieldObject(data_offset, object, false);
+}
+
+template<class T>
+inline void ObjectArray<T>::SetPtrWithoutChecks(int32_t i, T* object) {
+ DCHECK(IsValidIndex(i));
+ MemberOffset data_offset(DataOffset(sizeof(Object*)).Int32Value() + i * sizeof(Object*));
+ SetFieldPtr(data_offset, object, false);
+}
+
+template<class T>
+inline T* ObjectArray<T>::GetWithoutChecks(int32_t i) const {
+ DCHECK(IsValidIndex(i));
+ MemberOffset data_offset(DataOffset(sizeof(Object*)).Int32Value() + i * sizeof(Object*));
+ return GetFieldObject<T*>(data_offset, false);
+}
+
+template<class T>
+inline void ObjectArray<T>::Copy(const ObjectArray<T>* src, int src_pos,
+ ObjectArray<T>* dst, int dst_pos,
+ size_t length) {
+ if (src->IsValidIndex(src_pos) &&
+ src->IsValidIndex(src_pos+length-1) &&
+ dst->IsValidIndex(dst_pos) &&
+ dst->IsValidIndex(dst_pos+length-1)) {
+ MemberOffset src_offset(DataOffset(sizeof(Object*)).Int32Value() + src_pos * sizeof(Object*));
+ MemberOffset dst_offset(DataOffset(sizeof(Object*)).Int32Value() + dst_pos * sizeof(Object*));
+ Class* array_class = dst->GetClass();
+ Heap* heap = Runtime::Current()->GetHeap();
+ if (array_class == src->GetClass()) {
+ // No need for array store checks if arrays are of the same type
+ for (size_t i = 0; i < length; i++) {
+ Object* object = src->GetFieldObject<Object*>(src_offset, false);
+ heap->VerifyObject(object);
+ // directly set field, we do a bulk write barrier at the end
+ dst->SetField32(dst_offset, reinterpret_cast<uint32_t>(object), false, true);
+ src_offset = MemberOffset(src_offset.Uint32Value() + sizeof(Object*));
+ dst_offset = MemberOffset(dst_offset.Uint32Value() + sizeof(Object*));
+ }
+ } else {
+ Class* element_class = array_class->GetComponentType();
+ CHECK(!element_class->IsPrimitive());
+ for (size_t i = 0; i < length; i++) {
+ Object* object = src->GetFieldObject<Object*>(src_offset, false);
+ if (object != NULL && !object->InstanceOf(element_class)) {
+ dst->ThrowArrayStoreException(object);
+ return;
+ }
+ heap->VerifyObject(object);
+ // directly set field, we do a bulk write barrier at the end
+ dst->SetField32(dst_offset, reinterpret_cast<uint32_t>(object), false, true);
+ src_offset = MemberOffset(src_offset.Uint32Value() + sizeof(Object*));
+ dst_offset = MemberOffset(dst_offset.Uint32Value() + sizeof(Object*));
+ }
+ }
+ heap->WriteBarrierArray(dst, dst_pos, length);
+ }
+}
+
+template<class T>
+inline ObjectArray<T>* ObjectArray<T>::CopyOf(Thread* self, int32_t new_length) {
+ ObjectArray<T>* new_array = Alloc(self, GetClass(), new_length);
+ Copy(this, 0, new_array, 0, std::min(GetLength(), new_length));
+ return new_array;
+}
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_OBJET_ARRAY_INL_H_
diff --git a/src/mirror/object_array.h b/src/mirror/object_array.h
new file mode 100644
index 0000000..3d04b39
--- /dev/null
+++ b/src/mirror/object_array.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_OBJECT_ARRAY_H_
+#define ART_SRC_MIRROR_OBJECT_ARRAY_H_
+
+#include "array.h"
+
+namespace art {
+namespace mirror {
+
+template<class T>
+class MANAGED ObjectArray : public Array {
+ public:
+ static ObjectArray<T>* Alloc(Thread* self, Class* object_array_class, int32_t length)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ T* Get(int32_t i) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ void Set(int32_t i, T* object) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Set element without bound and element type checks, to be used in limited
+ // circumstances, such as during boot image writing
+ void SetWithoutChecks(int32_t i, T* object) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Set element without bound and element type checks, to be used in limited circumstances, such
+ // as during boot image writing. Does not do write barrier.
+ void SetPtrWithoutChecks(int32_t i, T* object) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ T* GetWithoutChecks(int32_t i) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static void Copy(const ObjectArray<T>* src, int src_pos,
+ ObjectArray<T>* dst, int dst_pos,
+ size_t length)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ ObjectArray<T>* CopyOf(Thread* self, int32_t new_length)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ private:
+ DISALLOW_IMPLICIT_CONSTRUCTORS(ObjectArray);
+};
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_OBJECT_ARRAY_H_
diff --git a/src/object_test.cc b/src/mirror/object_test.cc
similarity index 98%
rename from src/object_test.cc
rename to src/mirror/object_test.cc
index f3b6a19..29cf2f1 100644
--- a/src/object_test.cc
+++ b/src/mirror/object_test.cc
@@ -19,16 +19,26 @@
#include <stdint.h>
#include <stdio.h>
+#include "array-inl.h"
#include "asm_support.h"
+#include "class-inl.h"
#include "class_linker.h"
+#include "class_linker-inl.h"
#include "common_test.h"
#include "dex_file.h"
+#include "field-inl.h"
+#include "gc/card_table-inl.h"
#include "heap.h"
+#include "iftable-inl.h"
+#include "abstract_method-inl.h"
+#include "object-inl.h"
+#include "object_array-inl.h"
#include "runtime_support.h"
#include "sirt_ref.h"
#include "UniquePtr.h"
namespace art {
+namespace mirror {
class ObjectTest : public CommonTest {
protected:
@@ -626,4 +636,5 @@
// TODO: test that interfaces trump superclasses.
}
+} // namespace mirror
} // namespace art
diff --git a/src/mirror/proxy.h b/src/mirror/proxy.h
new file mode 100644
index 0000000..cac028a
--- /dev/null
+++ b/src/mirror/proxy.h
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_PROXY_H_
+#define ART_SRC_MIRROR_PROXY_H_
+
+#include "mirror/object.h"
+
+namespace art {
+
+struct ProxyOffsets;
+
+namespace mirror {
+
+class MANAGED SynthesizedProxyClass : public Class {
+ public:
+ ObjectArray<Class>* GetInterfaces() {
+ return interfaces_;
+ }
+
+ ObjectArray<ObjectArray<Class> >* GetThrows() {
+ return throws_;
+ }
+
+ private:
+ ObjectArray<Class>* interfaces_;
+ ObjectArray<ObjectArray<Class> >* throws_;
+ DISALLOW_IMPLICIT_CONSTRUCTORS(SynthesizedProxyClass);
+};
+
+class MANAGED Proxy : public Object {
+ private:
+ Object* h_;
+
+ friend struct art::ProxyOffsets; // for verifying offset information
+ DISALLOW_IMPLICIT_CONSTRUCTORS(Proxy);
+};
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_PROXY_H_
diff --git a/src/mirror/stack_trace_element.cc b/src/mirror/stack_trace_element.cc
new file mode 100644
index 0000000..9d557ec
--- /dev/null
+++ b/src/mirror/stack_trace_element.cc
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+#include "stack_trace_element.h"
+
+#include "class.h"
+#include "gc/card_table-inl.h"
+#include "object-inl.h"
+#include "string.h"
+
+namespace art {
+namespace mirror {
+
+Class* StackTraceElement::java_lang_StackTraceElement_ = NULL;
+
+void StackTraceElement::SetClass(Class* java_lang_StackTraceElement) {
+ CHECK(java_lang_StackTraceElement_ == NULL);
+ CHECK(java_lang_StackTraceElement != NULL);
+ java_lang_StackTraceElement_ = java_lang_StackTraceElement;
+}
+
+void StackTraceElement::ResetClass() {
+ CHECK(java_lang_StackTraceElement_ != NULL);
+ java_lang_StackTraceElement_ = NULL;
+}
+
+StackTraceElement* StackTraceElement::Alloc(Thread* self,
+ String* declaring_class,
+ String* method_name,
+ String* file_name,
+ int32_t line_number) {
+ StackTraceElement* trace =
+ down_cast<StackTraceElement*>(GetStackTraceElement()->AllocObject(self));
+ trace->SetFieldObject(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, declaring_class_),
+ const_cast<String*>(declaring_class), false);
+ trace->SetFieldObject(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, method_name_),
+ const_cast<String*>(method_name), false);
+ trace->SetFieldObject(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, file_name_),
+ const_cast<String*>(file_name), false);
+ trace->SetField32(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, line_number_),
+ line_number, false);
+ return trace;
+}
+
+} // namespace mirror
+} // namespace art
diff --git a/src/mirror/stack_trace_element.h b/src/mirror/stack_trace_element.h
new file mode 100644
index 0000000..d53c860
--- /dev/null
+++ b/src/mirror/stack_trace_element.h
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_STACK_TRACE_ELEMENT_H_
+#define ART_SRC_MIRROR_STACK_TRACE_ELEMENT_H_
+
+#include "object.h"
+
+namespace art {
+
+struct StackTraceElementOffsets;
+
+namespace mirror {
+
+// C++ mirror of java.lang.StackTraceElement
+class MANAGED StackTraceElement : public Object {
+ public:
+ const String* GetDeclaringClass() const {
+ return GetFieldObject<const String*>(
+ OFFSET_OF_OBJECT_MEMBER(StackTraceElement, declaring_class_), false);
+ }
+
+ const String* GetMethodName() const {
+ return GetFieldObject<const String*>(
+ OFFSET_OF_OBJECT_MEMBER(StackTraceElement, method_name_), false);
+ }
+
+ const String* GetFileName() const {
+ return GetFieldObject<const String*>(
+ OFFSET_OF_OBJECT_MEMBER(StackTraceElement, file_name_), false);
+ }
+
+ int32_t GetLineNumber() const {
+ return GetField32(
+ OFFSET_OF_OBJECT_MEMBER(StackTraceElement, line_number_), false);
+ }
+
+ static StackTraceElement* Alloc(Thread* self,
+ String* declaring_class,
+ String* method_name,
+ String* file_name,
+ int32_t line_number)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static void SetClass(Class* java_lang_StackTraceElement);
+
+ static void ResetClass();
+
+ private:
+ // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
+ String* declaring_class_;
+ String* file_name_;
+ String* method_name_;
+ int32_t line_number_;
+
+ static Class* GetStackTraceElement() {
+ DCHECK(java_lang_StackTraceElement_ != NULL);
+ return java_lang_StackTraceElement_;
+ }
+
+ static Class* java_lang_StackTraceElement_;
+
+ friend struct art::StackTraceElementOffsets; // for verifying offset information
+ DISALLOW_IMPLICIT_CONSTRUCTORS(StackTraceElement);
+};
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_STACK_TRACE_ELEMENT_H_
diff --git a/src/mirror/string.cc b/src/mirror/string.cc
new file mode 100644
index 0000000..f571fb8
--- /dev/null
+++ b/src/mirror/string.cc
@@ -0,0 +1,289 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+#include "string.h"
+
+#include "array.h"
+#include "gc/card_table-inl.h"
+#include "intern_table.h"
+#include "object-inl.h"
+#include "runtime.h"
+#include "sirt_ref.h"
+#include "thread.h"
+#include "utf.h"
+
+namespace art {
+namespace mirror {
+
+const CharArray* String::GetCharArray() const {
+ return GetFieldObject<const CharArray*>(ValueOffset(), false);
+}
+
+void String::ComputeHashCode() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ SetHashCode(ComputeUtf16Hash(GetCharArray(), GetOffset(), GetLength()));
+}
+
+int32_t String::GetUtfLength() const {
+ return CountUtf8Bytes(GetCharArray()->GetData() + GetOffset(), GetLength());
+}
+
+int32_t String::FastIndexOf(int32_t ch, int32_t start) const {
+ int32_t count = GetLength();
+ if (start < 0) {
+ start = 0;
+ } else if (start > count) {
+ start = count;
+ }
+ const uint16_t* chars = GetCharArray()->GetData() + GetOffset();
+ const uint16_t* p = chars + start;
+ const uint16_t* end = chars + count;
+ while (p < end) {
+ if (*p++ == ch) {
+ return (p - 1) - chars;
+ }
+ }
+ return -1;
+}
+
+void String::SetArray(CharArray* new_array) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ DCHECK(new_array != NULL);
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(String, array_), new_array, false);
+}
+
+// TODO: get global references for these
+Class* String::java_lang_String_ = NULL;
+
+void String::SetClass(Class* java_lang_String) {
+ CHECK(java_lang_String_ == NULL);
+ CHECK(java_lang_String != NULL);
+ java_lang_String_ = java_lang_String;
+}
+
+void String::ResetClass() {
+ CHECK(java_lang_String_ != NULL);
+ java_lang_String_ = NULL;
+}
+
+String* String::Intern() {
+ return Runtime::Current()->GetInternTable()->InternWeak(this);
+}
+
+int32_t String::GetHashCode() {
+ int32_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(String, hash_code_), false);
+ if (result == 0) {
+ ComputeHashCode();
+ }
+ result = GetField32(OFFSET_OF_OBJECT_MEMBER(String, hash_code_), false);
+ DCHECK(result != 0 || ComputeUtf16Hash(GetCharArray(), GetOffset(), GetLength()) == 0)
+ << ToModifiedUtf8() << " " << result;
+ return result;
+}
+
+int32_t String::GetLength() const {
+ int32_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(String, count_), false);
+ DCHECK(result >= 0 && result <= GetCharArray()->GetLength());
+ return result;
+}
+
+uint16_t String::CharAt(int32_t index) const {
+ // TODO: do we need this? Equals is the only caller, and could
+ // bounds check itself.
+ if (index < 0 || index >= count_) {
+ Thread* self = Thread::Current();
+ self->ThrowNewExceptionF("Ljava/lang/StringIndexOutOfBoundsException;",
+ "length=%i; index=%i", count_, index);
+ return 0;
+ }
+ return GetCharArray()->Get(index + GetOffset());
+}
+
+String* String::AllocFromUtf16(Thread* self,
+ int32_t utf16_length,
+ const uint16_t* utf16_data_in,
+ int32_t hash_code) {
+ CHECK(utf16_data_in != NULL || utf16_length == 0);
+ String* string = Alloc(self, GetJavaLangString(), utf16_length);
+ if (string == NULL) {
+ return NULL;
+ }
+ // TODO: use 16-bit wide memset variant
+ CharArray* array = const_cast<CharArray*>(string->GetCharArray());
+ if (array == NULL) {
+ return NULL;
+ }
+ for (int i = 0; i < utf16_length; i++) {
+ array->Set(i, utf16_data_in[i]);
+ }
+ if (hash_code != 0) {
+ string->SetHashCode(hash_code);
+ } else {
+ string->ComputeHashCode();
+ }
+ return string;
+}
+
+ String* String::AllocFromModifiedUtf8(Thread* self, const char* utf) {
+ if (utf == NULL) {
+ return NULL;
+ }
+ size_t char_count = CountModifiedUtf8Chars(utf);
+ return AllocFromModifiedUtf8(self, char_count, utf);
+}
+
+String* String::AllocFromModifiedUtf8(Thread* self, int32_t utf16_length,
+ const char* utf8_data_in) {
+ String* string = Alloc(self, GetJavaLangString(), utf16_length);
+ if (string == NULL) {
+ return NULL;
+ }
+ uint16_t* utf16_data_out =
+ const_cast<uint16_t*>(string->GetCharArray()->GetData());
+ ConvertModifiedUtf8ToUtf16(utf16_data_out, utf8_data_in);
+ string->ComputeHashCode();
+ return string;
+}
+
+String* String::Alloc(Thread* self, Class* java_lang_String, int32_t utf16_length) {
+ SirtRef<CharArray> array(self, CharArray::Alloc(self, utf16_length));
+ if (array.get() == NULL) {
+ return NULL;
+ }
+ return Alloc(self, java_lang_String, array.get());
+}
+
+String* String::Alloc(Thread* self, Class* java_lang_String, CharArray* array) {
+ // Hold reference in case AllocObject causes GC.
+ SirtRef<CharArray> array_ref(self, array);
+ String* string = down_cast<String*>(java_lang_String->AllocObject(self));
+ if (string == NULL) {
+ return NULL;
+ }
+ string->SetArray(array);
+ string->SetCount(array->GetLength());
+ return string;
+}
+
+bool String::Equals(const String* that) const {
+ if (this == that) {
+ // Quick reference equality test
+ return true;
+ } else if (that == NULL) {
+ // Null isn't an instanceof anything
+ return false;
+ } else if (this->GetLength() != that->GetLength()) {
+ // Quick length inequality test
+ return false;
+ } else {
+ // Note: don't short circuit on hash code as we're presumably here as the
+ // hash code was already equal
+ for (int32_t i = 0; i < that->GetLength(); ++i) {
+ if (this->CharAt(i) != that->CharAt(i)) {
+ return false;
+ }
+ }
+ return true;
+ }
+}
+
+bool String::Equals(const uint16_t* that_chars, int32_t that_offset, int32_t that_length) const {
+ if (this->GetLength() != that_length) {
+ return false;
+ } else {
+ for (int32_t i = 0; i < that_length; ++i) {
+ if (this->CharAt(i) != that_chars[that_offset + i]) {
+ return false;
+ }
+ }
+ return true;
+ }
+}
+
+bool String::Equals(const char* modified_utf8) const {
+ for (int32_t i = 0; i < GetLength(); ++i) {
+ uint16_t ch = GetUtf16FromUtf8(&modified_utf8);
+ if (ch == '\0' || ch != CharAt(i)) {
+ return false;
+ }
+ }
+ return *modified_utf8 == '\0';
+}
+
+bool String::Equals(const StringPiece& modified_utf8) const {
+ if (modified_utf8.size() != GetLength()) {
+ return false;
+ }
+ const char* p = modified_utf8.data();
+ for (int32_t i = 0; i < GetLength(); ++i) {
+ uint16_t ch = GetUtf16FromUtf8(&p);
+ if (ch != CharAt(i)) {
+ return false;
+ }
+ }
+ return true;
+}
+
+// Create a modified UTF-8 encoded std::string from a java/lang/String object.
+std::string String::ToModifiedUtf8() const {
+ const uint16_t* chars = GetCharArray()->GetData() + GetOffset();
+ size_t byte_count = GetUtfLength();
+ std::string result(byte_count, static_cast<char>(0));
+ ConvertUtf16ToModifiedUtf8(&result[0], chars, GetLength());
+ return result;
+}
+
+#ifdef HAVE__MEMCMP16
+// "count" is in 16-bit units.
+extern "C" uint32_t __memcmp16(const uint16_t* s0, const uint16_t* s1, size_t count);
+#define MemCmp16 __memcmp16
+#else
+static uint32_t MemCmp16(const uint16_t* s0, const uint16_t* s1, size_t count) {
+ for (size_t i = 0; i < count; i++) {
+ if (s0[i] != s1[i]) {
+ return static_cast<int32_t>(s0[i]) - static_cast<int32_t>(s1[i]);
+ }
+ }
+ return 0;
+}
+#endif
+
+int32_t String::CompareTo(String* rhs) const {
+ // Quick test for comparison of a string with itself.
+ const String* lhs = this;
+ if (lhs == rhs) {
+ return 0;
+ }
+ // TODO: is this still true?
+ // The annoying part here is that 0x00e9 - 0xffff != 0x00ea,
+ // because the interpreter converts the characters to 32-bit integers
+ // *without* sign extension before it subtracts them (which makes some
+ // sense since "char" is unsigned). So what we get is the result of
+ // 0x000000e9 - 0x0000ffff, which is 0xffff00ea.
+ int lhsCount = lhs->GetLength();
+ int rhsCount = rhs->GetLength();
+ int countDiff = lhsCount - rhsCount;
+ int minCount = (countDiff < 0) ? lhsCount : rhsCount;
+ const uint16_t* lhsChars = lhs->GetCharArray()->GetData() + lhs->GetOffset();
+ const uint16_t* rhsChars = rhs->GetCharArray()->GetData() + rhs->GetOffset();
+ int otherRes = MemCmp16(lhsChars, rhsChars, minCount);
+ if (otherRes != 0) {
+ return otherRes;
+ }
+ return countDiff;
+}
+
+} // namespace mirror
+} // namespace art
+
diff --git a/src/mirror/string.h b/src/mirror/string.h
new file mode 100644
index 0000000..ef74fed
--- /dev/null
+++ b/src/mirror/string.h
@@ -0,0 +1,174 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_STRING_H_
+#define ART_SRC_MIRROR_STRING_H_
+
+#include "class.h"
+#include "gtest/gtest.h"
+
+namespace art {
+
+struct StringClassOffsets;
+struct StringOffsets;
+class StringPiece;
+
+namespace mirror {
+
+// C++ mirror of java.lang.String
+class MANAGED String : public Object {
+ public:
+ static MemberOffset CountOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(String, count_);
+ }
+
+ static MemberOffset ValueOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(String, array_);
+ }
+
+ static MemberOffset OffsetOffset() {
+ return OFFSET_OF_OBJECT_MEMBER(String, offset_);
+ }
+
+ const CharArray* GetCharArray() const;
+
+ int32_t GetOffset() const {
+ int32_t result = GetField32(OffsetOffset(), false);
+ DCHECK_LE(0, result);
+ return result;
+ }
+
+ int32_t GetLength() const;
+
+ int32_t GetHashCode() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ void ComputeHashCode() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ int32_t GetUtfLength() const;
+
+ uint16_t CharAt(int32_t index) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ String* Intern() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static String* AllocFromUtf16(Thread* self,
+ int32_t utf16_length,
+ const uint16_t* utf16_data_in,
+ int32_t hash_code = 0)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static String* AllocFromModifiedUtf8(Thread* self, const char* utf)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static String* AllocFromModifiedUtf8(Thread* self, int32_t utf16_length,
+ const char* utf8_data_in)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static String* Alloc(Thread* self, Class* java_lang_String, int32_t utf16_length)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static String* Alloc(Thread* self, Class* java_lang_String, CharArray* array)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ bool Equals(const char* modified_utf8) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // TODO: do we need this overload? give it a more intention-revealing name.
+ bool Equals(const StringPiece& modified_utf8) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ bool Equals(const String* that) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Compare UTF-16 code point values not in a locale-sensitive manner
+ int Compare(int32_t utf16_length, const char* utf8_data_in);
+
+ // TODO: do we need this overload? give it a more intention-revealing name.
+ bool Equals(const uint16_t* that_chars, int32_t that_offset,
+ int32_t that_length) const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Create a modified UTF-8 encoded std::string from a java/lang/String object.
+ std::string ToModifiedUtf8() const;
+
+ int32_t FastIndexOf(int32_t ch, int32_t start) const;
+
+ int32_t CompareTo(String* other) const;
+
+ static Class* GetJavaLangString() {
+ DCHECK(java_lang_String_ != NULL);
+ return java_lang_String_;
+ }
+
+ static void SetClass(Class* java_lang_String);
+ static void ResetClass();
+
+ private:
+ void SetHashCode(int32_t new_hash_code) {
+ DCHECK_EQ(0u,
+ GetField32(OFFSET_OF_OBJECT_MEMBER(String, hash_code_), false));
+ SetField32(OFFSET_OF_OBJECT_MEMBER(String, hash_code_),
+ new_hash_code, false);
+ }
+
+ void SetCount(int32_t new_count) {
+ DCHECK_LE(0, new_count);
+ SetField32(OFFSET_OF_OBJECT_MEMBER(String, count_), new_count, false);
+ }
+
+ void SetOffset(int32_t new_offset) {
+ DCHECK_LE(0, new_offset);
+ DCHECK_GE(GetLength(), new_offset);
+ SetField32(OFFSET_OF_OBJECT_MEMBER(String, offset_), new_offset, false);
+ }
+
+ void SetArray(CharArray* new_array) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
+ CharArray* array_;
+
+ int32_t count_;
+
+ uint32_t hash_code_;
+
+ int32_t offset_;
+
+ static Class* java_lang_String_;
+
+ friend struct art::StringOffsets; // for verifying offset information
+ FRIEND_TEST(ObjectTest, StringLength); // for SetOffset and SetCount
+ DISALLOW_IMPLICIT_CONSTRUCTORS(String);
+};
+
+// TODO: remove? only used in a unit test of itself.
+struct StringHashCode {
+ int32_t operator()(String* string) const {
+ return string->GetHashCode();
+ }
+};
+
+class MANAGED StringClass : public Class {
+ private:
+ CharArray* ASCII_;
+ Object* CASE_INSENSITIVE_ORDER_;
+ uint32_t REPLACEMENT_CHAR_;
+ int64_t serialVersionUID_;
+ friend struct art::StringClassOffsets; // for verifying offset information
+ DISALLOW_IMPLICIT_CONSTRUCTORS(StringClass);
+};
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_STRING_H_
diff --git a/src/mirror/throwable.cc b/src/mirror/throwable.cc
new file mode 100644
index 0000000..bbab1dd
--- /dev/null
+++ b/src/mirror/throwable.cc
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+#include "throwable.h"
+
+#include "abstract_method-inl.h"
+#include "class-inl.h"
+#include "gc/card_table-inl.h"
+#include "object-inl.h"
+#include "object_array.h"
+#include "object_array-inl.h"
+#include "object_utils.h"
+#include "utils.h"
+#include "well_known_classes.h"
+
+namespace art {
+namespace mirror {
+
+Class* Throwable::java_lang_Throwable_ = NULL;
+
+void Throwable::SetCause(Throwable* cause) {
+ CHECK(cause != NULL);
+ CHECK(cause != this);
+ CHECK(GetFieldObject<Throwable*>(OFFSET_OF_OBJECT_MEMBER(Throwable, cause_), false) == NULL);
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Throwable, cause_), cause, false);
+}
+
+bool Throwable::IsCheckedException() const {
+ if (InstanceOf(WellKnownClasses::ToClass(WellKnownClasses::java_lang_Error))) {
+ return false;
+ }
+ return !InstanceOf(WellKnownClasses::ToClass(WellKnownClasses::java_lang_RuntimeException));
+}
+
+std::string Throwable::Dump() const {
+ std::string result(PrettyTypeOf(this));
+ result += ": ";
+ String* msg = GetDetailMessage();
+ if (msg != NULL) {
+ result += msg->ToModifiedUtf8();
+ }
+ result += "\n";
+ Object* stack_state = GetStackState();
+ // check stack state isn't missing or corrupt
+ if (stack_state != NULL && stack_state->IsObjectArray()) {
+ // Decode the internal stack trace into the depth and method trace
+ ObjectArray<Object>* method_trace = down_cast<ObjectArray<Object>*>(stack_state);
+ int32_t depth = method_trace->GetLength() - 1;
+ IntArray* pc_trace = down_cast<IntArray*>(method_trace->Get(depth));
+ MethodHelper mh;
+ for (int32_t i = 0; i < depth; ++i) {
+ AbstractMethod* method = down_cast<AbstractMethod*>(method_trace->Get(i));
+ mh.ChangeMethod(method);
+ 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);
+ }
+ }
+ Throwable* cause = GetFieldObject<Throwable*>(OFFSET_OF_OBJECT_MEMBER(Throwable, cause_), false);
+ if (cause != NULL && cause != this) { // Constructor makes cause == this by default.
+ result += "Caused by: ";
+ result += cause->Dump();
+ }
+ return result;
+}
+
+void Throwable::SetClass(Class* java_lang_Throwable) {
+ CHECK(java_lang_Throwable_ == NULL);
+ CHECK(java_lang_Throwable != NULL);
+ java_lang_Throwable_ = java_lang_Throwable;
+}
+
+void Throwable::ResetClass() {
+ CHECK(java_lang_Throwable_ != NULL);
+ java_lang_Throwable_ = NULL;
+}
+
+} // namespace mirror
+} // namespace art
diff --git a/src/mirror/throwable.h b/src/mirror/throwable.h
new file mode 100644
index 0000000..aafcc07
--- /dev/null
+++ b/src/mirror/throwable.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2011 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_MIRROR_THROWABLE_H_
+#define ART_SRC_MIRROR_THROWABLE_H_
+
+#include "object.h"
+#include "string.h"
+
+namespace art {
+
+struct ThrowableOffsets;
+
+namespace mirror {
+
+// C++ mirror of java.lang.Throwable
+class MANAGED Throwable : public Object {
+ public:
+ void SetDetailMessage(String* new_detail_message) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Throwable, detail_message_), new_detail_message, false);
+ }
+ String* GetDetailMessage() const {
+ return GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(Throwable, detail_message_), false);
+ }
+ std::string Dump() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ // This is a runtime version of initCause, you shouldn't use it if initCause may have been
+ // overridden. Also it asserts rather than throwing exceptions. Currently this is only used
+ // in cases like the verifier where the checks cannot fail and initCause isn't overridden.
+ void SetCause(Throwable* cause) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ bool IsCheckedException() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
+ static Class* GetJavaLangThrowable() {
+ DCHECK(java_lang_Throwable_ != NULL);
+ return java_lang_Throwable_;
+ }
+
+ static void SetClass(Class* java_lang_Throwable);
+ static void ResetClass();
+
+ private:
+ Object* GetStackState() const {
+ return GetFieldObject<Object*>(OFFSET_OF_OBJECT_MEMBER(Throwable, stack_state_), true);
+ }
+
+ // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
+ Throwable* cause_;
+ String* detail_message_;
+ Object* stack_state_; // Note this is Java volatile:
+ Object* stack_trace_;
+ Object* suppressed_exceptions_;
+
+ static Class* java_lang_Throwable_;
+
+ friend struct art::ThrowableOffsets; // for verifying offset information
+ DISALLOW_IMPLICIT_CONSTRUCTORS(Throwable);
+};
+
+} // namespace mirror
+} // namespace art
+
+#endif // ART_SRC_MIRROR_THROWABLE_H_
diff --git a/src/modifiers.h b/src/modifiers.h
index ee2d4ff..78ba140 100644
--- a/src/modifiers.h
+++ b/src/modifiers.h
@@ -17,6 +17,8 @@
#ifndef ART_SRC_MODIFIERS_H_
#define ART_SRC_MODIFIERS_H_
+#include <stdint.h>
+
static const uint32_t kAccPublic = 0x0001; // class, field, method, ic
static const uint32_t kAccPrivate = 0x0002; // field, method, ic
static const uint32_t kAccProtected = 0x0004; // field, method, ic
diff --git a/src/monitor.cc b/src/monitor.cc
index 47c87cb..aa4e5ac 100644
--- a/src/monitor.cc
+++ b/src/monitor.cc
@@ -22,7 +22,9 @@
#include "base/stl_util.h"
#include "class_linker.h"
#include "dex_instruction.h"
-#include "object.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object.h"
+#include "mirror/object_array-inl.h"
#include "object_utils.h"
#include "scoped_thread_state_change.h"
#include "thread.h"
@@ -111,7 +113,7 @@
is_sensitive_thread_hook_ = is_sensitive_thread_hook;
}
-Monitor::Monitor(Thread* owner, Object* obj)
+Monitor::Monitor(Thread* owner, mirror::Object* obj)
: monitor_lock_("a monitor lock", kMonitorLock),
owner_(owner),
lock_count_(0),
@@ -186,7 +188,7 @@
}
}
-Object* Monitor::GetObject() {
+mirror::Object* Monitor::GetObject() {
return obj_;
}
@@ -200,7 +202,7 @@
uint64_t waitStart = 0;
uint64_t waitEnd = 0;
uint32_t wait_threshold = lock_profiling_threshold_;
- const AbstractMethod* current_locking_method = NULL;
+ const mirror::AbstractMethod* current_locking_method = NULL;
uint32_t current_locking_dex_pc = 0;
{
ScopedThreadStateChange tsc(self, kBlocked);
@@ -270,7 +272,7 @@
return oss.str();
}
-void Monitor::FailedUnlock(Object* o, Thread* expected_owner, Thread* found_owner,
+void Monitor::FailedUnlock(mirror::Object* o, Thread* expected_owner, Thread* found_owner,
Monitor* monitor) {
Thread* current_owner = NULL;
std::string current_owner_string;
@@ -426,7 +428,7 @@
int prev_lock_count = lock_count_;
lock_count_ = 0;
owner_ = NULL;
- const AbstractMethod* saved_method = locking_method_;
+ const mirror::AbstractMethod* saved_method = locking_method_;
locking_method_ = NULL;
uintptr_t saved_dex_pc = locking_dex_pc_;
locking_dex_pc_ = 0;
@@ -570,7 +572,7 @@
* Changes the shape of a monitor from thin to fat, preserving the
* internal lock state. The calling thread must own the lock.
*/
-void Monitor::Inflate(Thread* self, Object* obj) {
+void Monitor::Inflate(Thread* self, mirror::Object* obj) {
DCHECK(self != NULL);
DCHECK(obj != NULL);
DCHECK_EQ(LW_SHAPE(*obj->GetRawLockWordAddress()), LW_SHAPE_THIN);
@@ -583,7 +585,7 @@
Runtime::Current()->GetMonitorList()->Add(m);
}
-void Monitor::MonitorEnter(Thread* self, Object* obj) {
+void Monitor::MonitorEnter(Thread* self, mirror::Object* obj) {
volatile int32_t* thinp = obj->GetRawLockWordAddress();
uint32_t sleepDelayNs;
uint32_t minSleepDelayNs = 1000000; /* 1 millisecond */
@@ -686,7 +688,7 @@
}
}
-bool Monitor::MonitorExit(Thread* self, Object* obj) {
+bool Monitor::MonitorExit(Thread* self, mirror::Object* obj) {
volatile int32_t* thinp = obj->GetRawLockWordAddress();
DCHECK(self != NULL);
@@ -748,7 +750,7 @@
/*
* Object.wait(). Also called for class init.
*/
-void Monitor::Wait(Thread* self, Object *obj, int64_t ms, int32_t ns,
+void Monitor::Wait(Thread* self, mirror::Object *obj, int64_t ms, int32_t ns,
bool interruptShouldThrow, ThreadState why) {
volatile int32_t* thinp = obj->GetRawLockWordAddress();
@@ -772,7 +774,7 @@
LW_MONITOR(*thinp)->Wait(self, ms, ns, interruptShouldThrow, why);
}
-void Monitor::Notify(Thread* self, Object *obj) {
+void Monitor::Notify(Thread* self, mirror::Object *obj) {
uint32_t thin = *obj->GetRawLockWordAddress();
// If the lock is still thin, there aren't any waiters;
@@ -791,7 +793,7 @@
}
}
-void Monitor::NotifyAll(Thread* self, Object *obj) {
+void Monitor::NotifyAll(Thread* self, mirror::Object *obj) {
uint32_t thin = *obj->GetRawLockWordAddress();
// If the lock is still thin, there aren't any waiters;
@@ -822,7 +824,7 @@
void Monitor::DescribeWait(std::ostream& os, const Thread* thread) {
ThreadState state = thread->GetState();
- Object* object = NULL;
+ mirror::Object* object = NULL;
uint32_t lock_owner = ThreadList::kInvalidId;
if (state == kWaiting || state == kTimedWaiting || state == kSleeping) {
if (state == kSleeping) {
@@ -860,10 +862,10 @@
os << "\n";
}
-Object* Monitor::GetContendedMonitor(Thread* thread) {
+mirror::Object* Monitor::GetContendedMonitor(Thread* thread) {
// This is used to implement JDWP's ThreadReference.CurrentContendedMonitor, and has a bizarre
// definition of contended that includes a monitor a thread is trying to enter...
- Object* result = thread->monitor_enter_object_;
+ mirror::Object* result = thread->monitor_enter_object_;
if (result != NULL) {
return result;
}
@@ -878,15 +880,16 @@
return NULL;
}
-void Monitor::VisitLocks(StackVisitor* stack_visitor, void (*callback)(Object*, void*), void* callback_context) {
- AbstractMethod* m = stack_visitor->GetMethod();
+void Monitor::VisitLocks(StackVisitor* stack_visitor, void (*callback)(mirror::Object*, void*),
+ void* callback_context) {
+ mirror::AbstractMethod* m = stack_visitor->GetMethod();
CHECK(m != NULL);
// Native methods are an easy special case.
// TODO: use the JNI implementation's table of explicit MonitorEnter calls and dump those too.
if (m->IsNative()) {
if (m->IsSynchronized()) {
- Object* jni_this = stack_visitor->GetCurrentSirt()->GetReference(0);
+ mirror::Object* jni_this = stack_visitor->GetCurrentSirt()->GetReference(0);
callback(jni_this, callback_context);
}
return;
@@ -933,13 +936,13 @@
}
uint16_t monitor_register = ((monitor_enter_instruction >> 8) & 0xff);
- Object* o = reinterpret_cast<Object*>(stack_visitor->GetVReg(m, monitor_register,
- kReferenceVReg));
+ mirror::Object* o = reinterpret_cast<mirror::Object*>(stack_visitor->GetVReg(m, monitor_register,
+ kReferenceVReg));
callback(o, callback_context);
}
}
-void Monitor::TranslateLocation(const AbstractMethod* method, uint32_t dex_pc,
+void Monitor::TranslateLocation(const mirror::AbstractMethod* method, uint32_t dex_pc,
const char*& source_file, uint32_t& line_number) const {
// If method is null, location is unknown
if (method == NULL) {
@@ -968,7 +971,7 @@
list_.push_front(m);
}
-void MonitorList::SweepMonitorList(Heap::IsMarkedTester is_marked, void* arg) {
+void MonitorList::SweepMonitorList(IsMarkedTester is_marked, void* arg) {
MutexLock mu(Thread::Current(), monitor_list_lock_);
typedef std::list<Monitor*>::iterator It; // TODO: C++0x auto
It it = list_.begin();
@@ -984,7 +987,7 @@
}
}
-MonitorInfo::MonitorInfo(Object* o) : owner(NULL), entry_count(0) {
+MonitorInfo::MonitorInfo(mirror::Object* o) : owner(NULL), entry_count(0) {
uint32_t lock_word = *o->GetRawLockWordAddress();
if (LW_SHAPE(lock_word) == LW_SHAPE_THIN) {
uint32_t owner_thin_lock_id = LW_LOCK_OWNER(lock_word);
diff --git a/src/monitor.h b/src/monitor.h
index 1b5ab76..9194c08 100644
--- a/src/monitor.h
+++ b/src/monitor.h
@@ -25,8 +25,8 @@
#include <vector>
#include "base/mutex.h"
-#include "heap.h"
-#include "thread.h"
+#include "root_visitor.h"
+#include "thread_state.h"
namespace art {
@@ -55,8 +55,10 @@
#define LW_LOCK_OWNER_SHIFT 3
#define LW_LOCK_OWNER(x) (((x) >> LW_LOCK_OWNER_SHIFT) & LW_LOCK_OWNER_MASK)
+namespace mirror {
class AbstractMethod;
class Object;
+} // namespace mirror
class Thread;
class StackVisitor;
@@ -70,18 +72,19 @@
static uint32_t GetThinLockId(uint32_t raw_lock_word)
NO_THREAD_SAFETY_ANALYSIS; // Reading lock owner without holding lock is racy.
- static void MonitorEnter(Thread* thread, Object* obj)
+ static void MonitorEnter(Thread* thread, mirror::Object* obj)
EXCLUSIVE_LOCK_FUNCTION(monitor_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- static bool MonitorExit(Thread* thread, Object* obj)
+ static bool MonitorExit(Thread* thread, mirror::Object* obj)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
UNLOCK_FUNCTION(monitor_lock_);
- static void Notify(Thread* self, Object* obj)
+ static void Notify(Thread* self, mirror::Object* obj)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- static void NotifyAll(Thread* self, Object* obj)
+ static void NotifyAll(Thread* self, mirror::Object* obj)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- static void Wait(Thread* self, Object* obj, int64_t ms, int32_t ns, bool interruptShouldThrow, ThreadState why)
+ static void Wait(Thread* self, mirror::Object* obj, int64_t ms, int32_t ns,
+ bool interruptShouldThrow, ThreadState why)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
static void DescribeWait(std::ostream& os, const Thread* thread)
@@ -89,30 +92,31 @@
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Used to implement JDWP's ThreadReference.CurrentContendedMonitor.
- static Object* GetContendedMonitor(Thread* thread);
+ static mirror::Object* GetContendedMonitor(Thread* thread);
// Calls 'callback' once for each lock held in the single stack frame represented by
// the current state of 'stack_visitor'.
- static void VisitLocks(StackVisitor* stack_visitor, void (*callback)(Object*, void*), void* callback_context)
+ static void VisitLocks(StackVisitor* stack_visitor, void (*callback)(mirror::Object*, void*),
+ void* callback_context)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Object* GetObject();
+ mirror::Object* GetObject();
private:
- explicit Monitor(Thread* owner, Object* obj)
+ explicit Monitor(Thread* owner, mirror::Object* obj)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void AppendToWaitSet(Thread* thread) EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_);
void RemoveFromWaitSet(Thread* thread) EXCLUSIVE_LOCKS_REQUIRED(monitor_lock_);
- static void Inflate(Thread* self, Object* obj)
+ static void Inflate(Thread* self, mirror::Object* obj)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void LogContentionEvent(Thread* self, uint32_t wait_ms, uint32_t sample_percent,
const char* owner_filename, uint32_t owner_line_number)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- static void FailedUnlock(Object* obj, Thread* expected_owner, Thread* found_owner, Monitor* mon)
+ static void FailedUnlock(mirror::Object* obj, Thread* expected_owner, Thread* found_owner, Monitor* mon)
LOCKS_EXCLUDED(Locks::thread_list_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -137,7 +141,7 @@
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Translates the provided method and pc into its declaring class' source file and line number.
- void TranslateLocation(const AbstractMethod* method, uint32_t pc,
+ void TranslateLocation(const mirror::AbstractMethod* method, uint32_t pc,
const char*& source_file, uint32_t& line_number) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -153,7 +157,7 @@
int lock_count_ GUARDED_BY(monitor_lock_);
// What object are we part of (for debugging).
- Object* const obj_;
+ mirror::Object* const obj_;
// Threads currently waiting on this monitor.
Thread* wait_set_ GUARDED_BY(monitor_lock_);
@@ -161,12 +165,12 @@
// 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 AbstractMethod* locking_method_ GUARDED_BY(monitor_lock_);
+ const mirror::AbstractMethod* locking_method_ GUARDED_BY(monitor_lock_);
uint32_t locking_dex_pc_ GUARDED_BY(monitor_lock_);
friend class MonitorInfo;
friend class MonitorList;
- friend class Object;
+ friend class mirror::Object;
DISALLOW_COPY_AND_ASSIGN(Monitor);
};
@@ -177,7 +181,7 @@
void Add(Monitor* m);
- void SweepMonitorList(Heap::IsMarkedTester is_marked, void* arg)
+ void SweepMonitorList(IsMarkedTester is_marked, void* arg)
SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_);
private:
@@ -192,7 +196,7 @@
// For use only by the JDWP implementation.
class MonitorInfo {
public:
- MonitorInfo(Object* o) EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_);
+ MonitorInfo(mirror::Object* o) EXCLUSIVE_LOCKS_REQUIRED(Locks::mutator_lock_);
Thread* owner;
size_t entry_count;
diff --git a/src/monitor_android.cc b/src/monitor_android.cc
index 6e22237..d3ac143 100644
--- a/src/monitor_android.cc
+++ b/src/monitor_android.cc
@@ -15,7 +15,6 @@
*/
#include "monitor.h"
-#include "object.h"
#include "thread.h"
#include <fcntl.h>
@@ -79,7 +78,7 @@
// Emit the source code file name, <= 37 bytes.
uintptr_t pc;
- AbstractMethod* m = self->GetCurrentMethod(&pc);
+ mirror::AbstractMethod* m = self->GetCurrentMethod(&pc);
const char* filename;
uint32_t line_number;
TranslateLocation(m, pc, filename, line_number);
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);
}
diff --git a/src/nth_caller_visitor.h b/src/nth_caller_visitor.h
index efed163..7d9feb6 100644
--- a/src/nth_caller_visitor.h
+++ b/src/nth_caller_visitor.h
@@ -17,10 +17,11 @@
#ifndef ART_SRC_NTH_CALLER_VISITOR_H_
#define ART_SRC_NTH_CALLER_VISITOR_H_
-#include "object.h"
-#include "thread.h"
+#include "mirror/abstract_method.h"
+#include "stack.h"
namespace art {
+class Thread;
// Walks up the stack 'n' callers, when used with Thread::WalkStack.
struct NthCallerVisitor : public StackVisitor {
@@ -38,7 +39,7 @@
size_t n;
size_t count;
- AbstractMethod* caller;
+ mirror::AbstractMethod* caller;
};
} // namespace art
diff --git a/src/oat.cc b/src/oat.cc
index 8032a11..b0a9aef 100644
--- a/src/oat.cc
+++ b/src/oat.cc
@@ -15,6 +15,7 @@
*/
#include "oat.h"
+#include "utils.h"
#include <zlib.h>
diff --git a/src/oat/jni/arm/jni_internal_arm.cc b/src/oat/jni/arm/jni_internal_arm.cc
index 36d436f..4af4f52 100644
--- a/src/oat/jni/arm/jni_internal_arm.cc
+++ b/src/oat/jni/arm/jni_internal_arm.cc
@@ -23,9 +23,9 @@
#include "compiler.h"
#include "invoke_arg_array_builder.h"
#include "jni_internal.h"
+#include "mirror/abstract_method.h"
#include "oat/utils/arm/assembler_arm.h"
#include "oat/utils/assembler.h"
-#include "object.h"
namespace art {
namespace arm {
@@ -131,7 +131,7 @@
}
// Load the code pointer we are about to call.
- __ LoadFromOffset(kLoadWord, IP, R0, AbstractMethod::GetCodeOffset().Int32Value());
+ __ LoadFromOffset(kLoadWord, IP, R0, mirror::AbstractMethod::GetCodeOffset().Int32Value());
// Do the call.
__ blx(IP);
diff --git a/src/oat/jni/jni_compiler.cc b/src/oat/jni/jni_compiler.cc
index ac35143..c0298de 100644
--- a/src/oat/jni/jni_compiler.cc
+++ b/src/oat/jni/jni_compiler.cc
@@ -118,7 +118,7 @@
// Check sirt offset is within frame
CHECK_LT(sirt_offset.Uint32Value(), frame_size);
__ LoadRef(main_jni_conv->InterproceduralScratchRegister(),
- mr_conv->MethodRegister(), AbstractMethod::DeclaringClassOffset());
+ mr_conv->MethodRegister(), mirror::AbstractMethod::DeclaringClassOffset());
__ VerifyObject(main_jni_conv->InterproceduralScratchRegister(), false);
__ StoreRef(sirt_offset, main_jni_conv->InterproceduralScratchRegister());
main_jni_conv->Next(); // in SIRT so move to next argument
@@ -269,7 +269,7 @@
}
// 9. Plant call to native code associated with method.
- __ Call(main_jni_conv->MethodStackOffset(), AbstractMethod::NativeMethodOffset(),
+ __ Call(main_jni_conv->MethodStackOffset(), mirror::AbstractMethod::NativeMethodOffset(),
mr_conv->InterproceduralScratchRegister());
// 10. Fix differences in result widths.
diff --git a/src/oat/jni/mips/jni_internal_mips.cc b/src/oat/jni/mips/jni_internal_mips.cc
index 4cfeaa9..69e86c3 100644
--- a/src/oat/jni/mips/jni_internal_mips.cc
+++ b/src/oat/jni/mips/jni_internal_mips.cc
@@ -23,9 +23,9 @@
#include "compiler.h"
#include "invoke_arg_array_builder.h"
#include "jni_internal.h"
+#include "mirror/abstract_method.h"
#include "oat/utils/mips/assembler_mips.h"
#include "oat/utils/assembler.h"
-#include "object.h"
namespace art {
namespace mips {
@@ -128,7 +128,7 @@
}
// Load the code pointer we are about to call.
- __ LoadFromOffset(kLoadWord, T9, A0, AbstractMethod::GetCodeOffset().Int32Value());
+ __ LoadFromOffset(kLoadWord, T9, A0, mirror::AbstractMethod::GetCodeOffset().Int32Value());
// Do the call.
__ Jalr(T9);
diff --git a/src/oat/jni/x86/jni_internal_x86.cc b/src/oat/jni/x86/jni_internal_x86.cc
index 9d41eda..fabd283 100644
--- a/src/oat/jni/x86/jni_internal_x86.cc
+++ b/src/oat/jni/x86/jni_internal_x86.cc
@@ -18,9 +18,9 @@
#include "compiler.h"
#include "invoke_arg_array_builder.h"
#include "jni_internal.h"
+#include "mirror/abstract_method.h"
#include "oat/utils/assembler.h"
#include "oat/utils/x86/assembler_x86.h"
-#include "object.h"
namespace art {
namespace x86 {
@@ -127,7 +127,7 @@
}
}
- __ call(Address(EAX, AbstractMethod::GetCodeOffset())); // Call code off of method
+ __ call(Address(EAX, mirror::AbstractMethod::GetCodeOffset())); // Call code off of method
// Pop arguments up to EBX and the return address.
__ addl(ESP, Immediate(frame_size + pad_size - (2 * kPointerSize)));
diff --git a/src/oat/runtime/argument_visitor.h b/src/oat/runtime/argument_visitor.h
index 06256ca..df7bc12 100644
--- a/src/oat/runtime/argument_visitor.h
+++ b/src/oat/runtime/argument_visitor.h
@@ -46,7 +46,7 @@
#define STACK_ARG_SKIP 0
#endif
- ArgumentVisitor(MethodHelper& caller_mh, AbstractMethod** sp)
+ ArgumentVisitor(MethodHelper& caller_mh, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) :
caller_mh_(caller_mh),
args_in_regs_(ComputeArgsInRegs(caller_mh)),
diff --git a/src/oat/runtime/arm/context_arm.cc b/src/oat/runtime/arm/context_arm.cc
index 5bd4b3d..2e76050 100644
--- a/src/oat/runtime/arm/context_arm.cc
+++ b/src/oat/runtime/arm/context_arm.cc
@@ -16,7 +16,9 @@
#include "context_arm.h"
-#include "object.h"
+#include "mirror/abstract_method.h"
+#include "stack.h"
+#include "thread.h"
namespace art {
namespace arm {
@@ -38,7 +40,7 @@
}
void ArmContext::FillCalleeSaves(const StackVisitor& fr) {
- AbstractMethod* method = fr.GetMethod();
+ mirror::AbstractMethod* method = fr.GetMethod();
uint32_t core_spills = method->GetCoreSpillMask();
uint32_t fp_core_spills = method->GetFpSpillMask();
size_t spill_count = __builtin_popcount(core_spills);
diff --git a/src/oat/runtime/arm/oat_support_entrypoints_arm.cc b/src/oat/runtime/arm/oat_support_entrypoints_arm.cc
index 15218b8..c43b7e2 100644
--- a/src/oat/runtime/arm/oat_support_entrypoints_arm.cc
+++ b/src/oat/runtime/arm/oat_support_entrypoints_arm.cc
@@ -28,12 +28,13 @@
extern "C" void* art_check_and_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
// Cast entrypoints.
-extern "C" uint32_t artIsAssignableFromCode(const Class* klass, const Class* ref_class);
+extern "C" uint32_t artIsAssignableFromCode(const mirror::Class* klass,
+ const mirror::Class* ref_class);
extern "C" void art_can_put_array_element_from_code(void*, void*);
extern "C" void art_check_cast_from_code(void*, void*);
// Debug entrypoints.
-extern void DebugMe(AbstractMethod* method, uint32_t info);
+extern void DebugMe(mirror::AbstractMethod* method, uint32_t info);
extern "C" void art_update_debugger(void*, void*, int32_t, void*);
// DexCache entrypoints.
@@ -69,11 +70,11 @@
extern void JniMethodEnd(uint32_t saved_local_ref_cookie, Thread* self);
extern void JniMethodEndSynchronized(uint32_t saved_local_ref_cookie, jobject locked,
Thread* self);
-extern Object* JniMethodEndWithReference(jobject result, uint32_t saved_local_ref_cookie,
- Thread* self);
-extern Object* JniMethodEndWithReferenceSynchronized(jobject result,
- uint32_t saved_local_ref_cookie,
- jobject locked, Thread* self);
+extern mirror::Object* JniMethodEndWithReference(jobject result, uint32_t saved_local_ref_cookie,
+ Thread* self);
+extern mirror::Object* JniMethodEndWithReferenceSynchronized(jobject result,
+ uint32_t saved_local_ref_cookie,
+ jobject locked, Thread* self);
// Lock entrypoints.
extern "C" void art_lock_object_from_code(void*);
@@ -113,7 +114,8 @@
extern "C" int32_t art_string_compareto(void*, void*);
// Invoke entrypoints.
-const void* UnresolvedDirectMethodTrampolineFromCode(AbstractMethod*, AbstractMethod**, Thread*,
+const void* UnresolvedDirectMethodTrampolineFromCode(mirror::AbstractMethod*,
+ mirror::AbstractMethod**, Thread*,
Runtime::TrampolineType);
extern "C" void art_invoke_direct_trampoline_with_access_check(uint32_t, void*);
extern "C" void art_invoke_interface_trampoline(uint32_t, void*);
@@ -127,7 +129,8 @@
extern "C" void art_test_suspend();
// Throw entrypoints.
-extern void ThrowAbstractMethodErrorFromCode(AbstractMethod* method, Thread* thread, AbstractMethod** sp);
+extern void ThrowAbstractMethodErrorFromCode(mirror::AbstractMethod* method, Thread* thread,
+ mirror::AbstractMethod** sp);
extern "C" void art_deliver_exception_from_code(void*);
extern "C" void art_throw_array_bounds_from_code(int32_t index, int32_t limit);
extern "C" void art_throw_div_zero_from_code();
diff --git a/src/oat/runtime/arm/stub_arm.cc b/src/oat/runtime/arm/stub_arm.cc
index 4099ddb..90dfffc 100644
--- a/src/oat/runtime/arm/stub_arm.cc
+++ b/src/oat/runtime/arm/stub_arm.cc
@@ -15,10 +15,10 @@
*/
#include "jni_internal.h"
+#include "mirror/array.h"
#include "oat/utils/arm/assembler_arm.h"
#include "oat/runtime/oat_support_entrypoints.h"
#include "oat/runtime/stub.h"
-#include "object.h"
#include "stack_indirect_reference_table.h"
#include "sirt_ref.h"
@@ -27,7 +27,7 @@
namespace art {
namespace arm {
-ByteArray* ArmCreateResolutionTrampoline(Runtime::TrampolineType type) {
+mirror::ByteArray* ArmCreateResolutionTrampoline(Runtime::TrampolineType type) {
UniquePtr<ArmAssembler> assembler(static_cast<ArmAssembler*>(Assembler::Create(kArm)));
#if !defined(ART_USE_LLVM_COMPILER)
// | Out args |
@@ -83,7 +83,7 @@
assembler->EmitSlowPaths();
size_t cs = assembler->CodeSize();
Thread* self = Thread::Current();
- SirtRef<ByteArray> resolution_trampoline(self, ByteArray::Alloc(self, cs));
+ SirtRef<mirror::ByteArray> resolution_trampoline(self, mirror::ByteArray::Alloc(self, cs));
CHECK(resolution_trampoline.get() != NULL);
MemoryRegion code(resolution_trampoline->GetData(), resolution_trampoline->GetLength());
assembler->FinalizeInstructions(code);
@@ -91,9 +91,9 @@
return resolution_trampoline.get();
}
-typedef void (*ThrowAme)(AbstractMethod*, Thread*);
+typedef void (*ThrowAme)(mirror::AbstractMethod*, Thread*);
-ByteArray* CreateAbstractMethodErrorStub() {
+mirror::ByteArray* CreateAbstractMethodErrorStub() {
UniquePtr<ArmAssembler> assembler(static_cast<ArmAssembler*>(Assembler::Create(kArm)));
#if !defined(ART_USE_LLVM_COMPILER)
// Save callee saves and ready frame for exception delivery
@@ -130,7 +130,7 @@
size_t cs = assembler->CodeSize();
Thread* self = Thread::Current();
- SirtRef<ByteArray> abstract_stub(self, ByteArray::Alloc(self, cs));
+ SirtRef<mirror::ByteArray> abstract_stub(self, mirror::ByteArray::Alloc(self, cs));
CHECK(abstract_stub.get() != NULL);
MemoryRegion code(abstract_stub->GetData(), abstract_stub->GetLength());
assembler->FinalizeInstructions(code);
@@ -138,7 +138,7 @@
return abstract_stub.get();
}
-ByteArray* CreateJniDlsymLookupStub() {
+mirror::ByteArray* CreateJniDlsymLookupStub() {
UniquePtr<ArmAssembler> assembler(static_cast<ArmAssembler*>(Assembler::Create(kArm)));
// Build frame and save argument registers and LR.
RegList save = (1 << R0) | (1 << R1) | (1 << R2) | (1 << R3) | (1 << LR);
@@ -159,7 +159,7 @@
size_t cs = assembler->CodeSize();
Thread* self = Thread::Current();
- SirtRef<ByteArray> jni_stub(self, ByteArray::Alloc(self, cs));
+ SirtRef<mirror::ByteArray> jni_stub(self, mirror::ByteArray::Alloc(self, cs));
CHECK(jni_stub.get() != NULL);
MemoryRegion code(jni_stub->GetData(), jni_stub->GetLength());
assembler->FinalizeInstructions(code);
diff --git a/src/oat/runtime/callee_save_frame.h b/src/oat/runtime/callee_save_frame.h
index fe66b91..08cf9d8 100644
--- a/src/oat/runtime/callee_save_frame.h
+++ b/src/oat/runtime/callee_save_frame.h
@@ -21,11 +21,12 @@
#include "thread.h"
namespace art {
-
+namespace mirror {
class AbstractMethod;
+} // namespace mirror
// Place a special frame at the TOS that will save the callee saves for the given type.
-static void FinishCalleeSaveFrameSetup(Thread* self, AbstractMethod** sp,
+static void FinishCalleeSaveFrameSetup(Thread* self, mirror::AbstractMethod** sp,
Runtime::CalleeSaveType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// Be aware the store below may well stomp on an incoming argument.
diff --git a/src/oat/runtime/mips/context_mips.cc b/src/oat/runtime/mips/context_mips.cc
index 0c2f915..36eb5b9 100644
--- a/src/oat/runtime/mips/context_mips.cc
+++ b/src/oat/runtime/mips/context_mips.cc
@@ -16,7 +16,7 @@
#include "context_mips.h"
-#include "object.h"
+#include "mirror/object.h"
namespace art {
namespace mips {
diff --git a/src/oat/runtime/mips/stub_mips.cc b/src/oat/runtime/mips/stub_mips.cc
index 4cb8813..fda9941 100644
--- a/src/oat/runtime/mips/stub_mips.cc
+++ b/src/oat/runtime/mips/stub_mips.cc
@@ -15,10 +15,10 @@
*/
#include "jni_internal.h"
+#include "mirror/array.h"
#include "oat/runtime/oat_support_entrypoints.h"
#include "oat/runtime/stub.h"
#include "oat/utils/mips/assembler_mips.h"
-#include "object.h"
#include "stack_indirect_reference_table.h"
#include "sirt_ref.h"
@@ -27,7 +27,7 @@
namespace art {
namespace mips {
-ByteArray* MipsCreateResolutionTrampoline(Runtime::TrampolineType type) {
+mirror::ByteArray* MipsCreateResolutionTrampoline(Runtime::TrampolineType type) {
UniquePtr<MipsAssembler> assembler(static_cast<MipsAssembler*>(Assembler::Create(kMips)));
#if !defined(ART_USE_LLVM_COMPILER)
// | Out args |
@@ -113,7 +113,7 @@
size_t cs = assembler->CodeSize();
Thread* self = Thread::Current();
- SirtRef<ByteArray> resolution_trampoline(self, ByteArray::Alloc(self, cs));
+ SirtRef<mirror::ByteArray> resolution_trampoline(self, mirror::ByteArray::Alloc(self, cs));
CHECK(resolution_trampoline.get() != NULL);
MemoryRegion code(resolution_trampoline->GetData(), resolution_trampoline->GetLength());
assembler->FinalizeInstructions(code);
@@ -121,9 +121,9 @@
return resolution_trampoline.get();
}
-typedef void (*ThrowAme)(AbstractMethod*, Thread*);
+typedef void (*ThrowAme)(mirror::AbstractMethod*, Thread*);
-ByteArray* CreateAbstractMethodErrorStub() {
+mirror::ByteArray* CreateAbstractMethodErrorStub() {
UniquePtr<MipsAssembler> assembler(static_cast<MipsAssembler*>(Assembler::Create(kMips)));
#if !defined(ART_USE_LLVM_COMPILER)
// Save callee saves and ready frame for exception delivery
@@ -161,7 +161,7 @@
size_t cs = assembler->CodeSize();
Thread* self = Thread::Current();
- SirtRef<ByteArray> abstract_stub(self, ByteArray::Alloc(self, cs));
+ SirtRef<mirror::ByteArray> abstract_stub(self, mirror::ByteArray::Alloc(self, cs));
CHECK(abstract_stub.get() != NULL);
MemoryRegion code(abstract_stub->GetData(), abstract_stub->GetLength());
assembler->FinalizeInstructions(code);
@@ -169,7 +169,7 @@
return abstract_stub.get();
}
-ByteArray* CreateJniDlsymLookupStub() {
+mirror::ByteArray* CreateJniDlsymLookupStub() {
UniquePtr<MipsAssembler> assembler(static_cast<MipsAssembler*>(Assembler::Create(kMips)));
// Build frame and save argument registers and RA.
@@ -203,7 +203,7 @@
size_t cs = assembler->CodeSize();
Thread* self = Thread::Current();
- SirtRef<ByteArray> jni_stub(self, ByteArray::Alloc(self, cs));
+ SirtRef<mirror::ByteArray> jni_stub(self, mirror::ByteArray::Alloc(self, cs));
CHECK(jni_stub.get() != NULL);
MemoryRegion code(jni_stub->GetData(), jni_stub->GetLength());
assembler->FinalizeInstructions(code);
diff --git a/src/oat/runtime/oat_support_entrypoints.h b/src/oat/runtime/oat_support_entrypoints.h
index 113a56c..a08a584 100644
--- a/src/oat/runtime/oat_support_entrypoints.h
+++ b/src/oat/runtime/oat_support_entrypoints.h
@@ -24,10 +24,12 @@
static_cast<uintptr_t>(OFFSETOF_MEMBER(EntryPoints, x)))
namespace art {
-
-class Class;
-class DvmDex;
+namespace mirror {
class AbstractMethod;
+class Class;
+class Object;
+} // namespace mirror
+class DvmDex;
class Thread;
struct PACKED(4) EntryPoints {
@@ -40,12 +42,12 @@
void* (*pCheckAndAllocArrayFromCodeWithAccessCheck)(uint32_t, void*, int32_t);
// Cast
- uint32_t (*pInstanceofNonTrivialFromCode)(const Class*, const Class*);
+ uint32_t (*pInstanceofNonTrivialFromCode)(const mirror::Class*, const mirror::Class*);
void (*pCanPutArrayElementFromCode)(void*, void*);
void (*pCheckCastFromCode)(void*, void*);
// Debug
- void (*pDebugMe)(AbstractMethod*, uint32_t);
+ void (*pDebugMe)(mirror::AbstractMethod*, uint32_t);
void (*pUpdateDebuggerFromCode)(void*, void*, int32_t, void*);
// DexCache
@@ -77,8 +79,8 @@
uint32_t (*pJniMethodStartSynchronized)(jobject to_lock, Thread* self);
void (*pJniMethodEnd)(uint32_t cookie, Thread* self);
void (*pJniMethodEndSynchronized)(uint32_t cookie, jobject locked, Thread* self);
- Object* (*pJniMethodEndWithReference)(jobject result, uint32_t cookie, Thread* self);
- Object* (*pJniMethodEndWithReferenceSynchronized)(jobject result, uint32_t cookie,
+ mirror::Object* (*pJniMethodEndWithReference)(jobject result, uint32_t cookie, Thread* self);
+ mirror::Object* (*pJniMethodEndWithReferenceSynchronized)(jobject result, uint32_t cookie,
jobject locked, Thread* self);
// Locks
@@ -114,7 +116,8 @@
void* (*pMemcpy)(void*, const void*, size_t);
// Invocation
- const void* (*pUnresolvedDirectMethodTrampolineFromCode)(AbstractMethod*, AbstractMethod**, Thread*,
+ const void* (*pUnresolvedDirectMethodTrampolineFromCode)(mirror::AbstractMethod*,
+ mirror::AbstractMethod**, Thread*,
Runtime::TrampolineType);
void (*pInvokeDirectTrampolineWithAccessCheck)(uint32_t, void*);
void (*pInvokeInterfaceTrampoline)(uint32_t, void*);
@@ -129,7 +132,8 @@
// Throws
void (*pDeliverException)(void*);
- void (*pThrowAbstractMethodErrorFromCode)(AbstractMethod* m, Thread* thread, AbstractMethod** sp);
+ void (*pThrowAbstractMethodErrorFromCode)(mirror::AbstractMethod* m, Thread* thread,
+ mirror::AbstractMethod** sp);
void (*pThrowArrayBoundsFromCode)(int32_t, int32_t);
void (*pThrowDivZeroFromCode)();
void (*pThrowNoSuchMethodFromCode)(int32_t);
diff --git a/src/oat/runtime/stub.h b/src/oat/runtime/stub.h
index 0e5f0dd..2679793 100644
--- a/src/oat/runtime/stub.h
+++ b/src/oat/runtime/stub.h
@@ -20,31 +20,35 @@
#include "runtime.h"
namespace art {
+namespace mirror {
+template<class T> class PrimitiveArray;
+typedef PrimitiveArray<int8_t> ByteArray;
+} // namespace mirror
namespace arm {
- ByteArray* CreateAbstractMethodErrorStub()
+ mirror::ByteArray* CreateAbstractMethodErrorStub()
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- ByteArray* ArmCreateResolutionTrampoline(Runtime::TrampolineType type)
+ mirror::ByteArray* ArmCreateResolutionTrampoline(Runtime::TrampolineType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- ByteArray* CreateJniDlsymLookupStub()
+ mirror::ByteArray* CreateJniDlsymLookupStub()
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
}
namespace mips {
- ByteArray* CreateAbstractMethodErrorStub()
+ mirror::ByteArray* CreateAbstractMethodErrorStub()
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- ByteArray* MipsCreateResolutionTrampoline(Runtime::TrampolineType type)
+ mirror::ByteArray* MipsCreateResolutionTrampoline(Runtime::TrampolineType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- ByteArray* CreateJniDlsymLookupStub()
+ mirror::ByteArray* CreateJniDlsymLookupStub()
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
}
namespace x86 {
- ByteArray* CreateAbstractMethodErrorStub()
+ mirror::ByteArray* CreateAbstractMethodErrorStub()
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- ByteArray* X86CreateResolutionTrampoline(Runtime::TrampolineType type)
+ mirror::ByteArray* X86CreateResolutionTrampoline(Runtime::TrampolineType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- ByteArray* CreateJniDlsymLookupStub()
+ mirror::ByteArray* CreateJniDlsymLookupStub()
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
}
diff --git a/src/oat/runtime/support_alloc.cc b/src/oat/runtime/support_alloc.cc
index fb70285..5e3af78 100644
--- a/src/oat/runtime/support_alloc.cc
+++ b/src/oat/runtime/support_alloc.cc
@@ -15,51 +15,61 @@
*/
#include "callee_save_frame.h"
+#include "mirror/class-inl.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object_array-inl.h"
#include "runtime_support.h"
namespace art {
-extern "C" Object* artAllocObjectFromCode(uint32_t type_idx, AbstractMethod* method,
- Thread* self, AbstractMethod** sp)
+extern "C" mirror::Object* artAllocObjectFromCode(uint32_t type_idx, mirror::AbstractMethod* method,
+ Thread* self, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
return AllocObjectFromCode(type_idx, method, self, false);
}
-extern "C" Object* artAllocObjectFromCodeWithAccessCheck(uint32_t type_idx, AbstractMethod* method,
- Thread* self, AbstractMethod** sp)
+extern "C" mirror::Object* artAllocObjectFromCodeWithAccessCheck(uint32_t type_idx,
+ mirror::AbstractMethod* method,
+ Thread* self,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
return AllocObjectFromCode(type_idx, method, self, true);
}
-extern "C" Array* artAllocArrayFromCode(uint32_t type_idx, AbstractMethod* method, int32_t component_count,
- Thread* self, AbstractMethod** sp)
+extern "C" mirror::Array* artAllocArrayFromCode(uint32_t type_idx, mirror::AbstractMethod* method,
+ int32_t component_count, Thread* self,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
return AllocArrayFromCode(type_idx, method, component_count, self, false);
}
-extern "C" Array* artAllocArrayFromCodeWithAccessCheck(uint32_t type_idx, AbstractMethod* method,
- int32_t component_count,
- Thread* self, AbstractMethod** sp)
+extern "C" mirror::Array* artAllocArrayFromCodeWithAccessCheck(uint32_t type_idx,
+ mirror::AbstractMethod* method,
+ int32_t component_count,
+ Thread* self,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
return AllocArrayFromCode(type_idx, method, component_count, self, true);
}
-extern "C" Array* artCheckAndAllocArrayFromCode(uint32_t type_idx, AbstractMethod* method,
- int32_t component_count, Thread* self,
- AbstractMethod** sp)
+extern "C" mirror::Array* artCheckAndAllocArrayFromCode(uint32_t type_idx,
+ mirror::AbstractMethod* method,
+ int32_t component_count, Thread* self,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
return CheckAndAllocArrayFromCode(type_idx, method, component_count, self, false);
}
-extern "C" Array* artCheckAndAllocArrayFromCodeWithAccessCheck(uint32_t type_idx,
- AbstractMethod* method,
- int32_t component_count,
- Thread* self, AbstractMethod** sp)
+extern "C" mirror::Array* artCheckAndAllocArrayFromCodeWithAccessCheck(uint32_t type_idx,
+ mirror::AbstractMethod* method,
+ int32_t component_count,
+ Thread* self,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
return CheckAndAllocArrayFromCode(type_idx, method, component_count, self, true);
diff --git a/src/oat/runtime/support_cast.cc b/src/oat/runtime/support_cast.cc
index 0db743b..71a37ef 100644
--- a/src/oat/runtime/support_cast.cc
+++ b/src/oat/runtime/support_cast.cc
@@ -15,12 +15,15 @@
*/
#include "callee_save_frame.h"
+#include "mirror/class-inl.h"
+#include "mirror/object-inl.h"
#include "runtime_support.h"
namespace art {
// Assignable test for code, won't throw. Null and equality tests already performed
-extern "C" uint32_t artIsAssignableFromCode(const Class* klass, const Class* ref_class)
+extern "C" uint32_t artIsAssignableFromCode(const mirror::Class* klass,
+ const mirror::Class* ref_class)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(klass != NULL);
DCHECK(ref_class != NULL);
@@ -28,8 +31,8 @@
}
// Check whether it is safe to cast one class to the other, throw exception and return -1 on failure
-extern "C" int artCheckCastFromCode(const Class* a, const Class* b, Thread* self,
- AbstractMethod** sp)
+extern "C" int artCheckCastFromCode(const mirror::Class* a, const mirror::Class* b, Thread* self,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(a->IsClass()) << PrettyClass(a);
DCHECK(b->IsClass()) << PrettyClass(b);
@@ -47,13 +50,14 @@
// Tests whether 'element' can be assigned into an array of type 'array_class'.
// Returns 0 on success and -1 if an exception is pending.
-extern "C" int artCanPutArrayElementFromCode(const Object* element, const Class* array_class,
- Thread* self, AbstractMethod** sp)
+extern "C" int artCanPutArrayElementFromCode(const mirror::Object* element,
+ const mirror::Class* array_class,
+ Thread* self, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(array_class != NULL);
// element can't be NULL as we catch this is screened in runtime_support
- Class* element_class = element->GetClass();
- Class* component_type = array_class->GetComponentType();
+ mirror::Class* element_class = element->GetClass();
+ mirror::Class* component_type = array_class->GetComponentType();
if (LIKELY(component_type->IsAssignableFrom(element_class))) {
return 0; // Success
} else {
diff --git a/src/oat/runtime/support_debug.cc b/src/oat/runtime/support_debug.cc
index e2ca493..0d67dd9 100644
--- a/src/oat/runtime/support_debug.cc
+++ b/src/oat/runtime/support_debug.cc
@@ -25,14 +25,14 @@
* method entry and offset 0 within the method, we'll use an offset of -1
* to denote method entry.
*/
-extern "C" void artUpdateDebuggerFromCode(int32_t dex_pc, Thread* self, AbstractMethod** sp)
+extern "C" void artUpdateDebuggerFromCode(int32_t dex_pc, Thread* self, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
Dbg::UpdateDebugger(dex_pc, self);
}
// Temporary debugging hook for compiler.
-extern void DebugMe(AbstractMethod* method, uint32_t info)
+extern void DebugMe(mirror::AbstractMethod* method, uint32_t info)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
LOG(INFO) << "DebugMe";
if (method != NULL) {
diff --git a/src/oat/runtime/support_deoptimize.cc b/src/oat/runtime/support_deoptimize.cc
index 75e671f..0d88c52 100644
--- a/src/oat/runtime/support_deoptimize.cc
+++ b/src/oat/runtime/support_deoptimize.cc
@@ -16,7 +16,8 @@
#include "callee_save_frame.h"
#include "interpreter/interpreter.h"
-#include "object.h" // for JValue
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object_array-inl.h"
#include "object_utils.h"
#include "stack.h"
#include "thread.h"
@@ -24,7 +25,7 @@
namespace art {
-extern "C" uint64_t artDeoptimize(JValue ret_val, Thread* self, AbstractMethod** sp)
+extern "C" uint64_t artDeoptimize(JValue ret_val, Thread* self, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
// Return value may hold Object* so avoid suspension.
@@ -36,7 +37,7 @@
: StackVisitor(thread, context), shadow_frame_(NULL), runtime_frames_(0) { }
virtual bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* m = GetMethod();
+ mirror::AbstractMethod* m = GetMethod();
if (m->IsRuntimeMethod()) {
if (runtime_frames_ == 0) {
runtime_frames_++;
@@ -84,7 +85,7 @@
}
-extern "C" JValue artEnterInterpreterFromDeoptimize(Thread* self, AbstractMethod** sp)
+extern "C" JValue artEnterInterpreterFromDeoptimize(Thread* self, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
JValue return_value;
diff --git a/src/oat/runtime/support_dexcache.cc b/src/oat/runtime/support_dexcache.cc
index 10c7930..da15917 100644
--- a/src/oat/runtime/support_dexcache.cc
+++ b/src/oat/runtime/support_dexcache.cc
@@ -15,12 +15,17 @@
*/
#include "callee_save_frame.h"
+#include "class_linker-inl.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object_array-inl.h"
#include "runtime_support.h"
namespace art {
-extern "C" Class* artInitializeStaticStorageFromCode(uint32_t type_idx, const AbstractMethod* referrer,
- Thread* self, AbstractMethod** sp)
+extern "C" mirror::Class* artInitializeStaticStorageFromCode(uint32_t type_idx,
+ const mirror::AbstractMethod* referrer,
+ Thread* self,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// Called to ensure static storage base is initialized for direct static field reads and writes.
// A class may be accessing another class' fields when it doesn't have access, as access has been
@@ -29,18 +34,19 @@
return ResolveVerifyAndClinit(type_idx, referrer, self, true, false);
}
-extern "C" Class* artInitializeTypeFromCode(uint32_t type_idx, const AbstractMethod* referrer,
- Thread* self, AbstractMethod** sp)
+extern "C" mirror::Class* artInitializeTypeFromCode(uint32_t type_idx,
+ const mirror::AbstractMethod* referrer,
+ Thread* self, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// Called when method->dex_cache_resolved_types_[] misses.
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
return ResolveVerifyAndClinit(type_idx, referrer, self, false, false);
}
-extern "C" Class* artInitializeTypeAndVerifyAccessFromCode(uint32_t type_idx,
- const AbstractMethod* referrer,
- Thread* self,
- AbstractMethod** sp)
+extern "C" mirror::Class* artInitializeTypeAndVerifyAccessFromCode(uint32_t type_idx,
+ const mirror::AbstractMethod* referrer,
+ Thread* self,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// Called when caller isn't guaranteed to have access to a type and the dex cache may be
// unpopulated.
@@ -48,8 +54,9 @@
return ResolveVerifyAndClinit(type_idx, referrer, self, false, true);
}
-extern "C" String* artResolveStringFromCode(AbstractMethod* referrer, int32_t string_idx,
- Thread* self, AbstractMethod** sp)
+extern "C" mirror::String* artResolveStringFromCode(mirror::AbstractMethod* referrer,
+ int32_t string_idx,
+ Thread* self, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
return ResolveStringFromCode(referrer, string_idx);
diff --git a/src/oat/runtime/support_field.cc b/src/oat/runtime/support_field.cc
index 9336247..a564fa9 100644
--- a/src/oat/runtime/support_field.cc
+++ b/src/oat/runtime/support_field.cc
@@ -15,16 +15,20 @@
*/
#include "callee_save_frame.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/class-inl.h"
+#include "mirror/field-inl.h"
#include "runtime_support.h"
#include <stdint.h>
namespace art {
-extern "C" uint32_t artGet32StaticFromCode(uint32_t field_idx, const AbstractMethod* referrer,
- Thread* self, AbstractMethod** sp)
+extern "C" uint32_t artGet32StaticFromCode(uint32_t field_idx,
+ const mirror::AbstractMethod* referrer,
+ Thread* self, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(int32_t));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(int32_t));
if (LIKELY(field != NULL)) {
return field->Get32(field->GetDeclaringClass());
}
@@ -36,10 +40,11 @@
return 0; // Will throw exception by checking with Thread::Current
}
-extern "C" uint64_t artGet64StaticFromCode(uint32_t field_idx, const AbstractMethod* referrer,
- Thread* self, AbstractMethod** sp)
+extern "C" uint64_t artGet64StaticFromCode(uint32_t field_idx,
+ const mirror::AbstractMethod* referrer,
+ Thread* self, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(int64_t));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(int64_t));
if (LIKELY(field != NULL)) {
return field->Get64(field->GetDeclaringClass());
}
@@ -51,26 +56,28 @@
return 0; // Will throw exception by checking with Thread::Current
}
-extern "C" Object* artGetObjStaticFromCode(uint32_t field_idx, const AbstractMethod* referrer,
- Thread* self, AbstractMethod** sp)
+extern "C" mirror::Object* artGetObjStaticFromCode(uint32_t field_idx,
+ const mirror::AbstractMethod* referrer,
+ Thread* self, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, StaticObjectRead, sizeof(Object*));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, StaticObjectRead,
+ sizeof(mirror::Object*));
if (LIKELY(field != NULL)) {
return field->GetObj(field->GetDeclaringClass());
}
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- field = FindFieldFromCode(field_idx, referrer, self, StaticObjectRead, sizeof(Object*));
+ field = FindFieldFromCode(field_idx, referrer, self, StaticObjectRead, sizeof(mirror::Object*));
if (LIKELY(field != NULL)) {
return field->GetObj(field->GetDeclaringClass());
}
return NULL; // Will throw exception by checking with Thread::Current
}
-extern "C" uint32_t artGet32InstanceFromCode(uint32_t field_idx, Object* obj,
- const AbstractMethod* referrer, Thread* self,
- AbstractMethod** sp)
+extern "C" uint32_t artGet32InstanceFromCode(uint32_t field_idx, mirror::Object* obj,
+ const mirror::AbstractMethod* referrer, Thread* self,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(int32_t));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(int32_t));
if (LIKELY(field != NULL && obj != NULL)) {
return field->Get32(obj);
}
@@ -86,11 +93,11 @@
return 0; // Will throw exception by checking with Thread::Current
}
-extern "C" uint64_t artGet64InstanceFromCode(uint32_t field_idx, Object* obj,
- const AbstractMethod* referrer, Thread* self,
- AbstractMethod** sp)
+extern "C" uint64_t artGet64InstanceFromCode(uint32_t field_idx, mirror::Object* obj,
+ const mirror::AbstractMethod* referrer, Thread* self,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(int64_t));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(int64_t));
if (LIKELY(field != NULL && obj != NULL)) {
return field->Get64(obj);
}
@@ -106,16 +113,17 @@
return 0; // Will throw exception by checking with Thread::Current
}
-extern "C" Object* artGetObjInstanceFromCode(uint32_t field_idx, Object* obj,
- const AbstractMethod* referrer, Thread* self,
- AbstractMethod** sp)
+extern "C" mirror::Object* artGetObjInstanceFromCode(uint32_t field_idx, mirror::Object* obj,
+ const mirror::AbstractMethod* referrer,
+ Thread* self,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, InstanceObjectRead, sizeof(Object*));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, InstanceObjectRead, sizeof(mirror::Object*));
if (LIKELY(field != NULL && obj != NULL)) {
return field->GetObj(obj);
}
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- field = FindFieldFromCode(field_idx, referrer, self, InstanceObjectRead, sizeof(Object*));
+ field = FindFieldFromCode(field_idx, referrer, self, InstanceObjectRead, sizeof(mirror::Object*));
if (LIKELY(field != NULL)) {
if (UNLIKELY(obj == NULL)) {
ThrowNullPointerExceptionForFieldAccess(field, true);
@@ -127,10 +135,10 @@
}
extern "C" int artSet32StaticFromCode(uint32_t field_idx, uint32_t new_value,
- const AbstractMethod* referrer, Thread* self,
- AbstractMethod** sp)
+ const mirror::AbstractMethod* referrer, Thread* self,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite, sizeof(int32_t));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite, sizeof(int32_t));
if (LIKELY(field != NULL)) {
field->Set32(field->GetDeclaringClass(), new_value);
return 0; // success
@@ -144,10 +152,10 @@
return -1; // failure
}
-extern "C" int artSet64StaticFromCode(uint32_t field_idx, const AbstractMethod* referrer,
- uint64_t new_value, Thread* self, AbstractMethod** sp)
+extern "C" int artSet64StaticFromCode(uint32_t field_idx, const mirror::AbstractMethod* referrer,
+ uint64_t new_value, Thread* self, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite, sizeof(int64_t));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite, sizeof(int64_t));
if (LIKELY(field != NULL)) {
field->Set64(field->GetDeclaringClass(), new_value);
return 0; // success
@@ -161,11 +169,12 @@
return -1; // failure
}
-extern "C" int artSetObjStaticFromCode(uint32_t field_idx, Object* new_value,
- const AbstractMethod* referrer, Thread* self,
- AbstractMethod** sp)
+extern "C" int artSetObjStaticFromCode(uint32_t field_idx, mirror::Object* new_value,
+ const mirror::AbstractMethod* referrer, Thread* self,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, StaticObjectWrite, sizeof(Object*));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, StaticObjectWrite,
+ sizeof(mirror::Object*));
if (LIKELY(field != NULL)) {
if (LIKELY(!FieldHelper(field).IsPrimitiveType())) {
field->SetObj(field->GetDeclaringClass(), new_value);
@@ -173,7 +182,7 @@
}
}
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- field = FindFieldFromCode(field_idx, referrer, self, StaticObjectWrite, sizeof(Object*));
+ field = FindFieldFromCode(field_idx, referrer, self, StaticObjectWrite, sizeof(mirror::Object*));
if (LIKELY(field != NULL)) {
field->SetObj(field->GetDeclaringClass(), new_value);
return 0; // success
@@ -181,11 +190,11 @@
return -1; // failure
}
-extern "C" int artSet32InstanceFromCode(uint32_t field_idx, Object* obj, uint32_t new_value,
- const AbstractMethod* referrer, Thread* self,
- AbstractMethod** sp)
+extern "C" int artSet32InstanceFromCode(uint32_t field_idx, mirror::Object* obj, uint32_t new_value,
+ const mirror::AbstractMethod* referrer, Thread* self,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite, sizeof(int32_t));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite, sizeof(int32_t));
if (LIKELY(field != NULL && obj != NULL)) {
field->Set32(obj, new_value);
return 0; // success
@@ -203,12 +212,14 @@
return -1; // failure
}
-extern "C" int artSet64InstanceFromCode(uint32_t field_idx, Object* obj, uint64_t new_value,
- Thread* self, AbstractMethod** sp)
+extern "C" int artSet64InstanceFromCode(uint32_t field_idx, mirror::Object* obj, uint64_t new_value,
+ Thread* self, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* callee_save = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsOnly);
- AbstractMethod* referrer = sp[callee_save->GetFrameSizeInBytes() / sizeof(AbstractMethod*)];
- Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite, sizeof(int64_t));
+ mirror::AbstractMethod* callee_save = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsOnly);
+ mirror::AbstractMethod* referrer =
+ sp[callee_save->GetFrameSizeInBytes() / sizeof(mirror::AbstractMethod*)];
+ mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite,
+ sizeof(int64_t));
if (LIKELY(field != NULL && obj != NULL)) {
field->Set64(obj, new_value);
return 0; // success
@@ -227,17 +238,20 @@
return -1; // failure
}
-extern "C" int artSetObjInstanceFromCode(uint32_t field_idx, Object* obj, Object* new_value,
- const AbstractMethod* referrer, Thread* self,
- AbstractMethod** sp)
+extern "C" int artSetObjInstanceFromCode(uint32_t field_idx, mirror::Object* obj,
+ mirror::Object* new_value,
+ const mirror::AbstractMethod* referrer, Thread* self,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* field = FindFieldFast(field_idx, referrer, InstanceObjectWrite, sizeof(Object*));
+ mirror::Field* field = FindFieldFast(field_idx, referrer, InstanceObjectWrite,
+ sizeof(mirror::Object*));
if (LIKELY(field != NULL && obj != NULL)) {
field->SetObj(obj, new_value);
return 0; // success
}
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
- field = FindFieldFromCode(field_idx, referrer, self, InstanceObjectWrite, sizeof(Object*));
+ field = FindFieldFromCode(field_idx, referrer, self, InstanceObjectWrite,
+ sizeof(mirror::Object*));
if (LIKELY(field != NULL)) {
if (UNLIKELY(obj == NULL)) {
ThrowNullPointerExceptionForFieldAccess(field, false);
diff --git a/src/oat/runtime/support_fillarray.cc b/src/oat/runtime/support_fillarray.cc
index 9c6231f..73f832a 100644
--- a/src/oat/runtime/support_fillarray.cc
+++ b/src/oat/runtime/support_fillarray.cc
@@ -16,7 +16,8 @@
#include "callee_save_frame.h"
#include "dex_instruction.h"
-#include "object.h"
+#include "mirror/array.h"
+#include "mirror/object-inl.h"
namespace art {
@@ -35,9 +36,9 @@
* ubyte data[size*width] table of data values (may contain a single-byte
* padding at the end)
*/
-extern "C" int artHandleFillArrayDataFromCode(Array* array,
+extern "C" int artHandleFillArrayDataFromCode(mirror::Array* array,
const Instruction::ArrayDataPayload* payload,
- Thread* self, AbstractMethod** sp)
+ Thread* self, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
DCHECK_EQ(payload->ident, static_cast<uint16_t>(Instruction::kArrayDataSignature));
diff --git a/src/oat/runtime/support_instrumentation.cc b/src/oat/runtime/support_instrumentation.cc
index 73e4371..f65717a 100644
--- a/src/oat/runtime/support_instrumentation.cc
+++ b/src/oat/runtime/support_instrumentation.cc
@@ -22,8 +22,10 @@
namespace art {
-extern "C" const void* artInstrumentationMethodEntryFromCode(AbstractMethod* method, Thread* self,
- AbstractMethod** sp, uintptr_t lr)
+extern "C" const void* artInstrumentationMethodEntryFromCode(mirror::AbstractMethod* method,
+ Thread* self,
+ mirror::AbstractMethod** sp,
+ uintptr_t lr)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
self->SetTopOfStack(sp, lr);
self->VerifyStack();
@@ -41,7 +43,7 @@
return instrumentation->GetSavedCodeFromMap(method);
}
-extern "C" uint64_t artInstrumentationMethodExitFromCode(Thread* self, AbstractMethod** sp)
+extern "C" uint64_t artInstrumentationMethodExitFromCode(Thread* self, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
self->SetTopOfStack(sp, 0);
self->VerifyStack();
diff --git a/src/oat/runtime/support_interpreter.cc b/src/oat/runtime/support_interpreter.cc
index 98751cc..a02ef27 100644
--- a/src/oat/runtime/support_interpreter.cc
+++ b/src/oat/runtime/support_interpreter.cc
@@ -17,7 +17,9 @@
#include "argument_visitor.h"
#include "callee_save_frame.h"
#include "interpreter/interpreter.h"
-#include "object.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object.h"
+#include "mirror/object_array-inl.h"
#include "object_utils.h"
namespace art {
@@ -25,7 +27,7 @@
// Visits arguments on the stack placing them into the shadow frame.
class BuildShadowFrameVisitor : public ArgumentVisitor {
public:
- BuildShadowFrameVisitor(MethodHelper& caller_mh, AbstractMethod** sp,
+ BuildShadowFrameVisitor(MethodHelper& caller_mh, mirror::AbstractMethod** sp,
ShadowFrame& sf, size_t first_arg_reg) :
ArgumentVisitor(caller_mh, sp), sf_(sf), cur_reg_(first_arg_reg) {}
@@ -41,7 +43,7 @@
}
break;
case Primitive::kPrimNot:
- sf_.SetVRegReference(cur_reg_, *reinterpret_cast<Object**>(GetParamAddress()));
+ sf_.SetVRegReference(cur_reg_, *reinterpret_cast<mirror::Object**>(GetParamAddress()));
break;
case Primitive::kPrimBoolean: // Fall-through.
case Primitive::kPrimByte: // Fall-through.
@@ -65,7 +67,8 @@
DISALLOW_COPY_AND_ASSIGN(BuildShadowFrameVisitor);
};
-extern "C" uint64_t artInterpreterEntry(AbstractMethod* method, Thread* self, AbstractMethod** sp)
+extern "C" uint64_t artInterpreterEntry(mirror::AbstractMethod* method, Thread* self,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// Ensure we don't get thread suspension until the object arguments are safely in the shadow
// frame.
diff --git a/src/oat/runtime/support_invoke.cc b/src/oat/runtime/support_invoke.cc
index 7a49489..438ac8f 100644
--- a/src/oat/runtime/support_invoke.cc
+++ b/src/oat/runtime/support_invoke.cc
@@ -15,16 +15,22 @@
*/
#include "callee_save_frame.h"
+#include "dex_instruction.h"
+#include "mirror/class-inl.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
#include "runtime_support.h"
namespace art {
// Determine target of interface dispatch. This object is known non-null.
-extern "C" uint64_t artInvokeInterfaceTrampoline(AbstractMethod* interface_method,
- Object* this_object, AbstractMethod* caller_method,
- Thread* self, AbstractMethod** sp)
+extern "C" uint64_t artInvokeInterfaceTrampoline(mirror::AbstractMethod* interface_method,
+ mirror::Object* this_object,
+ mirror::AbstractMethod* caller_method,
+ Thread* self, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* method;
+ mirror::AbstractMethod* method;
if (LIKELY(interface_method->GetDexMethodIndex() != DexFile::kDexNoIndex16)) {
method = this_object->GetClass()->FindVirtualMethodForInterface(interface_method);
if (UNLIKELY(method == NULL)) {
@@ -131,10 +137,13 @@
}
-static uint64_t artInvokeCommon(uint32_t method_idx, Object* this_object, AbstractMethod* caller_method,
- Thread* self, AbstractMethod** sp, bool access_check, InvokeType type)
+static uint64_t artInvokeCommon(uint32_t method_idx, mirror::Object* this_object,
+ mirror::AbstractMethod* caller_method,
+ Thread* self, mirror::AbstractMethod** sp, bool access_check,
+ InvokeType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* method = FindMethodFast(method_idx, this_object, caller_method, access_check, type);
+ mirror::AbstractMethod* method = FindMethodFast(method_idx, this_object, caller_method,
+ access_check, type);
if (UNLIKELY(method == NULL)) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
method = FindMethodFromCode(method_idx, this_object, caller_method, self, access_check, type);
@@ -163,47 +172,47 @@
// See comments in runtime_support_asm.S
extern "C" uint64_t artInvokeInterfaceTrampolineWithAccessCheck(uint32_t method_idx,
- Object* this_object,
- AbstractMethod* caller_method,
+ mirror::Object* this_object,
+ mirror::AbstractMethod* caller_method,
Thread* self,
- AbstractMethod** sp)
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kInterface);
}
extern "C" uint64_t artInvokeDirectTrampolineWithAccessCheck(uint32_t method_idx,
- Object* this_object,
- AbstractMethod* caller_method,
+ mirror::Object* this_object,
+ mirror::AbstractMethod* caller_method,
Thread* self,
- AbstractMethod** sp)
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kDirect);
}
extern "C" uint64_t artInvokeStaticTrampolineWithAccessCheck(uint32_t method_idx,
- Object* this_object,
- AbstractMethod* caller_method,
- Thread* self,
- AbstractMethod** sp)
+ mirror::Object* this_object,
+ mirror::AbstractMethod* caller_method,
+ Thread* self,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kStatic);
}
extern "C" uint64_t artInvokeSuperTrampolineWithAccessCheck(uint32_t method_idx,
- Object* this_object,
- AbstractMethod* caller_method,
+ mirror::Object* this_object,
+ mirror::AbstractMethod* caller_method,
Thread* self,
- AbstractMethod** sp)
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kSuper);
}
extern "C" uint64_t artInvokeVirtualTrampolineWithAccessCheck(uint32_t method_idx,
- Object* this_object,
- AbstractMethod* caller_method,
+ mirror::Object* this_object,
+ mirror::AbstractMethod* caller_method,
Thread* self,
- AbstractMethod** sp)
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kVirtual);
}
diff --git a/src/oat/runtime/support_jni.cc b/src/oat/runtime/support_jni.cc
index e1ae530..0e21700 100644
--- a/src/oat/runtime/support_jni.cc
+++ b/src/oat/runtime/support_jni.cc
@@ -14,7 +14,11 @@
* limitations under the License.
*/
-#include "object.h"
+#include "mirror/class-inl.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
#include "object_utils.h"
#include "runtime_support.h"
#include "scoped_thread_state_change.h"
@@ -28,7 +32,7 @@
DCHECK(Thread::Current() == self);
ScopedObjectAccess soa(self);
- AbstractMethod* method = self->GetCurrentMethod();
+ mirror::AbstractMethod* method = self->GetCurrentMethod();
DCHECK(method != NULL);
// Lookup symbol address for method, on failure we'll return NULL with an
@@ -81,11 +85,11 @@
PopLocalReferences(saved_local_ref_cookie, self);
}
-extern Object* JniMethodEndWithReference(jobject result, uint32_t saved_local_ref_cookie,
- Thread* self)
+extern mirror::Object* JniMethodEndWithReference(jobject result, uint32_t saved_local_ref_cookie,
+ Thread* self)
SHARED_LOCK_FUNCTION(Locks::mutator_lock_) {
self->TransitionFromSuspendedToRunnable();
- Object* o = self->DecodeJObject(result); // Must decode before pop.
+ mirror::Object* o = self->DecodeJObject(result); // Must decode before pop.
PopLocalReferences(saved_local_ref_cookie, self);
// Process result.
if (UNLIKELY(self->GetJniEnv()->check_jni)) {
@@ -97,13 +101,13 @@
return o;
}
-extern Object* JniMethodEndWithReferenceSynchronized(jobject result,
- uint32_t saved_local_ref_cookie,
- jobject locked, Thread* self)
+extern mirror::Object* JniMethodEndWithReferenceSynchronized(jobject result,
+ uint32_t saved_local_ref_cookie,
+ jobject locked, Thread* self)
SHARED_LOCK_FUNCTION(Locks::mutator_lock_) {
self->TransitionFromSuspendedToRunnable();
UnlockJniSynchronizedMethod(locked, self); // Must decode before pop.
- Object* o = self->DecodeJObject(result);
+ mirror::Object* o = self->DecodeJObject(result);
PopLocalReferences(saved_local_ref_cookie, self);
// Process result.
if (UNLIKELY(self->GetJniEnv()->check_jni)) {
@@ -117,9 +121,10 @@
static void WorkAroundJniBugsForJobject(intptr_t* arg_ptr) {
intptr_t value = *arg_ptr;
- Object** value_as_jni_rep = reinterpret_cast<Object**>(value);
- Object* value_as_work_around_rep = value_as_jni_rep != NULL ? *value_as_jni_rep : NULL;
- CHECK(Runtime::Current()->GetHeap()->IsHeapAddress(value_as_work_around_rep)) << value_as_work_around_rep;
+ mirror::Object** value_as_jni_rep = reinterpret_cast<mirror::Object**>(value);
+ mirror::Object* value_as_work_around_rep = value_as_jni_rep != NULL ? *value_as_jni_rep : NULL;
+ CHECK(Runtime::Current()->GetHeap()->IsHeapAddress(value_as_work_around_rep))
+ << value_as_work_around_rep;
*arg_ptr = reinterpret_cast<intptr_t>(value_as_work_around_rep);
}
@@ -137,7 +142,7 @@
// | unused |
// | unused |
// | unused | <- sp
- AbstractMethod* jni_method = self->GetCurrentMethod();
+ mirror::AbstractMethod* 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_locks.cc b/src/oat/runtime/support_locks.cc
index f3a3106..38fc48c 100644
--- a/src/oat/runtime/support_locks.cc
+++ b/src/oat/runtime/support_locks.cc
@@ -15,11 +15,12 @@
*/
#include "callee_save_frame.h"
-#include "object.h"
+#include "mirror/object.h"
namespace art {
-extern "C" int artUnlockObjectFromCode(Object* obj, Thread* self, AbstractMethod** sp)
+extern "C" int artUnlockObjectFromCode(mirror::Object* obj, Thread* self,
+ mirror::AbstractMethod** sp)
UNLOCK_FUNCTION(monitor_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
DCHECK(obj != NULL); // Assumed to have been checked before entry
@@ -27,7 +28,8 @@
return obj->MonitorExit(self) ? 0 /* Success */ : -1 /* Failure */;
}
-extern "C" void artLockObjectFromCode(Object* obj, Thread* thread, AbstractMethod** sp)
+extern "C" void artLockObjectFromCode(mirror::Object* obj, Thread* thread,
+ mirror::AbstractMethod** sp)
EXCLUSIVE_LOCK_FUNCTION(monitor_lock_) {
FinishCalleeSaveFrameSetup(thread, sp, Runtime::kRefsOnly);
DCHECK(obj != NULL); // Assumed to have been checked before entry
diff --git a/src/oat/runtime/support_proxy.cc b/src/oat/runtime/support_proxy.cc
index f0f07a1..65e404a 100644
--- a/src/oat/runtime/support_proxy.cc
+++ b/src/oat/runtime/support_proxy.cc
@@ -15,7 +15,9 @@
*/
#include "argument_visitor.h"
-#include "object.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object.h"
+#include "mirror/object_array-inl.h"
#include "object_utils.h"
#include "reflection.h"
#include "runtime_support.h"
@@ -31,7 +33,7 @@
// to jobjects.
class BuildArgumentVisitor : public ArgumentVisitor {
public:
- BuildArgumentVisitor(MethodHelper& caller_mh, AbstractMethod** sp,
+ BuildArgumentVisitor(MethodHelper& caller_mh, mirror::AbstractMethod** sp,
ScopedObjectAccessUnchecked& soa, std::vector<jvalue>& args) :
ArgumentVisitor(caller_mh, sp), soa_(soa), args_(args) {}
@@ -40,7 +42,7 @@
Primitive::Type type = GetParamPrimitiveType();
switch (type) {
case Primitive::kPrimNot: {
- Object* obj = *reinterpret_cast<Object**>(GetParamAddress());
+ mirror::Object* obj = *reinterpret_cast<mirror::Object**>(GetParamAddress());
val.l = soa_.AddLocalReference<jobject>(obj);
break;
}
@@ -79,8 +81,9 @@
// which is responsible for recording callee save registers. We explicitly place into jobjects the
// incoming reference arguments (so they survive GC). We invoke the invocation handler, which is a
// field within the proxy object, which will box the primitive arguments and deal with error cases.
-extern "C" uint64_t artProxyInvokeHandler(AbstractMethod* proxy_method, Object* receiver,
- Thread* self, AbstractMethod** sp)
+extern "C" uint64_t artProxyInvokeHandler(mirror::AbstractMethod* proxy_method,
+ mirror::Object* receiver,
+ Thread* self, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// Ensure we don't get thread suspension until the object arguments are safely in jobjects.
const char* old_cause =
@@ -106,7 +109,7 @@
args.erase(args.begin());
// Convert proxy method into expected interface method.
- AbstractMethod* interface_method = proxy_method->FindOverriddenMethod();
+ mirror::AbstractMethod* interface_method = proxy_method->FindOverriddenMethod();
DCHECK(interface_method != NULL);
DCHECK(!interface_method->IsProxyMethod()) << PrettyMethod(interface_method);
jobject interface_method_jobj = soa.AddLocalReference<jobject>(interface_method);
diff --git a/src/oat/runtime/support_stubs.cc b/src/oat/runtime/support_stubs.cc
index ac188a8..dcfea3a 100644
--- a/src/oat/runtime/support_stubs.cc
+++ b/src/oat/runtime/support_stubs.cc
@@ -17,8 +17,12 @@
#if !defined(ART_USE_LLVM_COMPILER)
#include "callee_save_frame.h"
#endif
+#include "class_linker-inl.h"
#include "dex_instruction.h"
-#include "object.h"
+#include "mirror/class-inl.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object.h"
+#include "mirror/object_array-inl.h"
#include "object_utils.h"
#if defined(ART_USE_LLVM_COMPILER)
#include "nth_caller_visitor.h"
@@ -32,7 +36,8 @@
#if !defined(ART_USE_LLVM_COMPILER)
// Lazily resolve a method. Called by stub code.
-const void* UnresolvedDirectMethodTrampolineFromCode(AbstractMethod* called, AbstractMethod** sp, Thread* thread,
+const void* UnresolvedDirectMethodTrampolineFromCode(mirror::AbstractMethod* called,
+ mirror::AbstractMethod** sp, Thread* thread,
Runtime::TrampolineType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#if defined(__arm__)
@@ -52,7 +57,7 @@
// | R0 |
// | Method* | <- sp
DCHECK_EQ(48U, Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes());
- AbstractMethod** caller_sp = reinterpret_cast<AbstractMethod**>(reinterpret_cast<byte*>(sp) + 48);
+ mirror::AbstractMethod** caller_sp = reinterpret_cast<mirror::AbstractMethod**>(reinterpret_cast<byte*>(sp) + 48);
uintptr_t* regs = reinterpret_cast<uintptr_t*>(reinterpret_cast<byte*>(sp) + kPointerSize);
uint32_t pc_offset = 10;
uintptr_t caller_pc = regs[pc_offset];
@@ -72,7 +77,7 @@
// | ECX | arg1
// | EAX/Method* | <- sp
DCHECK_EQ(32U, Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes());
- AbstractMethod** caller_sp = reinterpret_cast<AbstractMethod**>(reinterpret_cast<byte*>(sp) + 32);
+ mirror::AbstractMethod** caller_sp = reinterpret_cast<mirror::AbstractMethod**>(reinterpret_cast<byte*>(sp) + 32);
uintptr_t* regs = reinterpret_cast<uintptr_t*>(reinterpret_cast<byte*>(sp));
uintptr_t caller_pc = regs[7];
#elif defined(__mips__)
@@ -91,13 +96,13 @@
// | A1 | arg1
// | A0/Method* | <- sp
DCHECK_EQ(48U, Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes());
- AbstractMethod** caller_sp = reinterpret_cast<AbstractMethod**>(reinterpret_cast<byte*>(sp) + 48);
+ mirror::AbstractMethod** caller_sp = reinterpret_cast<mirror::AbstractMethod**>(reinterpret_cast<byte*>(sp) + 48);
uintptr_t* regs = reinterpret_cast<uintptr_t*>(reinterpret_cast<byte*>(sp));
uint32_t pc_offset = 11;
uintptr_t caller_pc = regs[pc_offset];
#else
UNIMPLEMENTED(FATAL);
- AbstractMethod** caller_sp = NULL;
+ mirror::AbstractMethod** caller_sp = NULL;
uintptr_t* regs = NULL;
uintptr_t caller_pc = 0;
#endif
@@ -109,7 +114,7 @@
// Compute details about the called method (avoid GCs)
ClassLinker* linker = Runtime::Current()->GetClassLinker();
- AbstractMethod* caller = *caller_sp;
+ mirror::AbstractMethod* caller = *caller_sp;
InvokeType invoke_type;
uint32_t dex_method_idx;
#if !defined(__i386__)
@@ -173,7 +178,7 @@
// Place into local references incoming arguments from the caller's register arguments
size_t cur_arg = 1; // skip method_idx in R0, first arg is in R1
if (invoke_type != kStatic) {
- Object* obj = reinterpret_cast<Object*>(regs[cur_arg]);
+ mirror::Object* obj = reinterpret_cast<mirror::Object*>(regs[cur_arg]);
cur_arg++;
if (args_in_regs < 3) {
// If we thought we had fewer than 3 arguments in registers, account for the receiver
@@ -188,7 +193,7 @@
char c = shorty[shorty_index];
shorty_index++;
if (c == 'L') {
- Object* obj = reinterpret_cast<Object*>(regs[cur_arg]);
+ mirror::Object* obj = reinterpret_cast<mirror::Object*>(regs[cur_arg]);
soa.AddLocalReference<jobject>(obj);
}
cur_arg = cur_arg + (c == 'J' || c == 'D' ? 2 : 1);
@@ -199,7 +204,7 @@
char c = shorty[shorty_index];
shorty_index++;
if (c == 'L') {
- Object* obj = reinterpret_cast<Object*>(regs[cur_arg]);
+ mirror::Object* obj = reinterpret_cast<mirror::Object*>(regs[cur_arg]);
soa.AddLocalReference<jobject>(obj);
}
cur_arg = cur_arg + (c == 'J' || c == 'D' ? 2 : 1);
@@ -214,7 +219,7 @@
// Incompatible class change should have been handled in resolve method.
CHECK(!called->CheckIncompatibleClassChange(invoke_type));
// Ensure that the called method's class is initialized.
- Class* called_class = called->GetDeclaringClass();
+ mirror::Class* called_class = called->GetDeclaringClass();
linker->EnsureInitialized(called_class, true, true);
if (LIKELY(called_class->IsInitialized())) {
code = called->GetCode();
@@ -252,7 +257,7 @@
Thread* thread, Runtime::TrampolineType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
uint32_t dex_pc;
- AbstractMethod* caller = thread->GetCurrentMethod(&dex_pc);
+ mirror::AbstractMethod* caller = thread->GetCurrentMethod(&dex_pc);
ClassLinker* linker = Runtime::Current()->GetClassLinker();
InvokeType invoke_type;
@@ -299,7 +304,7 @@
// Incompatible class change should have been handled in resolve method.
CHECK(!called->CheckIncompatibleClassChange(invoke_type));
// Ensure that the called method's class is initialized.
- Class* called_class = called->GetDeclaringClass();
+ mirror::Class* called_class = called->GetDeclaringClass();
linker->EnsureInitialized(called_class, true, true);
if (LIKELY(called_class->IsInitialized())) {
code = called->GetCode();
@@ -342,7 +347,8 @@
#if !defined(ART_USE_LLVM_COMPILER)
// Called by the AbstractMethodError. Called by stub code.
-extern void ThrowAbstractMethodErrorFromCode(AbstractMethod* method, Thread* thread, AbstractMethod** sp)
+extern void ThrowAbstractMethodErrorFromCode(mirror::AbstractMethod* method, Thread* thread,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
thread->ThrowNewExceptionF("Ljava/lang/AbstractMethodError;",
@@ -350,7 +356,8 @@
thread->QuickDeliverException();
}
#else // ART_USE_LLVM_COMPILER
-extern void ThrowAbstractMethodErrorFromCode(AbstractMethod* method, Thread* thread, AbstractMethod**)
+extern void ThrowAbstractMethodErrorFromCode(mirror::AbstractMethod* method, Thread* thread,
+ mirror::AbstractMethod**)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
thread->ThrowNewExceptionF("Ljava/lang/AbstractMethodError;",
"abstract method \"%s\"", PrettyMethod(method).c_str());
diff --git a/src/oat/runtime/support_thread.cc b/src/oat/runtime/support_thread.cc
index 04038ab..e711714 100644
--- a/src/oat/runtime/support_thread.cc
+++ b/src/oat/runtime/support_thread.cc
@@ -28,7 +28,7 @@
CheckSuspend(thread);
}
-extern "C" void artTestSuspendFromCode(Thread* thread, AbstractMethod** sp)
+extern "C" void artTestSuspendFromCode(Thread* thread, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// Called when suspend count check value is 0 and thread->suspend_count_ != 0
FinishCalleeSaveFrameSetup(thread, sp, Runtime::kRefsOnly);
diff --git a/src/oat/runtime/support_throw.cc b/src/oat/runtime/support_throw.cc
index 5bf48e4..80ba118 100644
--- a/src/oat/runtime/support_throw.cc
+++ b/src/oat/runtime/support_throw.cc
@@ -15,7 +15,7 @@
*/
#include "callee_save_frame.h"
-#include "object.h"
+#include "mirror/object.h"
#include "object_utils.h"
#include "runtime_support.h"
#include "thread.h"
@@ -26,21 +26,21 @@
// Used to implement MOVE_EXCEPTION.
extern "C" void* GetAndClearException(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(self->IsExceptionPending());
- Throwable* exception = self->GetException();
+ mirror::Throwable* exception = self->GetException();
self->ClearException();
return exception;
}
// Deliver an exception that's pending on thread helping set up a callee save frame on the way.
-extern "C" void artDeliverPendingExceptionFromCode(Thread* thread, AbstractMethod** sp)
+extern "C" void artDeliverPendingExceptionFromCode(Thread* thread, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
thread->QuickDeliverException();
}
// Called by generated call to throw an exception.
-extern "C" void artDeliverExceptionFromCode(Throwable* exception, Thread* thread,
- AbstractMethod** sp)
+extern "C" void artDeliverExceptionFromCode(mirror::Throwable* exception, Thread* thread,
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
/*
* exception may be NULL, in which case this routine should
@@ -56,18 +56,18 @@
// Called by generated call to throw a NPE exception.
extern "C" void artThrowNullPointerExceptionFromCode(Thread* self,
- AbstractMethod** sp)
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
uint32_t dex_pc;
- AbstractMethod* throw_method = self->GetCurrentMethod(&dex_pc);
+ mirror::AbstractMethod* throw_method = self->GetCurrentMethod(&dex_pc);
ThrowNullPointerExceptionFromDexPC(throw_method, dex_pc);
self->QuickDeliverException();
}
// Called by generated call to throw an arithmetic divide by zero exception.
extern "C" void artThrowDivZeroFromCode(Thread* thread,
- AbstractMethod** sp)
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
thread->ThrowNewException("Ljava/lang/ArithmeticException;", "divide by zero");
@@ -76,7 +76,7 @@
// Called by generated call to throw an array index out of bounds exception.
extern "C" void artThrowArrayBoundsFromCode(int index, int limit, Thread* thread,
- AbstractMethod** sp)
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
thread->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
@@ -84,7 +84,7 @@
thread->QuickDeliverException();
}
-extern "C" void artThrowStackOverflowFromCode(Thread* self, AbstractMethod** sp)
+extern "C" void artThrowStackOverflowFromCode(Thread* self, mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
ThrowStackOverflowError(self);
@@ -92,10 +92,10 @@
}
extern "C" void artThrowNoSuchMethodFromCode(int32_t method_idx, Thread* self,
- AbstractMethod** sp)
+ mirror::AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
- AbstractMethod* method = self->GetCurrentMethod();
+ mirror::AbstractMethod* method = self->GetCurrentMethod();
ThrowNoSuchMethodError(method_idx, method);
self->QuickDeliverException();
}
diff --git a/src/oat/runtime/x86/context_x86.cc b/src/oat/runtime/x86/context_x86.cc
index 4efdf81..9d930ca 100644
--- a/src/oat/runtime/x86/context_x86.cc
+++ b/src/oat/runtime/x86/context_x86.cc
@@ -16,7 +16,8 @@
#include "context_x86.h"
-#include "object.h"
+#include "mirror/abstract_method.h"
+#include "stack.h"
namespace art {
namespace x86 {
@@ -34,7 +35,7 @@
}
void X86Context::FillCalleeSaves(const StackVisitor& fr) {
- AbstractMethod* method = fr.GetMethod();
+ mirror::AbstractMethod* method = fr.GetMethod();
uint32_t core_spills = method->GetCoreSpillMask();
size_t spill_count = __builtin_popcount(core_spills);
DCHECK_EQ(method->GetFpSpillMask(), 0u);
diff --git a/src/oat/runtime/x86/oat_support_entrypoints_x86.cc b/src/oat/runtime/x86/oat_support_entrypoints_x86.cc
index fce2251..445ae2a 100644
--- a/src/oat/runtime/x86/oat_support_entrypoints_x86.cc
+++ b/src/oat/runtime/x86/oat_support_entrypoints_x86.cc
@@ -28,12 +28,13 @@
extern "C" void* art_check_and_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
// Cast entrypoints.
-extern "C" uint32_t art_is_assignable_from_code(const Class* klass, const Class* ref_class);
+extern "C" uint32_t art_is_assignable_from_code(const mirror::Class* klass,
+ const mirror::Class* ref_class);
extern "C" void art_can_put_array_element_from_code(void*, void*);
extern "C" void art_check_cast_from_code(void*, void*);
// Debug entrypoints.
-extern void DebugMe(AbstractMethod* method, uint32_t info);
+extern void DebugMe(mirror::AbstractMethod* method, uint32_t info);
extern "C" void art_update_debugger(void*, void*, int32_t, void*);
// DexCache entrypoints.
@@ -66,11 +67,11 @@
extern void JniMethodEnd(uint32_t saved_local_ref_cookie, Thread* self);
extern void JniMethodEndSynchronized(uint32_t saved_local_ref_cookie, jobject locked,
Thread* self);
-extern Object* JniMethodEndWithReference(jobject result, uint32_t saved_local_ref_cookie,
- Thread* self);
-extern Object* JniMethodEndWithReferenceSynchronized(jobject result,
- uint32_t saved_local_ref_cookie,
- jobject locked, Thread* self);
+extern mirror::Object* JniMethodEndWithReference(jobject result, uint32_t saved_local_ref_cookie,
+ Thread* self);
+extern mirror::Object* JniMethodEndWithReferenceSynchronized(jobject result,
+ uint32_t saved_local_ref_cookie,
+ jobject locked, Thread* self);
// Lock entrypoints.
extern "C" void art_lock_object_from_code(void*);
@@ -98,7 +99,8 @@
extern "C" void* art_memcpy(void*, const void*, size_t);
// Invoke entrypoints.
-const void* UnresolvedDirectMethodTrampolineFromCode(AbstractMethod*, AbstractMethod**, Thread*,
+const void* UnresolvedDirectMethodTrampolineFromCode(mirror::AbstractMethod*,
+ mirror::AbstractMethod**, Thread*,
Runtime::TrampolineType);
extern "C" void art_invoke_direct_trampoline_with_access_check(uint32_t, void*);
extern "C" void art_invoke_interface_trampoline(uint32_t, void*);
@@ -112,7 +114,8 @@
extern "C" void art_test_suspend();
// Throw entrypoints.
-extern void ThrowAbstractMethodErrorFromCode(AbstractMethod* method, Thread* thread, AbstractMethod** sp);
+extern void ThrowAbstractMethodErrorFromCode(mirror::AbstractMethod* method, Thread* thread,
+ mirror::AbstractMethod** sp);
extern "C" void art_deliver_exception_from_code(void*);
extern "C" void art_throw_array_bounds_from_code(int32_t index, int32_t limit);
extern "C" void art_throw_div_zero_from_code();
diff --git a/src/oat/runtime/x86/stub_x86.cc b/src/oat/runtime/x86/stub_x86.cc
index cade99d..92f3c5f 100644
--- a/src/oat/runtime/x86/stub_x86.cc
+++ b/src/oat/runtime/x86/stub_x86.cc
@@ -15,10 +15,10 @@
*/
#include "jni_internal.h"
+#include "mirror/array.h"
#include "oat/runtime/oat_support_entrypoints.h"
#include "oat/runtime/stub.h"
#include "oat/utils/x86/assembler_x86.h"
-#include "object.h"
#include "stack_indirect_reference_table.h"
#include "sirt_ref.h"
@@ -27,7 +27,7 @@
namespace art {
namespace x86 {
-ByteArray* X86CreateResolutionTrampoline(Runtime::TrampolineType type) {
+mirror::ByteArray* X86CreateResolutionTrampoline(Runtime::TrampolineType type) {
UniquePtr<X86Assembler> assembler(static_cast<X86Assembler*>(Assembler::Create(kX86)));
#if !defined(ART_USE_LLVM_COMPILER)
@@ -93,7 +93,7 @@
assembler->EmitSlowPaths();
size_t cs = assembler->CodeSize();
Thread* self = Thread::Current();
- SirtRef<ByteArray> resolution_trampoline(self, ByteArray::Alloc(self, cs));
+ SirtRef<mirror::ByteArray> resolution_trampoline(self, mirror::ByteArray::Alloc(self, cs));
CHECK(resolution_trampoline.get() != NULL);
MemoryRegion code(resolution_trampoline->GetData(), resolution_trampoline->GetLength());
assembler->FinalizeInstructions(code);
@@ -101,9 +101,9 @@
return resolution_trampoline.get();
}
-typedef void (*ThrowAme)(AbstractMethod*, Thread*);
+typedef void (*ThrowAme)(mirror::AbstractMethod*, Thread*);
-ByteArray* CreateAbstractMethodErrorStub() {
+mirror::ByteArray* CreateAbstractMethodErrorStub() {
UniquePtr<X86Assembler> assembler(static_cast<X86Assembler*>(Assembler::Create(kX86)));
#if !defined(ART_USE_LLVM_COMPILER)
@@ -148,7 +148,7 @@
size_t cs = assembler->CodeSize();
Thread* self = Thread::Current();
- SirtRef<ByteArray> abstract_stub(self, ByteArray::Alloc(self, cs));
+ SirtRef<mirror::ByteArray> abstract_stub(self, mirror::ByteArray::Alloc(self, cs));
CHECK(abstract_stub.get() != NULL);
MemoryRegion code(abstract_stub->GetData(), abstract_stub->GetLength());
assembler->FinalizeInstructions(code);
@@ -156,7 +156,7 @@
return abstract_stub.get();
}
-ByteArray* CreateJniDlsymLookupStub() {
+mirror::ByteArray* CreateJniDlsymLookupStub() {
UniquePtr<X86Assembler> assembler(static_cast<X86Assembler*>(Assembler::Create(kX86)));
// Pad stack to ensure 16-byte alignment
@@ -182,7 +182,7 @@
size_t cs = assembler->CodeSize();
Thread* self = Thread::Current();
- SirtRef<ByteArray> jni_stub(self, ByteArray::Alloc(self, cs));
+ SirtRef<mirror::ByteArray> jni_stub(self, mirror::ByteArray::Alloc(self, cs));
CHECK(jni_stub.get() != NULL);
MemoryRegion code(jni_stub->GetData(), jni_stub->GetLength());
assembler->FinalizeInstructions(code);
diff --git a/src/oat_compilation_unit.h b/src/oat_compilation_unit.h
index ec7c9a3..7eac322 100644
--- a/src/oat_compilation_unit.h
+++ b/src/oat_compilation_unit.h
@@ -22,11 +22,12 @@
#include <stdint.h>
namespace art {
-
+namespace mirror {
class ClassLoader;
+class DexCache;
+} // namespace mirror
class ClassLinker;
class DexFile;
-class DexCache;
class OatCompilationUnit {
public:
diff --git a/src/oat_file.cc b/src/oat_file.cc
index 8229f63..b806df8 100644
--- a/src/oat_file.cc
+++ b/src/oat_file.cc
@@ -22,7 +22,11 @@
#include "base/unix_file/fd_file.h"
#include "elf_file.h"
#include "oat.h"
+#include "mirror/class.h"
+#include "mirror/abstract_method.h"
+#include "mirror/abstract_method-inl.h"
#include "os.h"
+#include "utils.h"
namespace art {
@@ -296,7 +300,7 @@
const byte* oat_class_pointer = oat_file_->Begin() + oat_class_offset;
CHECK_LT(oat_class_pointer, oat_file_->End());
- Class::Status status = *reinterpret_cast<const Class::Status*>(oat_class_pointer);
+ mirror::Class::Status status = *reinterpret_cast<const mirror::Class::Status*>(oat_class_pointer);
const byte* methods_pointer = oat_class_pointer + sizeof(status);
CHECK_LT(methods_pointer, oat_file_->End());
@@ -307,13 +311,13 @@
}
OatFile::OatClass::OatClass(const OatFile* oat_file,
- Class::Status status,
+ mirror::Class::Status status,
const OatMethodOffsets* methods_pointer)
: oat_file_(oat_file), status_(status), methods_pointer_(methods_pointer) {}
OatFile::OatClass::~OatClass() {}
-Class::Status OatFile::OatClass::GetStatus() const {
+mirror::Class::Status OatFile::OatClass::GetStatus() const {
return status_;
}
@@ -392,9 +396,9 @@
return reinterpret_cast<uint32_t*>(code)[-1];
}
-AbstractMethod::InvokeStub* OatFile::OatMethod::GetInvokeStub() const {
+mirror::AbstractMethod::InvokeStub* OatFile::OatMethod::GetInvokeStub() const {
const byte* stub = GetOatPointer<const byte*>(invoke_stub_offset_);
- return reinterpret_cast<AbstractMethod::InvokeStub*>(const_cast<byte*>(stub));
+ return reinterpret_cast<mirror::AbstractMethod::InvokeStub*>(const_cast<byte*>(stub));
}
uint32_t OatFile::OatMethod::GetInvokeStubSize() const {
@@ -413,7 +417,7 @@
}
#endif
-void OatFile::OatMethod::LinkMethodPointers(AbstractMethod* method) const {
+void OatFile::OatMethod::LinkMethodPointers(mirror::AbstractMethod* method) const {
CHECK(method != NULL);
method->SetCode(GetCode());
method->SetFrameSizeInBytes(frame_size_in_bytes_);
@@ -425,7 +429,7 @@
method->SetInvokeStub(GetInvokeStub());
}
-void OatFile::OatMethod::LinkMethodOffsets(AbstractMethod* method) const {
+void OatFile::OatMethod::LinkMethodOffsets(mirror::AbstractMethod* method) const {
CHECK(method != NULL);
method->SetOatCodeOffset(GetCodeOffset());
method->SetFrameSizeInBytes(GetFrameSizeInBytes());
diff --git a/src/oat_file.h b/src/oat_file.h
index ff5cd80..bff48fa 100644
--- a/src/oat_file.h
+++ b/src/oat_file.h
@@ -20,8 +20,11 @@
#include <string>
#include <vector>
-#include "globals.h"
-#include "object.h"
+#include "dex_file.h"
+#include "invoke_type.h"
+#include "mem_map.h"
+#include "mirror/abstract_method.h"
+#include "oat.h"
#include "os.h"
namespace art {
@@ -65,10 +68,10 @@
class OatMethod {
public:
// Link Method for execution using the contents of this OatMethod
- void LinkMethodPointers(AbstractMethod* method) const;
+ void LinkMethodPointers(mirror::AbstractMethod* method) const;
// Link Method for image writing using the contents of this OatMethod
- void LinkMethodOffsets(AbstractMethod* method) const;
+ void LinkMethodOffsets(mirror::AbstractMethod* method) const;
uint32_t GetCodeOffset() const {
return code_offset_;
@@ -108,7 +111,7 @@
return GetOatPointer<const uint8_t*>(native_gc_map_offset_);
}
- AbstractMethod::InvokeStub* GetInvokeStub() const;
+ mirror::AbstractMethod::InvokeStub* GetInvokeStub() const;
uint32_t GetInvokeStubSize() const;
#if defined(ART_USE_LLVM_COMPILER)
@@ -161,7 +164,7 @@
class OatClass {
public:
- Class::Status GetStatus() const;
+ mirror::Class::Status GetStatus() const;
// get the OatMethod entry based on its index into the class
// defintion. direct methods come first, followed by virtual
@@ -172,11 +175,11 @@
private:
OatClass(const OatFile* oat_file,
- Class::Status status,
+ mirror::Class::Status status,
const OatMethodOffsets* methods_pointer);
const OatFile* oat_file_;
- const Class::Status status_;
+ const mirror::Class::Status status_;
const OatMethodOffsets* methods_pointer_;
friend class OatDexFile;
diff --git a/src/oat_test.cc b/src/oat_test.cc
index ec0fa7d..8da3626 100644
--- a/src/oat_test.cc
+++ b/src/oat_test.cc
@@ -14,6 +14,9 @@
* limitations under the License.
*/
+#include "mirror/abstract_method-inl.h"
+#include "mirror/class-inl.h"
+#include "mirror/object_array-inl.h"
#include "oat_file.h"
#include "oat_writer.h"
#include "vector_output_stream.h"
@@ -24,7 +27,7 @@
class OatTest : public CommonTest {
protected:
- void CheckMethod(AbstractMethod* method,
+ void CheckMethod(mirror::AbstractMethod* method,
const OatFile::OatMethod& oat_method,
const DexFile* dex_file)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -119,7 +122,7 @@
UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file->GetOatClass(i));
- Class* klass = class_linker->FindClass(descriptor, NULL);
+ mirror::Class* klass = class_linker->FindClass(descriptor, NULL);
size_t method_index = 0;
for (size_t i = 0; i < klass->NumDirectMethods(); i++, method_index++) {
diff --git a/src/oat_writer.cc b/src/oat_writer.cc
index 113beba..6fcea5d 100644
--- a/src/oat_writer.cc
+++ b/src/oat_writer.cc
@@ -21,7 +21,9 @@
#include "base/stl_util.h"
#include "base/unix_file/fd_file.h"
#include "class_linker.h"
-#include "class_loader.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/array.h"
+#include "mirror/class_loader.h"
#include "os.h"
#include "output_stream.h"
#include "safe_map.h"
@@ -134,13 +136,13 @@
Compiler::ClassReference class_ref = Compiler::ClassReference(dex_file, class_def_index);
CompiledClass* compiled_class = compiler_->GetCompiledClass(class_ref);
- Class::Status status;
+ mirror::Class::Status status;
if (compiled_class != NULL) {
status = compiled_class->GetStatus();
} else if (verifier::MethodVerifier::IsClassRejected(class_ref)) {
- status = Class::kStatusError;
+ status = mirror::Class::kStatusError;
} else {
- status = Class::kStatusNotReady;
+ status = mirror::Class::kStatusNotReady;
}
OatClass* oat_class = new OatClass(status, num_methods);
@@ -307,16 +309,18 @@
// We expect GC maps except when the class hasn't been verified or the method is native
Compiler::ClassReference class_ref = Compiler::ClassReference(dex_file, class_def_index);
CompiledClass* compiled_class = compiler_->GetCompiledClass(class_ref);
- Class::Status status;
+ mirror::Class::Status status;
if (compiled_class != NULL) {
status = compiled_class->GetStatus();
} else if (verifier::MethodVerifier::IsClassRejected(class_ref)) {
- status = Class::kStatusError;
+ status = mirror::Class::kStatusError;
} else {
- status = Class::kStatusNotReady;
+ status = mirror::Class::kStatusNotReady;
}
- CHECK(gc_map_size != 0 || is_native || status < Class::kStatusVerified)
- << &gc_map << " " << gc_map_size << " " << (is_native ? "true" : "false") << " " << (status < Class::kStatusVerified) << " " << status << " " << PrettyMethod(method_idx, *dex_file);
+ CHECK(gc_map_size != 0 || is_native || status < mirror::Class::kStatusVerified)
+ << &gc_map << " " << gc_map_size << " " << (is_native ? "true" : "false") << " "
+ << (status < mirror::Class::kStatusVerified) << " " << status << " "
+ << PrettyMethod(method_idx, *dex_file);
#endif
// Deduplicate GC maps
@@ -396,11 +400,11 @@
if (compiler_->IsImage()) {
ClassLinker* linker = Runtime::Current()->GetClassLinker();
- DexCache* dex_cache = linker->FindDexCache(*dex_file);
+ mirror::DexCache* dex_cache = linker->FindDexCache(*dex_file);
// Unchecked as we hold mutator_lock_ on entry.
ScopedObjectAccessUnchecked soa(Thread::Current());
- AbstractMethod* method = linker->ResolveMethod(*dex_file, method_idx, dex_cache,
- NULL, NULL, type);
+ mirror::AbstractMethod* method = linker->ResolveMethod(*dex_file, method_idx, dex_cache,
+ NULL, NULL, type);
CHECK(method != NULL);
method->SetFrameSizeInBytes(frame_size_in_bytes);
method->SetCoreSpillMask(core_spill_mask);
@@ -836,7 +840,7 @@
return true;
}
-OatWriter::OatClass::OatClass(Class::Status status, uint32_t methods_count) {
+OatWriter::OatClass::OatClass(mirror::Class::Status status, uint32_t methods_count) {
status_ = status;
method_offsets_.resize(methods_count);
}
diff --git a/src/oat_writer.h b/src/oat_writer.h
index 2bcbbc5..e1638d0 100644
--- a/src/oat_writer.h
+++ b/src/oat_writer.h
@@ -22,10 +22,9 @@
#include <cstddef>
#include "compiler.h"
-#include "dex_cache.h"
#include "mem_map.h"
#include "oat.h"
-#include "object.h"
+#include "mirror/class.h"
#include "safe_map.h"
#include "UniquePtr.h"
@@ -136,13 +135,13 @@
class OatClass {
public:
- explicit OatClass(Class::Status status, uint32_t methods_count);
+ explicit OatClass(mirror::Class::Status status, uint32_t methods_count);
size_t SizeOf() const;
void UpdateChecksum(OatHeader& oat_header) const;
bool Write(OutputStream& out) const;
// data to write
- Class::Status status_;
+ mirror::Class::Status status_;
std::vector<OatMethodOffsets> method_offsets_;
private:
diff --git a/src/oatdump.cc b/src/oatdump.cc
index 5ee433c..3fe62bc 100644
--- a/src/oatdump.cc
+++ b/src/oatdump.cc
@@ -25,6 +25,7 @@
#include "base/stringpiece.h"
#include "base/unix_file/fd_file.h"
#include "class_linker.h"
+#include "class_linker-inl.h"
#include "dex_instruction.h"
#include "disassembler.h"
#include "gc_map.h"
@@ -32,6 +33,12 @@
#include "gc/space.h"
#include "image.h"
#include "indenter.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/array-inl.h"
+#include "mirror/class-inl.h"
+#include "mirror/field-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
#include "oat.h"
#include "object_utils.h"
#include "os.h"
@@ -162,7 +169,7 @@
return oat_file_.GetOatHeader().GetInstructionSet();
}
- const void* GetOatCode(AbstractMethod* m) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ const void* GetOatCode(mirror::AbstractMethod* m) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
MethodHelper mh(m);
for (size_t i = 0; i < oat_dex_files_.size(); i++) {
const OatFile::OatDexFile* oat_dex_file = oat_dex_files_[i];
@@ -580,8 +587,8 @@
uint32_t method_access_flags, uint32_t dex_pc) {
bool first = true;
ScopedObjectAccess soa(Thread::Current());
- DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(*dex_file);
- ClassLoader* class_loader = NULL;
+ mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(*dex_file);
+ mirror::ClassLoader* class_loader = NULL;
std::vector<int32_t> kinds =
verifier::MethodVerifier::DescribeVRegs(dex_method_idx, dex_file, dex_cache,
class_loader, class_def_idx, code_item, NULL,
@@ -633,8 +640,8 @@
uint32_t method_access_flags) {
if ((method_access_flags & kAccNative) == 0) {
ScopedObjectAccess soa(Thread::Current());
- DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(*dex_file);
- ClassLoader* class_loader = NULL;
+ mirror::DexCache* dex_cache = Runtime::Current()->GetClassLinker()->FindDexCache(*dex_file);
+ mirror::ClassLoader* class_loader = NULL;
verifier::MethodVerifier::VerifyMethodAndDump(os, dex_method_idx, dex_file, dex_cache,
class_loader, class_def_idx, code_item, NULL,
method_access_flags);
@@ -713,17 +720,17 @@
for (int i = 0; i < ImageHeader::kImageRootsMax; i++) {
ImageHeader::ImageRoot image_root = static_cast<ImageHeader::ImageRoot>(i);
const char* image_root_description = image_roots_descriptions_[i];
- Object* image_root_object = image_header_.GetImageRoot(image_root);
+ mirror::Object* image_root_object = image_header_.GetImageRoot(image_root);
indent1_os << StringPrintf("%s: %p\n", image_root_description, image_root_object);
if (image_root_object->IsObjectArray()) {
Indenter indent2_filter(indent1_os.rdbuf(), kIndentChar, kIndentBy1Count);
std::ostream indent2_os(&indent2_filter);
// TODO: replace down_cast with AsObjectArray (g++ currently has a problem with this)
- ObjectArray<Object>* image_root_object_array
- = down_cast<ObjectArray<Object>*>(image_root_object);
+ mirror::ObjectArray<mirror::Object>* image_root_object_array
+ = down_cast<mirror::ObjectArray<mirror::Object>*>(image_root_object);
// = image_root_object->AsObjectArray<Object>();
for (int i = 0; i < image_root_object_array->GetLength(); i++) {
- Object* value = image_root_object_array->Get(i);
+ mirror::Object* value = image_root_object_array->Get(i);
if (value != NULL) {
indent2_os << i << ": ";
PrettyObjectValue(indent2_os, value->GetClass(), value);
@@ -737,7 +744,7 @@
os << "\n";
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- Object* oat_location_object = image_header_.GetImageRoot(ImageHeader::kOatLocation);
+ mirror::Object* oat_location_object = image_header_.GetImageRoot(ImageHeader::kOatLocation);
std::string oat_location(oat_location_object->AsString()->ToModifiedUtf8());
os << "OAT LOCATION: " << oat_location;
if (!host_prefix_.empty()) {
@@ -811,36 +818,36 @@
}
private:
- static void PrettyObjectValue(std::ostream& os, Class* type, Object* value)
+ static void PrettyObjectValue(std::ostream& os, mirror::Class* type, mirror::Object* value)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
CHECK(type != NULL);
if (value == NULL) {
os << StringPrintf("null %s\n", PrettyDescriptor(type).c_str());
} else if (type->IsStringClass()) {
- String* string = value->AsString();
+ mirror::String* string = value->AsString();
os << StringPrintf("%p String: %s\n", string,
PrintableString(string->ToModifiedUtf8()).c_str());
} else if (type->IsClassClass()) {
- Class* klass = value->AsClass();
+ mirror::Class* klass = value->AsClass();
os << StringPrintf("%p Class: %s\n", klass, PrettyDescriptor(klass).c_str());
} else if (type->IsFieldClass()) {
- Field* field = value->AsField();
+ mirror::Field* field = value->AsField();
os << StringPrintf("%p Field: %s\n", field, PrettyField(field).c_str());
} else if (type->IsMethodClass()) {
- AbstractMethod* method = value->AsMethod();
+ mirror::AbstractMethod* method = value->AsMethod();
os << StringPrintf("%p Method: %s\n", method, PrettyMethod(method).c_str());
} else {
os << StringPrintf("%p %s\n", value, PrettyDescriptor(type).c_str());
}
}
- static void PrintField(std::ostream& os, Field* field, Object* obj)
+ static void PrintField(std::ostream& os, mirror::Field* field, mirror::Object* obj)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FieldHelper fh(field);
const char* descriptor = fh.GetTypeDescriptor();
os << StringPrintf("%s: ", fh.GetName());
if (descriptor[0] != 'L' && descriptor[0] != '[') {
- Class* type = fh.GetType();
+ mirror::Class* type = fh.GetType();
if (type->IsPrimitiveLong()) {
os << StringPrintf("%lld (0x%llx)\n", field->Get64(obj), field->Get64(obj));
} else if (type->IsPrimitiveDouble()) {
@@ -854,7 +861,7 @@
} else {
// Get the value, don't compute the type unless it is non-null as we don't want
// to cause class loading.
- Object* value = field->GetObj(obj);
+ mirror::Object* value = field->GetObj(obj);
if (value == NULL) {
os << StringPrintf("null %s\n", PrettyDescriptor(descriptor).c_str());
} else {
@@ -863,26 +870,26 @@
}
}
- static void DumpFields(std::ostream& os, Object* obj, Class* klass)
+ static void DumpFields(std::ostream& os, mirror::Object* obj, mirror::Class* klass)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Class* super = klass->GetSuperClass();
+ mirror::Class* super = klass->GetSuperClass();
if (super != NULL) {
DumpFields(os, obj, super);
}
- ObjectArray<Field>* fields = klass->GetIFields();
+ mirror::ObjectArray<mirror::Field>* fields = klass->GetIFields();
if (fields != NULL) {
for (int32_t i = 0; i < fields->GetLength(); i++) {
- Field* field = fields->Get(i);
+ mirror::Field* field = fields->Get(i);
PrintField(os, field, obj);
}
}
}
- bool InDumpSpace(const Object* object) {
+ bool InDumpSpace(const mirror::Object* object) {
return image_space_.Contains(object);
}
- const void* GetOatCodeBegin(AbstractMethod* m)
+ const void* GetOatCodeBegin(mirror::AbstractMethod* m)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Runtime* runtime = Runtime::Current();
const void* code = m->GetCode();
@@ -895,7 +902,7 @@
return code;
}
- uint32_t GetOatCodeSize(AbstractMethod* m)
+ uint32_t GetOatCodeSize(mirror::AbstractMethod* m)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
const uint32_t* oat_code_begin = reinterpret_cast<const uint32_t*>(GetOatCodeBegin(m));
if (oat_code_begin == NULL) {
@@ -904,7 +911,7 @@
return oat_code_begin[-1];
}
- const void* GetOatCodeEnd(AbstractMethod* m)
+ const void* GetOatCodeEnd(mirror::AbstractMethod* m)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
const uint8_t* oat_code_begin = reinterpret_cast<const uint8_t*>(GetOatCodeBegin(m));
if (oat_code_begin == NULL) {
@@ -913,7 +920,7 @@
return oat_code_begin + GetOatCodeSize(m);
}
- static void Callback(Object* obj, void* arg)
+ static void Callback(mirror::Object* obj, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(obj != NULL);
DCHECK(arg != NULL);
@@ -928,12 +935,12 @@
state->stats_.alignment_bytes += alignment_bytes;
std::ostream& os = *state->os_;
- Class* obj_class = obj->GetClass();
+ mirror::Class* obj_class = obj->GetClass();
if (obj_class->IsArrayClass()) {
os << StringPrintf("%p: %s length:%d\n", obj, PrettyDescriptor(obj_class).c_str(),
obj->AsArray()->GetLength());
} else if (obj->IsClass()) {
- Class* klass = obj->AsClass();
+ mirror::Class* klass = obj->AsClass();
os << StringPrintf("%p: java.lang.Class \"%s\" (", obj, PrettyDescriptor(klass).c_str())
<< klass->GetStatus() << ")\n";
} else if (obj->IsField()) {
@@ -952,10 +959,10 @@
std::ostream indent_os(&indent_filter);
DumpFields(indent_os, obj, obj_class);
if (obj->IsObjectArray()) {
- ObjectArray<Object>* obj_array = obj->AsObjectArray<Object>();
+ mirror::ObjectArray<mirror::Object>* obj_array = obj->AsObjectArray<mirror::Object>();
int32_t length = obj_array->GetLength();
for (int32_t i = 0; i < length; i++) {
- Object* value = obj_array->Get(i);
+ mirror::Object* value = obj_array->Get(i);
size_t run = 0;
for (int32_t j = i + 1; j < length; j++) {
if (value == obj_array->Get(j)) {
@@ -970,22 +977,22 @@
indent_os << StringPrintf("%d to %zd: ", i, i + run);
i = i + run;
}
- Class* value_class = value == NULL ? obj_class->GetComponentType() : value->GetClass();
+ mirror::Class* value_class = value == NULL ? obj_class->GetComponentType() : value->GetClass();
PrettyObjectValue(indent_os, value_class, value);
}
} else if (obj->IsClass()) {
- ObjectArray<Field>* sfields = obj->AsClass()->GetSFields();
+ mirror::ObjectArray<mirror::Field>* sfields = obj->AsClass()->GetSFields();
if (sfields != NULL) {
indent_os << "STATICS:\n";
Indenter indent2_filter(indent_os.rdbuf(), kIndentChar, kIndentBy1Count);
std::ostream indent2_os(&indent2_filter);
for (int32_t i = 0; i < sfields->GetLength(); i++) {
- Field* field = sfields->Get(i);
+ mirror::Field* field = sfields->Get(i);
PrintField(indent2_os, field, field->GetDeclaringClass());
}
}
} else if (obj->IsMethod()) {
- AbstractMethod* method = obj->AsMethod();
+ mirror::AbstractMethod* method = obj->AsMethod();
if (method->IsNative()) {
DCHECK(method->GetNativeGcMap() == NULL) << PrettyMethod(method);
DCHECK(method->GetMappingTable() == NULL) << PrettyMethod(method);
@@ -1110,7 +1117,7 @@
size_t dex_instruction_bytes;
- std::vector<AbstractMethod*> method_outlier;
+ std::vector<mirror::AbstractMethod*> method_outlier;
std::vector<size_t> method_outlier_size;
std::vector<double> method_outlier_expansion;
std::vector<std::pair<std::string, size_t> > oat_dex_file_sizes;
@@ -1163,7 +1170,7 @@
return (static_cast<double>(size) / static_cast<double>(object_bytes)) * 100;
}
- void ComputeOutliers(size_t total_size, double expansion, AbstractMethod* method) {
+ void ComputeOutliers(size_t total_size, double expansion, mirror::AbstractMethod* method) {
method_outlier_size.push_back(total_size);
method_outlier_expansion.push_back(expansion);
method_outlier.push_back(method);
diff --git a/src/oatexec.cc b/src/oatexec.cc
index ede47998..c05266c 100644
--- a/src/oatexec.cc
+++ b/src/oatexec.cc
@@ -23,7 +23,7 @@
#include "base/logging.h"
#include "jni.h"
-#include "object.h"
+#include "modifiers.h"
#include "ScopedLocalRef.h"
#include "toStringArray.h"
#include "UniquePtr.h"
diff --git a/src/object.cc b/src/object.cc
deleted file mode 100644
index 10bf672..0000000
--- a/src/object.cc
+++ /dev/null
@@ -1,1828 +0,0 @@
-/*
- * Copyright (C) 2011 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.
- */
-
-#include "object.h"
-
-#include <string.h>
-
-#include <algorithm>
-#include <iostream>
-#include <string>
-#include <utility>
-
-#include "base/logging.h"
-#include "class_linker.h"
-#include "class_loader.h"
-#include "dex_cache.h"
-#include "dex_file.h"
-#include "globals.h"
-#include "heap.h"
-#include "intern_table.h"
-#include "interpreter/interpreter.h"
-#include "monitor.h"
-#include "object_utils.h"
-#include "runtime.h"
-#include "runtime_support.h"
-#include "sirt_ref.h"
-#include "stack.h"
-#include "utils.h"
-#include "well_known_classes.h"
-
-namespace art {
-
-BooleanArray* Object::AsBooleanArray() {
- DCHECK(GetClass()->IsArrayClass());
- DCHECK(GetClass()->GetComponentType()->IsPrimitiveBoolean());
- return down_cast<BooleanArray*>(this);
-}
-
-ByteArray* Object::AsByteArray() {
- DCHECK(GetClass()->IsArrayClass());
- DCHECK(GetClass()->GetComponentType()->IsPrimitiveByte());
- return down_cast<ByteArray*>(this);
-}
-
-CharArray* Object::AsCharArray() {
- DCHECK(GetClass()->IsArrayClass());
- DCHECK(GetClass()->GetComponentType()->IsPrimitiveChar());
- return down_cast<CharArray*>(this);
-}
-
-ShortArray* Object::AsShortArray() {
- DCHECK(GetClass()->IsArrayClass());
- DCHECK(GetClass()->GetComponentType()->IsPrimitiveShort());
- return down_cast<ShortArray*>(this);
-}
-
-IntArray* Object::AsIntArray() {
- DCHECK(GetClass()->IsArrayClass());
- DCHECK(GetClass()->GetComponentType()->IsPrimitiveInt() ||
- GetClass()->GetComponentType()->IsPrimitiveFloat());
- return down_cast<IntArray*>(this);
-}
-
-LongArray* Object::AsLongArray() {
- DCHECK(GetClass()->IsArrayClass());
- DCHECK(GetClass()->GetComponentType()->IsPrimitiveLong() ||
- GetClass()->GetComponentType()->IsPrimitiveDouble());
- return down_cast<LongArray*>(this);
-}
-
-String* Object::AsString() {
- DCHECK(GetClass()->IsStringClass());
- return down_cast<String*>(this);
-}
-
-Throwable* Object::AsThrowable() {
- DCHECK(GetClass()->IsThrowableClass());
- return down_cast<Throwable*>(this);
-}
-
-Object* Object::Clone(Thread* self) {
- Class* c = GetClass();
- DCHECK(!c->IsClassClass());
-
- // Object::SizeOf gets the right size even if we're an array.
- // Using c->AllocObject() here would be wrong.
- size_t num_bytes = SizeOf();
- Heap* heap = Runtime::Current()->GetHeap();
- SirtRef<Object> copy(self, heap->AllocObject(self, c, num_bytes));
- if (copy.get() == NULL) {
- return NULL;
- }
-
- // Copy instance data. We assume memcpy copies by words.
- // TODO: expose and use move32.
- byte* src_bytes = reinterpret_cast<byte*>(this);
- byte* dst_bytes = reinterpret_cast<byte*>(copy.get());
- size_t offset = sizeof(Object);
- memcpy(dst_bytes + offset, src_bytes + offset, num_bytes - offset);
-
- // Perform write barriers on copied object references.
- if (c->IsArrayClass()) {
- if (!c->GetComponentType()->IsPrimitive()) {
- const ObjectArray<Object>* array = copy->AsObjectArray<Object>();
- heap->WriteBarrierArray(copy.get(), 0, array->GetLength());
- }
- } else {
- for (const Class* klass = c; klass != NULL; klass = klass->GetSuperClass()) {
- size_t num_reference_fields = klass->NumReferenceInstanceFields();
- for (size_t i = 0; i < num_reference_fields; ++i) {
- Field* field = klass->GetInstanceField(i);
- MemberOffset field_offset = field->GetOffset();
- const Object* ref = copy->GetFieldObject<const Object*>(field_offset, false);
- heap->WriteBarrierField(copy.get(), field_offset, ref);
- }
- }
- }
-
- if (c->IsFinalizable()) {
- heap->AddFinalizerReference(Thread::Current(), copy.get());
- }
-
- return copy.get();
-}
-
-uint32_t Object::GetThinLockId() {
- return Monitor::GetThinLockId(monitor_);
-}
-
-void Object::MonitorEnter(Thread* thread) {
- Monitor::MonitorEnter(thread, this);
-}
-
-bool Object::MonitorExit(Thread* thread) {
- return Monitor::MonitorExit(thread, this);
-}
-
-void Object::Notify() {
- Monitor::Notify(Thread::Current(), this);
-}
-
-void Object::NotifyAll() {
- Monitor::NotifyAll(Thread::Current(), this);
-}
-
-void Object::Wait() {
- Monitor::Wait(Thread::Current(), this, 0, 0, true, kWaiting);
-}
-
-void Object::Wait(int64_t ms, int32_t ns) {
- Monitor::Wait(Thread::Current(), this, ms, ns, true, kTimedWaiting);
-}
-
-#if VERIFY_OBJECT_ENABLED
-void Object::CheckFieldAssignment(MemberOffset field_offset, const Object* new_value) {
- const Class* c = GetClass();
- if (Runtime::Current()->GetClassLinker() == NULL ||
- !Runtime::Current()->GetHeap()->IsObjectValidationEnabled() ||
- !c->IsResolved()) {
- return;
- }
- for (const Class* cur = c; cur != NULL; cur = cur->GetSuperClass()) {
- ObjectArray<Field>* fields = cur->GetIFields();
- if (fields != NULL) {
- size_t num_ref_ifields = cur->NumReferenceInstanceFields();
- for (size_t i = 0; i < num_ref_ifields; ++i) {
- Field* field = fields->Get(i);
- if (field->GetOffset().Int32Value() == field_offset.Int32Value()) {
- FieldHelper fh(field);
- CHECK(fh.GetType()->IsAssignableFrom(new_value->GetClass()));
- return;
- }
- }
- }
- }
- if (c->IsArrayClass()) {
- // Bounds and assign-ability done in the array setter.
- return;
- }
- if (IsClass()) {
- ObjectArray<Field>* fields = AsClass()->GetSFields();
- if (fields != NULL) {
- size_t num_ref_sfields = AsClass()->NumReferenceStaticFields();
- for (size_t i = 0; i < num_ref_sfields; ++i) {
- Field* field = fields->Get(i);
- if (field->GetOffset().Int32Value() == field_offset.Int32Value()) {
- FieldHelper fh(field);
- CHECK(fh.GetType()->IsAssignableFrom(new_value->GetClass()));
- return;
- }
- }
- }
- }
- LOG(FATAL) << "Failed to find field for assignment to " << reinterpret_cast<void*>(this)
- << " of type " << PrettyDescriptor(c) << " at offset " << field_offset;
-}
-#endif
-
-// TODO: get global references for these
-Class* Field::java_lang_reflect_Field_ = NULL;
-
-void Field::SetClass(Class* java_lang_reflect_Field) {
- CHECK(java_lang_reflect_Field_ == NULL);
- CHECK(java_lang_reflect_Field != NULL);
- java_lang_reflect_Field_ = java_lang_reflect_Field;
-}
-
-void Field::ResetClass() {
- CHECK(java_lang_reflect_Field_ != NULL);
- java_lang_reflect_Field_ = NULL;
-}
-
-void Field::SetOffset(MemberOffset num_bytes) {
- DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
-#if 0 // TODO enable later in boot and under !NDEBUG
- FieldHelper fh(this);
- Primitive::Type type = fh.GetTypeAsPrimitiveType();
- if (type == Primitive::kPrimDouble || type == Primitive::kPrimLong) {
- DCHECK_ALIGNED(num_bytes.Uint32Value(), 8);
- }
-#endif
- SetField32(OFFSET_OF_OBJECT_MEMBER(Field, offset_), num_bytes.Uint32Value(), false);
-}
-
-uint32_t Field::Get32(const Object* object) const {
- DCHECK(object != NULL) << PrettyField(this);
- DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
- return object->GetField32(GetOffset(), IsVolatile());
-}
-
-void Field::Set32(Object* object, uint32_t new_value) const {
- DCHECK(object != NULL) << PrettyField(this);
- DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
- object->SetField32(GetOffset(), new_value, IsVolatile());
-}
-
-uint64_t Field::Get64(const Object* object) const {
- DCHECK(object != NULL) << PrettyField(this);
- DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
- return object->GetField64(GetOffset(), IsVolatile());
-}
-
-void Field::Set64(Object* object, uint64_t new_value) const {
- DCHECK(object != NULL) << PrettyField(this);
- DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
- object->SetField64(GetOffset(), new_value, IsVolatile());
-}
-
-Object* Field::GetObj(const Object* object) const {
- DCHECK(object != NULL) << PrettyField(this);
- DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
- return object->GetFieldObject<Object*>(GetOffset(), IsVolatile());
-}
-
-void Field::SetObj(Object* object, const Object* new_value) const {
- DCHECK(object != NULL) << PrettyField(this);
- DCHECK(!IsStatic() || (object == GetDeclaringClass()) || !Runtime::Current()->IsStarted());
- object->SetFieldObject(GetOffset(), new_value, IsVolatile());
-}
-
-bool Field::GetBoolean(const Object* object) const {
- DCHECK_EQ(Primitive::kPrimBoolean, FieldHelper(this).GetTypeAsPrimitiveType())
- << PrettyField(this);
- return Get32(object);
-}
-
-void Field::SetBoolean(Object* object, bool z) const {
- DCHECK_EQ(Primitive::kPrimBoolean, FieldHelper(this).GetTypeAsPrimitiveType())
- << PrettyField(this);
- Set32(object, z);
-}
-
-int8_t Field::GetByte(const Object* object) const {
- DCHECK_EQ(Primitive::kPrimByte, FieldHelper(this).GetTypeAsPrimitiveType())
- << PrettyField(this);
- return Get32(object);
-}
-
-void Field::SetByte(Object* object, int8_t b) const {
- DCHECK_EQ(Primitive::kPrimByte, FieldHelper(this).GetTypeAsPrimitiveType())
- << PrettyField(this);
- Set32(object, b);
-}
-
-uint16_t Field::GetChar(const Object* object) const {
- DCHECK_EQ(Primitive::kPrimChar, FieldHelper(this).GetTypeAsPrimitiveType())
- << PrettyField(this);
- return Get32(object);
-}
-
-void Field::SetChar(Object* object, uint16_t c) const {
- DCHECK_EQ(Primitive::kPrimChar, FieldHelper(this).GetTypeAsPrimitiveType())
- << PrettyField(this);
- Set32(object, c);
-}
-
-int16_t Field::GetShort(const Object* object) const {
- DCHECK_EQ(Primitive::kPrimShort, FieldHelper(this).GetTypeAsPrimitiveType())
- << PrettyField(this);
- return Get32(object);
-}
-
-void Field::SetShort(Object* object, int16_t s) const {
- DCHECK_EQ(Primitive::kPrimShort, FieldHelper(this).GetTypeAsPrimitiveType())
- << PrettyField(this);
- Set32(object, s);
-}
-
-int32_t Field::GetInt(const Object* object) const {
-#ifndef NDEBUG
- Primitive::Type type = FieldHelper(this).GetTypeAsPrimitiveType();
- CHECK(type == Primitive::kPrimInt || type == Primitive::kPrimFloat) << PrettyField(this);
-#endif
- return Get32(object);
-}
-
-void Field::SetInt(Object* object, int32_t i) const {
-#ifndef NDEBUG
- Primitive::Type type = FieldHelper(this).GetTypeAsPrimitiveType();
- CHECK(type == Primitive::kPrimInt || type == Primitive::kPrimFloat) << PrettyField(this);
-#endif
- Set32(object, i);
-}
-
-int64_t Field::GetLong(const Object* object) const {
-#ifndef NDEBUG
- Primitive::Type type = FieldHelper(this).GetTypeAsPrimitiveType();
- CHECK(type == Primitive::kPrimLong || type == Primitive::kPrimDouble) << PrettyField(this);
-#endif
- return Get64(object);
-}
-
-void Field::SetLong(Object* object, int64_t j) const {
-#ifndef NDEBUG
- Primitive::Type type = FieldHelper(this).GetTypeAsPrimitiveType();
- CHECK(type == Primitive::kPrimLong || type == Primitive::kPrimDouble) << PrettyField(this);
-#endif
- Set64(object, j);
-}
-
-union Bits {
- jdouble d;
- jfloat f;
- jint i;
- jlong j;
-};
-
-float Field::GetFloat(const Object* object) const {
- DCHECK_EQ(Primitive::kPrimFloat, FieldHelper(this).GetTypeAsPrimitiveType())
- << PrettyField(this);
- Bits bits;
- bits.i = Get32(object);
- return bits.f;
-}
-
-void Field::SetFloat(Object* object, float f) const {
- DCHECK_EQ(Primitive::kPrimFloat, FieldHelper(this).GetTypeAsPrimitiveType())
- << PrettyField(this);
- Bits bits;
- bits.f = f;
- Set32(object, bits.i);
-}
-
-double Field::GetDouble(const Object* object) const {
- DCHECK_EQ(Primitive::kPrimDouble, FieldHelper(this).GetTypeAsPrimitiveType())
- << PrettyField(this);
- Bits bits;
- bits.j = Get64(object);
- return bits.d;
-}
-
-void Field::SetDouble(Object* object, double d) const {
- DCHECK_EQ(Primitive::kPrimDouble, FieldHelper(this).GetTypeAsPrimitiveType())
- << PrettyField(this);
- Bits bits;
- bits.d = d;
- Set64(object, bits.j);
-}
-
-Object* Field::GetObject(const Object* object) const {
- DCHECK_EQ(Primitive::kPrimNot, FieldHelper(this).GetTypeAsPrimitiveType())
- << PrettyField(this);
- return GetObj(object);
-}
-
-void Field::SetObject(Object* object, const Object* l) const {
- DCHECK_EQ(Primitive::kPrimNot, FieldHelper(this).GetTypeAsPrimitiveType())
- << PrettyField(this);
- SetObj(object, l);
-}
-
-// TODO: get global references for these
-Class* AbstractMethod::java_lang_reflect_Constructor_ = NULL;
-Class* AbstractMethod::java_lang_reflect_Method_ = NULL;
-
-InvokeType AbstractMethod::GetInvokeType() const {
- // TODO: kSuper?
- if (GetDeclaringClass()->IsInterface()) {
- return kInterface;
- } else if (IsStatic()) {
- return kStatic;
- } else if (IsDirect()) {
- return kDirect;
- } else {
- return kVirtual;
- }
-}
-
-void AbstractMethod::SetClasses(Class* java_lang_reflect_Constructor, Class* java_lang_reflect_Method) {
- CHECK(java_lang_reflect_Constructor_ == NULL);
- CHECK(java_lang_reflect_Constructor != NULL);
- java_lang_reflect_Constructor_ = java_lang_reflect_Constructor;
-
- CHECK(java_lang_reflect_Method_ == NULL);
- CHECK(java_lang_reflect_Method != NULL);
- java_lang_reflect_Method_ = java_lang_reflect_Method;
-}
-
-void AbstractMethod::ResetClasses() {
- CHECK(java_lang_reflect_Constructor_ != NULL);
- java_lang_reflect_Constructor_ = NULL;
-
- CHECK(java_lang_reflect_Method_ != NULL);
- java_lang_reflect_Method_ = NULL;
-}
-
-ObjectArray<String>* AbstractMethod::GetDexCacheStrings() const {
- return GetFieldObject<ObjectArray<String>*>(
- OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_strings_), false);
-}
-
-void AbstractMethod::SetDexCacheStrings(ObjectArray<String>* new_dex_cache_strings) {
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_strings_),
- new_dex_cache_strings, false);
-}
-
-ObjectArray<AbstractMethod>* AbstractMethod::GetDexCacheResolvedMethods() const {
- return GetFieldObject<ObjectArray<AbstractMethod>*>(
- OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_methods_), false);
-}
-
-void AbstractMethod::SetDexCacheResolvedMethods(ObjectArray<AbstractMethod>* new_dex_cache_methods) {
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_methods_),
- new_dex_cache_methods, false);
-}
-
-ObjectArray<Class>* AbstractMethod::GetDexCacheResolvedTypes() const {
- return GetFieldObject<ObjectArray<Class>*>(
- OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_types_), false);
-}
-
-void AbstractMethod::SetDexCacheResolvedTypes(ObjectArray<Class>* new_dex_cache_classes) {
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_types_),
- new_dex_cache_classes, false);
-}
-
-ObjectArray<StaticStorageBase>* AbstractMethod::GetDexCacheInitializedStaticStorage() const {
- return GetFieldObject<ObjectArray<StaticStorageBase>*>(
- OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_initialized_static_storage_),
- false);
-}
-
-void AbstractMethod::SetDexCacheInitializedStaticStorage(ObjectArray<StaticStorageBase>* new_value) {
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_initialized_static_storage_),
- new_value, false);
-}
-
-size_t AbstractMethod::NumArgRegisters(const StringPiece& shorty) {
- CHECK_LE(1, shorty.length());
- uint32_t num_registers = 0;
- for (int i = 1; i < shorty.length(); ++i) {
- char ch = shorty[i];
- if (ch == 'D' || ch == 'J') {
- num_registers += 2;
- } else {
- num_registers += 1;
- }
- }
- return num_registers;
-}
-
-bool AbstractMethod::IsProxyMethod() const {
- return GetDeclaringClass()->IsProxyClass();
-}
-
-AbstractMethod* AbstractMethod::FindOverriddenMethod() const {
- if (IsStatic()) {
- return NULL;
- }
- Class* declaring_class = GetDeclaringClass();
- Class* super_class = declaring_class->GetSuperClass();
- uint16_t method_index = GetMethodIndex();
- ObjectArray<AbstractMethod>* super_class_vtable = super_class->GetVTable();
- AbstractMethod* result = NULL;
- // Did this method override a super class method? If so load the result from the super class'
- // vtable
- if (super_class_vtable != NULL && method_index < super_class_vtable->GetLength()) {
- result = super_class_vtable->Get(method_index);
- } else {
- // Method didn't override superclass method so search interfaces
- if (IsProxyMethod()) {
- result = GetDexCacheResolvedMethods()->Get(GetDexMethodIndex());
- CHECK_EQ(result,
- Runtime::Current()->GetClassLinker()->FindMethodForProxy(GetDeclaringClass(), this));
- } else {
- MethodHelper mh(this);
- MethodHelper interface_mh;
- IfTable* iftable = GetDeclaringClass()->GetIfTable();
- for (size_t i = 0; i < iftable->Count() && result == NULL; i++) {
- Class* interface = iftable->GetInterface(i);
- for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
- AbstractMethod* interface_method = interface->GetVirtualMethod(j);
- interface_mh.ChangeMethod(interface_method);
- if (mh.HasSameNameAndSignature(&interface_mh)) {
- result = interface_method;
- break;
- }
- }
- }
- }
- }
-#ifndef NDEBUG
- MethodHelper result_mh(result);
- DCHECK(result == NULL || MethodHelper(this).HasSameNameAndSignature(&result_mh));
-#endif
- return result;
-}
-
-static const void* GetOatCode(const AbstractMethod* m)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Runtime* runtime = Runtime::Current();
- const void* code = m->GetCode();
- // Peel off any method tracing trampoline.
- if (runtime->IsMethodTracingActive() && runtime->GetInstrumentation()->GetSavedCodeFromMap(m) != NULL) {
- code = runtime->GetInstrumentation()->GetSavedCodeFromMap(m);
- }
- // Peel off any resolution stub.
- if (code == runtime->GetResolutionStubArray(Runtime::kStaticMethod)->GetData()) {
- code = runtime->GetClassLinker()->GetOatCodeFor(m);
- }
- return code;
-}
-
-uintptr_t AbstractMethod::NativePcOffset(const uintptr_t pc) const {
- return pc - reinterpret_cast<uintptr_t>(GetOatCode(this));
-}
-
-// Find the lowest-address native safepoint pc for a given dex pc
-uintptr_t AbstractMethod::ToFirstNativeSafepointPc(const uint32_t dex_pc) const {
-#if !defined(ART_USE_LLVM_COMPILER)
- const uint32_t* mapping_table = GetPcToDexMappingTable();
- if (mapping_table == NULL) {
- DCHECK(IsNative() || IsCalleeSaveMethod() || IsProxyMethod()) << PrettyMethod(this);
- return DexFile::kDexNoIndex; // Special no mapping case
- }
- size_t mapping_table_length = GetPcToDexMappingTableLength();
- for (size_t i = 0; i < mapping_table_length; i += 2) {
- if (mapping_table[i + 1] == dex_pc) {
- return mapping_table[i] + reinterpret_cast<uintptr_t>(GetOatCode(this));
- }
- }
- LOG(FATAL) << "Failed to find native offset for dex pc 0x" << std::hex << dex_pc
- << " in " << PrettyMethod(this);
- return 0;
-#else
- // Compiler LLVM doesn't use the machine pc, we just use dex pc instead.
- return static_cast<uint32_t>(dex_pc);
-#endif
-}
-
-uint32_t AbstractMethod::ToDexPc(const uintptr_t pc) const {
-#if !defined(ART_USE_LLVM_COMPILER)
- const uint32_t* mapping_table = GetPcToDexMappingTable();
- if (mapping_table == NULL) {
- DCHECK(IsNative() || IsCalleeSaveMethod() || IsProxyMethod()) << PrettyMethod(this);
- return DexFile::kDexNoIndex; // Special no mapping case
- }
- size_t mapping_table_length = GetPcToDexMappingTableLength();
- uint32_t sought_offset = pc - reinterpret_cast<uintptr_t>(GetOatCode(this));
- for (size_t i = 0; i < mapping_table_length; i += 2) {
- if (mapping_table[i] == sought_offset) {
- return mapping_table[i + 1];
- }
- }
- LOG(ERROR) << "Failed to find Dex offset for PC offset " << reinterpret_cast<void*>(sought_offset)
- << "(PC " << reinterpret_cast<void*>(pc) << ") in " << PrettyMethod(this);
- return DexFile::kDexNoIndex;
-#else
- // Compiler LLVM doesn't use the machine pc, we just use dex pc instead.
- return static_cast<uint32_t>(pc);
-#endif
-}
-
-uintptr_t AbstractMethod::ToNativePc(const uint32_t dex_pc) const {
- const uint32_t* mapping_table = GetDexToPcMappingTable();
- if (mapping_table == NULL) {
- DCHECK_EQ(dex_pc, 0U);
- return 0; // Special no mapping/pc == 0 case
- }
- size_t mapping_table_length = GetDexToPcMappingTableLength();
- for (size_t i = 0; i < mapping_table_length; i += 2) {
- uint32_t map_offset = mapping_table[i];
- uint32_t map_dex_offset = mapping_table[i + 1];
- if (map_dex_offset == dex_pc) {
- return reinterpret_cast<uintptr_t>(GetOatCode(this)) + map_offset;
- }
- }
- LOG(FATAL) << "Looking up Dex PC not contained in method, 0x" << std::hex << dex_pc
- << " in " << PrettyMethod(this);
- return 0;
-}
-
-uint32_t AbstractMethod::FindCatchBlock(Class* exception_type, uint32_t dex_pc) const {
- MethodHelper mh(this);
- const DexFile::CodeItem* code_item = mh.GetCodeItem();
- // Iterate over the catch handlers associated with dex_pc
- for (CatchHandlerIterator it(*code_item, dex_pc); it.HasNext(); it.Next()) {
- uint16_t iter_type_idx = it.GetHandlerTypeIndex();
- // Catch all case
- if (iter_type_idx == DexFile::kDexNoIndex16) {
- return it.GetHandlerAddress();
- }
- // Does this catch exception type apply?
- Class* iter_exception_type = mh.GetDexCacheResolvedType(iter_type_idx);
- if (iter_exception_type == NULL) {
- // The verifier should take care of resolving all exception classes early
- LOG(WARNING) << "Unresolved exception class when finding catch block: "
- << mh.GetTypeDescriptorFromTypeIdx(iter_type_idx);
- } else if (iter_exception_type->IsAssignableFrom(exception_type)) {
- return it.GetHandlerAddress();
- }
- }
- // Handler not found
- return DexFile::kDexNoIndex;
-}
-
-void AbstractMethod::Invoke(Thread* self, Object* receiver, JValue* args, JValue* result) {
- if (kIsDebugBuild) {
- self->AssertThreadSuspensionIsAllowable();
- CHECK_EQ(kRunnable, self->GetState());
- }
-
- // Push a transition back into managed code onto the linked list in thread.
- ManagedStack fragment;
- self->PushManagedStackFragment(&fragment);
-
- // Call the invoke stub associated with the method.
- // Pass everything as arguments.
- AbstractMethod::InvokeStub* stub = GetInvokeStub();
-
- if (UNLIKELY(!Runtime::Current()->IsStarted())){
- LOG(INFO) << "Not invoking " << PrettyMethod(this) << " for a runtime that isn't started";
- if (result != NULL) {
- result->SetJ(0);
- }
- } else {
- bool interpret = self->ReadFlag(kEnterInterpreter) && !IsNative() && !IsProxyMethod();
- const bool kLogInvocationStartAndReturn = false;
- if (!interpret && GetCode() != NULL && stub != NULL) {
- if (kLogInvocationStartAndReturn) {
- LOG(INFO) << StringPrintf("Invoking '%s' code=%p stub=%p",
- PrettyMethod(this).c_str(), GetCode(), stub);
- }
- (*stub)(this, receiver, self, args, result);
- if (kLogInvocationStartAndReturn) {
- LOG(INFO) << StringPrintf("Returned '%s' code=%p stub=%p",
- PrettyMethod(this).c_str(), GetCode(), stub);
- }
- } else {
- const bool kInterpretMethodsWithNoCode = false;
- if (interpret || kInterpretMethodsWithNoCode) {
- if (kLogInvocationStartAndReturn) {
- LOG(INFO) << "Interpreting " << PrettyMethod(this) << "'";
- }
- art::interpreter::EnterInterpreterFromInvoke(self, this, receiver, args, result);
- if (kLogInvocationStartAndReturn) {
- LOG(INFO) << "Returned '" << PrettyMethod(this) << "'";
- }
- } else {
- LOG(INFO) << "Not invoking '" << PrettyMethod(this)
- << "' code=" << reinterpret_cast<const void*>(GetCode())
- << " stub=" << reinterpret_cast<void*>(stub);
- if (result != NULL) {
- result->SetJ(0);
- }
- }
- }
- }
-
- // Pop transition.
- self->PopManagedStackFragment(fragment);
-}
-
-bool AbstractMethod::IsRegistered() const {
- void* native_method = GetFieldPtr<void*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_method_), false);
- CHECK(native_method != NULL);
- void* jni_stub = Runtime::Current()->GetJniDlsymLookupStub()->GetData();
- return native_method != jni_stub;
-}
-
-void AbstractMethod::RegisterNative(Thread* self, const void* native_method) {
- DCHECK(Thread::Current() == self);
- CHECK(IsNative()) << PrettyMethod(this);
- CHECK(native_method != NULL) << PrettyMethod(this);
-#if defined(ART_USE_LLVM_COMPILER)
- SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_method_),
- native_method, false);
-#else
- if (!self->GetJniEnv()->vm->work_around_app_jni_bugs) {
- SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_method_),
- native_method, false);
- } else {
- // We've been asked to associate this method with the given native method but are working
- // around JNI bugs, that include not giving Object** SIRT references to native methods. Direct
- // the native method to runtime support and store the target somewhere runtime support will
- // find it.
-#if defined(__arm__)
- SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_method_),
- reinterpret_cast<const void*>(art_work_around_app_jni_bugs), false);
-#else
- UNIMPLEMENTED(FATAL);
-#endif
- SetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_gc_map_),
- reinterpret_cast<const uint8_t*>(native_method), false);
- }
-#endif
-}
-
-void AbstractMethod::UnregisterNative(Thread* self) {
- CHECK(IsNative()) << PrettyMethod(this);
- // restore stub to lookup native pointer via dlsym
- RegisterNative(self, Runtime::Current()->GetJniDlsymLookupStub()->GetData());
-}
-
-Class* Class::java_lang_Class_ = NULL;
-
-void Class::SetClassClass(Class* java_lang_Class) {
- CHECK(java_lang_Class_ == NULL) << java_lang_Class_ << " " << java_lang_Class;
- CHECK(java_lang_Class != NULL);
- java_lang_Class_ = java_lang_Class;
-}
-
-void Class::ResetClass() {
- CHECK(java_lang_Class_ != NULL);
- java_lang_Class_ = NULL;
-}
-
-void Class::SetStatus(Status new_status) {
- CHECK(new_status > GetStatus() || new_status == kStatusError || !Runtime::Current()->IsStarted())
- << PrettyClass(this) << " " << GetStatus() << " -> " << new_status;
- CHECK(sizeof(Status) == sizeof(uint32_t)) << PrettyClass(this);
- if (new_status > kStatusResolved) {
- CHECK_EQ(GetThinLockId(), Thread::Current()->GetThinLockId()) << PrettyClass(this);
- }
- if (new_status == kStatusError) {
- CHECK_NE(GetStatus(), kStatusError) << PrettyClass(this);
-
- // stash current exception
- Thread* self = Thread::Current();
- SirtRef<Throwable> exception(self, self->GetException());
- CHECK(exception.get() != NULL);
-
- // clear exception to call FindSystemClass
- self->ClearException();
- ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- Class* eiie_class = class_linker->FindSystemClass("Ljava/lang/ExceptionInInitializerError;");
- CHECK(!self->IsExceptionPending());
-
- // only verification errors, not initialization problems, should set a verify error.
- // this is to ensure that ThrowEarlierClassFailure will throw NoClassDefFoundError in that case.
- Class* exception_class = exception->GetClass();
- if (!eiie_class->IsAssignableFrom(exception_class)) {
- SetVerifyErrorClass(exception_class);
- }
-
- // restore exception
- self->SetException(exception.get());
- }
- return SetField32(OFFSET_OF_OBJECT_MEMBER(Class, status_), new_status, false);
-}
-
-DexCache* Class::GetDexCache() const {
- return GetFieldObject<DexCache*>(OFFSET_OF_OBJECT_MEMBER(Class, dex_cache_), false);
-}
-
-void Class::SetDexCache(DexCache* new_dex_cache) {
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, dex_cache_), new_dex_cache, false);
-}
-
-Object* Class::AllocObject(Thread* self) {
- DCHECK(!IsArrayClass()) << PrettyClass(this);
- DCHECK(IsInstantiable()) << PrettyClass(this);
- // TODO: decide whether we want this check. It currently fails during bootstrap.
- // DCHECK(!Runtime::Current()->IsStarted() || IsInitializing()) << PrettyClass(this);
- DCHECK_GE(this->object_size_, sizeof(Object));
- return Runtime::Current()->GetHeap()->AllocObject(self, this, this->object_size_);
-}
-
-void Class::SetClassSize(size_t new_class_size) {
- DCHECK_GE(new_class_size, GetClassSize()) << " class=" << PrettyTypeOf(this);
- SetField32(OFFSET_OF_OBJECT_MEMBER(Class, class_size_), new_class_size, false);
-}
-
-// Return the class' name. The exact format is bizarre, but it's the specified behavior for
-// Class.getName: keywords for primitive types, regular "[I" form for primitive arrays (so "int"
-// but "[I"), and arrays of reference types written between "L" and ";" but with dots rather than
-// slashes (so "java.lang.String" but "[Ljava.lang.String;"). Madness.
-String* Class::ComputeName() {
- String* name = GetName();
- if (name != NULL) {
- return name;
- }
- std::string descriptor(ClassHelper(this).GetDescriptor());
- if ((descriptor[0] != 'L') && (descriptor[0] != '[')) {
- // The descriptor indicates that this is the class for
- // a primitive type; special-case the return value.
- const char* c_name = NULL;
- switch (descriptor[0]) {
- case 'Z': c_name = "boolean"; break;
- case 'B': c_name = "byte"; break;
- case 'C': c_name = "char"; break;
- case 'S': c_name = "short"; break;
- case 'I': c_name = "int"; break;
- case 'J': c_name = "long"; break;
- case 'F': c_name = "float"; break;
- case 'D': c_name = "double"; break;
- case 'V': c_name = "void"; break;
- default:
- LOG(FATAL) << "Unknown primitive type: " << PrintableChar(descriptor[0]);
- }
- name = String::AllocFromModifiedUtf8(Thread::Current(), c_name);
- } else {
- // Convert the UTF-8 name to a java.lang.String. The name must use '.' to separate package
- // components.
- if (descriptor.size() > 2 && descriptor[0] == 'L' && descriptor[descriptor.size() - 1] == ';') {
- descriptor.erase(0, 1);
- descriptor.erase(descriptor.size() - 1);
- }
- std::replace(descriptor.begin(), descriptor.end(), '/', '.');
- name = String::AllocFromModifiedUtf8(Thread::Current(), descriptor.c_str());
- }
- SetName(name);
- return name;
-}
-
-void Class::DumpClass(std::ostream& os, int flags) const {
- if ((flags & kDumpClassFullDetail) == 0) {
- os << PrettyClass(this);
- if ((flags & kDumpClassClassLoader) != 0) {
- os << ' ' << GetClassLoader();
- }
- if ((flags & kDumpClassInitialized) != 0) {
- os << ' ' << GetStatus();
- }
- os << "\n";
- return;
- }
-
- Class* super = GetSuperClass();
- ClassHelper kh(this);
- os << "----- " << (IsInterface() ? "interface" : "class") << " "
- << "'" << kh.GetDescriptor() << "' cl=" << GetClassLoader() << " -----\n",
- os << " objectSize=" << SizeOf() << " "
- << "(" << (super != NULL ? super->SizeOf() : -1) << " from super)\n",
- os << StringPrintf(" access=0x%04x.%04x\n",
- GetAccessFlags() >> 16, GetAccessFlags() & kAccJavaFlagsMask);
- if (super != NULL) {
- os << " super='" << PrettyClass(super) << "' (cl=" << super->GetClassLoader() << ")\n";
- }
- if (IsArrayClass()) {
- os << " componentType=" << PrettyClass(GetComponentType()) << "\n";
- }
- if (kh.NumDirectInterfaces() > 0) {
- os << " interfaces (" << kh.NumDirectInterfaces() << "):\n";
- for (size_t i = 0; i < kh.NumDirectInterfaces(); ++i) {
- Class* interface = kh.GetDirectInterface(i);
- const ClassLoader* cl = interface->GetClassLoader();
- os << StringPrintf(" %2zd: %s (cl=%p)\n", i, PrettyClass(interface).c_str(), cl);
- }
- }
- os << " vtable (" << NumVirtualMethods() << " entries, "
- << (super != NULL ? super->NumVirtualMethods() : 0) << " in super):\n";
- for (size_t i = 0; i < NumVirtualMethods(); ++i) {
- os << StringPrintf(" %2zd: %s\n", i, PrettyMethod(GetVirtualMethodDuringLinking(i)).c_str());
- }
- os << " direct methods (" << NumDirectMethods() << " entries):\n";
- for (size_t i = 0; i < NumDirectMethods(); ++i) {
- os << StringPrintf(" %2zd: %s\n", i, PrettyMethod(GetDirectMethod(i)).c_str());
- }
- if (NumStaticFields() > 0) {
- os << " static fields (" << NumStaticFields() << " entries):\n";
- if (IsResolved() || IsErroneous()) {
- for (size_t i = 0; i < NumStaticFields(); ++i) {
- os << StringPrintf(" %2zd: %s\n", i, PrettyField(GetStaticField(i)).c_str());
- }
- } else {
- os << " <not yet available>";
- }
- }
- if (NumInstanceFields() > 0) {
- os << " instance fields (" << NumInstanceFields() << " entries):\n";
- if (IsResolved() || IsErroneous()) {
- for (size_t i = 0; i < NumInstanceFields(); ++i) {
- os << StringPrintf(" %2zd: %s\n", i, PrettyField(GetInstanceField(i)).c_str());
- }
- } else {
- os << " <not yet available>";
- }
- }
-}
-
-void Class::SetReferenceInstanceOffsets(uint32_t new_reference_offsets) {
- if (new_reference_offsets != CLASS_WALK_SUPER) {
- // Sanity check that the number of bits set in the reference offset bitmap
- // agrees with the number of references
- size_t count = 0;
- for (Class* c = this; c != NULL; c = c->GetSuperClass()) {
- count += c->NumReferenceInstanceFieldsDuringLinking();
- }
- CHECK_EQ((size_t)__builtin_popcount(new_reference_offsets), count);
- }
- SetField32(OFFSET_OF_OBJECT_MEMBER(Class, reference_instance_offsets_),
- new_reference_offsets, false);
-}
-
-void Class::SetReferenceStaticOffsets(uint32_t new_reference_offsets) {
- if (new_reference_offsets != CLASS_WALK_SUPER) {
- // Sanity check that the number of bits set in the reference offset bitmap
- // agrees with the number of references
- CHECK_EQ((size_t)__builtin_popcount(new_reference_offsets),
- NumReferenceStaticFieldsDuringLinking());
- }
- SetField32(OFFSET_OF_OBJECT_MEMBER(Class, reference_static_offsets_),
- new_reference_offsets, false);
-}
-
-bool Class::Implements(const Class* klass) const {
- DCHECK(klass != NULL);
- DCHECK(klass->IsInterface()) << PrettyClass(this);
- // All interfaces implemented directly and by our superclass, and
- // recursively all super-interfaces of those interfaces, are listed
- // in iftable_, so we can just do a linear scan through that.
- int32_t iftable_count = GetIfTableCount();
- IfTable* iftable = GetIfTable();
- for (int32_t i = 0; i < iftable_count; i++) {
- if (iftable->GetInterface(i) == klass) {
- return true;
- }
- }
- return false;
-}
-
-// Determine whether "this" is assignable from "src", where both of these
-// are array classes.
-//
-// Consider an array class, e.g. Y[][], where Y is a subclass of X.
-// Y[][] = Y[][] --> true (identity)
-// X[][] = Y[][] --> true (element superclass)
-// Y = Y[][] --> false
-// Y[] = Y[][] --> false
-// Object = Y[][] --> true (everything is an object)
-// Object[] = Y[][] --> true
-// Object[][] = Y[][] --> true
-// Object[][][] = Y[][] --> false (too many []s)
-// Serializable = Y[][] --> true (all arrays are Serializable)
-// Serializable[] = Y[][] --> true
-// Serializable[][] = Y[][] --> false (unless Y is Serializable)
-//
-// Don't forget about primitive types.
-// Object[] = int[] --> false
-//
-bool Class::IsArrayAssignableFromArray(const Class* src) const {
- DCHECK(IsArrayClass()) << PrettyClass(this);
- DCHECK(src->IsArrayClass()) << PrettyClass(src);
- return GetComponentType()->IsAssignableFrom(src->GetComponentType());
-}
-
-bool Class::IsAssignableFromArray(const Class* src) const {
- DCHECK(!IsInterface()) << PrettyClass(this); // handled first in IsAssignableFrom
- DCHECK(src->IsArrayClass()) << PrettyClass(src);
- if (!IsArrayClass()) {
- // If "this" is not also an array, it must be Object.
- // src's super should be java_lang_Object, since it is an array.
- Class* java_lang_Object = src->GetSuperClass();
- DCHECK(java_lang_Object != NULL) << PrettyClass(src);
- DCHECK(java_lang_Object->GetSuperClass() == NULL) << PrettyClass(src);
- return this == java_lang_Object;
- }
- return IsArrayAssignableFromArray(src);
-}
-
-bool Class::IsSubClass(const Class* klass) const {
- DCHECK(!IsInterface()) << PrettyClass(this);
- DCHECK(!IsArrayClass()) << PrettyClass(this);
- const Class* current = this;
- do {
- if (current == klass) {
- return true;
- }
- current = current->GetSuperClass();
- } while (current != NULL);
- return false;
-}
-
-bool Class::IsInSamePackage(const StringPiece& descriptor1, const StringPiece& descriptor2) {
- size_t i = 0;
- while (descriptor1[i] != '\0' && descriptor1[i] == descriptor2[i]) {
- ++i;
- }
- if (descriptor1.find('/', i) != StringPiece::npos ||
- descriptor2.find('/', i) != StringPiece::npos) {
- return false;
- } else {
- return true;
- }
-}
-
-bool Class::IsInSamePackage(const Class* that) const {
- const Class* klass1 = this;
- const Class* klass2 = that;
- if (klass1 == klass2) {
- return true;
- }
- // Class loaders must match.
- if (klass1->GetClassLoader() != klass2->GetClassLoader()) {
- return false;
- }
- // Arrays are in the same package when their element classes are.
- while (klass1->IsArrayClass()) {
- klass1 = klass1->GetComponentType();
- }
- while (klass2->IsArrayClass()) {
- klass2 = klass2->GetComponentType();
- }
- // Compare the package part of the descriptor string.
- ClassHelper kh(klass1);
- std::string descriptor1(kh.GetDescriptor());
- kh.ChangeClass(klass2);
- std::string descriptor2(kh.GetDescriptor());
- return IsInSamePackage(descriptor1, descriptor2);
-}
-
-bool Class::IsClassClass() const {
- Class* java_lang_Class = GetClass()->GetClass();
- return this == java_lang_Class;
-}
-
-bool Class::IsStringClass() const {
- return this == String::GetJavaLangString();
-}
-
-bool Class::IsThrowableClass() const {
- return WellKnownClasses::ToClass(WellKnownClasses::java_lang_Throwable)->IsAssignableFrom(this);
-}
-
-bool Class::IsFieldClass() const {
- Class* java_lang_Class = GetClass();
- Class* java_lang_reflect_Field = java_lang_Class->GetInstanceField(0)->GetClass();
- return this == java_lang_reflect_Field;
-
-}
-
-bool Class::IsMethodClass() const {
- return (this == AbstractMethod::GetMethodClass()) ||
- (this == AbstractMethod::GetConstructorClass());
-
-}
-
-ClassLoader* Class::GetClassLoader() const {
- return GetFieldObject<ClassLoader*>(OFFSET_OF_OBJECT_MEMBER(Class, class_loader_), false);
-}
-
-void Class::SetClassLoader(ClassLoader* new_class_loader) {
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, class_loader_), new_class_loader, false);
-}
-
-AbstractMethod* Class::FindVirtualMethodForInterface(AbstractMethod* method) {
- Class* declaring_class = method->GetDeclaringClass();
- DCHECK(declaring_class != NULL) << PrettyClass(this);
- DCHECK(declaring_class->IsInterface()) << PrettyMethod(method);
- // TODO cache to improve lookup speed
- int32_t iftable_count = GetIfTableCount();
- IfTable* iftable = GetIfTable();
- for (int32_t i = 0; i < iftable_count; i++) {
- if (iftable->GetInterface(i) == declaring_class) {
- return iftable->GetMethodArray(i)->Get(method->GetMethodIndex());
- }
- }
- return NULL;
-}
-
-AbstractMethod* Class::FindInterfaceMethod(const StringPiece& name, const StringPiece& signature) const {
- // Check the current class before checking the interfaces.
- AbstractMethod* method = FindDeclaredVirtualMethod(name, signature);
- if (method != NULL) {
- return method;
- }
-
- int32_t iftable_count = GetIfTableCount();
- IfTable* iftable = GetIfTable();
- for (int32_t i = 0; i < iftable_count; i++) {
- method = iftable->GetInterface(i)->FindDeclaredVirtualMethod(name, signature);
- if (method != NULL) {
- return method;
- }
- }
- return NULL;
-}
-
-AbstractMethod* Class::FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
- // Check the current class before checking the interfaces.
- AbstractMethod* method = FindDeclaredVirtualMethod(dex_cache, dex_method_idx);
- if (method != NULL) {
- return method;
- }
-
- int32_t iftable_count = GetIfTableCount();
- IfTable* iftable = GetIfTable();
- for (int32_t i = 0; i < iftable_count; i++) {
- method = iftable->GetInterface(i)->FindDeclaredVirtualMethod(dex_cache, dex_method_idx);
- if (method != NULL) {
- return method;
- }
- }
- return NULL;
-}
-
-
-AbstractMethod* Class::FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature) const {
- MethodHelper mh;
- for (size_t i = 0; i < NumDirectMethods(); ++i) {
- AbstractMethod* method = GetDirectMethod(i);
- mh.ChangeMethod(method);
- if (name == mh.GetName() && signature == mh.GetSignature()) {
- return method;
- }
- }
- return NULL;
-}
-
-AbstractMethod* Class::FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
- if (GetDexCache() == dex_cache) {
- for (size_t i = 0; i < NumDirectMethods(); ++i) {
- AbstractMethod* method = GetDirectMethod(i);
- if (method->GetDexMethodIndex() == dex_method_idx) {
- return method;
- }
- }
- }
- return NULL;
-}
-
-AbstractMethod* Class::FindDirectMethod(const StringPiece& name, const StringPiece& signature) const {
- for (const Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) {
- AbstractMethod* method = klass->FindDeclaredDirectMethod(name, signature);
- if (method != NULL) {
- return method;
- }
- }
- return NULL;
-}
-
-AbstractMethod* Class::FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
- for (const Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) {
- AbstractMethod* method = klass->FindDeclaredDirectMethod(dex_cache, dex_method_idx);
- if (method != NULL) {
- return method;
- }
- }
- return NULL;
-}
-
-AbstractMethod* Class::FindDeclaredVirtualMethod(const StringPiece& name,
- const StringPiece& signature) const {
- MethodHelper mh;
- for (size_t i = 0; i < NumVirtualMethods(); ++i) {
- AbstractMethod* method = GetVirtualMethod(i);
- mh.ChangeMethod(method);
- if (name == mh.GetName() && signature == mh.GetSignature()) {
- return method;
- }
- }
- return NULL;
-}
-
-AbstractMethod* Class::FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
- if (GetDexCache() == dex_cache) {
- for (size_t i = 0; i < NumVirtualMethods(); ++i) {
- AbstractMethod* method = GetVirtualMethod(i);
- if (method->GetDexMethodIndex() == dex_method_idx) {
- return method;
- }
- }
- }
- return NULL;
-}
-
-AbstractMethod* Class::FindVirtualMethod(const StringPiece& name, const StringPiece& signature) const {
- for (const Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) {
- AbstractMethod* method = klass->FindDeclaredVirtualMethod(name, signature);
- if (method != NULL) {
- return method;
- }
- }
- return NULL;
-}
-
-AbstractMethod* Class::FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
- for (const Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) {
- AbstractMethod* method = klass->FindDeclaredVirtualMethod(dex_cache, dex_method_idx);
- if (method != NULL) {
- return method;
- }
- }
- return NULL;
-}
-
-Field* Class::FindDeclaredInstanceField(const StringPiece& name, const StringPiece& type) {
- // Is the field in this class?
- // Interfaces are not relevant because they can't contain instance fields.
- FieldHelper fh;
- for (size_t i = 0; i < NumInstanceFields(); ++i) {
- Field* f = GetInstanceField(i);
- fh.ChangeField(f);
- if (name == fh.GetName() && type == fh.GetTypeDescriptor()) {
- return f;
- }
- }
- return NULL;
-}
-
-Field* Class::FindDeclaredInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx) {
- if (GetDexCache() == dex_cache) {
- for (size_t i = 0; i < NumInstanceFields(); ++i) {
- Field* f = GetInstanceField(i);
- if (f->GetDexFieldIndex() == dex_field_idx) {
- return f;
- }
- }
- }
- return NULL;
-}
-
-Field* Class::FindInstanceField(const StringPiece& name, const StringPiece& type) {
- // Is the field in this class, or any of its superclasses?
- // Interfaces are not relevant because they can't contain instance fields.
- for (Class* c = this; c != NULL; c = c->GetSuperClass()) {
- Field* f = c->FindDeclaredInstanceField(name, type);
- if (f != NULL) {
- return f;
- }
- }
- return NULL;
-}
-
-Field* Class::FindInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx) {
- // Is the field in this class, or any of its superclasses?
- // Interfaces are not relevant because they can't contain instance fields.
- for (Class* c = this; c != NULL; c = c->GetSuperClass()) {
- Field* f = c->FindDeclaredInstanceField(dex_cache, dex_field_idx);
- if (f != NULL) {
- return f;
- }
- }
- return NULL;
-}
-
-Field* Class::FindDeclaredStaticField(const StringPiece& name, const StringPiece& type) {
- DCHECK(type != NULL);
- FieldHelper fh;
- for (size_t i = 0; i < NumStaticFields(); ++i) {
- Field* f = GetStaticField(i);
- fh.ChangeField(f);
- if (name == fh.GetName() && type == fh.GetTypeDescriptor()) {
- return f;
- }
- }
- return NULL;
-}
-
-Field* Class::FindDeclaredStaticField(const DexCache* dex_cache, uint32_t dex_field_idx) {
- if (dex_cache == GetDexCache()) {
- for (size_t i = 0; i < NumStaticFields(); ++i) {
- Field* f = GetStaticField(i);
- if (f->GetDexFieldIndex() == dex_field_idx) {
- return f;
- }
- }
- }
- return NULL;
-}
-
-Field* Class::FindStaticField(const StringPiece& name, const StringPiece& type) {
- // Is the field in this class (or its interfaces), or any of its
- // superclasses (or their interfaces)?
- ClassHelper kh;
- for (Class* k = this; k != NULL; k = k->GetSuperClass()) {
- // Is the field in this class?
- Field* f = k->FindDeclaredStaticField(name, type);
- if (f != NULL) {
- return f;
- }
- // Is this field in any of this class' interfaces?
- kh.ChangeClass(k);
- for (uint32_t i = 0; i < kh.NumDirectInterfaces(); ++i) {
- Class* interface = kh.GetDirectInterface(i);
- f = interface->FindStaticField(name, type);
- if (f != NULL) {
- return f;
- }
- }
- }
- return NULL;
-}
-
-Field* Class::FindStaticField(const DexCache* dex_cache, uint32_t dex_field_idx) {
- ClassHelper kh;
- for (Class* k = this; k != NULL; k = k->GetSuperClass()) {
- // Is the field in this class?
- Field* f = k->FindDeclaredStaticField(dex_cache, dex_field_idx);
- if (f != NULL) {
- return f;
- }
- // Is this field in any of this class' interfaces?
- kh.ChangeClass(k);
- for (uint32_t i = 0; i < kh.NumDirectInterfaces(); ++i) {
- Class* interface = kh.GetDirectInterface(i);
- f = interface->FindStaticField(dex_cache, dex_field_idx);
- if (f != NULL) {
- return f;
- }
- }
- }
- return NULL;
-}
-
-Field* Class::FindField(const StringPiece& name, const StringPiece& type) {
- // Find a field using the JLS field resolution order
- ClassHelper kh;
- for (Class* k = this; k != NULL; k = k->GetSuperClass()) {
- // Is the field in this class?
- Field* f = k->FindDeclaredInstanceField(name, type);
- if (f != NULL) {
- return f;
- }
- f = k->FindDeclaredStaticField(name, type);
- if (f != NULL) {
- return f;
- }
- // Is this field in any of this class' interfaces?
- kh.ChangeClass(k);
- for (uint32_t i = 0; i < kh.NumDirectInterfaces(); ++i) {
- Class* interface = kh.GetDirectInterface(i);
- f = interface->FindStaticField(name, type);
- if (f != NULL) {
- return f;
- }
- }
- }
- return NULL;
-}
-
-Array* Array::Alloc(Thread* self, Class* array_class, int32_t component_count,
- size_t component_size) {
- DCHECK(array_class != NULL);
- DCHECK_GE(component_count, 0);
- DCHECK(array_class->IsArrayClass());
-
- size_t header_size = sizeof(Object) + (component_size == sizeof(int64_t) ? 8 : 4);
- size_t data_size = component_count * component_size;
- size_t size = header_size + data_size;
-
- // Check for overflow and throw OutOfMemoryError if this was an unreasonable request.
- size_t component_shift = sizeof(size_t) * 8 - 1 - CLZ(component_size);
- if (data_size >> component_shift != size_t(component_count) || size < data_size) {
- self->ThrowNewExceptionF("Ljava/lang/OutOfMemoryError;",
- "%s of length %d would overflow",
- PrettyDescriptor(array_class).c_str(), component_count);
- return NULL;
- }
-
- Heap* heap = Runtime::Current()->GetHeap();
- Array* array = down_cast<Array*>(heap->AllocObject(self, array_class, size));
- if (array != NULL) {
- DCHECK(array->IsArrayInstance());
- array->SetLength(component_count);
- }
- return array;
-}
-
-Array* Array::Alloc(Thread* self, Class* array_class, int32_t component_count) {
- DCHECK(array_class->IsArrayClass());
- return Alloc(self, array_class, component_count, array_class->GetComponentSize());
-}
-
-// Create a multi-dimensional array of Objects or primitive types.
-//
-// We have to generate the names for X[], X[][], X[][][], and so on. The
-// easiest way to deal with that is to create the full name once and then
-// subtract pieces off. Besides, we want to start with the outermost
-// piece and work our way in.
-// Recursively create an array with multiple dimensions. Elements may be
-// Objects or primitive types.
-static Array* RecursiveCreateMultiArray(Thread* self, Class* array_class, int current_dimension,
- IntArray* dimensions)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- int32_t array_length = dimensions->Get(current_dimension);
- SirtRef<Array> new_array(self, Array::Alloc(self, array_class, array_length));
- if (UNLIKELY(new_array.get() == NULL)) {
- CHECK(self->IsExceptionPending());
- return NULL;
- }
- if ((current_dimension + 1) < dimensions->GetLength()) {
- // Create a new sub-array in every element of the array.
- for (int32_t i = 0; i < array_length; i++) {
- Array* sub_array = RecursiveCreateMultiArray(self, array_class->GetComponentType(),
- current_dimension + 1, dimensions);
- if (UNLIKELY(sub_array == NULL)) {
- CHECK(self->IsExceptionPending());
- return NULL;
- }
- new_array->AsObjectArray<Array>()->Set(i, sub_array);
- }
- }
- return new_array.get();
-}
-
-Array* Array::CreateMultiArray(Thread* self, Class* element_class, IntArray* dimensions) {
- // Verify dimensions.
- //
- // The caller is responsible for verifying that "dimArray" is non-null
- // and has a length > 0 and <= 255.
- int num_dimensions = dimensions->GetLength();
- DCHECK_GT(num_dimensions, 0);
- DCHECK_LE(num_dimensions, 255);
-
- for (int i = 0; i < num_dimensions; i++) {
- int dimension = dimensions->Get(i);
- if (UNLIKELY(dimension < 0)) {
- self->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;",
- "Dimension %d: %d", i, dimension);
- return NULL;
- }
- }
-
- // Generate the full name of the array class.
- std::string descriptor(num_dimensions, '[');
- descriptor += ClassHelper(element_class).GetDescriptor();
-
- // Find/generate the array class.
- ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- Class* array_class = class_linker->FindClass(descriptor.c_str(), element_class->GetClassLoader());
- if (UNLIKELY(array_class == NULL)) {
- CHECK(self->IsExceptionPending());
- return NULL;
- }
- // create the array
- Array* new_array = RecursiveCreateMultiArray(self, array_class, 0, dimensions);
- if (UNLIKELY(new_array == NULL)) {
- CHECK(self->IsExceptionPending());
- return NULL;
- }
- return new_array;
-}
-
-bool Array::ThrowArrayIndexOutOfBoundsException(int32_t index) const {
- Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
- "length=%i; index=%i", length_, index);
- return false;
-}
-
-bool Array::ThrowArrayStoreException(Object* object) const {
- Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayStoreException;",
- "%s cannot be stored in an array of type %s",
- PrettyTypeOf(object).c_str(), PrettyTypeOf(this).c_str());
- return false;
-}
-
-template<typename T>
-PrimitiveArray<T>* PrimitiveArray<T>::Alloc(Thread* self, size_t length) {
- DCHECK(array_class_ != NULL);
- Array* raw_array = Array::Alloc(self, array_class_, length, sizeof(T));
- return down_cast<PrimitiveArray<T>*>(raw_array);
-}
-
-template <typename T> Class* PrimitiveArray<T>::array_class_ = NULL;
-
-// Explicitly instantiate all the primitive array types.
-template class PrimitiveArray<uint8_t>; // BooleanArray
-template class PrimitiveArray<int8_t>; // ByteArray
-template class PrimitiveArray<uint16_t>; // CharArray
-template class PrimitiveArray<double>; // DoubleArray
-template class PrimitiveArray<float>; // FloatArray
-template class PrimitiveArray<int32_t>; // IntArray
-template class PrimitiveArray<int64_t>; // LongArray
-template class PrimitiveArray<int16_t>; // ShortArray
-
-// Explicitly instantiate Class[][]
-template class ObjectArray<ObjectArray<Class> >;
-
-// TODO: get global references for these
-Class* String::java_lang_String_ = NULL;
-
-void String::SetClass(Class* java_lang_String) {
- CHECK(java_lang_String_ == NULL);
- CHECK(java_lang_String != NULL);
- java_lang_String_ = java_lang_String;
-}
-
-void String::ResetClass() {
- CHECK(java_lang_String_ != NULL);
- java_lang_String_ = NULL;
-}
-
-String* String::Intern() {
- return Runtime::Current()->GetInternTable()->InternWeak(this);
-}
-
-int32_t String::GetHashCode() {
- int32_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(String, hash_code_), false);
- if (result == 0) {
- ComputeHashCode();
- }
- result = GetField32(OFFSET_OF_OBJECT_MEMBER(String, hash_code_), false);
- DCHECK(result != 0 || ComputeUtf16Hash(GetCharArray(), GetOffset(), GetLength()) == 0)
- << ToModifiedUtf8() << " " << result;
- return result;
-}
-
-int32_t String::GetLength() const {
- int32_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(String, count_), false);
- DCHECK(result >= 0 && result <= GetCharArray()->GetLength());
- return result;
-}
-
-uint16_t String::CharAt(int32_t index) const {
- // TODO: do we need this? Equals is the only caller, and could
- // bounds check itself.
- if (index < 0 || index >= count_) {
- Thread* self = Thread::Current();
- self->ThrowNewExceptionF("Ljava/lang/StringIndexOutOfBoundsException;",
- "length=%i; index=%i", count_, index);
- return 0;
- }
- return GetCharArray()->Get(index + GetOffset());
-}
-
-String* String::AllocFromUtf16(Thread* self,
- int32_t utf16_length,
- const uint16_t* utf16_data_in,
- int32_t hash_code) {
- CHECK(utf16_data_in != NULL || utf16_length == 0);
- String* string = Alloc(self, GetJavaLangString(), utf16_length);
- if (string == NULL) {
- return NULL;
- }
- // TODO: use 16-bit wide memset variant
- CharArray* array = const_cast<CharArray*>(string->GetCharArray());
- if (array == NULL) {
- return NULL;
- }
- for (int i = 0; i < utf16_length; i++) {
- array->Set(i, utf16_data_in[i]);
- }
- if (hash_code != 0) {
- string->SetHashCode(hash_code);
- } else {
- string->ComputeHashCode();
- }
- return string;
-}
-
- String* String::AllocFromModifiedUtf8(Thread* self, const char* utf) {
- if (utf == NULL) {
- return NULL;
- }
- size_t char_count = CountModifiedUtf8Chars(utf);
- return AllocFromModifiedUtf8(self, char_count, utf);
-}
-
-String* String::AllocFromModifiedUtf8(Thread* self, int32_t utf16_length,
- const char* utf8_data_in) {
- String* string = Alloc(self, GetJavaLangString(), utf16_length);
- if (string == NULL) {
- return NULL;
- }
- uint16_t* utf16_data_out =
- const_cast<uint16_t*>(string->GetCharArray()->GetData());
- ConvertModifiedUtf8ToUtf16(utf16_data_out, utf8_data_in);
- string->ComputeHashCode();
- return string;
-}
-
-String* String::Alloc(Thread* self, Class* java_lang_String, int32_t utf16_length) {
- SirtRef<CharArray> array(self, CharArray::Alloc(self, utf16_length));
- if (array.get() == NULL) {
- return NULL;
- }
- return Alloc(self, java_lang_String, array.get());
-}
-
-String* String::Alloc(Thread* self, Class* java_lang_String, CharArray* array) {
- // Hold reference in case AllocObject causes GC.
- SirtRef<CharArray> array_ref(self, array);
- String* string = down_cast<String*>(java_lang_String->AllocObject(self));
- if (string == NULL) {
- return NULL;
- }
- string->SetArray(array);
- string->SetCount(array->GetLength());
- return string;
-}
-
-bool String::Equals(const String* that) const {
- if (this == that) {
- // Quick reference equality test
- return true;
- } else if (that == NULL) {
- // Null isn't an instanceof anything
- return false;
- } else if (this->GetLength() != that->GetLength()) {
- // Quick length inequality test
- return false;
- } else {
- // Note: don't short circuit on hash code as we're presumably here as the
- // hash code was already equal
- for (int32_t i = 0; i < that->GetLength(); ++i) {
- if (this->CharAt(i) != that->CharAt(i)) {
- return false;
- }
- }
- return true;
- }
-}
-
-bool String::Equals(const uint16_t* that_chars, int32_t that_offset, int32_t that_length) const {
- if (this->GetLength() != that_length) {
- return false;
- } else {
- for (int32_t i = 0; i < that_length; ++i) {
- if (this->CharAt(i) != that_chars[that_offset + i]) {
- return false;
- }
- }
- return true;
- }
-}
-
-bool String::Equals(const char* modified_utf8) const {
- for (int32_t i = 0; i < GetLength(); ++i) {
- uint16_t ch = GetUtf16FromUtf8(&modified_utf8);
- if (ch == '\0' || ch != CharAt(i)) {
- return false;
- }
- }
- return *modified_utf8 == '\0';
-}
-
-bool String::Equals(const StringPiece& modified_utf8) const {
- if (modified_utf8.size() != GetLength()) {
- return false;
- }
- const char* p = modified_utf8.data();
- for (int32_t i = 0; i < GetLength(); ++i) {
- uint16_t ch = GetUtf16FromUtf8(&p);
- if (ch != CharAt(i)) {
- return false;
- }
- }
- return true;
-}
-
-// Create a modified UTF-8 encoded std::string from a java/lang/String object.
-std::string String::ToModifiedUtf8() const {
- const uint16_t* chars = GetCharArray()->GetData() + GetOffset();
- size_t byte_count = GetUtfLength();
- std::string result(byte_count, static_cast<char>(0));
- ConvertUtf16ToModifiedUtf8(&result[0], chars, GetLength());
- return result;
-}
-
-#ifdef HAVE__MEMCMP16
-// "count" is in 16-bit units.
-extern "C" uint32_t __memcmp16(const uint16_t* s0, const uint16_t* s1, size_t count);
-#define MemCmp16 __memcmp16
-#else
-static uint32_t MemCmp16(const uint16_t* s0, const uint16_t* s1, size_t count) {
- for (size_t i = 0; i < count; i++) {
- if (s0[i] != s1[i]) {
- return static_cast<int32_t>(s0[i]) - static_cast<int32_t>(s1[i]);
- }
- }
- return 0;
-}
-#endif
-
-int32_t String::CompareTo(String* rhs) const {
- // Quick test for comparison of a string with itself.
- const String* lhs = this;
- if (lhs == rhs) {
- return 0;
- }
- // TODO: is this still true?
- // The annoying part here is that 0x00e9 - 0xffff != 0x00ea,
- // because the interpreter converts the characters to 32-bit integers
- // *without* sign extension before it subtracts them (which makes some
- // sense since "char" is unsigned). So what we get is the result of
- // 0x000000e9 - 0x0000ffff, which is 0xffff00ea.
- int lhsCount = lhs->GetLength();
- int rhsCount = rhs->GetLength();
- int countDiff = lhsCount - rhsCount;
- int minCount = (countDiff < 0) ? lhsCount : rhsCount;
- const uint16_t* lhsChars = lhs->GetCharArray()->GetData() + lhs->GetOffset();
- const uint16_t* rhsChars = rhs->GetCharArray()->GetData() + rhs->GetOffset();
- int otherRes = MemCmp16(lhsChars, rhsChars, minCount);
- if (otherRes != 0) {
- return otherRes;
- }
- return countDiff;
-}
-
-void Throwable::SetCause(Throwable* cause) {
- CHECK(cause != NULL);
- CHECK(cause != this);
- CHECK(GetFieldObject<Throwable*>(OFFSET_OF_OBJECT_MEMBER(Throwable, cause_), false) == NULL);
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Throwable, cause_), cause, false);
-}
-
-bool Throwable::IsCheckedException() const {
- if (InstanceOf(WellKnownClasses::ToClass(WellKnownClasses::java_lang_Error))) {
- return false;
- }
- return !InstanceOf(WellKnownClasses::ToClass(WellKnownClasses::java_lang_RuntimeException));
-}
-
-std::string Throwable::Dump() const {
- std::string result(PrettyTypeOf(this));
- result += ": ";
- String* msg = GetDetailMessage();
- if (msg != NULL) {
- result += msg->ToModifiedUtf8();
- }
- result += "\n";
- Object* stack_state = GetStackState();
- // check stack state isn't missing or corrupt
- if (stack_state != NULL && stack_state->IsObjectArray()) {
- // Decode the internal stack trace into the depth and method trace
- ObjectArray<Object>* method_trace = down_cast<ObjectArray<Object>*>(stack_state);
- int32_t depth = method_trace->GetLength() - 1;
- IntArray* pc_trace = down_cast<IntArray*>(method_trace->Get(depth));
- MethodHelper mh;
- for (int32_t i = 0; i < depth; ++i) {
- AbstractMethod* method = down_cast<AbstractMethod*>(method_trace->Get(i));
- mh.ChangeMethod(method);
- 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);
- }
- }
- Throwable* cause = GetFieldObject<Throwable*>(OFFSET_OF_OBJECT_MEMBER(Throwable, cause_), false);
- if (cause != NULL && cause != this) { // Constructor makes cause == this by default.
- result += "Caused by: ";
- result += cause->Dump();
- }
- return result;
-}
-
-
-Class* Throwable::java_lang_Throwable_ = NULL;
-
-void Throwable::SetClass(Class* java_lang_Throwable) {
- CHECK(java_lang_Throwable_ == NULL);
- CHECK(java_lang_Throwable != NULL);
- java_lang_Throwable_ = java_lang_Throwable;
-}
-
-void Throwable::ResetClass() {
- CHECK(java_lang_Throwable_ != NULL);
- java_lang_Throwable_ = NULL;
-}
-
-Class* StackTraceElement::java_lang_StackTraceElement_ = NULL;
-
-void StackTraceElement::SetClass(Class* java_lang_StackTraceElement) {
- CHECK(java_lang_StackTraceElement_ == NULL);
- CHECK(java_lang_StackTraceElement != NULL);
- java_lang_StackTraceElement_ = java_lang_StackTraceElement;
-}
-
-void StackTraceElement::ResetClass() {
- CHECK(java_lang_StackTraceElement_ != NULL);
- java_lang_StackTraceElement_ = NULL;
-}
-
-StackTraceElement* StackTraceElement::Alloc(Thread* self,
- String* declaring_class,
- String* method_name,
- String* file_name,
- int32_t line_number) {
- StackTraceElement* trace =
- down_cast<StackTraceElement*>(GetStackTraceElement()->AllocObject(self));
- trace->SetFieldObject(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, declaring_class_),
- const_cast<String*>(declaring_class), false);
- trace->SetFieldObject(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, method_name_),
- const_cast<String*>(method_name), false);
- trace->SetFieldObject(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, file_name_),
- const_cast<String*>(file_name), false);
- trace->SetField32(OFFSET_OF_OBJECT_MEMBER(StackTraceElement, line_number_),
- line_number, false);
- return trace;
-}
-
-} // namespace art
diff --git a/src/object.h b/src/object.h
deleted file mode 100644
index f02e312..0000000
--- a/src/object.h
+++ /dev/null
@@ -1,2748 +0,0 @@
-/*
- * Copyright (C) 2011 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_OBJECT_H_
-#define ART_SRC_OBJECT_H_
-
-#include <iosfwd>
-#include <vector>
-
-#include "atomic.h"
-#include "base/casts.h"
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/stringpiece.h"
-#include "globals.h"
-#include "heap.h"
-#include "invoke_type.h"
-#include "modifiers.h"
-#include "offsets.h"
-#include "primitive.h"
-#include "runtime.h"
-#include "thread.h"
-#include "UniquePtr.h"
-#include "utf.h"
-
-namespace art {
-
-class Array;
-class Class;
-class ClassLoader;
-class CodeAndDirectMethods;
-class DexCache;
-class Field;
-class IfTable;
-class Monitor;
-class Member;
-class AbstractMethod;
-class Object;
-class StaticStorageBase;
-class String;
-template<class T> class ObjectArray;
-template<class T> class PrimitiveArray;
-typedef PrimitiveArray<uint8_t> BooleanArray;
-typedef PrimitiveArray<int8_t> ByteArray;
-typedef PrimitiveArray<uint16_t> CharArray;
-typedef PrimitiveArray<double> DoubleArray;
-typedef PrimitiveArray<float> FloatArray;
-typedef PrimitiveArray<int32_t> IntArray;
-typedef PrimitiveArray<int64_t> LongArray;
-typedef PrimitiveArray<int16_t> ShortArray;
-union JValue;
-
-#if defined(ART_USE_LLVM_COMPILER)
-namespace compiler_llvm {
- class InferredRegCategoryMap;
-} // namespace compiler_llvm
-#endif
-
-/*
- * Definitions for packing refOffsets in Class.
- */
-/*
- * A magic value for refOffsets. Ignore the bits and walk the super
- * chain when this is the value.
- * [This is an unlikely "natural" value, since it would be 30 non-ref instance
- * fields followed by 2 ref instance fields.]
- */
-#define CLASS_WALK_SUPER ((unsigned int)(3))
-#define CLASS_BITS_PER_WORD (sizeof(unsigned long int) * 8)
-#define CLASS_OFFSET_ALIGNMENT 4
-#define CLASS_HIGH_BIT ((unsigned int)1 << (CLASS_BITS_PER_WORD - 1))
-/*
- * Given an offset, return the bit number which would encode that offset.
- * Local use only.
- */
-#define _CLASS_BIT_NUMBER_FROM_OFFSET(byteOffset) \
- ((unsigned int)(byteOffset) / \
- CLASS_OFFSET_ALIGNMENT)
-/*
- * Is the given offset too large to be encoded?
- */
-#define CLASS_CAN_ENCODE_OFFSET(byteOffset) \
- (_CLASS_BIT_NUMBER_FROM_OFFSET(byteOffset) < CLASS_BITS_PER_WORD)
-/*
- * Return a single bit, encoding the offset.
- * Undefined if the offset is too large, as defined above.
- */
-#define CLASS_BIT_FROM_OFFSET(byteOffset) \
- (CLASS_HIGH_BIT >> _CLASS_BIT_NUMBER_FROM_OFFSET(byteOffset))
-/*
- * Return an offset, given a bit number as returned from CLZ.
- */
-#define CLASS_OFFSET_FROM_CLZ(rshift) \
- MemberOffset((static_cast<int>(rshift) * CLASS_OFFSET_ALIGNMENT))
-
-#define OFFSET_OF_OBJECT_MEMBER(type, field) \
- MemberOffset(OFFSETOF_MEMBER(type, field))
-
-// Classes shared with the managed side of the world need to be packed
-// so that they don't have extra platform specific padding.
-#define MANAGED PACKED(4)
-
-// C++ mirror of java.lang.Object
-class MANAGED Object {
- public:
- static MemberOffset ClassOffset() {
- return OFFSET_OF_OBJECT_MEMBER(Object, klass_);
- }
-
- Class* GetClass() const {
- return GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Object, klass_), false);
- }
-
- void SetClass(Class* new_klass);
-
- bool InstanceOf(const Class* klass) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- size_t SizeOf() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- Object* Clone(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- int32_t IdentityHashCode() const {
- #ifdef MOVING_GARBAGE_COLLECTOR
- // TODO: we'll need to use the Object's internal concept of identity
- UNIMPLEMENTED(FATAL);
- #endif
- return reinterpret_cast<int32_t>(this);
- }
-
- static MemberOffset MonitorOffset() {
- return OFFSET_OF_OBJECT_MEMBER(Object, monitor_);
- }
-
- volatile int32_t* GetRawLockWordAddress() {
- byte* raw_addr = reinterpret_cast<byte*>(this) +
- OFFSET_OF_OBJECT_MEMBER(Object, monitor_).Int32Value();
- int32_t* word_addr = reinterpret_cast<int32_t*>(raw_addr);
- return const_cast<volatile int32_t*>(word_addr);
- }
-
- uint32_t GetThinLockId();
-
- void MonitorEnter(Thread* thread) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
- EXCLUSIVE_LOCK_FUNCTION(monitor_lock_);
-
- bool MonitorExit(Thread* thread) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
- UNLOCK_FUNCTION(monitor_lock_);
-
- void Notify() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- void NotifyAll() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- void Wait() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- void Wait(int64_t timeout) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- void Wait(int64_t timeout, int32_t nanos) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- bool IsClass() const;
-
- Class* AsClass() {
- DCHECK(IsClass());
- return down_cast<Class*>(this);
- }
-
- const Class* AsClass() const {
- DCHECK(IsClass());
- return down_cast<const Class*>(this);
- }
-
- bool IsObjectArray() const;
-
- template<class T>
- ObjectArray<T>* AsObjectArray();
-
- template<class T>
- const ObjectArray<T>* AsObjectArray() const;
-
- bool IsArrayInstance() const;
-
- Array* AsArray() {
- DCHECK(IsArrayInstance());
- return down_cast<Array*>(this);
- }
-
- const Array* AsArray() const {
- DCHECK(IsArrayInstance());
- return down_cast<const Array*>(this);
- }
-
- BooleanArray* AsBooleanArray();
- ByteArray* AsByteArray();
- CharArray* AsCharArray();
- ShortArray* AsShortArray();
- IntArray* AsIntArray();
- LongArray* AsLongArray();
-
- String* AsString();
-
- Throwable* AsThrowable() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- bool IsMethod() const;
-
- AbstractMethod* AsMethod() {
- DCHECK(IsMethod());
- return down_cast<AbstractMethod*>(this);
- }
-
- const AbstractMethod* AsMethod() const {
- DCHECK(IsMethod());
- return down_cast<const AbstractMethod*>(this);
- }
-
- bool IsField() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- Field* AsField() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DCHECK(IsField());
- return down_cast<Field*>(this);
- }
-
- const Field* AsField() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DCHECK(IsField());
- return down_cast<const Field*>(this);
- }
-
- bool IsReferenceInstance() const;
-
- bool IsWeakReferenceInstance() const;
-
- bool IsSoftReferenceInstance() const;
-
- bool IsFinalizerReferenceInstance() const;
-
- bool IsPhantomReferenceInstance() const;
-
- // Accessors for Java type fields
- template<class T>
- T GetFieldObject(MemberOffset field_offset, bool is_volatile) const {
- T result = reinterpret_cast<T>(GetField32(field_offset, is_volatile));
- Runtime::Current()->GetHeap()->VerifyObject(result);
- return result;
- }
-
- void SetFieldObject(MemberOffset field_offset, const Object* new_value, bool is_volatile,
- bool this_is_valid = true) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Runtime::Current()->GetHeap()->VerifyObject(new_value);
- SetField32(field_offset, reinterpret_cast<uint32_t>(new_value), is_volatile, this_is_valid);
- if (new_value != NULL) {
- CheckFieldAssignment(field_offset, new_value);
- Runtime::Current()->GetHeap()->WriteBarrierField(this, field_offset, new_value);
- }
- }
-
- uint32_t GetField32(MemberOffset field_offset, bool is_volatile) const {
- Runtime::Current()->GetHeap()->VerifyObject(this);
- const byte* raw_addr = reinterpret_cast<const byte*>(this) + field_offset.Int32Value();
- const int32_t* word_addr = reinterpret_cast<const int32_t*>(raw_addr);
- if (UNLIKELY(is_volatile)) {
- return android_atomic_acquire_load(word_addr);
- } else {
- return *word_addr;
- }
- }
-
- void SetField32(MemberOffset field_offset, uint32_t new_value, bool is_volatile, bool this_is_valid = true) {
- if (this_is_valid) {
- Runtime::Current()->GetHeap()->VerifyObject(this);
- }
- byte* raw_addr = reinterpret_cast<byte*>(this) + field_offset.Int32Value();
- uint32_t* word_addr = reinterpret_cast<uint32_t*>(raw_addr);
- if (UNLIKELY(is_volatile)) {
- /*
- * TODO: add an android_atomic_synchronization_store() function and
- * use it in the 32-bit volatile set handlers. On some platforms we
- * can use a fast atomic instruction and avoid the barriers.
- */
- ANDROID_MEMBAR_STORE();
- *word_addr = new_value;
- ANDROID_MEMBAR_FULL();
- } else {
- *word_addr = new_value;
- }
- }
-
- uint64_t GetField64(MemberOffset field_offset, bool is_volatile) const {
- Runtime::Current()->GetHeap()->VerifyObject(this);
- const byte* raw_addr = reinterpret_cast<const byte*>(this) + field_offset.Int32Value();
- const int64_t* addr = reinterpret_cast<const int64_t*>(raw_addr);
- if (UNLIKELY(is_volatile)) {
- uint64_t result = QuasiAtomic::Read64(addr);
- ANDROID_MEMBAR_FULL();
- return result;
- } else {
- return *addr;
- }
- }
-
- void SetField64(MemberOffset field_offset, uint64_t new_value, bool is_volatile) {
- Runtime::Current()->GetHeap()->VerifyObject(this);
- byte* raw_addr = reinterpret_cast<byte*>(this) + field_offset.Int32Value();
- int64_t* addr = reinterpret_cast<int64_t*>(raw_addr);
- if (UNLIKELY(is_volatile)) {
- ANDROID_MEMBAR_STORE();
- QuasiAtomic::Write64(addr, new_value);
- // Post-store barrier not required due to use of atomic op or mutex.
- } else {
- *addr = new_value;
- }
- }
-
- protected:
- // Accessors for non-Java type fields
- template<class T>
- T GetFieldPtr(MemberOffset field_offset, bool is_volatile) const {
- return reinterpret_cast<T>(GetField32(field_offset, is_volatile));
- }
-
- template<typename T>
- void SetFieldPtr(MemberOffset field_offset, T new_value, bool is_volatile, bool this_is_valid = true) {
- SetField32(field_offset, reinterpret_cast<uint32_t>(new_value), is_volatile, this_is_valid);
- }
-
- private:
-#if VERIFY_OBJECT_ENABLED
- void CheckFieldAssignment(MemberOffset field_offset, const Object* new_value)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-#else
- void CheckFieldAssignment(MemberOffset, const Object*)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {}
-#endif
-
- Class* klass_;
-
- uint32_t monitor_;
-
- friend class ImageWriter; // for abusing monitor_ directly
- friend struct ObjectOffsets; // for verifying offset information
- DISALLOW_IMPLICIT_CONSTRUCTORS(Object);
-};
-
-// C++ mirror of java.lang.reflect.Field
-class MANAGED Field : public Object {
- public:
- Class* GetDeclaringClass() const;
-
- void SetDeclaringClass(Class *new_declaring_class) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- uint32_t GetAccessFlags() const;
-
- void SetAccessFlags(uint32_t new_access_flags) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(Field, access_flags_), new_access_flags, false);
- }
-
- bool IsPublic() const {
- return (GetAccessFlags() & kAccPublic) != 0;
- }
-
- bool IsStatic() const {
- return (GetAccessFlags() & kAccStatic) != 0;
- }
-
- bool IsFinal() const {
- return (GetAccessFlags() & kAccFinal) != 0;
- }
-
- uint32_t GetDexFieldIndex() const {
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Field, field_dex_idx_), false);
- }
-
- void SetDexFieldIndex(uint32_t new_idx) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(Field, field_dex_idx_), new_idx, false);
- }
-
- // Offset to field within an Object
- MemberOffset GetOffset() const;
-
- static MemberOffset OffsetOffset() {
- return MemberOffset(OFFSETOF_MEMBER(Field, offset_));
- }
-
- MemberOffset GetOffsetDuringLinking() const;
-
- void SetOffset(MemberOffset num_bytes);
-
- // field access, null object for static fields
- bool GetBoolean(const Object* object) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void SetBoolean(Object* object, bool z) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- int8_t GetByte(const Object* object) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void SetByte(Object* object, int8_t b) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- uint16_t GetChar(const Object* object) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void SetChar(Object* object, uint16_t c) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- int16_t GetShort(const Object* object) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void SetShort(Object* object, int16_t s) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- int32_t GetInt(const Object* object) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void SetInt(Object* object, int32_t i) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- int64_t GetLong(const Object* object) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void SetLong(Object* object, int64_t j) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- float GetFloat(const Object* object) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void SetFloat(Object* object, float f) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- double GetDouble(const Object* object) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void SetDouble(Object* object, double d) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Object* GetObject(const Object* object) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void SetObject(Object* object, const Object* l) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // raw field accesses
- uint32_t Get32(const Object* object) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void Set32(Object* object, uint32_t new_value) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- uint64_t Get64(const Object* object) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void Set64(Object* object, uint64_t new_value) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Object* GetObj(const Object* object) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void SetObj(Object* object, const Object* new_value) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- static Class* GetJavaLangReflectField() {
- DCHECK(java_lang_reflect_Field_ != NULL);
- return java_lang_reflect_Field_;
- }
-
- static void SetClass(Class* java_lang_reflect_Field);
- static void ResetClass();
-
- bool IsVolatile() const {
- return (GetAccessFlags() & kAccVolatile) != 0;
- }
-
- private:
- // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
- // The class we are a part of
- Class* declaring_class_;
-
- uint32_t access_flags_;
-
- // Dex cache index of field id
- uint32_t field_dex_idx_;
-
- // Offset of field within an instance or in the Class' static fields
- uint32_t offset_;
-
- static Class* java_lang_reflect_Field_;
-
- friend struct FieldOffsets; // for verifying offset information
- DISALLOW_IMPLICIT_CONSTRUCTORS(Field);
-};
-
-// C++ mirror of java.lang.reflect.Method and java.lang.reflect.Constructor
-class MANAGED AbstractMethod : public Object {
- public:
- // A function that invokes a method with an array of its arguments.
- typedef void InvokeStub(const AbstractMethod* method,
- Object* obj,
- Thread* thread,
- JValue* args,
- JValue* result);
-
- Class* GetDeclaringClass() const;
-
- void SetDeclaringClass(Class *new_declaring_class) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- static MemberOffset DeclaringClassOffset() {
- return MemberOffset(OFFSETOF_MEMBER(AbstractMethod, declaring_class_));
- }
-
- uint32_t GetAccessFlags() const;
-
- void SetAccessFlags(uint32_t new_access_flags) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, access_flags_), new_access_flags, false);
- }
-
- // Approximate what kind of method call would be used for this method.
- InvokeType GetInvokeType() const;
-
- // Returns true if the method is declared public.
- bool IsPublic() const {
- return (GetAccessFlags() & kAccPublic) != 0;
- }
-
- // Returns true if the method is declared private.
- bool IsPrivate() const {
- return (GetAccessFlags() & kAccPrivate) != 0;
- }
-
- // Returns true if the method is declared static.
- bool IsStatic() const {
- return (GetAccessFlags() & kAccStatic) != 0;
- }
-
- // Returns true if the method is a constructor.
- bool IsConstructor() const {
- return (GetAccessFlags() & kAccConstructor) != 0;
- }
-
- // Returns true if the method is static, private, or a constructor.
- bool IsDirect() const {
- return IsDirect(GetAccessFlags());
- }
-
- static bool IsDirect(uint32_t access_flags) {
- return (access_flags & (kAccStatic | kAccPrivate | kAccConstructor)) != 0;
- }
-
- // Returns true if the method is declared synchronized.
- bool IsSynchronized() const {
- uint32_t synchonized = kAccSynchronized | kAccDeclaredSynchronized;
- return (GetAccessFlags() & synchonized) != 0;
- }
-
- bool IsFinal() const {
- return (GetAccessFlags() & kAccFinal) != 0;
- }
-
- bool IsMiranda() const {
- return (GetAccessFlags() & kAccMiranda) != 0;
- }
-
- bool IsNative() const {
- return (GetAccessFlags() & kAccNative) != 0;
- }
-
- bool IsAbstract() const {
- return (GetAccessFlags() & kAccAbstract) != 0;
- }
-
- bool IsSynthetic() const {
- return (GetAccessFlags() & kAccSynthetic) != 0;
- }
-
- bool IsProxyMethod() const;
-
- bool CheckIncompatibleClassChange(InvokeType type);
-
- uint16_t GetMethodIndex() const;
-
- size_t GetVtableIndex() const {
- return GetMethodIndex();
- }
-
- void SetMethodIndex(uint16_t new_method_index) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_index_), new_method_index, false);
- }
-
- static MemberOffset MethodIndexOffset() {
- return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_index_);
- }
-
- uint32_t GetCodeItemOffset() const {
- return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, code_item_offset_), false);
- }
-
- void SetCodeItemOffset(uint32_t new_code_off) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, code_item_offset_), new_code_off, false);
- }
-
- // Number of 32bit registers that would be required to hold all the arguments
- static size_t NumArgRegisters(const StringPiece& shorty);
-
- uint32_t GetDexMethodIndex() const;
-
- void SetDexMethodIndex(uint32_t new_idx) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_dex_index_), new_idx, false);
- }
-
- ObjectArray<String>* GetDexCacheStrings() const;
- void SetDexCacheStrings(ObjectArray<String>* new_dex_cache_strings)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- static MemberOffset DexCacheStringsOffset() {
- return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_strings_);
- }
-
- static MemberOffset DexCacheResolvedMethodsOffset() {
- return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_methods_);
- }
-
- static MemberOffset DexCacheResolvedTypesOffset() {
- return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_types_);
- }
-
- static MemberOffset DexCacheInitializedStaticStorageOffset() {
- return OFFSET_OF_OBJECT_MEMBER(AbstractMethod,
- dex_cache_initialized_static_storage_);
- }
-
- ObjectArray<AbstractMethod>* GetDexCacheResolvedMethods() const;
- void SetDexCacheResolvedMethods(ObjectArray<AbstractMethod>* new_dex_cache_methods)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- ObjectArray<Class>* GetDexCacheResolvedTypes() const;
- void SetDexCacheResolvedTypes(ObjectArray<Class>* new_dex_cache_types)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- ObjectArray<StaticStorageBase>* GetDexCacheInitializedStaticStorage() const;
- void SetDexCacheInitializedStaticStorage(ObjectArray<StaticStorageBase>* new_value)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // Find the method that this method overrides
- AbstractMethod* FindOverriddenMethod() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- void Invoke(Thread* self, Object* receiver, JValue* args, JValue* result)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- const void* GetCode() const {
- return GetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, code_), false);
- }
-
- void SetCode(const void* code) {
- SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, code_), code, false);
- }
-
- uint32_t GetCodeSize() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DCHECK(!IsRuntimeMethod() && !IsProxyMethod()) << PrettyMethod(this);
- uintptr_t code = reinterpret_cast<uintptr_t>(GetCode());
- if (code == 0) {
- return 0;
- }
- // TODO: make this Thumb2 specific
- code &= ~0x1;
- return reinterpret_cast<uint32_t*>(code)[-1];
- }
-
- bool IsWithinCode(uintptr_t pc) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- uintptr_t code = reinterpret_cast<uintptr_t>(GetCode());
- if (code == 0) {
- return pc == 0;
- }
- /*
- * During a stack walk, a return PC may point to the end of the code + 1
- * (in the case that the last instruction is a call that isn't expected to
- * return. Thus, we check <= code + GetCodeSize().
- */
- return (code <= pc && pc <= code + GetCodeSize());
- }
-
- void AssertPcIsWithinCode(uintptr_t pc) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- uint32_t GetOatCodeOffset() const {
- DCHECK(!Runtime::Current()->IsStarted());
- return reinterpret_cast<uint32_t>(GetCode());
- }
-
- void SetOatCodeOffset(uint32_t code_offset) {
- DCHECK(!Runtime::Current()->IsStarted());
- SetCode(reinterpret_cast<void*>(code_offset));
- }
-
- static MemberOffset GetCodeOffset() {
- return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, code_);
- }
-
- const uint32_t* GetMappingTable() const {
- const uint32_t* map = GetMappingTableRaw();
- if (map == NULL) {
- return map;
- }
- return map + 1;
- }
-
- uint32_t GetPcToDexMappingTableLength() const {
- const uint32_t* map = GetMappingTableRaw();
- if (map == NULL) {
- return 0;
- }
- return map[2];
- }
-
- const uint32_t* GetPcToDexMappingTable() const {
- const uint32_t* map = GetMappingTableRaw();
- if (map == NULL) {
- return map;
- }
- return map + 3;
- }
-
-
- uint32_t GetDexToPcMappingTableLength() const {
- const uint32_t* map = GetMappingTableRaw();
- if (map == NULL) {
- return 0;
- }
- return map[1] - map[2];
- }
-
- const uint32_t* GetDexToPcMappingTable() const {
- const uint32_t* map = GetMappingTableRaw();
- if (map == NULL) {
- return map;
- }
- return map + 3 + map[2];
- }
-
-
- const uint32_t* GetMappingTableRaw() const {
- return GetFieldPtr<const uint32_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, mapping_table_), false);
- }
-
- void SetMappingTable(const uint32_t* mapping_table) {
- SetFieldPtr<const uint32_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, mapping_table_),
- mapping_table, false);
- }
-
- uint32_t GetOatMappingTableOffset() const {
- DCHECK(!Runtime::Current()->IsStarted());
- return reinterpret_cast<uint32_t>(GetMappingTableRaw());
- }
-
- void SetOatMappingTableOffset(uint32_t mapping_table_offset) {
- DCHECK(!Runtime::Current()->IsStarted());
- SetMappingTable(reinterpret_cast<const uint32_t*>(mapping_table_offset));
- }
-
- // Callers should wrap the uint16_t* in a VmapTable instance for convenient access.
- const uint16_t* GetVmapTableRaw() const {
- return GetFieldPtr<const uint16_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, vmap_table_), false);
- }
-
- void SetVmapTable(const uint16_t* vmap_table) {
- SetFieldPtr<const uint16_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, vmap_table_), vmap_table, false);
- }
-
- uint32_t GetOatVmapTableOffset() const {
- DCHECK(!Runtime::Current()->IsStarted());
- return reinterpret_cast<uint32_t>(GetVmapTableRaw());
- }
-
- void SetOatVmapTableOffset(uint32_t vmap_table_offset) {
- DCHECK(!Runtime::Current()->IsStarted());
- SetVmapTable(reinterpret_cast<uint16_t*>(vmap_table_offset));
- }
-
- const uint8_t* GetNativeGcMap() const {
- return GetFieldPtr<uint8_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_gc_map_), false);
- }
- void SetNativeGcMap(const uint8_t* data) {
- SetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_gc_map_), data,
- false);
- }
-
- // When building the oat need a convenient place to stuff the offset of the native GC map.
- void SetOatNativeGcMapOffset(uint32_t gc_map_offset) {
- DCHECK(!Runtime::Current()->IsStarted());
- SetNativeGcMap(reinterpret_cast<uint8_t*>(gc_map_offset));
- }
-
- uint32_t GetOatNativeGcMapOffset() const {
- DCHECK(!Runtime::Current()->IsStarted());
- return reinterpret_cast<uint32_t>(GetNativeGcMap());
- }
-
- size_t GetFrameSizeInBytes() const {
- DCHECK_EQ(sizeof(size_t), sizeof(uint32_t));
- size_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, frame_size_in_bytes_), false);
- DCHECK_LE(static_cast<size_t>(kStackAlignment), result);
- return result;
- }
-
- void SetFrameSizeInBytes(size_t new_frame_size_in_bytes) {
- DCHECK_EQ(sizeof(size_t), sizeof(uint32_t));
- SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, frame_size_in_bytes_),
- new_frame_size_in_bytes, false);
- }
-
- size_t GetReturnPcOffsetInBytes() const {
- return GetFrameSizeInBytes() - kPointerSize;
- }
-
- bool IsRegistered() const;
-
- void RegisterNative(Thread* self, const void* native_method)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- void UnregisterNative(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- static MemberOffset NativeMethodOffset() {
- return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_method_);
- }
-
- const void* GetNativeMethod() const {
- return reinterpret_cast<const void*>(GetField32(NativeMethodOffset(), false));
- }
-
- // Native to managed invocation stub entry point
- InvokeStub* GetInvokeStub() const {
- InvokeStub* result = GetFieldPtr<InvokeStub*>(
- OFFSET_OF_OBJECT_MEMBER(AbstractMethod, invoke_stub_), false);
- // TODO: DCHECK(result != NULL); should be ahead of time compiled
- return result;
- }
-
- void SetInvokeStub(InvokeStub* invoke_stub) {
- SetFieldPtr<InvokeStub*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, invoke_stub_),
- invoke_stub, false);
- }
-
- uint32_t GetInvokeStubSize() const {
- uintptr_t invoke_stub = reinterpret_cast<uintptr_t>(GetInvokeStub());
- if (invoke_stub == 0) {
- return 0;
- }
- // TODO: make this Thumb2 specific
- invoke_stub &= ~0x1;
- return reinterpret_cast<const uint32_t*>(invoke_stub)[-1];
- }
-
- uint32_t GetOatInvokeStubOffset() const {
- DCHECK(!Runtime::Current()->IsStarted());
- return reinterpret_cast<uint32_t>(GetInvokeStub());
- }
-
- void SetOatInvokeStubOffset(uint32_t invoke_stub_offset) {
- DCHECK(!Runtime::Current()->IsStarted());
- SetInvokeStub(reinterpret_cast<InvokeStub*>(invoke_stub_offset));
- }
-
- static MemberOffset GetInvokeStubOffset() {
- return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, invoke_stub_);
- }
-
- static MemberOffset GetMethodIndexOffset() {
- return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_index_);
- }
-
- uint32_t GetCoreSpillMask() const {
- return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, core_spill_mask_), false);
- }
-
- void SetCoreSpillMask(uint32_t core_spill_mask) {
- // Computed during compilation
- SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, core_spill_mask_), core_spill_mask, false);
- }
-
- uint32_t GetFpSpillMask() const {
- return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, fp_spill_mask_), false);
- }
-
- void SetFpSpillMask(uint32_t fp_spill_mask) {
- // Computed during compilation
- SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, fp_spill_mask_), fp_spill_mask, false);
- }
-
- // Is this a CalleSaveMethod or ResolutionMethod and therefore doesn't adhere to normal
- // conventions for a method of managed code. Returns false for Proxy methods.
- bool IsRuntimeMethod() const {
- return GetDexMethodIndex() == DexFile::kDexNoIndex16;
- }
-
- // Is this a hand crafted method used for something like describing callee saves?
- bool IsCalleeSaveMethod() const {
- if (!IsRuntimeMethod()) {
- return false;
- }
- Runtime* runtime = Runtime::Current();
- bool result = false;
- for (int i = 0; i < Runtime::kLastCalleeSaveType; i++) {
- if (this == runtime->GetCalleeSaveMethod(Runtime::CalleeSaveType(i))) {
- result = true;
- break;
- }
- }
- return result;
- }
-
- bool IsResolutionMethod() const {
- bool result = this == Runtime::Current()->GetResolutionMethod();
- // Check that if we do think it is phony it looks like the resolution method
- DCHECK(!result || GetDexMethodIndex() == DexFile::kDexNoIndex16);
- return result;
- }
-
- uintptr_t NativePcOffset(const uintptr_t pc) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // Converts a native PC to a dex PC.
- uint32_t ToDexPc(const uintptr_t pc) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // Converts a dex PC to a native PC.
- uintptr_t ToNativePc(const uint32_t dex_pc) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // Converts a dex PC to the first corresponding safepoint PC.
- uintptr_t ToFirstNativeSafepointPc(const uint32_t dex_pc)
- const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // Find the catch block for the given exception type and dex_pc
- uint32_t FindCatchBlock(Class* exception_type, uint32_t dex_pc) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- static void SetClasses(Class* java_lang_reflect_Constructor, Class* java_lang_reflect_Method);
-
- static Class* GetConstructorClass() {
- return java_lang_reflect_Constructor_;
- }
-
- static Class* GetMethodClass() {
- return java_lang_reflect_Method_;
- }
-
- static void ResetClasses();
-
- protected:
- // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
- // The class we are a part of
- Class* declaring_class_;
-
- // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
- ObjectArray<StaticStorageBase>* dex_cache_initialized_static_storage_;
-
- // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
- ObjectArray<AbstractMethod>* dex_cache_resolved_methods_;
-
- // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
- ObjectArray<Class>* dex_cache_resolved_types_;
-
- // short cuts to declaring_class_->dex_cache_ member for fast compiled code access
- ObjectArray<String>* dex_cache_strings_;
-
- // Access flags; low 16 bits are defined by spec.
- uint32_t access_flags_;
-
- // Compiled code associated with this method for callers from managed code.
- // May be compiled managed code or a bridge for invoking a native method.
- const void* code_;
-
- // Offset to the CodeItem.
- uint32_t code_item_offset_;
-
- // Architecture-dependent register spill mask
- uint32_t core_spill_mask_;
-
- // Architecture-dependent register spill mask
- uint32_t fp_spill_mask_;
-
- // Total size in bytes of the frame
- size_t frame_size_in_bytes_;
-
- // Garbage collection map of native PC offsets to reference bitmaps.
- const uint8_t* native_gc_map_;
-
- // Native invocation stub entry point for calling from native to managed code.
- InvokeStub* invoke_stub_;
-
- // Mapping from native pc to dex pc
- const uint32_t* mapping_table_;
-
- // Index into method_ids of the dex file associated with this method
- uint32_t method_dex_index_;
-
- // For concrete virtual methods, this is the offset of the method in Class::vtable_.
- //
- // For abstract methods in an interface class, this is the offset of the method in
- // "iftable_->Get(n)->GetMethodArray()".
- //
- // For static and direct methods this is the index in the direct methods table.
- uint32_t method_index_;
-
- // The target native method registered with this method
- const void* native_method_;
-
- // When a register is promoted into a register, the spill mask holds which registers hold dex
- // registers. The first promoted register's corresponding dex register is vmap_table_[1], the Nth
- // is vmap_table_[N]. vmap_table_[0] holds the length of the table.
- const uint16_t* vmap_table_;
-
- static Class* java_lang_reflect_Constructor_;
- static Class* java_lang_reflect_Method_;
-
- friend class ImageWriter; // for relocating code_ and invoke_stub_
- friend struct AbstractMethodOffsets; // for verifying offset information
- friend struct ConstructorMethodOffsets; // for verifying offset information
- friend struct MethodOffsets; // for verifying offset information
- DISALLOW_IMPLICIT_CONSTRUCTORS(AbstractMethod);
-};
-
-class MANAGED Method : public AbstractMethod {
-
-};
-
-class MANAGED Constructor : public AbstractMethod {
-
-};
-
-class MANAGED Array : public Object {
- public:
- // A convenience for code that doesn't know the component size,
- // and doesn't want to have to work it out itself.
- static Array* Alloc(Thread* self, Class* array_class, int32_t component_count)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- static Array* Alloc(Thread* self, Class* array_class, int32_t component_count,
- size_t component_size)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- static Array* CreateMultiArray(Thread* self, Class* element_class, IntArray* dimensions)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- size_t SizeOf() const;
-
- int32_t GetLength() const {
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Array, length_), false);
- }
-
- void SetLength(int32_t length) {
- CHECK_GE(length, 0);
- SetField32(OFFSET_OF_OBJECT_MEMBER(Array, length_), length, false);
- }
-
- static MemberOffset LengthOffset() {
- return OFFSET_OF_OBJECT_MEMBER(Array, length_);
- }
-
- static MemberOffset DataOffset(size_t component_size) {
- if (component_size != sizeof(int64_t)) {
- return OFFSET_OF_OBJECT_MEMBER(Array, first_element_);
- } else {
- // Align longs and doubles.
- return MemberOffset(OFFSETOF_MEMBER(Array, first_element_) + 4);
- }
- }
-
- void* GetRawData(size_t component_size) {
- intptr_t data = reinterpret_cast<intptr_t>(this) + DataOffset(component_size).Int32Value();
- return reinterpret_cast<void*>(data);
- }
-
- const void* GetRawData(size_t component_size) const {
- intptr_t data = reinterpret_cast<intptr_t>(this) + DataOffset(component_size).Int32Value();
- return reinterpret_cast<const void*>(data);
- }
-
- protected:
- bool IsValidIndex(int32_t index) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- if (UNLIKELY(index < 0 || index >= GetLength())) {
- return ThrowArrayIndexOutOfBoundsException(index);
- }
- return true;
- }
-
- protected:
- bool ThrowArrayIndexOutOfBoundsException(int32_t index) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool ThrowArrayStoreException(Object* object) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- private:
- // The number of array elements.
- int32_t length_;
- // Marker for the data (used by generated code)
- uint32_t first_element_[0];
-
- DISALLOW_IMPLICIT_CONSTRUCTORS(Array);
-};
-
-template<class T>
-class MANAGED ObjectArray : public Array {
- public:
- static ObjectArray<T>* Alloc(Thread* self, Class* object_array_class, int32_t length)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- T* Get(int32_t i) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- void Set(int32_t i, T* object) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // Set element without bound and element type checks, to be used in limited
- // circumstances, such as during boot image writing
- void SetWithoutChecks(int32_t i, T* object) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // Set element without bound and element type checks, to be used in limited circumstances, such
- // as during boot image writing. Does not do write barrier.
- void SetPtrWithoutChecks(int32_t i, T* object) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- T* GetWithoutChecks(int32_t i) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- static void Copy(const ObjectArray<T>* src, int src_pos,
- ObjectArray<T>* dst, int dst_pos,
- size_t length)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- ObjectArray<T>* CopyOf(Thread* self, int32_t new_length)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- private:
- DISALLOW_IMPLICIT_CONSTRUCTORS(ObjectArray);
-};
-
-template<class T>
-ObjectArray<T>* ObjectArray<T>::Alloc(Thread* self, Class* object_array_class, int32_t length) {
- Array* array = Array::Alloc(self, object_array_class, length, sizeof(Object*));
- if (UNLIKELY(array == NULL)) {
- return NULL;
- } else {
- return array->AsObjectArray<T>();
- }
-}
-
-template<class T>
-inline T* ObjectArray<T>::Get(int32_t i) const {
- if (UNLIKELY(!IsValidIndex(i))) {
- return NULL;
- }
- MemberOffset data_offset(DataOffset(sizeof(Object*)).Int32Value() + i * sizeof(Object*));
- return GetFieldObject<T*>(data_offset, false);
-}
-
-template<class T>
-ObjectArray<T>* ObjectArray<T>::CopyOf(Thread* self, int32_t new_length) {
- ObjectArray<T>* new_array = Alloc(self, GetClass(), new_length);
- Copy(this, 0, new_array, 0, std::min(GetLength(), new_length));
- return new_array;
-}
-
-class MANAGED IfTable : public ObjectArray<Object> {
- public:
- Class* GetInterface(int32_t i) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Class* interface = Get((i * kMax) + kInterface)->AsClass();
- DCHECK(interface != NULL);
- return interface;
- }
-
- void SetInterface(int32_t i, Class* interface) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- ObjectArray<AbstractMethod>* GetMethodArray(int32_t i) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- ObjectArray<AbstractMethod>* method_array =
- down_cast<ObjectArray<AbstractMethod>*>(Get((i * kMax) + kMethodArray));
- DCHECK(method_array != NULL);
- return method_array;
- }
-
- size_t GetMethodArrayCount(int32_t i) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- ObjectArray<AbstractMethod>* method_array =
- down_cast<ObjectArray<AbstractMethod>*>(Get((i * kMax) + kMethodArray));
- if (method_array == NULL) {
- return 0;
- }
- return method_array->GetLength();
- }
-
- void SetMethodArray(int32_t i, ObjectArray<AbstractMethod>* new_ma)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DCHECK(new_ma != NULL);
- DCHECK(Get((i * kMax) + kMethodArray) == NULL);
- Set((i * kMax) + kMethodArray, new_ma);
- }
-
- size_t Count() const {
- return GetLength() / kMax;
- }
-
- enum {
- // Points to the interface class.
- kInterface = 0,
- // Method pointers into the vtable, allow fast map from interface method index to concrete
- // instance method.
- kMethodArray = 1,
- kMax = 2,
- };
-
- private:
- DISALLOW_IMPLICIT_CONSTRUCTORS(IfTable);
-};
-
-// Type for the InitializedStaticStorage table. Currently the Class
-// provides the static storage. However, this might change to an Array
-// to improve image sharing, so we use this type to avoid assumptions
-// on the current storage.
-class MANAGED StaticStorageBase : public Object {
-};
-
-// C++ mirror of java.lang.Class
-class MANAGED Class : public StaticStorageBase {
- public:
- // Class Status
- //
- // kStatusNotReady: If a Class cannot be found in the class table by
- // FindClass, it allocates an new one with AllocClass in the
- // kStatusNotReady and calls LoadClass. Note if it does find a
- // class, it may not be kStatusResolved and it will try to push it
- // forward toward kStatusResolved.
- //
- // kStatusIdx: LoadClass populates with Class with information from
- // the DexFile, moving the status to kStatusIdx, indicating that the
- // Class value in super_class_ has not been populated. The new Class
- // can then be inserted into the classes table.
- //
- // kStatusLoaded: After taking a lock on Class, the ClassLinker will
- // attempt to move a kStatusIdx class forward to kStatusLoaded by
- // using ResolveClass to initialize the super_class_ and ensuring the
- // interfaces are resolved.
- //
- // kStatusResolved: Still holding the lock on Class, the ClassLinker
- // shows linking is complete and fields of the Class populated by making
- // it kStatusResolved. Java allows circularities of the form where a super
- // class has a field that is of the type of the sub class. We need to be able
- // to fully resolve super classes while resolving types for fields.
- //
- // kStatusRetryVerificationAtRuntime: The verifier sets a class to
- // this state if it encounters a soft failure at compile time. This
- // often happens when there are unresolved classes in other dex
- // files, and this status marks a class as needing to be verified
- // again at runtime.
- //
- // TODO: Explain the other states
- enum Status {
- kStatusError = -1,
- kStatusNotReady = 0,
- kStatusIdx = 1, // Loaded, DEX idx in super_class_type_idx_ and interfaces_type_idx_.
- kStatusLoaded = 2, // DEX idx values resolved.
- kStatusResolved = 3, // Part of linking.
- kStatusVerifying = 4, // In the process of being verified.
- kStatusRetryVerificationAtRuntime = 5, // Compile time verification failed, retry at runtime.
- kStatusVerifyingAtRuntime = 6, // Retrying verification at runtime.
- kStatusVerified = 7, // Logically part of linking; done pre-init.
- kStatusInitializing = 8, // Class init in progress.
- kStatusInitialized = 9, // Ready to go.
- };
-
- Status GetStatus() const {
- DCHECK_EQ(sizeof(Status), sizeof(uint32_t));
- return static_cast<Status>(GetField32(OFFSET_OF_OBJECT_MEMBER(Class, status_), false));
- }
-
- void SetStatus(Status new_status) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // Returns true if the class has failed to link.
- bool IsErroneous() const {
- return GetStatus() == kStatusError;
- }
-
- // Returns true if the class has been loaded.
- bool IsIdxLoaded() const {
- return GetStatus() >= kStatusIdx;
- }
-
- // Returns true if the class has been loaded.
- bool IsLoaded() const {
- return GetStatus() >= kStatusLoaded;
- }
-
- // Returns true if the class has been linked.
- bool IsResolved() const {
- return GetStatus() >= kStatusResolved;
- }
-
- // Returns true if the class was compile-time verified.
- bool IsCompileTimeVerified() const {
- return GetStatus() >= kStatusRetryVerificationAtRuntime;
- }
-
- // Returns true if the class has been verified.
- bool IsVerified() const {
- return GetStatus() >= kStatusVerified;
- }
-
- // Returns true if the class is initializing.
- bool IsInitializing() const {
- return GetStatus() >= kStatusInitializing;
- }
-
- // Returns true if the class is initialized.
- bool IsInitialized() const {
- return GetStatus() == kStatusInitialized;
- }
-
- uint32_t GetAccessFlags() const;
-
- void SetAccessFlags(uint32_t new_access_flags) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_), new_access_flags, false);
- }
-
- // Returns true if the class is an interface.
- bool IsInterface() const {
- return (GetAccessFlags() & kAccInterface) != 0;
- }
-
- // Returns true if the class is declared public.
- bool IsPublic() const {
- return (GetAccessFlags() & kAccPublic) != 0;
- }
-
- // Returns true if the class is declared final.
- bool IsFinal() const {
- return (GetAccessFlags() & kAccFinal) != 0;
- }
-
- bool IsFinalizable() const {
- return (GetAccessFlags() & kAccClassIsFinalizable) != 0;
- }
-
- void SetFinalizable() {
- uint32_t flags = GetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_), false);
- SetAccessFlags(flags | kAccClassIsFinalizable);
- }
-
- // Returns true if the class is abstract.
- bool IsAbstract() const {
- return (GetAccessFlags() & kAccAbstract) != 0;
- }
-
- // Returns true if the class is an annotation.
- bool IsAnnotation() const {
- return (GetAccessFlags() & kAccAnnotation) != 0;
- }
-
- // Returns true if the class is synthetic.
- bool IsSynthetic() const {
- return (GetAccessFlags() & kAccSynthetic) != 0;
- }
-
- bool IsReferenceClass() const {
- return (GetAccessFlags() & kAccClassIsReference) != 0;
- }
-
- bool IsWeakReferenceClass() const {
- return (GetAccessFlags() & kAccClassIsWeakReference) != 0;
- }
-
- bool IsSoftReferenceClass() const {
- return (GetAccessFlags() & kAccReferenceFlagsMask) == kAccClassIsReference;
- }
-
- bool IsFinalizerReferenceClass() const {
- return (GetAccessFlags() & kAccClassIsFinalizerReference) != 0;
- }
-
- bool IsPhantomReferenceClass() const {
- return (GetAccessFlags() & kAccClassIsPhantomReference) != 0;
- }
-
-
- String* GetName() const; // Returns the cached name.
- void SetName(String* name) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); // Sets the cached name.
- // Computes the name, then sets the cached value.
- String* ComputeName() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- bool IsProxyClass() const {
- // Read access flags without using getter as whether something is a proxy can be check in
- // any loaded state
- // TODO: switch to a check if the super class is java.lang.reflect.Proxy?
- uint32_t access_flags = GetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_), false);
- return (access_flags & kAccClassIsProxy) != 0;
- }
-
- Primitive::Type GetPrimitiveType() const {
- DCHECK_EQ(sizeof(Primitive::Type), sizeof(int32_t));
- return static_cast<Primitive::Type>(
- GetField32(OFFSET_OF_OBJECT_MEMBER(Class, primitive_type_), false));
- }
-
- void SetPrimitiveType(Primitive::Type new_type) {
- DCHECK_EQ(sizeof(Primitive::Type), sizeof(int32_t));
- SetField32(OFFSET_OF_OBJECT_MEMBER(Class, primitive_type_), new_type, false);
- }
-
- // Returns true if the class is a primitive type.
- bool IsPrimitive() const {
- return GetPrimitiveType() != Primitive::kPrimNot;
- }
-
- bool IsPrimitiveBoolean() const {
- return GetPrimitiveType() == Primitive::kPrimBoolean;
- }
-
- bool IsPrimitiveByte() const {
- return GetPrimitiveType() == Primitive::kPrimByte;
- }
-
- bool IsPrimitiveChar() const {
- return GetPrimitiveType() == Primitive::kPrimChar;
- }
-
- bool IsPrimitiveShort() const {
- return GetPrimitiveType() == Primitive::kPrimShort;
- }
-
- bool IsPrimitiveInt() const {
- return GetPrimitiveType() == Primitive::kPrimInt;
- }
-
- bool IsPrimitiveLong() const {
- return GetPrimitiveType() == Primitive::kPrimLong;
- }
-
- bool IsPrimitiveFloat() const {
- return GetPrimitiveType() == Primitive::kPrimFloat;
- }
-
- bool IsPrimitiveDouble() const {
- return GetPrimitiveType() == Primitive::kPrimDouble;
- }
-
- bool IsPrimitiveVoid() const {
- return GetPrimitiveType() == Primitive::kPrimVoid;
- }
-
- bool IsPrimitiveArray() const {
- return IsArrayClass() && GetComponentType()->IsPrimitive();
- }
-
- // Depth of class from java.lang.Object
- size_t Depth() {
- size_t depth = 0;
- for (Class* klass = this; klass->GetSuperClass() != NULL; klass = klass->GetSuperClass()) {
- depth++;
- }
- return depth;
- }
-
- bool IsArrayClass() const {
- return GetComponentType() != NULL;
- }
-
- bool IsClassClass() const;
-
- bool IsStringClass() const;
-
- bool IsThrowableClass() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- bool IsFieldClass() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- bool IsMethodClass() const;
-
- Class* GetComponentType() const {
- return GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Class, component_type_), false);
- }
-
- void SetComponentType(Class* new_component_type) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DCHECK(GetComponentType() == NULL);
- DCHECK(new_component_type != NULL);
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, component_type_), new_component_type, false);
- }
-
- size_t GetComponentSize() const {
- return Primitive::ComponentSize(GetComponentType()->GetPrimitiveType());
- }
-
- bool IsObjectClass() const {
- return !IsPrimitive() && GetSuperClass() == NULL;
- }
- bool IsInstantiable() const {
- return !IsPrimitive() && !IsInterface() && !IsAbstract();
- }
-
- bool IsObjectArrayClass() const {
- return GetComponentType() != NULL && !GetComponentType()->IsPrimitive();
- }
-
- // Creates a raw object instance but does not invoke the default constructor.
- Object* AllocObject(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- bool IsVariableSize() const {
- // Classes and arrays vary in size, and so the object_size_ field cannot
- // be used to get their instance size
- return IsClassClass() || IsArrayClass();
- }
-
- size_t SizeOf() const {
- DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, class_size_), false);
- }
-
- size_t GetClassSize() const {
- DCHECK_EQ(sizeof(size_t), sizeof(uint32_t));
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, class_size_), false);
- }
-
- void SetClassSize(size_t new_class_size)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- size_t GetObjectSize() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- CHECK(!IsVariableSize()) << " class=" << PrettyTypeOf(this);
- DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
- size_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(Class, object_size_), false);
- CHECK_GE(result, sizeof(Object)) << " class=" << PrettyTypeOf(this);
- return result;
- }
-
- void SetObjectSize(size_t new_object_size) {
- DCHECK(!IsVariableSize());
- DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
- return SetField32(OFFSET_OF_OBJECT_MEMBER(Class, object_size_), new_object_size, false);
- }
-
- // Returns true if this class is in the same packages as that class.
- bool IsInSamePackage(const Class* that) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- static bool IsInSamePackage(const StringPiece& descriptor1, const StringPiece& descriptor2);
-
- // Returns true if this class can access that class.
- bool CanAccess(Class* that) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return that->IsPublic() || this->IsInSamePackage(that);
- }
-
- // Can this class access a member in the provided class with the provided member access flags?
- // Note that access to the class isn't checked in case the declaring class is protected and the
- // method has been exposed by a public sub-class
- bool CanAccessMember(Class* access_to, uint32_t member_flags) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- // Classes can access all of their own members
- if (this == access_to) {
- return true;
- }
- // Public members are trivially accessible
- if (member_flags & kAccPublic) {
- return true;
- }
- // Private members are trivially not accessible
- if (member_flags & kAccPrivate) {
- return false;
- }
- // Check for protected access from a sub-class, which may or may not be in the same package.
- if (member_flags & kAccProtected) {
- if (this->IsSubClass(access_to)) {
- return true;
- }
- }
- // Allow protected access from other classes in the same package.
- return this->IsInSamePackage(access_to);
- }
-
- bool IsSubClass(const Class* klass) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // Can src be assigned to this class? For example, String can be assigned to Object (by an
- // upcast), however, an Object cannot be assigned to a String as a potentially exception throwing
- // downcast would be necessary. Similarly for interfaces, a class that implements (or an interface
- // that extends) another can be assigned to its parent, but not vice-versa. All Classes may assign
- // to themselves. Classes for primitive types may not assign to each other.
- bool IsAssignableFrom(const Class* src) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DCHECK(src != NULL);
- if (this == src) {
- // Can always assign to things of the same type.
- return true;
- } else if (IsObjectClass()) {
- // Can assign any reference to java.lang.Object.
- return !src->IsPrimitive();
- } else if (IsInterface()) {
- return src->Implements(this);
- } else if (src->IsArrayClass()) {
- return IsAssignableFromArray(src);
- } else {
- return !src->IsInterface() && src->IsSubClass(this);
- }
- }
-
- Class* GetSuperClass() const {
- // Can only get super class for loaded classes (hack for when runtime is
- // initializing)
- DCHECK(IsLoaded() || !Runtime::Current()->IsStarted()) << IsLoaded();
- return GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Class, super_class_), false);
- }
-
- void SetSuperClass(Class *new_super_class) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- // super class is assigned once, except during class linker initialization
- Class* old_super_class = GetFieldObject<Class*>(
- OFFSET_OF_OBJECT_MEMBER(Class, super_class_), false);
- DCHECK(old_super_class == NULL || old_super_class == new_super_class);
- DCHECK(new_super_class != NULL);
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, super_class_), new_super_class, false);
- }
-
- bool HasSuperClass() const {
- return GetSuperClass() != NULL;
- }
-
- static MemberOffset SuperClassOffset() {
- return MemberOffset(OFFSETOF_MEMBER(Class, super_class_));
- }
-
- ClassLoader* GetClassLoader() const;
-
- void SetClassLoader(ClassLoader* new_cl) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- static MemberOffset DexCacheOffset() {
- return MemberOffset(OFFSETOF_MEMBER(Class, dex_cache_));
- }
-
- enum {
- kDumpClassFullDetail = 1,
- kDumpClassClassLoader = (1 << 1),
- kDumpClassInitialized = (1 << 2),
- };
-
- void DumpClass(std::ostream& os, int flags) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- DexCache* GetDexCache() const;
-
- void SetDexCache(DexCache* new_dex_cache) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- ObjectArray<AbstractMethod>* GetDirectMethods() const {
- DCHECK(IsLoaded() || IsErroneous());
- return GetFieldObject<ObjectArray<AbstractMethod>*>(
- OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_), false);
- }
-
- void SetDirectMethods(ObjectArray<AbstractMethod>* new_direct_methods)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DCHECK(NULL == GetFieldObject<ObjectArray<AbstractMethod>*>(
- OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_), false));
- DCHECK_NE(0, new_direct_methods->GetLength());
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_),
- new_direct_methods, false);
- }
-
- AbstractMethod* GetDirectMethod(int32_t i) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return GetDirectMethods()->Get(i);
- }
-
- void SetDirectMethod(uint32_t i, AbstractMethod* f) // TODO: uint16_t
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_){
- ObjectArray<AbstractMethod>* direct_methods =
- GetFieldObject<ObjectArray<AbstractMethod>*>(
- OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_), false);
- direct_methods->Set(i, f);
- }
-
- // Returns the number of static, private, and constructor methods.
- size_t NumDirectMethods() const {
- return (GetDirectMethods() != NULL) ? GetDirectMethods()->GetLength() : 0;
- }
-
- ObjectArray<AbstractMethod>* GetVirtualMethods() const {
- DCHECK(IsLoaded() || IsErroneous());
- return GetFieldObject<ObjectArray<AbstractMethod>*>(
- OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_), false);
- }
-
- void SetVirtualMethods(ObjectArray<AbstractMethod>* new_virtual_methods)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- // TODO: we reassign virtual methods to grow the table for miranda
- // methods.. they should really just be assigned once
- DCHECK_NE(0, new_virtual_methods->GetLength());
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_),
- new_virtual_methods, false);
- }
-
- // Returns the number of non-inherited virtual methods.
- size_t NumVirtualMethods() const {
- return (GetVirtualMethods() != NULL) ? GetVirtualMethods()->GetLength() : 0;
- }
-
- AbstractMethod* GetVirtualMethod(uint32_t i) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DCHECK(IsResolved() || IsErroneous());
- return GetVirtualMethods()->Get(i);
- }
-
- AbstractMethod* GetVirtualMethodDuringLinking(uint32_t i) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DCHECK(IsLoaded() || IsErroneous());
- return GetVirtualMethods()->Get(i);
- }
-
- void SetVirtualMethod(uint32_t i, AbstractMethod* f) // TODO: uint16_t
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- ObjectArray<AbstractMethod>* virtual_methods =
- GetFieldObject<ObjectArray<AbstractMethod>*>(
- OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_), false);
- virtual_methods->Set(i, f);
- }
-
- ObjectArray<AbstractMethod>* GetVTable() const {
- DCHECK(IsResolved() || IsErroneous());
- return GetFieldObject<ObjectArray<AbstractMethod>*>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
- }
-
- ObjectArray<AbstractMethod>* GetVTableDuringLinking() const {
- DCHECK(IsLoaded() || IsErroneous());
- return GetFieldObject<ObjectArray<AbstractMethod>*>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
- }
-
- void SetVTable(ObjectArray<AbstractMethod>* new_vtable)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), new_vtable, false);
- }
-
- static MemberOffset VTableOffset() {
- return OFFSET_OF_OBJECT_MEMBER(Class, vtable_);
- }
-
- // Given a method implemented by this class but potentially from a
- // super class, return the specific implementation
- // method for this class.
- AbstractMethod* FindVirtualMethodForVirtual(AbstractMethod* method)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DCHECK(!method->GetDeclaringClass()->IsInterface());
- // The argument method may from a super class.
- // Use the index to a potentially overridden one for this instance's class.
- return GetVTable()->Get(method->GetMethodIndex());
- }
-
- // Given a method implemented by this class' super class, return the specific implementation
- // method for this class.
- AbstractMethod* FindVirtualMethodForSuper(AbstractMethod* method)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DCHECK(!method->GetDeclaringClass()->IsInterface());
- return GetSuperClass()->GetVTable()->Get(method->GetMethodIndex());
- }
-
- // Given a method implemented by this class, but potentially from a
- // super class or interface, return the specific implementation
- // method for this class.
- AbstractMethod* FindVirtualMethodForInterface(AbstractMethod* method)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- AbstractMethod* FindInterfaceMethod(const StringPiece& name, const StringPiece& descriptor) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- AbstractMethod* FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- AbstractMethod* FindVirtualMethodForVirtualOrInterface(AbstractMethod* method)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- if (method->IsDirect()) {
- return method;
- }
- if (method->GetDeclaringClass()->IsInterface()) {
- return FindVirtualMethodForInterface(method);
- }
- return FindVirtualMethodForVirtual(method);
- }
-
- AbstractMethod* FindDeclaredVirtualMethod(const StringPiece& name, const StringPiece& signature) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- AbstractMethod* FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- AbstractMethod* FindVirtualMethod(const StringPiece& name, const StringPiece& descriptor) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- AbstractMethod* FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- AbstractMethod* FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- AbstractMethod* FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- AbstractMethod* FindDirectMethod(const StringPiece& name, const StringPiece& signature) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- AbstractMethod* FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- int32_t GetIfTableCount() const {
- IfTable* iftable = GetIfTable();
- if (iftable == NULL) {
- return 0;
- }
- return iftable->Count();
- }
-
- IfTable* GetIfTable() const {
- return GetFieldObject<IfTable*>(OFFSET_OF_OBJECT_MEMBER(Class, iftable_), false);
- }
-
- void SetIfTable(IfTable* new_iftable)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, iftable_), new_iftable, false);
- }
-
- // Get instance fields of the class (See also GetSFields).
- ObjectArray<Field>* GetIFields() const {
- DCHECK(IsLoaded() || IsErroneous());
- return GetFieldObject<ObjectArray<Field>*>(OFFSET_OF_OBJECT_MEMBER(Class, ifields_), false);
- }
-
- void SetIFields(ObjectArray<Field>* new_ifields) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DCHECK(NULL == GetFieldObject<ObjectArray<Field>*>(
- OFFSET_OF_OBJECT_MEMBER(Class, ifields_), false));
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, ifields_), new_ifields, false);
- }
-
- size_t NumInstanceFields() const {
- return (GetIFields() != NULL) ? GetIFields()->GetLength() : 0;
- }
-
- Field* GetInstanceField(uint32_t i) const // TODO: uint16_t
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_){
- DCHECK_NE(NumInstanceFields(), 0U);
- return GetIFields()->Get(i);
- }
-
- void SetInstanceField(uint32_t i, Field* f) // TODO: uint16_t
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_){
- ObjectArray<Field>* ifields= GetFieldObject<ObjectArray<Field>*>(
- OFFSET_OF_OBJECT_MEMBER(Class, ifields_), false);
- ifields->Set(i, f);
- }
-
- // Returns the number of instance fields containing reference types.
- size_t NumReferenceInstanceFields() const {
- DCHECK(IsResolved() || IsErroneous());
- DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_instance_fields_), false);
- }
-
- size_t NumReferenceInstanceFieldsDuringLinking() const {
- DCHECK(IsLoaded() || IsErroneous());
- DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_instance_fields_), false);
- }
-
- void SetNumReferenceInstanceFields(size_t new_num) {
- DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
- SetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_instance_fields_), new_num, false);
- }
-
- uint32_t GetReferenceInstanceOffsets() const {
- DCHECK(IsResolved() || IsErroneous());
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, reference_instance_offsets_), false);
- }
-
- void SetReferenceInstanceOffsets(uint32_t new_reference_offsets);
-
- // Beginning of static field data
- static MemberOffset FieldsOffset() {
- return OFFSET_OF_OBJECT_MEMBER(Class, fields_);
- }
-
- // Returns the number of static fields containing reference types.
- size_t NumReferenceStaticFields() const {
- DCHECK(IsResolved() || IsErroneous());
- DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_static_fields_), false);
- }
-
- size_t NumReferenceStaticFieldsDuringLinking() const {
- DCHECK(IsLoaded() || IsErroneous());
- DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_static_fields_), false);
- }
-
- void SetNumReferenceStaticFields(size_t new_num) {
- DCHECK_EQ(sizeof(size_t), sizeof(int32_t));
- SetField32(OFFSET_OF_OBJECT_MEMBER(Class, num_reference_static_fields_), new_num, false);
- }
-
- // Gets the static fields of the class.
- ObjectArray<Field>* GetSFields() const {
- DCHECK(IsLoaded() || IsErroneous());
- return GetFieldObject<ObjectArray<Field>*>(OFFSET_OF_OBJECT_MEMBER(Class, sfields_), false);
- }
-
- void SetSFields(ObjectArray<Field>* new_sfields) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DCHECK(NULL == GetFieldObject<ObjectArray<Field>*>(
- OFFSET_OF_OBJECT_MEMBER(Class, sfields_), false));
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, sfields_), new_sfields, false);
- }
-
- size_t NumStaticFields() const {
- return (GetSFields() != NULL) ? GetSFields()->GetLength() : 0;
- }
-
- Field* GetStaticField(uint32_t i) const // TODO: uint16_t
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return GetSFields()->Get(i);
- }
-
- void SetStaticField(uint32_t i, Field* f) // TODO: uint16_t
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- ObjectArray<Field>* sfields= GetFieldObject<ObjectArray<Field>*>(
- OFFSET_OF_OBJECT_MEMBER(Class, sfields_), false);
- sfields->Set(i, f);
- }
-
- uint32_t GetReferenceStaticOffsets() const {
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, reference_static_offsets_), false);
- }
-
- void SetReferenceStaticOffsets(uint32_t new_reference_offsets);
-
- // Find a static or instance field using the JLS resolution order
- Field* FindField(const StringPiece& name, const StringPiece& type)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // Finds the given instance field in this class or a superclass.
- Field* FindInstanceField(const StringPiece& name, const StringPiece& type)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // Finds the given instance field in this class or a superclass, only searches classes that
- // have the same dex cache.
- Field* FindInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- Field* FindDeclaredInstanceField(const StringPiece& name, const StringPiece& type)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- Field* FindDeclaredInstanceField(const DexCache* dex_cache, uint32_t dex_field_idx)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // Finds the given static field in this class or a superclass.
- Field* FindStaticField(const StringPiece& name, const StringPiece& type)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // Finds the given static field in this class or superclass, only searches classes that
- // have the same dex cache.
- Field* FindStaticField(const DexCache* dex_cache, uint32_t dex_field_idx)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- Field* FindDeclaredStaticField(const StringPiece& name, const StringPiece& type)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- Field* FindDeclaredStaticField(const DexCache* dex_cache, uint32_t dex_field_idx)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- pid_t GetClinitThreadId() const {
- DCHECK(IsIdxLoaded() || IsErroneous());
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, clinit_thread_id_), false);
- }
-
- void SetClinitThreadId(pid_t new_clinit_thread_id) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(Class, clinit_thread_id_), new_clinit_thread_id, false);
- }
-
- Class* GetVerifyErrorClass() const {
- // DCHECK(IsErroneous());
- return GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Class, verify_error_class_), false);
- }
-
- uint16_t GetDexTypeIndex() const {
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, dex_type_idx_), false);
- }
-
- void SetDexTypeIndex(uint16_t type_idx) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(Class, dex_type_idx_), type_idx, false);
- }
-
- static Class* GetJavaLangClass() {
- DCHECK(java_lang_Class_ != NULL);
- return java_lang_Class_;
- }
-
- // Can't call this SetClass or else gets called instead of Object::SetClass in places.
- static void SetClassClass(Class* java_lang_Class);
- static void ResetClass();
-
- private:
- void SetVerifyErrorClass(Class* klass) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- CHECK(klass != NULL) << PrettyClass(this);
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, verify_error_class_), klass, false);
- }
-
- bool Implements(const Class* klass) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool IsArrayAssignableFromArray(const Class* klass) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool IsAssignableFromArray(const Class* klass) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // defining class loader, or NULL for the "bootstrap" system loader
- ClassLoader* class_loader_;
-
- // For array classes, the component class object for instanceof/checkcast
- // (for String[][][], this will be String[][]). NULL for non-array classes.
- Class* component_type_;
-
- // DexCache of resolved constant pool entries (will be NULL for classes generated by the
- // runtime such as arrays and primitive classes).
- DexCache* dex_cache_;
-
- // static, private, and <init> methods
- ObjectArray<AbstractMethod>* direct_methods_;
-
- // instance fields
- //
- // These describe the layout of the contents of an Object.
- // Note that only the fields directly declared by this class are
- // listed in ifields; fields declared by a superclass are listed in
- // the superclass's Class.ifields.
- //
- // All instance fields that refer to objects are guaranteed to be at
- // the beginning of the field list. num_reference_instance_fields_
- // specifies the number of reference fields.
- ObjectArray<Field>* ifields_;
-
- // The interface table (iftable_) contains pairs of a interface class and an array of the
- // interface methods. There is one pair per interface supported by this class. That means one
- // pair for each interface we support directly, indirectly via superclass, or indirectly via a
- // superinterface. This will be null if neither we nor our superclass implement any interfaces.
- //
- // Why we need this: given "class Foo implements Face", declare "Face faceObj = new Foo()".
- // Invoke faceObj.blah(), where "blah" is part of the Face interface. We can't easily use a
- // single vtable.
- //
- // For every interface a concrete class implements, we create an array of the concrete vtable_
- // methods for the methods in the interface.
- IfTable* iftable_;
-
- // descriptor for the class such as "java.lang.Class" or "[C". Lazily initialized by ComputeName
- String* name_;
-
- // Static fields
- ObjectArray<Field>* sfields_;
-
- // The superclass, or NULL if this is java.lang.Object, an interface or primitive type.
- Class* super_class_;
-
- // If class verify fails, we must return same error on subsequent tries.
- Class* verify_error_class_;
-
- // virtual methods defined in this class; invoked through vtable
- ObjectArray<AbstractMethod>* virtual_methods_;
-
- // Virtual method table (vtable), for use by "invoke-virtual". The vtable from the superclass is
- // copied in, and virtual methods from our class either replace those from the super or are
- // appended. For abstract classes, methods may be created in the vtable that aren't in
- // virtual_ methods_ for miranda methods.
- ObjectArray<AbstractMethod>* vtable_;
-
- // access flags; low 16 bits are defined by VM spec
- uint32_t access_flags_;
-
- // Total size of the Class instance; used when allocating storage on gc heap.
- // See also object_size_.
- size_t class_size_;
-
- // tid used to check for recursive <clinit> invocation
- pid_t clinit_thread_id_;
-
- // type index from dex file
- // TODO: really 16bits
- uint32_t dex_type_idx_;
-
- // number of instance fields that are object refs
- size_t num_reference_instance_fields_;
-
- // number of static fields that are object refs
- size_t num_reference_static_fields_;
-
- // Total object size; used when allocating storage on gc heap.
- // (For interfaces and abstract classes this will be zero.)
- // See also class_size_.
- size_t object_size_;
-
- // primitive type value, or Primitive::kPrimNot (0); set for generated prim classes
- Primitive::Type primitive_type_;
-
- // Bitmap of offsets of ifields.
- uint32_t reference_instance_offsets_;
-
- // Bitmap of offsets of sfields.
- uint32_t reference_static_offsets_;
-
- // state of class initialization
- Status status_;
-
- // TODO: ?
- // initiating class loader list
- // NOTE: for classes with low serialNumber, these are unused, and the
- // values are kept in a table in gDvm.
- // InitiatingLoaderList initiating_loader_list_;
-
- // Location of first static field.
- uint32_t fields_[0];
-
- // java.lang.Class
- static Class* java_lang_Class_;
-
- friend struct ClassOffsets; // for verifying offset information
- DISALLOW_IMPLICIT_CONSTRUCTORS(Class);
-};
-
-std::ostream& operator<<(std::ostream& os, const Class::Status& rhs);
-
-inline void Object::SetClass(Class* new_klass) {
- // new_klass may be NULL prior to class linker initialization
- // We don't mark the card since the class is guaranteed to be referenced from another location.
- // Proxy classes are held live by the class loader, and other classes are roots of the class
- // linker.
- SetFieldPtr(OFFSET_OF_OBJECT_MEMBER(Object, klass_), new_klass, false, false);
-}
-
-inline bool Object::InstanceOf(const Class* klass) const {
- DCHECK(klass != NULL);
- DCHECK(GetClass() != NULL);
- return klass->IsAssignableFrom(GetClass());
-}
-
-inline bool Object::IsClass() const {
- Class* java_lang_Class = GetClass()->GetClass();
- return GetClass() == java_lang_Class;
-}
-
-inline bool Object::IsObjectArray() const {
- return IsArrayInstance() && !GetClass()->GetComponentType()->IsPrimitive();
-}
-
-template<class T>
-inline ObjectArray<T>* Object::AsObjectArray() {
- DCHECK(IsObjectArray());
- return down_cast<ObjectArray<T>*>(this);
-}
-
-template<class T>
-inline const ObjectArray<T>* Object::AsObjectArray() const {
- DCHECK(IsObjectArray());
- return down_cast<const ObjectArray<T>*>(this);
-}
-
-inline bool Object::IsArrayInstance() const {
- return GetClass()->IsArrayClass();
-}
-
-inline bool Object::IsField() const {
- return GetClass()->IsFieldClass();
-}
-
-inline bool Object::IsMethod() const {
- return GetClass()->IsMethodClass();
-}
-
-inline bool Object::IsReferenceInstance() const {
- return GetClass()->IsReferenceClass();
-}
-
-inline bool Object::IsWeakReferenceInstance() const {
- return GetClass()->IsWeakReferenceClass();
-}
-
-inline bool Object::IsSoftReferenceInstance() const {
- return GetClass()->IsSoftReferenceClass();
-}
-
-inline bool Object::IsFinalizerReferenceInstance() const {
- return GetClass()->IsFinalizerReferenceClass();
-}
-
-inline bool Object::IsPhantomReferenceInstance() const {
- return GetClass()->IsPhantomReferenceClass();
-}
-
-inline size_t Object::SizeOf() const {
- size_t result;
- if (IsArrayInstance()) {
- result = AsArray()->SizeOf();
- } else if (IsClass()) {
- result = AsClass()->SizeOf();
- } else {
- result = GetClass()->GetObjectSize();
- }
- DCHECK(!IsField() || result == sizeof(Field));
- DCHECK(!IsMethod() || result == sizeof(AbstractMethod));
- return result;
-}
-
-inline Class* Field::GetDeclaringClass() const {
- Class* result = GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Field, declaring_class_), false);
- DCHECK(result != NULL);
- DCHECK(result->IsLoaded() || result->IsErroneous());
- return result;
-}
-
-inline void Field::SetDeclaringClass(Class *new_declaring_class) {
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Field, declaring_class_), new_declaring_class, false);
-}
-
-inline Class* AbstractMethod::GetDeclaringClass() const {
- Class* result = GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, declaring_class_), false);
- DCHECK(result != NULL) << this;
- DCHECK(result->IsIdxLoaded() || result->IsErroneous()) << this;
- return result;
-}
-
-inline void AbstractMethod::SetDeclaringClass(Class *new_declaring_class) {
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, declaring_class_), new_declaring_class, false);
-}
-
-inline size_t Array::SizeOf() const {
- // This is safe from overflow because the array was already allocated, so we know it's sane.
- size_t component_size = GetClass()->GetComponentSize();
- int32_t component_count = GetLength();
- size_t header_size = sizeof(Object) + (component_size == sizeof(int64_t) ? 8 : 4);
- size_t data_size = component_count * component_size;
- return header_size + data_size;
-}
-
-template<class T>
-void ObjectArray<T>::Set(int32_t i, T* object) {
- if (LIKELY(IsValidIndex(i))) {
- if (object != NULL) {
- Class* element_class = GetClass()->GetComponentType();
- if (UNLIKELY(!object->InstanceOf(element_class))) {
- ThrowArrayStoreException(object);
- return;
- }
- }
- MemberOffset data_offset(DataOffset(sizeof(Object*)).Int32Value() + i * sizeof(Object*));
- SetFieldObject(data_offset, object, false);
- }
-}
-
-template<class T>
-void ObjectArray<T>::SetWithoutChecks(int32_t i, T* object) {
- DCHECK(IsValidIndex(i));
- MemberOffset data_offset(DataOffset(sizeof(Object*)).Int32Value() + i * sizeof(Object*));
- SetFieldObject(data_offset, object, false);
-}
-
-template<class T>
-void ObjectArray<T>::SetPtrWithoutChecks(int32_t i, T* object) {
- DCHECK(IsValidIndex(i));
- MemberOffset data_offset(DataOffset(sizeof(Object*)).Int32Value() + i * sizeof(Object*));
- SetFieldPtr(data_offset, object, false);
-}
-
-template<class T>
-T* ObjectArray<T>::GetWithoutChecks(int32_t i) const {
- DCHECK(IsValidIndex(i));
- MemberOffset data_offset(DataOffset(sizeof(Object*)).Int32Value() + i * sizeof(Object*));
- return GetFieldObject<T*>(data_offset, false);
-}
-
-template<class T>
-void ObjectArray<T>::Copy(const ObjectArray<T>* src, int src_pos,
- ObjectArray<T>* dst, int dst_pos,
- size_t length) {
- if (src->IsValidIndex(src_pos) &&
- src->IsValidIndex(src_pos+length-1) &&
- dst->IsValidIndex(dst_pos) &&
- dst->IsValidIndex(dst_pos+length-1)) {
- MemberOffset src_offset(DataOffset(sizeof(Object*)).Int32Value() + src_pos * sizeof(Object*));
- MemberOffset dst_offset(DataOffset(sizeof(Object*)).Int32Value() + dst_pos * sizeof(Object*));
- Class* array_class = dst->GetClass();
- Heap* heap = Runtime::Current()->GetHeap();
- if (array_class == src->GetClass()) {
- // No need for array store checks if arrays are of the same type
- for (size_t i = 0; i < length; i++) {
- Object* object = src->GetFieldObject<Object*>(src_offset, false);
- heap->VerifyObject(object);
- // directly set field, we do a bulk write barrier at the end
- dst->SetField32(dst_offset, reinterpret_cast<uint32_t>(object), false, true);
- src_offset = MemberOffset(src_offset.Uint32Value() + sizeof(Object*));
- dst_offset = MemberOffset(dst_offset.Uint32Value() + sizeof(Object*));
- }
- } else {
- Class* element_class = array_class->GetComponentType();
- CHECK(!element_class->IsPrimitive());
- for (size_t i = 0; i < length; i++) {
- Object* object = src->GetFieldObject<Object*>(src_offset, false);
- if (object != NULL && !object->InstanceOf(element_class)) {
- dst->ThrowArrayStoreException(object);
- return;
- }
- heap->VerifyObject(object);
- // directly set field, we do a bulk write barrier at the end
- dst->SetField32(dst_offset, reinterpret_cast<uint32_t>(object), false, true);
- src_offset = MemberOffset(src_offset.Uint32Value() + sizeof(Object*));
- dst_offset = MemberOffset(dst_offset.Uint32Value() + sizeof(Object*));
- }
- }
- heap->WriteBarrierArray(dst, dst_pos, length);
- }
-}
-
-inline void IfTable::SetInterface(int32_t i, Class* interface) {
- DCHECK(interface != NULL);
- DCHECK(interface->IsInterface());
- DCHECK(Get((i * kMax) + kInterface) == NULL);
- Set((i * kMax) + kInterface, interface);
-}
-
-class MANAGED ClassClass : public Class {
- private:
- int32_t padding_;
- int64_t serialVersionUID_;
- friend struct ClassClassOffsets; // for verifying offset information
- DISALLOW_IMPLICIT_CONSTRUCTORS(ClassClass);
-};
-
-class MANAGED StringClass : public Class {
- private:
- CharArray* ASCII_;
- Object* CASE_INSENSITIVE_ORDER_;
- uint32_t REPLACEMENT_CHAR_;
- int64_t serialVersionUID_;
- friend struct StringClassOffsets; // for verifying offset information
- DISALLOW_IMPLICIT_CONSTRUCTORS(StringClass);
-};
-
-class MANAGED FieldClass : public Class {
- private:
- Object* ORDER_BY_NAME_AND_DECLARING_CLASS_;
- friend struct FieldClassOffsets; // for verifying offset information
- DISALLOW_IMPLICIT_CONSTRUCTORS(FieldClass);
-};
-
-class MANAGED MethodClass : public Class {
- private:
- Object* ORDER_BY_SIGNATURE_;
- friend struct MethodClassOffsets; // for verifying offset information
- DISALLOW_IMPLICIT_CONSTRUCTORS(MethodClass);
-};
-
-template<class T>
-class MANAGED PrimitiveArray : public Array {
- public:
- typedef T ElementType;
-
- static PrimitiveArray<T>* Alloc(Thread* self, size_t length)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- const T* GetData() const {
- intptr_t data = reinterpret_cast<intptr_t>(this) + DataOffset(sizeof(T)).Int32Value();
- return reinterpret_cast<T*>(data);
- }
-
- T* GetData() {
- intptr_t data = reinterpret_cast<intptr_t>(this) + DataOffset(sizeof(T)).Int32Value();
- return reinterpret_cast<T*>(data);
- }
-
- T Get(int32_t i) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- if (!IsValidIndex(i)) {
- return T(0);
- }
- return GetData()[i];
- }
-
- void Set(int32_t i, T value) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- if (IsValidIndex(i)) {
- GetData()[i] = value;
- }
- }
-
- static void SetArrayClass(Class* array_class) {
- CHECK(array_class_ == NULL);
- CHECK(array_class != NULL);
- array_class_ = array_class;
- }
-
- static void ResetArrayClass() {
- CHECK(array_class_ != NULL);
- array_class_ = NULL;
- }
-
- private:
- static Class* array_class_;
-
- DISALLOW_IMPLICIT_CONSTRUCTORS(PrimitiveArray);
-};
-
-// C++ mirror of java.lang.String
-class MANAGED String : public Object {
- public:
- static MemberOffset CountOffset() {
- return OFFSET_OF_OBJECT_MEMBER(String, count_);
- }
-
- static MemberOffset ValueOffset() {
- return OFFSET_OF_OBJECT_MEMBER(String, array_);
- }
-
- static MemberOffset OffsetOffset() {
- return OFFSET_OF_OBJECT_MEMBER(String, offset_);
- }
-
- const CharArray* GetCharArray() const {
- return GetFieldObject<const CharArray*>(ValueOffset(), false);
- }
-
- int32_t GetOffset() const {
- int32_t result = GetField32(OffsetOffset(), false);
- DCHECK_LE(0, result);
- return result;
- }
-
- int32_t GetLength() const;
-
- int32_t GetHashCode() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- void ComputeHashCode() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- SetHashCode(ComputeUtf16Hash(GetCharArray(), GetOffset(), GetLength()));
- }
-
- int32_t GetUtfLength() const {
- return CountUtf8Bytes(GetCharArray()->GetData() + GetOffset(), GetLength());
- }
-
- uint16_t CharAt(int32_t index) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- String* Intern() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- static String* AllocFromUtf16(Thread* self,
- int32_t utf16_length,
- const uint16_t* utf16_data_in,
- int32_t hash_code = 0)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- static String* AllocFromModifiedUtf8(Thread* self, const char* utf)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- static String* AllocFromModifiedUtf8(Thread* self, int32_t utf16_length,
- const char* utf8_data_in)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- static String* Alloc(Thread* self, Class* java_lang_String, int32_t utf16_length)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- static String* Alloc(Thread* self, Class* java_lang_String, CharArray* array)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- bool Equals(const char* modified_utf8) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // TODO: do we need this overload? give it a more intention-revealing name.
- bool Equals(const StringPiece& modified_utf8) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- bool Equals(const String* that) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // Compare UTF-16 code point values not in a locale-sensitive manner
- int Compare(int32_t utf16_length, const char* utf8_data_in);
-
- // TODO: do we need this overload? give it a more intention-revealing name.
- bool Equals(const uint16_t* that_chars, int32_t that_offset,
- int32_t that_length) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // Create a modified UTF-8 encoded std::string from a java/lang/String object.
- std::string ToModifiedUtf8() const;
-
- int32_t FastIndexOf(int32_t ch, int32_t start) {
- int32_t count = GetLength();
- if (start < 0) {
- start = 0;
- } else if (start > count) {
- start = count;
- }
- const uint16_t* chars = GetCharArray()->GetData() + GetOffset();
- const uint16_t* p = chars + start;
- const uint16_t* end = chars + count;
- while (p < end) {
- if (*p++ == ch) {
- return (p - 1) - chars;
- }
- }
- return -1;
- }
-
- int32_t CompareTo(String* other) const;
-
- static Class* GetJavaLangString() {
- DCHECK(java_lang_String_ != NULL);
- return java_lang_String_;
- }
-
- static void SetClass(Class* java_lang_String);
- static void ResetClass();
-
- private:
- void SetHashCode(int32_t new_hash_code) {
- DCHECK_EQ(0u,
- GetField32(OFFSET_OF_OBJECT_MEMBER(String, hash_code_), false));
- SetField32(OFFSET_OF_OBJECT_MEMBER(String, hash_code_),
- new_hash_code, false);
- }
-
- void SetCount(int32_t new_count) {
- DCHECK_LE(0, new_count);
- SetField32(OFFSET_OF_OBJECT_MEMBER(String, count_), new_count, false);
- }
-
- void SetOffset(int32_t new_offset) {
- DCHECK_LE(0, new_offset);
- DCHECK_GE(GetLength(), new_offset);
- SetField32(OFFSET_OF_OBJECT_MEMBER(String, offset_), new_offset, false);
- }
-
- void SetArray(CharArray* new_array) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DCHECK(new_array != NULL);
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(String, array_), new_array, false);
- }
-
- // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
- CharArray* array_;
-
- int32_t count_;
-
- uint32_t hash_code_;
-
- int32_t offset_;
-
- static Class* java_lang_String_;
-
- friend struct StringOffsets; // for verifying offset information
- FRIEND_TEST(ObjectTest, StringLength); // for SetOffset and SetCount
- DISALLOW_IMPLICIT_CONSTRUCTORS(String);
-};
-
-// TODO: remove? only used in a unit test of itself.
-struct StringHashCode {
- int32_t operator()(String* string) const {
- return string->GetHashCode();
- }
-};
-
-inline uint32_t Field::GetAccessFlags() const {
- DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Field, access_flags_), false);
-}
-
-inline MemberOffset Field::GetOffset() const {
- DCHECK(GetDeclaringClass()->IsResolved() || GetDeclaringClass()->IsErroneous());
- return MemberOffset(GetField32(OFFSET_OF_OBJECT_MEMBER(Field, offset_), false));
-}
-
-inline MemberOffset Field::GetOffsetDuringLinking() const {
- DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
- return MemberOffset(GetField32(OFFSET_OF_OBJECT_MEMBER(Field, offset_), false));
-}
-
-inline uint32_t Class::GetAccessFlags() const {
- // Check class is loaded or this is java.lang.String that has a
- // circularity issue during loading the names of its members
- DCHECK(IsLoaded() || IsErroneous() ||
- this == String::GetJavaLangString() ||
- this == Field::GetJavaLangReflectField() ||
- this == AbstractMethod::GetConstructorClass() ||
- this == AbstractMethod::GetMethodClass());
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_), false);
-}
-
-inline uint32_t AbstractMethod::GetAccessFlags() const {
- DCHECK(GetDeclaringClass()->IsIdxLoaded() || GetDeclaringClass()->IsErroneous());
- return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, access_flags_), false);
-}
-
-inline uint16_t AbstractMethod::GetMethodIndex() const {
- DCHECK(GetDeclaringClass()->IsResolved() || GetDeclaringClass()->IsErroneous());
- return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_index_), false);
-}
-
-inline uint32_t AbstractMethod::GetDexMethodIndex() const {
- DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
- return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_dex_index_), false);
-}
-
-inline bool AbstractMethod::CheckIncompatibleClassChange(InvokeType type) {
- switch (type) {
- case kStatic:
- return !IsStatic();
- case kDirect:
- return !IsDirect() || IsStatic();
- case kVirtual: {
- Class* methods_class = GetDeclaringClass();
- return IsDirect() || (methods_class->IsInterface() && !IsMiranda());
- }
- case kSuper:
- return false; // TODO: appropriate checks for call to super class.
- case kInterface: {
- Class* methods_class = GetDeclaringClass();
- return IsDirect() || !(methods_class->IsInterface() || methods_class->IsObjectClass());
- }
- default:
- LOG(FATAL) << "Unreachable - invocation type: " << type;
- return true;
- }
-}
-
-inline void AbstractMethod::AssertPcIsWithinCode(uintptr_t pc) const {
- if (!kIsDebugBuild) {
- return;
- }
- if (IsNative() || IsRuntimeMethod() || IsProxyMethod()) {
- return;
- }
- Runtime* runtime = Runtime::Current();
- if (GetCode() == runtime->GetResolutionStubArray(Runtime::kStaticMethod)->GetData()) {
- return;
- }
- DCHECK(IsWithinCode(pc))
- << PrettyMethod(this)
- << " pc=" << std::hex << pc
- << " code=" << GetCode()
- << " size=" << GetCodeSize();
-}
-
-inline String* Class::GetName() const {
- return GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(Class, name_), false);
-}
-inline void Class::SetName(String* name) {
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, name_), name, false);
-}
-
-// C++ mirror of java.lang.Throwable
-class MANAGED Throwable : public Object {
- public:
- void SetDetailMessage(String* new_detail_message) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Throwable, detail_message_), new_detail_message, false);
- }
- String* GetDetailMessage() const {
- return GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(Throwable, detail_message_), false);
- }
- std::string Dump() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- // This is a runtime version of initCause, you shouldn't use it if initCause may have been
- // overridden. Also it asserts rather than throwing exceptions. Currently this is only used
- // in cases like the verifier where the checks cannot fail and initCause isn't overridden.
- void SetCause(Throwable* cause) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool IsCheckedException() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- static Class* GetJavaLangThrowable() {
- DCHECK(java_lang_Throwable_ != NULL);
- return java_lang_Throwable_;
- }
-
- static void SetClass(Class* java_lang_Throwable);
- static void ResetClass();
-
- private:
- Object* GetStackState() const {
- return GetFieldObject<Object*>(OFFSET_OF_OBJECT_MEMBER(Throwable, stack_state_), true);
- }
-
- // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
- Throwable* cause_;
- String* detail_message_;
- Object* stack_state_; // Note this is Java volatile:
- Object* stack_trace_;
- Object* suppressed_exceptions_;
-
- static Class* java_lang_Throwable_;
-
- friend struct ThrowableOffsets; // for verifying offset information
- DISALLOW_IMPLICIT_CONSTRUCTORS(Throwable);
-};
-
-// C++ mirror of java.lang.StackTraceElement
-class MANAGED StackTraceElement : public Object {
- public:
- const String* GetDeclaringClass() const {
- return GetFieldObject<const String*>(
- OFFSET_OF_OBJECT_MEMBER(StackTraceElement, declaring_class_), false);
- }
-
- const String* GetMethodName() const {
- return GetFieldObject<const String*>(
- OFFSET_OF_OBJECT_MEMBER(StackTraceElement, method_name_), false);
- }
-
- const String* GetFileName() const {
- return GetFieldObject<const String*>(
- OFFSET_OF_OBJECT_MEMBER(StackTraceElement, file_name_), false);
- }
-
- int32_t GetLineNumber() const {
- return GetField32(
- OFFSET_OF_OBJECT_MEMBER(StackTraceElement, line_number_), false);
- }
-
- static StackTraceElement* Alloc(Thread* self,
- String* declaring_class,
- String* method_name,
- String* file_name,
- int32_t line_number)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-
- static void SetClass(Class* java_lang_StackTraceElement);
-
- static void ResetClass();
-
- private:
- // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
- String* declaring_class_;
- String* file_name_;
- String* method_name_;
- int32_t line_number_;
-
- static Class* GetStackTraceElement() {
- DCHECK(java_lang_StackTraceElement_ != NULL);
- return java_lang_StackTraceElement_;
- }
-
- static Class* java_lang_StackTraceElement_;
-
- friend struct StackTraceElementOffsets; // for verifying offset information
- DISALLOW_IMPLICIT_CONSTRUCTORS(StackTraceElement);
-};
-
-class MANAGED SynthesizedProxyClass : public Class {
- public:
- ObjectArray<Class>* GetInterfaces() {
- return interfaces_;
- }
-
- ObjectArray<ObjectArray<Class> >* GetThrows() {
- return throws_;
- }
-
- private:
- ObjectArray<Class>* interfaces_;
- ObjectArray<ObjectArray<Class> >* throws_;
- DISALLOW_IMPLICIT_CONSTRUCTORS(SynthesizedProxyClass);
-};
-
-class MANAGED Proxy : public Object {
- private:
- Object* h_;
-
- friend struct ProxyOffsets; // for verifying offset information
- DISALLOW_IMPLICIT_CONSTRUCTORS(Proxy);
-};
-
-} // namespace art
-
-#endif // ART_SRC_OBJECT_H_
diff --git a/src/object_utils.h b/src/object_utils.h
index 068dd66..ea4de90 100644
--- a/src/object_utils.h
+++ b/src/object_utils.h
@@ -18,14 +18,17 @@
#define ART_SRC_OBJECT_UTILS_H_
#include "class_linker.h"
-#include "dex_cache.h"
#include "dex_file.h"
-#include "intern_table.h"
#include "monitor.h"
-#include "object.h"
+#include "mirror/abstract_method.h"
+#include "mirror/class.h"
+#include "mirror/dex_cache.h"
+#include "mirror/field.h"
+#include "mirror/iftable.h"
+#include "mirror/string.h"
+
#include "runtime.h"
#include "sirt_ref.h"
-#include "UniquePtr.h"
#include <string>
@@ -33,7 +36,7 @@
class ObjectLock {
public:
- explicit ObjectLock(Thread* self, Object* object) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
+ explicit ObjectLock(Thread* self, mirror::Object* object) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
: self_(self), obj_(object) {
CHECK(object != NULL);
obj_->MonitorEnter(self_);
@@ -57,13 +60,13 @@
private:
Thread* const self_;
- Object* obj_;
+ mirror::Object* obj_;
DISALLOW_COPY_AND_ASSIGN(ObjectLock);
};
class ClassHelper {
public:
- ClassHelper(const Class* c = NULL, ClassLinker* l = NULL)
+ ClassHelper(const mirror::Class* c = NULL, ClassLinker* l = NULL)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
: class_def_(NULL),
class_linker_(l),
@@ -76,12 +79,12 @@
}
}
- void ChangeClass(const Class* new_c)
+ void ChangeClass(const mirror::Class* new_c)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
CHECK(new_c != NULL) << "klass_=" << klass_; // Log what we were changing from if any
CHECK(new_c->IsClass()) << "new_c=" << new_c;
if (dex_cache_ != NULL) {
- DexCache* new_c_dex_cache = new_c->GetDexCache();
+ mirror::DexCache* new_c_dex_cache = new_c->GetDexCache();
if (new_c_dex_cache != dex_cache_) {
dex_cache_ = new_c_dex_cache;
dex_file_ = NULL;
@@ -112,7 +115,7 @@
const char* GetArrayDescriptor() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
std::string result("[");
- const Class* saved_klass = klass_;
+ const mirror::Class* saved_klass = klass_;
CHECK(saved_klass != NULL);
ChangeClass(klass_->GetComponentType());
result += GetDescriptor();
@@ -157,7 +160,7 @@
return GetInterfaceTypeList()->GetTypeItem(idx).type_idx_;
}
- Class* GetDirectInterface(uint32_t idx)
+ mirror::Class* GetDirectInterface(uint32_t idx)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(klass_ != NULL);
DCHECK(!klass_->IsPrimitive());
@@ -172,7 +175,7 @@
return klass_->GetIfTable()->GetInterface(idx);
} else {
uint16_t type_idx = GetDirectInterfaceTypeIdx(idx);
- Class* interface = GetDexCache()->GetResolvedType(type_idx);
+ mirror::Class* interface = GetDexCache()->GetResolvedType(type_idx);
if (interface == NULL) {
interface = GetClassLinker()->ResolveType(GetDexFile(), type_idx, klass_);
CHECK(interface != NULL || Thread::Current()->IsExceptionPending());
@@ -190,7 +193,7 @@
}
std::string GetLocation() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DexCache* dex_cache = GetDexCache();
+ mirror::DexCache* dex_cache = GetDexCache();
if (dex_cache != NULL && !klass_->IsProxyClass()) {
return dex_cache->GetLocation()->ToModifiedUtf8();
} else {
@@ -206,8 +209,8 @@
return *dex_file_;
}
- DexCache* GetDexCache() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DexCache* result = dex_cache_;
+ mirror::DexCache* GetDexCache() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ mirror::DexCache* result = dex_cache_;
if (result == NULL) {
DCHECK(klass_ != NULL);
result = klass_->GetDexCache();
@@ -241,10 +244,10 @@
const DexFile::ClassDef* class_def_;
ClassLinker* class_linker_;
- DexCache* dex_cache_;
+ mirror::DexCache* dex_cache_;
const DexFile* dex_file_;
const DexFile::TypeList* interface_type_list_;
- const Class* klass_;
+ const mirror::Class* klass_;
std::string descriptor_;
DISALLOW_COPY_AND_ASSIGN(ClassHelper);
@@ -253,14 +256,14 @@
class FieldHelper {
public:
FieldHelper() : class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL), field_(NULL) {}
- explicit FieldHelper(const Field* f) : class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL), field_(f) {}
- FieldHelper(const Field* f, ClassLinker* l)
+ explicit FieldHelper(const mirror::Field* f) : class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL), field_(f) {}
+ FieldHelper(const mirror::Field* f, ClassLinker* l)
: class_linker_(l), dex_cache_(NULL), dex_file_(NULL), field_(f) {}
- void ChangeField(const Field* new_f) {
+ void ChangeField(const mirror::Field* new_f) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(new_f != NULL);
if (dex_cache_ != NULL) {
- DexCache* new_f_dex_cache = new_f->GetDeclaringClass()->GetDexCache();
+ mirror::DexCache* new_f_dex_cache = new_f->GetDeclaringClass()->GetDexCache();
if (new_f_dex_cache != dex_cache_) {
dex_cache_ = new_f_dex_cache;
dex_file_ = NULL;
@@ -279,22 +282,12 @@
return field_index == 0 ? "interfaces" : "throws";
}
}
- String* GetNameAsString() {
+ mirror::Class* GetType() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
uint32_t field_index = field_->GetDexFieldIndex();
if (!field_->GetDeclaringClass()->IsProxyClass()) {
const DexFile& dex_file = GetDexFile();
const DexFile::FieldId& field_id = dex_file.GetFieldId(field_index);
- return GetClassLinker()->ResolveString(dex_file, field_id.name_idx_, GetDexCache());
- } else {
- return Runtime::Current()->GetInternTable()->InternStrong(GetName());
- }
- }
- Class* GetType() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- uint32_t field_index = field_->GetDexFieldIndex();
- if (!field_->GetDeclaringClass()->IsProxyClass()) {
- const DexFile& dex_file = GetDexFile();
- const DexFile::FieldId& field_id = dex_file.GetFieldId(field_index);
- Class* type = GetDexCache()->GetResolvedType(field_id.type_idx_);
+ mirror::Class* type = GetDexCache()->GetResolvedType(field_id.type_idx_);
if (type == NULL) {
type = GetClassLinker()->ResolveType(field_id.type_idx_, field_);
CHECK(type != NULL || Thread::Current()->IsExceptionPending());
@@ -347,8 +340,8 @@
}
private:
- DexCache* GetDexCache() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DexCache* result = dex_cache_;
+ mirror::DexCache* GetDexCache() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ mirror::DexCache* result = dex_cache_;
if (result == NULL) {
result = field_->GetDeclaringClass()->GetDexCache();
dex_cache_ = result;
@@ -371,9 +364,9 @@
}
ClassLinker* class_linker_;
- DexCache* dex_cache_;
+ mirror::DexCache* dex_cache_;
const DexFile* dex_file_;
- const Field* field_;
+ const mirror::Field* field_;
std::string declaring_class_descriptor_;
DISALLOW_COPY_AND_ASSIGN(FieldHelper);
@@ -385,29 +378,29 @@
: class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL), method_(NULL), shorty_(NULL),
shorty_len_(0) {}
- explicit MethodHelper(const AbstractMethod* m)
+ explicit MethodHelper(const mirror::AbstractMethod* m)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
: class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL), method_(NULL), shorty_(NULL),
shorty_len_(0) {
SetMethod(m);
}
- MethodHelper(const AbstractMethod* m, ClassLinker* l)
+ MethodHelper(const mirror::AbstractMethod* m, ClassLinker* l)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
: class_linker_(l), dex_cache_(NULL), dex_file_(NULL), method_(NULL), shorty_(NULL),
shorty_len_(0) {
SetMethod(m);
}
- void ChangeMethod(AbstractMethod* new_m) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ void ChangeMethod(mirror::AbstractMethod* new_m) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(new_m != NULL);
if (dex_cache_ != NULL) {
- Class* klass = new_m->GetDeclaringClass();
+ mirror::Class* klass = new_m->GetDeclaringClass();
if (klass->IsProxyClass()) {
dex_cache_ = NULL;
dex_file_ = NULL;
} else {
- DexCache* new_m_dex_cache = klass->GetDexCache();
+ mirror::DexCache* new_m_dex_cache = klass->GetDexCache();
if (new_m_dex_cache != dex_cache_) {
dex_cache_ = new_m_dex_cache;
dex_file_ = NULL;
@@ -439,7 +432,7 @@
}
}
- String* GetNameAsString() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ mirror::String* GetNameAsString() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
const DexFile& dex_file = GetDexFile();
uint32_t dex_method_idx = method_->GetDexMethodIndex();
const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
@@ -487,17 +480,18 @@
return GetDexFile().GetProtoParameters(proto);
}
- ObjectArray<Class>* GetParameterTypes(Thread* self)
+ mirror::ObjectArray<mirror::Class>* GetParameterTypes(Thread* self)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
const DexFile::TypeList* params = GetParameterTypeList();
uint32_t num_params = params == NULL ? 0 : params->Size();
- SirtRef<ObjectArray<Class> > result(self, GetClassLinker()->AllocClassArray(self, num_params));
+ SirtRef<mirror::ObjectArray<mirror::Class> >
+ result(self, GetClassLinker()->AllocClassArray(self, num_params));
if (UNLIKELY(result.get() == NULL)) {
CHECK(self->IsExceptionPending());
return NULL;
}
for (uint32_t i = 0; i < num_params; i++) {
- Class* param_type = GetClassFromTypeIdx(params->GetTypeItem(i).type_idx_);
+ mirror::Class* param_type = GetClassFromTypeIdx(params->GetTypeItem(i).type_idx_);
if (param_type == NULL) {
DCHECK(Thread::Current()->IsExceptionPending());
return NULL;
@@ -507,7 +501,7 @@
return result.get();
}
- Class* GetReturnType() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ mirror::Class* GetReturnType() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
const DexFile& dex_file = GetDexFile();
const DexFile::MethodId& method_id = dex_file.GetMethodId(method_->GetDexMethodIndex());
const DexFile::ProtoId& proto_id = dex_file.GetMethodPrototype(method_id);
@@ -536,7 +530,7 @@
const char* GetDeclaringClassDescriptor()
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Class* klass = method_->GetDeclaringClass();
+ mirror::Class* klass = method_->GetDeclaringClass();
DCHECK(!klass->IsProxyClass());
uint16_t type_idx = klass->GetDexTypeIndex();
const DexFile& dex_file = GetDexFile();
@@ -561,7 +555,7 @@
return index;
}
- ClassLoader* GetClassLoader()
+ mirror::ClassLoader* GetClassLoader()
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return method_->GetDeclaringClass()->GetClassLoader();
}
@@ -626,9 +620,9 @@
return method_->GetDexCacheResolvedTypes()->Get(type_idx) != NULL;
}
- Class* GetClassFromTypeIdx(uint16_t type_idx)
+ mirror::Class* GetClassFromTypeIdx(uint16_t type_idx)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Class* type = method_->GetDexCacheResolvedTypes()->Get(type_idx);
+ mirror::Class* type = method_->GetDexCacheResolvedTypes()->Get(type_idx);
if (type == NULL) {
type = GetClassLinker()->ResolveType(type_idx, method_);
CHECK(type != NULL || Thread::Current()->IsExceptionPending());
@@ -642,7 +636,7 @@
return dex_file.GetTypeDescriptor(dex_file.GetTypeId(type_idx));
}
- Class* GetDexCacheResolvedType(uint16_t type_idx)
+ mirror::Class* GetDexCacheResolvedType(uint16_t type_idx)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return method_->GetDexCacheResolvedTypes()->Get(type_idx);
}
@@ -650,24 +644,24 @@
const DexFile& GetDexFile() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
const DexFile* result = dex_file_;
if (result == NULL) {
- const DexCache* dex_cache = GetDexCache();
+ const mirror::DexCache* dex_cache = GetDexCache();
result = dex_file_ = dex_cache->GetDexFile();
}
return *result;
}
- DexCache* GetDexCache() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- DexCache* result = dex_cache_;
+ mirror::DexCache* GetDexCache() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ mirror::DexCache* result = dex_cache_;
if (result == NULL) {
- Class* klass = method_->GetDeclaringClass();
+ mirror::Class* klass = method_->GetDeclaringClass();
result = klass->GetDexCache();
dex_cache_ = result;
}
return result;
}
- String* ResolveString(uint32_t string_idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- String* s = method_->GetDexCacheStrings()->Get(string_idx);
+ mirror::String* ResolveString(uint32_t string_idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ mirror::String* s = method_->GetDexCacheStrings()->Get(string_idx);
if (UNLIKELY(s == NULL)) {
s = GetClassLinker()->ResolveString(GetDexFile(), string_idx, GetDexCache());
}
@@ -677,11 +671,11 @@
private:
// Set the method_ field, for proxy methods looking up the interface method via the resolved
// methods table.
- void SetMethod(const AbstractMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ void SetMethod(const mirror::AbstractMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (method != NULL) {
- Class* klass = method->GetDeclaringClass();
+ mirror::Class* klass = method->GetDeclaringClass();
if (klass->IsProxyClass()) {
- AbstractMethod* interface_method =
+ mirror::AbstractMethod* interface_method =
method->GetDexCacheResolvedMethods()->Get(method->GetDexMethodIndex());
CHECK(interface_method != NULL);
CHECK(interface_method == GetClassLinker()->FindMethodForProxy(klass, method));
@@ -701,9 +695,9 @@
}
ClassLinker* class_linker_;
- DexCache* dex_cache_;
+ mirror::DexCache* dex_cache_;
const DexFile* dex_file_;
- const AbstractMethod* method_;
+ const mirror::AbstractMethod* method_;
const char* shorty_;
uint32_t shorty_len_;
diff --git a/src/primitive.h b/src/primitive.h
index cb78ccc..eaa04cd 100644
--- a/src/primitive.h
+++ b/src/primitive.h
@@ -23,8 +23,9 @@
#include "base/macros.h"
namespace art {
-
+namespace mirror {
class Object;
+} // namespace mirror
class Primitive {
public:
@@ -77,7 +78,7 @@
case kPrimFloat: return 4;
case kPrimLong:
case kPrimDouble: return 8;
- case kPrimNot: return sizeof(Object*);
+ case kPrimNot: return sizeof(mirror::Object*);
default:
LOG(FATAL) << "Invalid type " << static_cast<int>(type);
return 0;
diff --git a/src/reference_table.cc b/src/reference_table.cc
index cdb3004..192535a 100644
--- a/src/reference_table.cc
+++ b/src/reference_table.cc
@@ -18,8 +18,14 @@
#include "base/mutex.h"
#include "indirect_reference_table.h"
-
-#include "object.h"
+#include "mirror/array.h"
+#include "mirror/array-inl.h"
+#include "mirror/class.h"
+#include "mirror/class-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/string.h"
+#include "thread.h"
+#include "utils.h"
namespace art {
@@ -32,7 +38,7 @@
ReferenceTable::~ReferenceTable() {
}
-void ReferenceTable::Add(const Object* obj) {
+void ReferenceTable::Add(const mirror::Object* obj) {
DCHECK(obj != NULL);
if (entries_.size() == max_size_) {
LOG(FATAL) << "ReferenceTable '" << name_ << "' "
@@ -41,7 +47,7 @@
entries_.push_back(obj);
}
-void ReferenceTable::Remove(const Object* obj) {
+void ReferenceTable::Remove(const mirror::Object* obj) {
// We iterate backwards on the assumption that references are LIFO.
for (int i = entries_.size() - 1; i >= 0; --i) {
if (entries_[i] == obj) {
@@ -53,7 +59,7 @@
// If "obj" is an array, return the number of elements in the array.
// Otherwise, return zero.
-static size_t GetElementCount(const Object* obj) {
+static size_t GetElementCount(const mirror::Object* obj) {
if (obj == NULL || obj == kClearedJniWeakGlobal || !obj->IsArrayInstance()) {
return 0;
}
@@ -61,7 +67,7 @@
}
struct ObjectComparator {
- bool operator()(const Object* obj1, const Object* obj2)
+ bool operator()(const mirror::Object* obj1, const mirror::Object* obj2)
// TODO: enable analysis when analysis can work with the STL.
NO_THREAD_SAFETY_ANALYSIS {
Locks::mutator_lock_->AssertSharedHeld(Thread::Current());
@@ -99,7 +105,7 @@
// Pass in the number of elements in the array (or 0 if this is not an
// array object), and the number of additional objects that are identical
// or equivalent to the original.
-static void DumpSummaryLine(std::ostream& os, const Object* obj, size_t element_count,
+static void DumpSummaryLine(std::ostream& os, const mirror::Object* obj, size_t element_count,
int identical, int equiv)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (obj == NULL) {
@@ -153,7 +159,7 @@
}
os << " Last " << (count - first) << " entries (of " << count << "):\n";
for (int idx = count - 1; idx >= first; --idx) {
- const Object* ref = entries[idx];
+ const mirror::Object* ref = entries[idx];
if (ref == NULL) {
continue;
}
@@ -175,7 +181,7 @@
if (element_count != 0) {
StringAppendF(&extras, " (%zd elements)", element_count);
} else if (ref->GetClass()->IsStringClass()) {
- String* s = const_cast<Object*>(ref)->AsString();
+ mirror::String* s = const_cast<mirror::Object*>(ref)->AsString();
std::string utf8(s->ToModifiedUtf8());
if (s->GetLength() <= 16) {
StringAppendF(&extras, " \"%s\"", utf8.c_str());
@@ -206,8 +212,8 @@
size_t equiv = 0;
size_t identical = 0;
for (size_t idx = 1; idx < count; idx++) {
- const Object* prev = sorted_entries[idx-1];
- const Object* current = sorted_entries[idx];
+ const mirror::Object* prev = sorted_entries[idx-1];
+ const mirror::Object* current = sorted_entries[idx];
size_t element_count = GetElementCount(prev);
if (current == prev) {
// Same reference, added more than once.
@@ -225,7 +231,7 @@
DumpSummaryLine(os, sorted_entries.back(), GetElementCount(sorted_entries.back()), identical, equiv);
}
-void ReferenceTable::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
+void ReferenceTable::VisitRoots(RootVisitor* visitor, void* arg) {
typedef Table::const_iterator It; // TODO: C++0x auto
for (It it = entries_.begin(), end = entries_.end(); it != end; ++it) {
visitor(*it, arg);
diff --git a/src/reference_table.h b/src/reference_table.h
index f398eb2..5abb5c7 100644
--- a/src/reference_table.h
+++ b/src/reference_table.h
@@ -22,11 +22,13 @@
#include <string>
#include <vector>
-#include "heap.h"
+#include "locks.h"
+#include "root_visitor.h"
namespace art {
-
+namespace mirror {
class Object;
+} // namespace mirror
// Maintain a table of references. Used for JNI monitor references and
// JNI pinned array references.
@@ -37,18 +39,18 @@
ReferenceTable(const char* name, size_t initial_size, size_t max_size);
~ReferenceTable();
- void Add(const Object* obj);
+ void Add(const mirror::Object* obj);
- void Remove(const Object* obj);
+ void Remove(const mirror::Object* obj);
size_t Size() const;
void Dump(std::ostream& os) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void VisitRoots(Heap::RootVisitor* visitor, void* arg);
+ void VisitRoots(RootVisitor* visitor, void* arg);
private:
- typedef std::vector<const Object*> Table;
+ typedef std::vector<const mirror::Object*> Table;
static void Dump(std::ostream& os, const Table& entries)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
friend class IndirectReferenceTable; // For Dump.
diff --git a/src/reference_table_test.cc b/src/reference_table_test.cc
index c400f83..16fbd94 100644
--- a/src/reference_table_test.cc
+++ b/src/reference_table_test.cc
@@ -25,7 +25,7 @@
TEST_F(ReferenceTableTest, Basics) {
ScopedObjectAccess soa(Thread::Current());
- Object* o1 = String::AllocFromModifiedUtf8(soa.Self(), "hello");
+ mirror::Object* o1 = mirror::String::AllocFromModifiedUtf8(soa.Self(), "hello");
ReferenceTable rt("test", 0, 11);
@@ -56,7 +56,7 @@
}
// Add a second object 10 times and check dumping is sane.
- Object* o2 = ShortArray::Alloc(soa.Self(), 0);
+ mirror::Object* o2 = mirror::ShortArray::Alloc(soa.Self(), 0);
for (size_t i = 0; i < 10; ++i) {
rt.Add(o2);
EXPECT_EQ(i + 2, rt.Size());
diff --git a/src/reflection.cc b/src/reflection.cc
index 1ffad3f..16a5502 100644
--- a/src/reflection.cc
+++ b/src/reflection.cc
@@ -18,7 +18,13 @@
#include "class_linker.h"
#include "jni_internal.h"
-#include "object.h"
+#include "mirror/abstract_method.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/class.h"
+#include "mirror/class-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array.h"
+#include "mirror/object_array-inl.h"
#include "object_utils.h"
#include "scoped_thread_state_change.h"
#include "well_known_classes.h"
@@ -28,17 +34,17 @@
jobject InvokeMethod(const ScopedObjectAccess& soa, jobject javaMethod, jobject javaReceiver,
jobject javaArgs) {
jmethodID mid = soa.Env()->FromReflectedMethod(javaMethod);
- AbstractMethod* m = soa.DecodeMethod(mid);
+ mirror::AbstractMethod* m = soa.DecodeMethod(mid);
- Class* declaring_class = m->GetDeclaringClass();
+ mirror::Class* declaring_class = m->GetDeclaringClass();
if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(declaring_class, true, true)) {
return NULL;
}
- Object* receiver = NULL;
+ mirror::Object* receiver = NULL;
if (!m->IsStatic()) {
// Check that the receiver is non-null and an instance of the field's declaring class.
- receiver = soa.Decode<Object*>(javaReceiver);
+ receiver = soa.Decode<mirror::Object*>(javaReceiver);
if (!VerifyObjectInClass(receiver, declaring_class)) {
return NULL;
}
@@ -49,7 +55,8 @@
}
// Get our arrays of arguments and their types, and check they're the same size.
- ObjectArray<Object>* objects = soa.Decode<ObjectArray<Object>*>(javaArgs);
+ mirror::ObjectArray<mirror::Object>* objects =
+ soa.Decode<mirror::ObjectArray<mirror::Object>*>(javaArgs);
MethodHelper mh(m);
const DexFile::TypeList* classes = mh.GetParameterTypeList();
uint32_t classes_size = classes == NULL ? 0 : classes->Size();
@@ -65,8 +72,8 @@
UniquePtr<jvalue[]> args(new jvalue[arg_count]);
JValue* decoded_args = reinterpret_cast<JValue*>(args.get());
for (uint32_t i = 0; i < arg_count; ++i) {
- Object* arg = objects->Get(i);
- Class* dst_class = mh.GetClassFromTypeIdx(classes->GetTypeItem(i).type_idx_);
+ mirror::Object* arg = objects->Get(i);
+ mirror::Class* dst_class = mh.GetClassFromTypeIdx(classes->GetTypeItem(i).type_idx_);
if (!UnboxPrimitiveForArgument(arg, dst_class, decoded_args[i], m, i)) {
return NULL;
}
@@ -93,7 +100,7 @@
return soa.AddLocalReference<jobject>(BoxPrimitive(mh.GetReturnType()->GetPrimitiveType(), value));
}
-bool VerifyObjectInClass(Object* o, Class* c) {
+bool VerifyObjectInClass(mirror::Object* o, mirror::Class* c) {
const char* exception = NULL;
if (o == NULL) {
exception = "Ljava/lang/NullPointerException;";
@@ -194,7 +201,7 @@
return false;
}
-Object* BoxPrimitive(Primitive::Type src_class, const JValue& value) {
+mirror::Object* BoxPrimitive(Primitive::Type src_class, const JValue& value) {
if (src_class == Primitive::kPrimNot) {
return value.GetL();
}
@@ -242,7 +249,7 @@
return result.GetL();
}
-static std::string UnboxingFailureKind(AbstractMethod* m, int index, Field* f)
+static std::string UnboxingFailureKind(mirror::AbstractMethod* m, int index, mirror::Field* f)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (m != NULL && index != -1) {
++index; // Humans count from 1.
@@ -254,8 +261,8 @@
return "result";
}
-static bool UnboxPrimitive(Object* o, Class* dst_class, JValue& unboxed_value, AbstractMethod* m,
- int index, Field* f)
+static bool UnboxPrimitive(mirror::Object* o, mirror::Class* dst_class, JValue& unboxed_value,
+ mirror::AbstractMethod* m, int index, mirror::Field* f)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (!dst_class->IsPrimitive()) {
if (o != NULL && !o->InstanceOf(dst_class)) {
@@ -285,9 +292,9 @@
JValue boxed_value;
std::string src_descriptor(ClassHelper(o->GetClass()).GetDescriptor());
- Class* src_class = NULL;
+ mirror::Class* src_class = NULL;
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- Field* primitive_field = o->GetClass()->GetIFields()->Get(0);
+ mirror::Field* primitive_field = o->GetClass()->GetIFields()->Get(0);
if (src_descriptor == "Ljava/lang/Boolean;") {
src_class = class_linker->FindPrimitiveClass('Z');
boxed_value.SetZ(primitive_field->GetBoolean(o));
@@ -325,17 +332,19 @@
boxed_value, unboxed_value);
}
-bool UnboxPrimitiveForArgument(Object* o, Class* dst_class, JValue& unboxed_value, AbstractMethod* m, size_t index) {
+bool UnboxPrimitiveForArgument(mirror::Object* o, mirror::Class* dst_class, JValue& unboxed_value,
+ mirror::AbstractMethod* m, size_t index) {
CHECK(m != NULL);
return UnboxPrimitive(o, dst_class, unboxed_value, m, index, NULL);
}
-bool UnboxPrimitiveForField(Object* o, Class* dst_class, JValue& unboxed_value, Field* f) {
+bool UnboxPrimitiveForField(mirror::Object* o, mirror::Class* dst_class, JValue& unboxed_value,
+ mirror::Field* f) {
CHECK(f != NULL);
return UnboxPrimitive(o, dst_class, unboxed_value, NULL, -1, f);
}
-bool UnboxPrimitiveForResult(Object* o, Class* dst_class, JValue& unboxed_value) {
+bool UnboxPrimitiveForResult(mirror::Object* o, mirror::Class* dst_class, JValue& unboxed_value) {
return UnboxPrimitive(o, dst_class, unboxed_value, NULL, -1, NULL);
}
diff --git a/src/reflection.h b/src/reflection.h
index 601543f..8f32243 100644
--- a/src/reflection.h
+++ b/src/reflection.h
@@ -21,22 +21,24 @@
#include "primitive.h"
namespace art {
-
+namespace mirror {
+class AbstractMethod;
class Class;
class Field;
-union JValue;
-class AbstractMethod;
class Object;
+} // namespace mirror
+union JValue;
class ScopedObjectAccess;
-Object* BoxPrimitive(Primitive::Type src_class, const JValue& value)
+mirror::Object* BoxPrimitive(Primitive::Type src_class, const JValue& value)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-bool UnboxPrimitiveForArgument(Object* o, Class* dst_class, JValue& unboxed_value,
- AbstractMethod* m, size_t index)
+bool UnboxPrimitiveForArgument(mirror::Object* o, mirror::Class* dst_class, JValue& unboxed_value,
+ mirror::AbstractMethod* m, size_t index)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-bool UnboxPrimitiveForField(Object* o, Class* dst_class, JValue& unboxed_value, Field* f)
+bool UnboxPrimitiveForField(mirror::Object* o, mirror::Class* dst_class, JValue& unboxed_value,
+ mirror::Field* f)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-bool UnboxPrimitiveForResult(Object* o, Class* dst_class, JValue& unboxed_value)
+bool UnboxPrimitiveForResult(mirror::Object* o, mirror::Class* dst_class, JValue& unboxed_value)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
bool ConvertPrimitiveValue(Primitive::Type src_class, Primitive::Type dst_class, const JValue& src,
@@ -46,7 +48,7 @@
jobject InvokeMethod(const ScopedObjectAccess& soa, jobject method, jobject receiver, jobject args)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-bool VerifyObjectInClass(Object* o, Class* c)
+bool VerifyObjectInClass(mirror::Object* o, mirror::Class* c)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
} // namespace art
diff --git a/src/root_visitor.h b/src/root_visitor.h
new file mode 100644
index 0000000..d53acd3
--- /dev/null
+++ b/src/root_visitor.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2013 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_ROOT_VISITOR_H_
+#define ART_SRC_ROOT_VISITOR_H_
+
+namespace art {
+namespace mirror {
+class Object;
+} // namespace mirror
+class StackVisitor;
+
+typedef void (RootVisitor)(const mirror::Object* root, void* arg);
+typedef void (VerifyRootVisitor)(const mirror::Object* root, void* arg, size_t vreg,
+ const StackVisitor* visitor);
+typedef bool (IsMarkedTester)(const mirror::Object* object, void* arg);
+
+} // namespace art
+
+#endif // ART_SRC_ROOT_VISITOR_H_
diff --git a/src/runtime.cc b/src/runtime.cc
index 5c73fef..085a9bf 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -24,17 +24,24 @@
#include <limits>
#include <vector>
+#include "atomic.h"
#include "class_linker.h"
-#include "class_loader.h"
#include "constants_arm.h"
#include "constants_mips.h"
#include "constants_x86.h"
#include "debugger.h"
+#include "gc/card_table-inl.h"
#include "heap.h"
#include "image.h"
#include "instrumentation.h"
#include "intern_table.h"
#include "jni_internal.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/array.h"
+#include "mirror/class_loader.h"
+#include "mirror/field.h"
+#include "mirror/object-inl.h"
+#include "mirror/throwable.h"
#include "monitor.h"
#include "oat_file.h"
#include "ScopedLocalRef.h"
@@ -627,23 +634,25 @@
ScopedObjectAccess soa(Thread::Current());
- Class* class_loader_class = soa.Decode<Class*>(WellKnownClasses::java_lang_ClassLoader);
+ mirror::Class* class_loader_class =
+ soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_ClassLoader);
CHECK(Runtime::Current()->GetClassLinker()->EnsureInitialized(class_loader_class, true, true));
- AbstractMethod* getSystemClassLoader = class_loader_class->FindDirectMethod("getSystemClassLoader", "()Ljava/lang/ClassLoader;");
+ mirror::AbstractMethod* getSystemClassLoader =
+ class_loader_class->FindDirectMethod("getSystemClassLoader", "()Ljava/lang/ClassLoader;");
CHECK(getSystemClassLoader != NULL);
- ClassLoader* class_loader =
- down_cast<ClassLoader*>(InvokeWithJValues(soa, NULL, getSystemClassLoader, NULL).GetL());
+ mirror::ClassLoader* class_loader =
+ down_cast<mirror::ClassLoader*>(InvokeWithJValues(soa, NULL, getSystemClassLoader, NULL).GetL());
CHECK(class_loader != NULL);
soa.Self()->SetClassLoaderOverride(class_loader);
- Class* thread_class = soa.Decode<Class*>(WellKnownClasses::java_lang_Thread);
+ mirror::Class* thread_class = soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_Thread);
CHECK(Runtime::Current()->GetClassLinker()->EnsureInitialized(thread_class, true, true));
- Field* contextClassLoader = thread_class->FindDeclaredInstanceField("contextClassLoader",
- "Ljava/lang/ClassLoader;");
+ mirror::Field* contextClassLoader = thread_class->FindDeclaredInstanceField("contextClassLoader",
+ "Ljava/lang/ClassLoader;");
CHECK(contextClassLoader != NULL);
contextClassLoader->SetObject(soa.Self()->GetPeer(), class_loader);
@@ -1015,7 +1024,7 @@
thread_list_->Unregister(self);
}
-void Runtime::VisitConcurrentRoots(Heap::RootVisitor* visitor, void* arg) {
+void Runtime::VisitConcurrentRoots(RootVisitor* visitor, void* arg) {
if (intern_table_->IsDirty()) {
intern_table_->VisitRoots(visitor, arg);
}
@@ -1024,7 +1033,7 @@
}
}
-void Runtime::VisitNonThreadRoots(Heap::RootVisitor* visitor, void* arg) {
+void Runtime::VisitNonThreadRoots(RootVisitor* visitor, void* arg) {
Dbg::VisitRoots(visitor, arg);
java_vm_->VisitRoots(visitor, arg);
if (pre_allocated_OutOfMemoryError_ != NULL) {
@@ -1041,7 +1050,7 @@
}
}
-void Runtime::VisitNonConcurrentRoots(Heap::RootVisitor* visitor, void* arg) {
+void Runtime::VisitNonConcurrentRoots(RootVisitor* visitor, void* arg) {
thread_list_->VisitRoots(visitor, arg);
VisitNonThreadRoots(visitor, arg);
}
@@ -1053,48 +1062,50 @@
class_linker_->Dirty();
}
-void Runtime::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
+void Runtime::VisitRoots(RootVisitor* visitor, void* arg) {
VisitConcurrentRoots(visitor, arg);
VisitNonConcurrentRoots(visitor, arg);
}
-void Runtime::SetJniDlsymLookupStub(ByteArray* jni_stub_array) {
+void Runtime::SetJniDlsymLookupStub(mirror::ByteArray* jni_stub_array) {
CHECK(jni_stub_array != NULL) << " jni_stub_array=" << jni_stub_array;
CHECK(jni_stub_array_ == NULL || jni_stub_array_ == jni_stub_array)
<< "jni_stub_array_=" << jni_stub_array_ << " jni_stub_array=" << jni_stub_array;
jni_stub_array_ = jni_stub_array;
}
-void Runtime::SetAbstractMethodErrorStubArray(ByteArray* abstract_method_error_stub_array) {
+void Runtime::SetAbstractMethodErrorStubArray(mirror::ByteArray* abstract_method_error_stub_array) {
CHECK(abstract_method_error_stub_array != NULL);
CHECK(abstract_method_error_stub_array_ == NULL || abstract_method_error_stub_array_ == abstract_method_error_stub_array);
abstract_method_error_stub_array_ = abstract_method_error_stub_array;
}
-void Runtime::SetResolutionStubArray(ByteArray* resolution_stub_array, TrampolineType type) {
+void Runtime::SetResolutionStubArray(mirror::ByteArray* resolution_stub_array, TrampolineType type) {
CHECK(resolution_stub_array != NULL);
CHECK(!HasResolutionStubArray(type) || resolution_stub_array_[type] == resolution_stub_array);
resolution_stub_array_[type] = resolution_stub_array;
}
-AbstractMethod* Runtime::CreateResolutionMethod() {
- Class* method_class = AbstractMethod::GetMethodClass();
+mirror::AbstractMethod* Runtime::CreateResolutionMethod() {
+ mirror::Class* method_class = mirror::AbstractMethod::GetMethodClass();
Thread* self = Thread::Current();
- SirtRef<AbstractMethod> method(self, down_cast<AbstractMethod*>(method_class->AllocObject(self)));
+ SirtRef<mirror::AbstractMethod>
+ method(self, down_cast<mirror::AbstractMethod*>(method_class->AllocObject(self)));
method->SetDeclaringClass(method_class);
// TODO: use a special method for resolution method saves
method->SetDexMethodIndex(DexFile::kDexNoIndex16);
- ByteArray* unknown_resolution_stub = GetResolutionStubArray(kUnknownMethod);
+ mirror::ByteArray* unknown_resolution_stub = GetResolutionStubArray(kUnknownMethod);
CHECK(unknown_resolution_stub != NULL);
method->SetCode(unknown_resolution_stub->GetData());
return method.get();
}
-AbstractMethod* Runtime::CreateCalleeSaveMethod(InstructionSet instruction_set,
- CalleeSaveType type) {
- Class* method_class = AbstractMethod::GetMethodClass();
+mirror::AbstractMethod* Runtime::CreateCalleeSaveMethod(InstructionSet instruction_set,
+ CalleeSaveType type) {
+ mirror::Class* method_class = mirror::AbstractMethod::GetMethodClass();
Thread* self = Thread::Current();
- SirtRef<AbstractMethod> method(self, down_cast<AbstractMethod*>(method_class->AllocObject(self)));
+ SirtRef<mirror::AbstractMethod>
+ method(self, down_cast<mirror::AbstractMethod*>(method_class->AllocObject(self)));
method->SetDeclaringClass(method_class);
// TODO: use a special method for callee saves
method->SetDexMethodIndex(DexFile::kDexNoIndex16);
@@ -1154,7 +1165,7 @@
return method.get();
}
-void Runtime::SetCalleeSaveMethod(AbstractMethod* method, CalleeSaveType type) {
+void Runtime::SetCalleeSaveMethod(mirror::AbstractMethod* method, CalleeSaveType type) {
DCHECK_LT(static_cast<int>(type), static_cast<int>(kLastCalleeSaveType));
callee_save_methods_[type] = method;
}
diff --git a/src/runtime.h b/src/runtime.h
index 84cc826..1d71c13 100644
--- a/src/runtime.h
+++ b/src/runtime.h
@@ -32,6 +32,7 @@
#include "instruction_set.h"
#include "jobject_comparator.h"
#include "locks.h"
+#include "root_visitor.h"
#include "runtime_stats.h"
#include "safe_map.h"
@@ -41,21 +42,23 @@
namespace art {
+namespace mirror {
+class AbstractMethod;
+class ClassLoader;
template<class T> class PrimitiveArray;
typedef PrimitiveArray<int8_t> ByteArray;
+class String;
+class Throwable;
+} // namespace mirror
class ClassLinker;
-class ClassLoader;
class DexFile;
class Heap;
class Instrumentation;
class InternTable;
struct JavaVMExt;
-class AbstractMethod;
class MonitorList;
class SignalCatcher;
-class String;
class ThreadList;
-class Throwable;
class Trace;
class Runtime {
@@ -215,7 +218,7 @@
return monitor_list_;
}
- Throwable* GetPreAllocatedOutOfMemoryError() {
+ mirror::Throwable* GetPreAllocatedOutOfMemoryError() {
return pre_allocated_OutOfMemoryError_;
}
@@ -235,40 +238,40 @@
void DirtyRoots();
// Visit all the roots.
- void VisitRoots(Heap::RootVisitor* visitor, void* arg)
+ void VisitRoots(RootVisitor* visitor, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Visit all of the roots we can do safely do concurrently.
- void VisitConcurrentRoots(Heap::RootVisitor* visitor, void* arg);
+ void VisitConcurrentRoots(RootVisitor* visitor, void* arg);
// Visit all of the non thread roots, we can do this with mutators unpaused.
- void VisitNonThreadRoots(Heap::RootVisitor* visitor, void* arg);
+ void VisitNonThreadRoots(RootVisitor* visitor, void* arg);
// Visit all other roots which must be done with mutators suspended.
- void VisitNonConcurrentRoots(Heap::RootVisitor* visitor, void* arg)
+ void VisitNonConcurrentRoots(RootVisitor* visitor, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
bool HasJniDlsymLookupStub() const {
return jni_stub_array_ != NULL;
}
- ByteArray* GetJniDlsymLookupStub() const {
+ mirror::ByteArray* GetJniDlsymLookupStub() const {
CHECK(HasJniDlsymLookupStub());
return jni_stub_array_;
}
- void SetJniDlsymLookupStub(ByteArray* jni_stub_array);
+ void SetJniDlsymLookupStub(mirror::ByteArray* jni_stub_array);
bool HasAbstractMethodErrorStubArray() const {
return abstract_method_error_stub_array_ != NULL;
}
- ByteArray* GetAbstractMethodErrorStubArray() const {
+ mirror::ByteArray* GetAbstractMethodErrorStubArray() const {
CHECK(abstract_method_error_stub_array_ != NULL);
return abstract_method_error_stub_array_;
}
- void SetAbstractMethodErrorStubArray(ByteArray* abstract_method_error_stub_array);
+ void SetAbstractMethodErrorStubArray(mirror::ByteArray* abstract_method_error_stub_array);
enum TrampolineType {
kStaticMethod,
@@ -280,16 +283,16 @@
return resolution_stub_array_[type] != NULL;
}
- ByteArray* GetResolutionStubArray(TrampolineType type) const {
+ mirror::ByteArray* GetResolutionStubArray(TrampolineType type) const {
CHECK(HasResolutionStubArray(type));
DCHECK_LT(static_cast<int>(type), static_cast<int>(kLastTrampolineMethodType));
return resolution_stub_array_[type];
}
- void SetResolutionStubArray(ByteArray* resolution_stub_array, TrampolineType type);
+ void SetResolutionStubArray(mirror::ByteArray* resolution_stub_array, TrampolineType type);
// Returns a special method that calls into a trampoline for runtime method resolution
- AbstractMethod* GetResolutionMethod() const {
+ mirror::AbstractMethod* GetResolutionMethod() const {
CHECK(HasResolutionMethod());
return resolution_method_;
}
@@ -298,11 +301,11 @@
return resolution_method_ != NULL;
}
- void SetResolutionMethod(AbstractMethod* method) {
+ void SetResolutionMethod(mirror::AbstractMethod* method) {
resolution_method_ = method;
}
- AbstractMethod* CreateResolutionMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ mirror::AbstractMethod* CreateResolutionMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Returns a special method that describes all callee saves being spilled to the stack.
enum CalleeSaveType {
@@ -316,20 +319,21 @@
return callee_save_methods_[type] != NULL;
}
- AbstractMethod* GetCalleeSaveMethod(CalleeSaveType type) const {
+ mirror::AbstractMethod* GetCalleeSaveMethod(CalleeSaveType type) const {
DCHECK(HasCalleeSaveMethod(type));
return callee_save_methods_[type];
}
- void SetCalleeSaveMethod(AbstractMethod* method, CalleeSaveType type);
+ void SetCalleeSaveMethod(mirror::AbstractMethod* method, CalleeSaveType type);
- AbstractMethod* CreateCalleeSaveMethod(InstructionSet instruction_set, CalleeSaveType type)
+ mirror::AbstractMethod* CreateCalleeSaveMethod(InstructionSet instruction_set,
+ CalleeSaveType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- AbstractMethod* CreateRefOnlyCalleeSaveMethod(InstructionSet instruction_set)
+ mirror::AbstractMethod* CreateRefOnlyCalleeSaveMethod(InstructionSet instruction_set)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- AbstractMethod* CreateRefAndArgsCalleeSaveMethod(InstructionSet instruction_set)
+ mirror::AbstractMethod* CreateRefAndArgsCalleeSaveMethod(InstructionSet instruction_set)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
int32_t GetStat(int kind);
@@ -419,20 +423,20 @@
JavaVMExt* java_vm_;
- Throwable* pre_allocated_OutOfMemoryError_;
+ mirror::Throwable* pre_allocated_OutOfMemoryError_;
- ByteArray* jni_stub_array_;
+ mirror::ByteArray* jni_stub_array_;
- ByteArray* abstract_method_error_stub_array_;
+ mirror::ByteArray* abstract_method_error_stub_array_;
- ByteArray* resolution_stub_array_[kLastTrampolineMethodType];
+ mirror::ByteArray* resolution_stub_array_[kLastTrampolineMethodType];
- AbstractMethod* callee_save_methods_[kLastCalleeSaveType];
+ mirror::AbstractMethod* callee_save_methods_[kLastCalleeSaveType];
- AbstractMethod* resolution_method_;
+ mirror::AbstractMethod* resolution_method_;
// As returned by ClassLoader.getSystemClassLoader()
- ClassLoader* system_class_loader_;
+ mirror::ClassLoader* system_class_loader_;
// A non-zero value indicates that a thread has been created but not yet initialized. Guarded by
// the shutdown lock so that threads aren't born while we're shutting down.
diff --git a/src/runtime_support.cc b/src/runtime_support.cc
index b276917..84a19cf 100644
--- a/src/runtime_support.cc
+++ b/src/runtime_support.cc
@@ -16,6 +16,14 @@
#include "runtime_support.h"
+#include "class_linker-inl.h"
+#include "gc/card_table-inl.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/class-inl.h"
+#include "mirror/field-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
+#include "mirror/proxy.h"
#include "reflection.h"
#include "scoped_thread_state_change.h"
#include "ScopedLocalRef.h"
@@ -92,13 +100,14 @@
namespace art {
// Helper function to allocate array for FILLED_NEW_ARRAY.
-Array* CheckAndAllocArrayFromCode(uint32_t type_idx, AbstractMethod* method, int32_t component_count,
- Thread* self, bool access_check) {
+mirror::Array* CheckAndAllocArrayFromCode(uint32_t type_idx, mirror::AbstractMethod* method,
+ int32_t component_count, Thread* self,
+ bool access_check) {
if (UNLIKELY(component_count < 0)) {
self->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d", component_count);
return NULL; // Failure
}
- Class* klass = method->GetDexCacheResolvedTypes()->Get(type_idx);
+ mirror::Class* klass = method->GetDexCacheResolvedTypes()->Get(type_idx);
if (UNLIKELY(klass == NULL)) { // Not in dex cache so try to resolve
klass = Runtime::Current()->GetClassLinker()->ResolveType(type_idx, method);
if (klass == NULL) { // Error
@@ -119,19 +128,19 @@
return NULL; // Failure
} else {
if (access_check) {
- Class* referrer = method->GetDeclaringClass();
+ mirror::Class* referrer = method->GetDeclaringClass();
if (UNLIKELY(!referrer->CanAccess(klass))) {
ThrowIllegalAccessErrorClass(referrer, klass);
return NULL; // Failure
}
}
DCHECK(klass->IsArrayClass()) << PrettyClass(klass);
- return Array::Alloc(self, klass, component_count);
+ return mirror::Array::Alloc(self, klass, component_count);
}
}
-Field* FindFieldFromCode(uint32_t field_idx, const AbstractMethod* referrer, Thread* self,
- FindFieldType type, size_t expected_size) {
+mirror::Field* FindFieldFromCode(uint32_t field_idx, const mirror::AbstractMethod* referrer,
+ Thread* self, FindFieldType type, size_t expected_size) {
bool is_primitive;
bool is_set;
bool is_static;
@@ -147,7 +156,7 @@
default: is_primitive = true; is_set = true; is_static = true; break;
}
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- Field* resolved_field = class_linker->ResolveField(field_idx, referrer, is_static);
+ mirror::Field* resolved_field = class_linker->ResolveField(field_idx, referrer, is_static);
if (UNLIKELY(resolved_field == NULL)) {
DCHECK(self->IsExceptionPending()); // Throw exception and unwind.
return NULL; // Failure.
@@ -156,8 +165,8 @@
ThrowIncompatibleClassChangeErrorField(resolved_field, is_static, referrer);
return NULL;
}
- Class* fields_class = resolved_field->GetDeclaringClass();
- Class* referring_class = referrer->GetDeclaringClass();
+ mirror::Class* fields_class = resolved_field->GetDeclaringClass();
+ mirror::Class* referring_class = referrer->GetDeclaringClass();
if (UNLIKELY(!referring_class->CanAccess(fields_class) ||
!referring_class->CanAccessMember(fields_class,
resolved_field->GetAccessFlags()))) {
@@ -210,11 +219,12 @@
}
// Slow path method resolution
-AbstractMethod* FindMethodFromCode(uint32_t method_idx, Object* this_object, AbstractMethod* referrer,
- Thread* self, bool access_check, InvokeType type) {
+mirror::AbstractMethod* FindMethodFromCode(uint32_t method_idx, mirror::Object* this_object,
+ mirror::AbstractMethod* referrer,
+ Thread* self, bool access_check, InvokeType type) {
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
bool is_direct = type == kStatic || type == kDirect;
- AbstractMethod* resolved_method = class_linker->ResolveMethod(method_idx, referrer, type);
+ mirror::AbstractMethod* resolved_method = class_linker->ResolveMethod(method_idx, referrer, type);
if (UNLIKELY(resolved_method == NULL)) {
DCHECK(self->IsExceptionPending()); // Throw exception and unwind.
return NULL; // Failure.
@@ -228,7 +238,7 @@
if (is_direct) {
return resolved_method;
} else if (type == kInterface) {
- AbstractMethod* interface_method =
+ mirror::AbstractMethod* interface_method =
this_object->GetClass()->FindVirtualMethodForInterface(resolved_method);
if (UNLIKELY(interface_method == NULL)) {
ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(resolved_method, this_object,
@@ -238,7 +248,7 @@
return interface_method;
}
} else {
- ObjectArray<AbstractMethod>* vtable;
+ mirror::ObjectArray<mirror::AbstractMethod>* vtable;
uint16_t vtable_index = resolved_method->GetMethodIndex();
if (type == kSuper) {
vtable = referrer->GetDeclaringClass()->GetSuperClass()->GetVTable();
@@ -255,8 +265,8 @@
referrer);
return NULL; // Failure.
}
- Class* methods_class = resolved_method->GetDeclaringClass();
- Class* referring_class = referrer->GetDeclaringClass();
+ mirror::Class* methods_class = resolved_method->GetDeclaringClass();
+ mirror::Class* referring_class = referrer->GetDeclaringClass();
if (UNLIKELY(!referring_class->CanAccess(methods_class) ||
!referring_class->CanAccessMember(methods_class,
resolved_method->GetAccessFlags()))) {
@@ -280,7 +290,7 @@
if (is_direct) {
return resolved_method;
} else if (type == kInterface) {
- AbstractMethod* interface_method =
+ mirror::AbstractMethod* interface_method =
this_object->GetClass()->FindVirtualMethodForInterface(resolved_method);
if (UNLIKELY(interface_method == NULL)) {
ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(resolved_method, this_object,
@@ -290,10 +300,10 @@
return interface_method;
}
} else {
- ObjectArray<AbstractMethod>* vtable;
+ mirror::ObjectArray<mirror::AbstractMethod>* vtable;
uint16_t vtable_index = resolved_method->GetMethodIndex();
if (type == kSuper) {
- Class* super_class = referring_class->GetSuperClass();
+ mirror::Class* super_class = referring_class->GetSuperClass();
if (LIKELY(super_class != NULL)) {
vtable = referring_class->GetSuperClass()->GetVTable();
} else {
@@ -317,16 +327,16 @@
}
}
-Class* ResolveVerifyAndClinit(uint32_t type_idx, const AbstractMethod* referrer, Thread* self,
- bool can_run_clinit, bool verify_access) {
+mirror::Class* ResolveVerifyAndClinit(uint32_t type_idx, const mirror::AbstractMethod* referrer,
+ Thread* self, bool can_run_clinit, bool verify_access) {
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- Class* klass = class_linker->ResolveType(type_idx, referrer);
+ mirror::Class* klass = class_linker->ResolveType(type_idx, referrer);
if (UNLIKELY(klass == NULL)) {
CHECK(self->IsExceptionPending());
return NULL; // Failure - Indicate to caller to deliver exception
}
// Perform access check if necessary.
- Class* referring_class = referrer->GetDeclaringClass();
+ mirror::Class* referring_class = referrer->GetDeclaringClass();
if (verify_access && UNLIKELY(!referring_class->CanAccess(klass))) {
ThrowIllegalAccessErrorClass(referring_class, klass);
return NULL; // Failure - Indicate to caller to deliver exception
@@ -396,12 +406,12 @@
} else {
JValue jv;
jv.SetJ(args.at(i).j);
- Object* val = BoxPrimitive(Primitive::GetType(shorty[i + 1]), jv);
+ mirror::Object* val = BoxPrimitive(Primitive::GetType(shorty[i + 1]), jv);
if (val == NULL) {
CHECK(soa.Self()->IsExceptionPending());
return zero;
}
- soa.Decode<ObjectArray<Object>* >(args_jobj)->Set(i, val);
+ soa.Decode<mirror::ObjectArray<mirror::Object>* >(args_jobj)->Set(i, val);
}
}
}
@@ -425,9 +435,9 @@
return zero;
} else {
JValue result_unboxed;
- MethodHelper mh(soa.Decode<AbstractMethod*>(interface_method_jobj));
- Class* result_type = mh.GetReturnType();
- Object* result_ref = soa.Decode<Object*>(result);
+ MethodHelper mh(soa.Decode<mirror::AbstractMethod*>(interface_method_jobj));
+ mirror::Class* result_type = mh.GetReturnType();
+ mirror::Object* result_ref = soa.Decode<mirror::Object*>(result);
bool unboxed_okay = UnboxPrimitiveForResult(result_ref, result_type, result_unboxed);
if (!unboxed_okay) {
soa.Self()->ThrowNewWrappedException("Ljava/lang/ClassCastException;",
@@ -441,12 +451,14 @@
} else {
// In the case of checked exceptions that aren't declared, the exception must be wrapped by
// a UndeclaredThrowableException.
- Throwable* exception = soa.Self()->GetException();
+ mirror::Throwable* exception = soa.Self()->GetException();
if (exception->IsCheckedException()) {
- Object* rcvr = soa.Decode<Object*>(rcvr_jobj);
- SynthesizedProxyClass* proxy_class = down_cast<SynthesizedProxyClass*>(rcvr->GetClass());
- AbstractMethod* interface_method = soa.Decode<AbstractMethod*>(interface_method_jobj);
- AbstractMethod* proxy_method =
+ mirror::Object* rcvr = soa.Decode<mirror::Object*>(rcvr_jobj);
+ mirror::SynthesizedProxyClass* proxy_class =
+ down_cast<mirror::SynthesizedProxyClass*>(rcvr->GetClass());
+ mirror::AbstractMethod* interface_method =
+ soa.Decode<mirror::AbstractMethod*>(interface_method_jobj);
+ mirror::AbstractMethod* proxy_method =
rcvr->GetClass()->FindVirtualMethodForInterface(interface_method);
int throws_index = -1;
size_t num_virt_methods = proxy_class->NumVirtualMethods();
@@ -457,11 +469,11 @@
}
}
CHECK_NE(throws_index, -1);
- ObjectArray<Class>* declared_exceptions = proxy_class->GetThrows()->Get(throws_index);
- Class* exception_class = exception->GetClass();
+ mirror::ObjectArray<mirror::Class>* declared_exceptions = proxy_class->GetThrows()->Get(throws_index);
+ mirror::Class* exception_class = exception->GetClass();
bool declares_exception = false;
for (int i = 0; i < declared_exceptions->GetLength() && !declares_exception; i++) {
- Class* declared_exception = declared_exceptions->Get(i);
+ mirror::Class* declared_exception = declared_exceptions->Get(i);
declares_exception = declared_exception->IsAssignableFrom(exception_class);
}
if (!declares_exception) {
diff --git a/src/runtime_support.h b/src/runtime_support.h
index 1c8d174..a504237 100644
--- a/src/runtime_support.h
+++ b/src/runtime_support.h
@@ -23,10 +23,11 @@
#include "indirect_reference_table.h"
#include "invoke_type.h"
#include "jni_internal.h"
-#include "object.h"
+#include "mirror/abstract_method.h"
+#include "mirror/array.h"
+#include "mirror/throwable.h"
#include "object_utils.h"
#include "thread.h"
-#include "verifier/method_verifier.h"
extern "C" void art_interpreter_invoke_handler();
extern "C" void art_proxy_invoke_handler();
@@ -40,21 +41,21 @@
extern "C" int32_t art_f2i(float f);
namespace art {
-
-class Array;
+namespace mirror {
class Class;
class Field;
-class AbstractMethod;
class Object;
+}
// Given the context of a calling Method, use its DexCache to resolve a type to a Class. If it
// cannot be resolved, throw an error. If it can, use it to create an instance.
// When verification/compiler hasn't been able to verify access, optionally perform an access
// check.
-static inline Object* AllocObjectFromCode(uint32_t type_idx, AbstractMethod* method, Thread* self,
- bool access_check)
+static inline mirror::Object* AllocObjectFromCode(uint32_t type_idx, mirror::AbstractMethod* method,
+ Thread* self,
+ bool access_check)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Class* klass = method->GetDexCacheResolvedTypes()->Get(type_idx);
+ mirror::Class* klass = method->GetDexCacheResolvedTypes()->Get(type_idx);
Runtime* runtime = Runtime::Current();
if (UNLIKELY(klass == NULL)) {
klass = runtime->GetClassLinker()->ResolveType(type_idx, method);
@@ -69,7 +70,7 @@
PrettyDescriptor(klass).c_str());
return NULL; // Failure
}
- Class* referrer = method->GetDeclaringClass();
+ mirror::Class* referrer = method->GetDeclaringClass();
if (UNLIKELY(!referrer->CanAccess(klass))) {
ThrowIllegalAccessErrorClass(referrer, klass);
return NULL; // Failure
@@ -87,14 +88,15 @@
// it cannot be resolved, throw an error. If it can, use it to create an array.
// When verification/compiler hasn't been able to verify access, optionally perform an access
// check.
-static inline Array* AllocArrayFromCode(uint32_t type_idx, AbstractMethod* method, int32_t component_count,
- Thread* self, bool access_check)
+static inline mirror::Array* AllocArrayFromCode(uint32_t type_idx, mirror::AbstractMethod* method,
+ int32_t component_count,
+ Thread* self, bool access_check)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (UNLIKELY(component_count < 0)) {
self->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d", component_count);
return NULL; // Failure
}
- Class* klass = method->GetDexCacheResolvedTypes()->Get(type_idx);
+ mirror::Class* klass = method->GetDexCacheResolvedTypes()->Get(type_idx);
if (UNLIKELY(klass == NULL)) { // Not in dex cache so try to resolve
klass = Runtime::Current()->GetClassLinker()->ResolveType(type_idx, method);
if (klass == NULL) { // Error
@@ -104,17 +106,18 @@
CHECK(klass->IsArrayClass()) << PrettyClass(klass);
}
if (access_check) {
- Class* referrer = method->GetDeclaringClass();
+ mirror::Class* referrer = method->GetDeclaringClass();
if (UNLIKELY(!referrer->CanAccess(klass))) {
ThrowIllegalAccessErrorClass(referrer, klass);
return NULL; // Failure
}
}
- return Array::Alloc(self, klass, component_count);
+ return mirror::Array::Alloc(self, klass, component_count);
}
-extern Array* CheckAndAllocArrayFromCode(uint32_t type_idx, AbstractMethod* method, int32_t component_count,
- Thread* self, bool access_check)
+extern mirror::Array* CheckAndAllocArrayFromCode(uint32_t type_idx, mirror::AbstractMethod* method,
+ int32_t component_count,
+ Thread* self, bool access_check)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Type of find field operation for fast and slow case.
@@ -130,19 +133,21 @@
};
// Slow field find that can initialize classes and may throw exceptions.
-extern Field* FindFieldFromCode(uint32_t field_idx, const AbstractMethod* referrer, Thread* self,
- FindFieldType type, size_t expected_size)
+extern mirror::Field* FindFieldFromCode(uint32_t field_idx, const mirror::AbstractMethod* referrer,
+ Thread* self, FindFieldType type, size_t expected_size)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Fast path field resolution that can't initialize classes or throw exceptions.
-static inline Field* FindFieldFast(uint32_t field_idx, const AbstractMethod* referrer,
- FindFieldType type, size_t expected_size)
+static inline mirror::Field* FindFieldFast(uint32_t field_idx,
+ const mirror::AbstractMethod* referrer,
+ FindFieldType type, size_t expected_size)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Field* resolved_field = referrer->GetDeclaringClass()->GetDexCache()->GetResolvedField(field_idx);
+ mirror::Field* resolved_field =
+ referrer->GetDeclaringClass()->GetDexCache()->GetResolvedField(field_idx);
if (UNLIKELY(resolved_field == NULL)) {
return NULL;
}
- Class* fields_class = resolved_field->GetDeclaringClass();
+ mirror::Class* fields_class = resolved_field->GetDeclaringClass();
// Check class is initiliazed or initializing.
if (UNLIKELY(!fields_class->IsInitializing())) {
return NULL;
@@ -167,7 +172,7 @@
// Incompatible class change.
return NULL;
}
- Class* referring_class = referrer->GetDeclaringClass();
+ mirror::Class* referring_class = referrer->GetDeclaringClass();
if (UNLIKELY(!referring_class->CanAccess(fields_class) ||
!referring_class->CanAccessMember(fields_class,
resolved_field->GetAccessFlags()) ||
@@ -184,14 +189,16 @@
}
// Fast path method resolution that can't throw exceptions.
-static inline AbstractMethod* FindMethodFast(uint32_t method_idx, Object* this_object,
- const AbstractMethod* referrer, bool access_check, InvokeType type)
+static inline mirror::AbstractMethod* FindMethodFast(uint32_t method_idx,
+ mirror::Object* this_object,
+ const mirror::AbstractMethod* referrer,
+ bool access_check, InvokeType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
bool is_direct = type == kStatic || type == kDirect;
if (UNLIKELY(this_object == NULL && !is_direct)) {
return NULL;
}
- AbstractMethod* resolved_method =
+ mirror::AbstractMethod* resolved_method =
referrer->GetDeclaringClass()->GetDexCache()->GetResolvedMethod(method_idx);
if (UNLIKELY(resolved_method == NULL)) {
return NULL;
@@ -202,8 +209,8 @@
if (UNLIKELY(icce)) {
return NULL;
}
- Class* methods_class = resolved_method->GetDeclaringClass();
- Class* referring_class = referrer->GetDeclaringClass();
+ mirror::Class* methods_class = resolved_method->GetDeclaringClass();
+ mirror::Class* referring_class = referrer->GetDeclaringClass();
if (UNLIKELY(!referring_class->CanAccess(methods_class) ||
!referring_class->CanAccessMember(methods_class,
resolved_method->GetAccessFlags()))) {
@@ -224,17 +231,20 @@
}
}
-extern AbstractMethod* FindMethodFromCode(uint32_t method_idx, Object* this_object, AbstractMethod* referrer,
- Thread* self, bool access_check, InvokeType type)
+extern mirror::AbstractMethod* FindMethodFromCode(uint32_t method_idx, mirror::Object* this_object,
+ mirror::AbstractMethod* referrer,
+ Thread* self, bool access_check, InvokeType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-extern Class* ResolveVerifyAndClinit(uint32_t type_idx, const AbstractMethod* referrer, Thread* self,
- bool can_run_clinit, bool verify_access)
+extern mirror::Class* ResolveVerifyAndClinit(uint32_t type_idx,
+ const mirror::AbstractMethod* referrer, Thread* self,
+ bool can_run_clinit, bool verify_access)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
extern void ThrowStackOverflowError(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-static inline String* ResolveStringFromCode(const AbstractMethod* referrer, uint32_t string_idx)
+static inline mirror::String* ResolveStringFromCode(const mirror::AbstractMethod* referrer,
+ uint32_t string_idx)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
return class_linker->ResolveString(string_idx, referrer);
@@ -244,7 +254,7 @@
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
UNLOCK_FUNCTION(monitor_lock_) {
// Save any pending exception over monitor exit call.
- Throwable* saved_exception = NULL;
+ mirror::Throwable* saved_exception = NULL;
if (UNLIKELY(self->IsExceptionPending())) {
saved_exception = self->GetException();
self->ClearException();
@@ -263,7 +273,7 @@
}
}
-static inline void CheckReferenceResult(Object* o, Thread* self)
+static inline void CheckReferenceResult(mirror::Object* o, Thread* self)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (o == NULL) {
return;
@@ -273,9 +283,9 @@
PrettyMethod(self->GetCurrentMethod()).c_str());
}
// Make sure that the result is an instance of the type this method was expected to return.
- AbstractMethod* m = self->GetCurrentMethod();
+ mirror::AbstractMethod* m = self->GetCurrentMethod();
MethodHelper mh(m);
- Class* return_type = mh.GetReturnType();
+ mirror::Class* return_type = mh.GetReturnType();
if (!o->InstanceOf(return_type)) {
JniAbortF(NULL, "attempt to return an instance of %s from %s",
diff --git a/src/scoped_thread_state_change.h b/src/scoped_thread_state_change.h
index 5eabbdf..80d47c5 100644
--- a/src/scoped_thread_state_change.h
+++ b/src/scoped_thread_state_change.h
@@ -165,7 +165,7 @@
* passed in), or NULL on failure.
*/
template<typename T>
- T AddLocalReference(Object* obj) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ T AddLocalReference(mirror::Object* obj) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK_EQ(thread_state_, kRunnable); // Don't work with raw objects in non-runnable states.
if (obj == NULL) {
return NULL;
@@ -208,7 +208,7 @@
return down_cast<T>(Self()->DecodeJObject(obj));
}
- Field* DecodeField(jfieldID fid) const
+ mirror::Field* DecodeField(jfieldID fid) const
LOCKS_EXCLUDED(JavaVMExt::globals_lock,
JavaVMExt::weak_globals_lock)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -218,10 +218,10 @@
// TODO: we should make these unique weak globals if Field instances can ever move.
UNIMPLEMENTED(WARNING);
#endif
- return reinterpret_cast<Field*>(fid);
+ return reinterpret_cast<mirror::Field*>(fid);
}
- jfieldID EncodeField(Field* field) const
+ jfieldID EncodeField(mirror::Field* field) const
LOCKS_EXCLUDED(JavaVMExt::globals_lock,
JavaVMExt::weak_globals_lock)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -233,7 +233,7 @@
return reinterpret_cast<jfieldID>(field);
}
- AbstractMethod* DecodeMethod(jmethodID mid) const
+ mirror::AbstractMethod* DecodeMethod(jmethodID mid) const
LOCKS_EXCLUDED(JavaVMExt::globals_lock,
JavaVMExt::weak_globals_lock)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -243,10 +243,10 @@
// TODO: we should make these unique weak globals if Method instances can ever move.
UNIMPLEMENTED(WARNING);
#endif
- return reinterpret_cast<AbstractMethod*>(mid);
+ return reinterpret_cast<mirror::AbstractMethod*>(mid);
}
- jmethodID EncodeMethod(AbstractMethod* method) const
+ jmethodID EncodeMethod(mirror::AbstractMethod* method) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Locks::mutator_lock_->AssertSharedHeld(Self());
DCHECK_EQ(thread_state_, kRunnable); // Don't work with raw objects in non-runnable states.
diff --git a/src/stack.cc b/src/stack.cc
index 2e1f4ae..c998f2a 100644
--- a/src/stack.cc
+++ b/src/stack.cc
@@ -18,7 +18,10 @@
#include "compiler.h"
#include "oat/runtime/context.h"
-#include "object.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
#include "object_utils.h"
#include "thread_list.h"
@@ -39,7 +42,7 @@
return count;
}
-bool ManagedStack::ShadowFramesContain(Object** shadow_frame_entry) const {
+bool ManagedStack::ShadowFramesContain(mirror::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;
@@ -74,7 +77,7 @@
return GetMethod()->NativePcOffset(cur_quick_frame_pc_);
}
-uint32_t StackVisitor::GetVReg(AbstractMethod* m, uint16_t vreg, VRegKind kind) const {
+uint32_t StackVisitor::GetVReg(mirror::AbstractMethod* m, uint16_t vreg, VRegKind kind) const {
if (cur_quick_frame_ != NULL) {
DCHECK(context_ != NULL); // You can't reliably read registers without a context.
DCHECK(m == GetMethod());
@@ -98,7 +101,8 @@
}
}
-void StackVisitor::SetVReg(AbstractMethod* m, uint16_t vreg, uint32_t new_value, VRegKind kind) {
+void StackVisitor::SetVReg(mirror::AbstractMethod* m, uint16_t vreg, uint32_t new_value,
+ VRegKind kind) {
if (cur_quick_frame_ != NULL) {
DCHECK(context_ != NULL); // You can't reliably write registers without a context.
DCHECK(m == GetMethod());
@@ -136,14 +140,14 @@
}
uintptr_t StackVisitor::GetReturnPc() const {
- AbstractMethod** sp = GetCurrentQuickFrame();
+ mirror::AbstractMethod** sp = GetCurrentQuickFrame();
DCHECK(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) {
- AbstractMethod** sp = GetCurrentQuickFrame();
+ mirror::AbstractMethod** sp = GetCurrentQuickFrame();
CHECK(sp != NULL);
byte* pc_addr = reinterpret_cast<byte*>(sp) + GetMethod()->GetReturnPcOffsetInBytes();
*reinterpret_cast<uintptr_t*>(pc_addr) = new_ret_pc;
@@ -182,7 +186,7 @@
std::string StackVisitor::DescribeLocation() const {
std::string result("Visiting method '");
- AbstractMethod* m = GetMethod();
+ mirror::AbstractMethod* m = GetMethod();
if (m == NULL) {
return "upcall";
}
@@ -200,9 +204,9 @@
void StackVisitor::SanityCheckFrame() const {
#ifndef NDEBUG
- AbstractMethod* method = GetMethod();
- CHECK(method->GetClass() == AbstractMethod::GetMethodClass() ||
- method->GetClass() == AbstractMethod::GetConstructorClass());
+ mirror::AbstractMethod* method = GetMethod();
+ CHECK(method->GetClass() == mirror::AbstractMethod::GetMethodClass() ||
+ method->GetClass() == mirror::AbstractMethod::GetConstructorClass());
if (cur_quick_frame_ != NULL) {
method->AssertPcIsWithinCode(cur_quick_frame_pc_);
// Frame sanity.
@@ -229,7 +233,7 @@
if (cur_quick_frame_ != NULL) { // Handle quick stack frames.
// Can't be both a shadow and a quick fragment.
DCHECK(current_fragment->GetTopShadowFrame() == NULL);
- AbstractMethod* method = *cur_quick_frame_;
+ mirror::AbstractMethod* method = *cur_quick_frame_;
while (method != NULL) {
SanityCheckFrame();
bool should_continue = VisitFrame();
@@ -259,7 +263,7 @@
}
cur_quick_frame_pc_ = return_pc;
byte* next_frame = reinterpret_cast<byte*>(cur_quick_frame_) + frame_size;
- cur_quick_frame_ = reinterpret_cast<AbstractMethod**>(next_frame);
+ cur_quick_frame_ = reinterpret_cast<mirror::AbstractMethod**>(next_frame);
cur_depth_++;
method = *cur_quick_frame_;
}
diff --git a/src/stack.h b/src/stack.h
index 8d0efe9..c3d20f5 100644
--- a/src/stack.h
+++ b/src/stack.h
@@ -17,11 +17,9 @@
#ifndef ART_SRC_STACK_H_
#define ART_SRC_STACK_H_
-#include "base/macros.h"
#include "dex_file.h"
-#include "heap.h"
#include "instrumentation.h"
-#include "jni.h"
+#include "base/macros.h"
#include "oat/runtime/context.h"
#include <stdint.h>
@@ -29,9 +27,12 @@
namespace art {
+namespace mirror {
class AbstractMethod;
-class Context;
class Object;
+} // namespace mirror
+
+class Context;
class ShadowFrame;
class StackIndirectReferenceTable;
class ScopedObjectAccess;
@@ -59,10 +60,10 @@
public:
// Create ShadowFrame for interpreter.
static ShadowFrame* Create(uint32_t num_vregs, ShadowFrame* link,
- AbstractMethod* method, uint32_t dex_pc) {
+ mirror::AbstractMethod* method, uint32_t dex_pc) {
size_t sz = sizeof(ShadowFrame) +
(sizeof(uint32_t) * num_vregs) +
- (sizeof(Object*) * num_vregs);
+ (sizeof(mirror::Object*) * num_vregs);
uint8_t* memory = new uint8_t[sz];
ShadowFrame* sf = new (memory) ShadowFrame(num_vregs, link, method, dex_pc, true);
return sf;
@@ -121,13 +122,13 @@
return *reinterpret_cast<const double*>(vreg);
}
- Object* GetVRegReference(size_t i) const {
+ mirror::Object* GetVRegReference(size_t i) const {
DCHECK_LT(i, NumberOfVRegs());
if (HasReferenceArray()) {
return References()[i];
} else {
const uint32_t* vreg = &vregs_[i];
- return *reinterpret_cast<Object* const*>(vreg);
+ return *reinterpret_cast<mirror::Object* const*>(vreg);
}
}
@@ -153,26 +154,26 @@
*reinterpret_cast<double*>(vreg) = val;
}
- void SetVRegReference(size_t i, Object* val) {
+ void SetVRegReference(size_t i, mirror::Object* val) {
DCHECK_LT(i, NumberOfVRegs());
uint32_t* vreg = &vregs_[i];
- *reinterpret_cast<Object**>(vreg) = val;
+ *reinterpret_cast<mirror::Object**>(vreg) = val;
if (HasReferenceArray()) {
References()[i] = val;
}
}
- AbstractMethod* GetMethod() const {
+ mirror::AbstractMethod* GetMethod() const {
DCHECK_NE(method_, static_cast<void*>(NULL));
return method_;
}
- void SetMethod(AbstractMethod* method) {
+ void SetMethod(mirror::AbstractMethod* method) {
DCHECK_NE(method, static_cast<void*>(NULL));
method_ = method;
}
- bool Contains(Object** shadow_frame_entry_obj) const {
+ bool Contains(mirror::Object** shadow_frame_entry_obj) const {
if (HasReferenceArray()) {
return ((&References()[0] <= shadow_frame_entry_obj) &&
(shadow_frame_entry_obj <= (&References()[NumberOfVRegs() - 1])));
@@ -204,8 +205,8 @@
}
private:
- ShadowFrame(uint32_t num_vregs, ShadowFrame* link, AbstractMethod* method, uint32_t dex_pc,
- bool has_reference_array)
+ ShadowFrame(uint32_t num_vregs, ShadowFrame* link, mirror::AbstractMethod* method,
+ uint32_t dex_pc, bool has_reference_array)
: number_of_vregs_(num_vregs), link_(link), method_(method), dex_pc_(dex_pc) {
CHECK_LT(num_vregs, static_cast<uint32_t>(kHasReferenceArray));
if (has_reference_array) {
@@ -220,14 +221,14 @@
}
}
- Object* const* References() const {
+ mirror::Object* const* References() const {
DCHECK(HasReferenceArray());
const uint32_t* vreg_end = &vregs_[NumberOfVRegs()];
- return reinterpret_cast<Object* const*>(vreg_end);
+ return reinterpret_cast<mirror::Object* const*>(vreg_end);
}
- Object** References() {
- return const_cast<Object**>(const_cast<const ShadowFrame*>(this)->References());
+ mirror::Object** References() {
+ return const_cast<mirror::Object**>(const_cast<const ShadowFrame*>(this)->References());
}
enum ShadowFrameFlag {
@@ -237,7 +238,7 @@
uint32_t number_of_vregs_;
// Link to previous shadow frame or NULL.
ShadowFrame* link_;
- AbstractMethod* method_;
+ mirror::AbstractMethod* method_;
uint32_t dex_pc_;
uint32_t vregs_[0];
@@ -272,11 +273,11 @@
return link_;
}
- AbstractMethod** GetTopQuickFrame() const {
+ mirror::AbstractMethod** GetTopQuickFrame() const {
return top_quick_frame_;
}
- void SetTopQuickFrame(AbstractMethod** top) {
+ void SetTopQuickFrame(mirror::AbstractMethod** top) {
top_quick_frame_ = top;
}
@@ -320,12 +321,12 @@
size_t NumJniShadowFrameReferences() const;
- bool ShadowFramesContain(Object** shadow_frame_entry) const;
+ bool ShadowFramesContain(mirror::Object** shadow_frame_entry) const;
private:
ManagedStack* link_;
ShadowFrame* top_shadow_frame_;
- AbstractMethod** top_quick_frame_;
+ mirror::AbstractMethod** top_quick_frame_;
uintptr_t top_quick_frame_pc_;
};
@@ -342,7 +343,7 @@
void WalkStack(bool include_transitions = false)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- AbstractMethod* GetMethod() const {
+ mirror::AbstractMethod* GetMethod() const {
if (cur_shadow_frame_ != NULL) {
return cur_shadow_frame_->GetMethod();
} else if (cur_quick_frame_ != NULL) {
@@ -388,16 +389,16 @@
return num_frames_;
}
- uint32_t GetVReg(AbstractMethod* m, uint16_t vreg, VRegKind kind) const
+ uint32_t GetVReg(mirror::AbstractMethod* m, uint16_t vreg, VRegKind kind) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void SetVReg(AbstractMethod* m, uint16_t vreg, uint32_t new_value, VRegKind kind)
+ void SetVReg(mirror::AbstractMethod* m, uint16_t vreg, uint32_t new_value, VRegKind kind)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
uintptr_t GetGPR(uint32_t reg) const;
void SetGPR(uint32_t reg, uintptr_t value);
- uint32_t GetVReg(AbstractMethod** cur_quick_frame, const DexFile::CodeItem* code_item,
+ uint32_t GetVReg(mirror::AbstractMethod** cur_quick_frame, const DexFile::CodeItem* code_item,
uint32_t core_spills, uint32_t fp_spills, size_t frame_size,
uint16_t vreg) const {
int offset = GetVRegOffset(code_item, core_spills, fp_spills, frame_size, vreg);
@@ -471,7 +472,7 @@
return cur_quick_frame_pc_;
}
- AbstractMethod** GetCurrentQuickFrame() const {
+ mirror::AbstractMethod** GetCurrentQuickFrame() const {
return cur_quick_frame_;
}
@@ -480,7 +481,7 @@
}
StackIndirectReferenceTable* GetCurrentSirt() const {
- AbstractMethod** sp = GetCurrentQuickFrame();
+ mirror::AbstractMethod** sp = GetCurrentQuickFrame();
++sp; // Skip Method*; SIRT comes next;
return reinterpret_cast<StackIndirectReferenceTable*>(sp);
}
@@ -499,7 +500,7 @@
Thread* const thread_;
ShadowFrame* cur_shadow_frame_;
- AbstractMethod** cur_quick_frame_;
+ mirror::AbstractMethod** cur_quick_frame_;
uintptr_t cur_quick_frame_pc_;
// Lazily computed, number of frames in the stack.
size_t num_frames_;
diff --git a/src/stack_indirect_reference_table.h b/src/stack_indirect_reference_table.h
index 92fb003..dd10634 100644
--- a/src/stack_indirect_reference_table.h
+++ b/src/stack_indirect_reference_table.h
@@ -21,8 +21,9 @@
#include "base/macros.h"
namespace art {
-
+namespace mirror {
class Object;
+}
class Thread;
// Stack allocated indirect reference table. It can allocated within
@@ -30,7 +31,8 @@
// storage or manually allocated by SirtRef to hold one reference.
class StackIndirectReferenceTable {
public:
- explicit StackIndirectReferenceTable(Object* object) : number_of_references_(1), link_(NULL) {
+ explicit StackIndirectReferenceTable(mirror::Object* object) :
+ number_of_references_(1), link_(NULL) {
references_[0] = object;
}
@@ -51,17 +53,17 @@
link_ = sirt;
}
- Object* GetReference(size_t i) const {
+ mirror::Object* GetReference(size_t i) const {
DCHECK_LT(i, number_of_references_);
return references_[i];
}
- void SetReference(size_t i, Object* object) {
+ void SetReference(size_t i, mirror::Object* object) {
DCHECK_LT(i, number_of_references_);
references_[i] = object;
}
- bool Contains(Object** sirt_entry) const {
+ bool Contains(mirror::Object** sirt_entry) const {
// A SIRT should always contain something. One created by the
// jni_compiler should have a jobject/jclass as a native method is
// passed in a this pointer or a class
@@ -87,7 +89,7 @@
StackIndirectReferenceTable* link_;
// number_of_references_ are available if this is allocated and filled in by jni_compiler.
- Object* references_[1];
+ mirror::Object* references_[1];
DISALLOW_COPY_AND_ASSIGN(StackIndirectReferenceTable);
};
diff --git a/src/thread.cc b/src/thread.cc
index 46cba06..01d6072 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -30,16 +30,22 @@
#include "base/mutex.h"
#include "class_linker.h"
-#include "class_loader.h"
+#include "class_linker-inl.h"
#include "cutils/atomic.h"
#include "cutils/atomic-inline.h"
#include "debugger.h"
#include "gc_map.h"
+#include "gc/card_table-inl.h"
#include "heap.h"
#include "jni_internal.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/class-inl.h"
+#include "mirror/class_loader.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
+#include "mirror/stack_trace_element.h"
#include "monitor.h"
#include "oat/runtime/context.h"
-#include "object.h"
#include "object_utils.h"
#include "reflection.h"
#include "runtime.h"
@@ -139,20 +145,20 @@
// Copy peer into self, deleting global reference when done.
CHECK(self->jpeer_ != NULL);
- self->opeer_ = soa.Decode<Object*>(self->jpeer_);
+ self->opeer_ = soa.Decode<mirror::Object*>(self->jpeer_);
self->GetJniEnv()->DeleteGlobalRef(self->jpeer_);
self->jpeer_ = NULL;
{
- SirtRef<String> thread_name(self, self->GetThreadName(soa));
+ SirtRef<mirror::String> thread_name(self, self->GetThreadName(soa));
self->SetThreadName(thread_name->ToModifiedUtf8().c_str());
}
Dbg::PostThreadStart(self);
// Invoke the 'run' method of our java.lang.Thread.
- Object* receiver = self->opeer_;
+ mirror::Object* receiver = self->opeer_;
jmethodID mid = WellKnownClasses::java_lang_Thread_run;
- AbstractMethod* m =
+ mirror::AbstractMethod* m =
receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(soa.DecodeMethod(mid));
m->Invoke(self, receiver, NULL, NULL);
}
@@ -162,8 +168,9 @@
return NULL;
}
-Thread* Thread::FromManagedThread(const ScopedObjectAccessUnchecked& soa, Object* thread_peer) {
- Field* f = soa.DecodeField(WellKnownClasses::java_lang_Thread_vmData);
+Thread* Thread::FromManagedThread(const ScopedObjectAccessUnchecked& soa,
+ mirror::Object* thread_peer) {
+ mirror::Field* f = soa.DecodeField(WellKnownClasses::java_lang_Thread_vmData);
Thread* result = reinterpret_cast<Thread*>(static_cast<uintptr_t>(f->GetInt(thread_peer)));
// Sanity check that if we have a result it is either suspended or we hold the thread_list_lock_
// to stop it from going away.
@@ -177,7 +184,7 @@
}
Thread* Thread::FromManagedThread(const ScopedObjectAccessUnchecked& soa, jobject java_thread) {
- return FromManagedThread(soa, soa.Decode<Object*>(java_thread));
+ return FromManagedThread(soa, soa.Decode<mirror::Object*>(java_thread));
}
static size_t FixStackSize(size_t stack_size) {
@@ -391,7 +398,7 @@
}
{
ScopedObjectAccess soa(this);
- opeer_ = soa.Decode<Object*>(peer.get());
+ opeer_ = soa.Decode<mirror::Object*>(peer.get());
}
env->CallNonvirtualVoidMethod(peer.get(),
WellKnownClasses::java_lang_Thread,
@@ -405,7 +412,7 @@
reinterpret_cast<jint>(self));
ScopedObjectAccess soa(self);
- SirtRef<String> peer_thread_name(soa.Self(), GetThreadName(soa));
+ SirtRef<mirror::String> peer_thread_name(soa.Self(), GetThreadName(soa));
if (peer_thread_name.get() == NULL) {
// The Thread constructor should have set the Thread.name to a
// non-null value. However, because we can run without code
@@ -414,9 +421,9 @@
soa.DecodeField(WellKnownClasses::java_lang_Thread_daemon)->
SetBoolean(opeer_, thread_is_daemon);
soa.DecodeField(WellKnownClasses::java_lang_Thread_group)->
- SetObject(opeer_, soa.Decode<Object*>(thread_group));
+ SetObject(opeer_, soa.Decode<mirror::Object*>(thread_group));
soa.DecodeField(WellKnownClasses::java_lang_Thread_name)->
- SetObject(opeer_, soa.Decode<Object*>(thread_name.get()));
+ SetObject(opeer_, soa.Decode<mirror::Object*>(thread_name.get()));
soa.DecodeField(WellKnownClasses::java_lang_Thread_priority)->
SetInt(opeer_, thread_priority);
peer_thread_name.reset(GetThreadName(soa));
@@ -506,9 +513,9 @@
DumpStack(os);
}
-String* Thread::GetThreadName(const ScopedObjectAccessUnchecked& soa) const {
- Field* f = soa.DecodeField(WellKnownClasses::java_lang_Thread_name);
- return (opeer_ != NULL) ? reinterpret_cast<String*>(f->GetObject(opeer_)) : NULL;
+mirror::String* Thread::GetThreadName(const ScopedObjectAccessUnchecked& soa) const {
+ mirror::Field* f = soa.DecodeField(WellKnownClasses::java_lang_Thread_name);
+ return (opeer_ != NULL) ? reinterpret_cast<mirror::String*>(f->GetObject(opeer_)) : NULL;
}
void Thread::GetThreadName(std::string& name) const {
@@ -748,12 +755,14 @@
priority = soa.DecodeField(WellKnownClasses::java_lang_Thread_priority)->GetInt(thread->opeer_);
is_daemon = soa.DecodeField(WellKnownClasses::java_lang_Thread_daemon)->GetBoolean(thread->opeer_);
- Object* thread_group =
+ mirror::Object* thread_group =
soa.DecodeField(WellKnownClasses::java_lang_Thread_group)->GetObject(thread->opeer_);
if (thread_group != NULL) {
- Field* group_name_field = soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_name);
- String* group_name_string = reinterpret_cast<String*>(group_name_field->GetObject(thread_group));
+ mirror::Field* group_name_field =
+ soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_name);
+ mirror::String* group_name_string =
+ reinterpret_cast<mirror::String*>(group_name_field->GetObject(thread_group));
group_name = (group_name_string != NULL) ? group_name_string->ToModifiedUtf8() : "<null>";
}
} else {
@@ -848,13 +857,13 @@
}
bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* m = GetMethod();
+ mirror::AbstractMethod* m = GetMethod();
if (m->IsRuntimeMethod()) {
return true;
}
const int kMaxRepetition = 3;
- Class* c = m->GetDeclaringClass();
- const DexCache* dex_cache = c->GetDexCache();
+ mirror::Class* c = m->GetDeclaringClass();
+ const mirror::DexCache* dex_cache = c->GetDexCache();
int line_number = -1;
if (dex_cache != NULL) { // be tolerant of bad input
const DexFile& dex_file = *dex_cache->GetDexFile();
@@ -893,7 +902,7 @@
return true;
}
- static void DumpLockedObject(Object* o, void* context)
+ static void DumpLockedObject(mirror::Object* o, void* context)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
std::ostream& os = *reinterpret_cast<std::ostream*>(context);
os << " - locked <" << o << "> (a " << PrettyTypeOf(o) << ")\n";
@@ -903,7 +912,7 @@
const Thread* thread;
bool can_allocate;
MethodHelper mh;
- AbstractMethod* last_method;
+ mirror::AbstractMethod* last_method;
int last_line_number;
int repetition_count;
int frame_count;
@@ -1016,14 +1025,14 @@
void Thread::AssertNoPendingException() const {
if (UNLIKELY(IsExceptionPending())) {
ScopedObjectAccess soa(Thread::Current());
- Throwable* exception = GetException();
+ mirror::Throwable* exception = GetException();
LOG(FATAL) << "No pending exception expected: " << exception->Dump();
}
}
-static void MonitorExitVisitor(const Object* object, void* arg) NO_THREAD_SAFETY_ANALYSIS {
+static void MonitorExitVisitor(const mirror::Object* object, void* arg) NO_THREAD_SAFETY_ANALYSIS {
Thread* self = reinterpret_cast<Thread*>(arg);
- Object* entered_monitor = const_cast<Object*>(object);
+ mirror::Object* entered_monitor = const_cast<mirror::Object*>(object);
if (self->HoldsLock(entered_monitor)) {
LOG(WARNING) << "Calling MonitorExit on object "
<< object << " (" << PrettyTypeOf(object) << ")"
@@ -1049,7 +1058,8 @@
// Thread.join() is implemented as an Object.wait() on the Thread.lock object. Signal anyone
// who is waiting.
- Object* lock = soa.DecodeField(WellKnownClasses::java_lang_Thread_lock)->GetObject(opeer_);
+ mirror::Object* lock =
+ soa.DecodeField(WellKnownClasses::java_lang_Thread_lock)->GetObject(opeer_);
// (This conditional is only needed for tests, where Thread.lock won't have been set.)
if (lock != NULL) {
lock->MonitorEnter(self);
@@ -1125,7 +1135,7 @@
void Thread::RemoveFromThreadGroup(ScopedObjectAccess& soa) {
// this.group.removeThread(this);
// group can be null if we're in the compiler or a test.
- Object* ogroup = soa.DecodeField(WellKnownClasses::java_lang_Thread_group)->GetObject(opeer_);
+ mirror::Object* ogroup = soa.DecodeField(WellKnownClasses::java_lang_Thread_group)->GetObject(opeer_);
if (ogroup != NULL) {
ScopedLocalRef<jobject> group(soa.Env(), soa.AddLocalReference<jobject>(ogroup));
ScopedLocalRef<jobject> peer(soa.Env(), soa.AddLocalReference<jobject>(opeer_));
@@ -1144,7 +1154,7 @@
}
bool Thread::SirtContains(jobject obj) const {
- Object** sirt_entry = reinterpret_cast<Object**>(obj);
+ mirror::Object** sirt_entry = reinterpret_cast<mirror::Object**>(obj);
for (StackIndirectReferenceTable* cur = top_sirt_; cur; cur = cur->GetLink()) {
if (cur->Contains(sirt_entry)) {
return true;
@@ -1154,11 +1164,11 @@
return managed_stack_.ShadowFramesContain(sirt_entry);
}
-void Thread::SirtVisitRoots(Heap::RootVisitor* visitor, void* arg) {
+void Thread::SirtVisitRoots(RootVisitor* visitor, void* arg) {
for (StackIndirectReferenceTable* cur = top_sirt_; cur; cur = cur->GetLink()) {
size_t num_refs = cur->NumberOfReferences();
for (size_t j = 0; j < num_refs; j++) {
- Object* object = cur->GetReference(j);
+ mirror::Object* object = cur->GetReference(j);
if (object != NULL) {
visitor(object, arg);
}
@@ -1166,19 +1176,19 @@
}
}
-Object* Thread::DecodeJObject(jobject obj) const {
+mirror::Object* Thread::DecodeJObject(jobject obj) const {
Locks::mutator_lock_->AssertSharedHeld(this);
if (obj == NULL) {
return NULL;
}
IndirectRef ref = reinterpret_cast<IndirectRef>(obj);
IndirectRefKind kind = GetIndirectRefKind(ref);
- Object* result;
+ mirror::Object* result;
switch (kind) {
case kLocal:
{
IndirectReferenceTable& locals = jni_env_->locals;
- result = const_cast<Object*>(locals.Get(ref));
+ result = const_cast<mirror::Object*>(locals.Get(ref));
break;
}
case kGlobal:
@@ -1186,7 +1196,7 @@
JavaVMExt* vm = Runtime::Current()->GetJavaVM();
IndirectReferenceTable& globals = vm->globals;
MutexLock mu(const_cast<Thread*>(this), vm->globals_lock);
- result = const_cast<Object*>(globals.Get(ref));
+ result = const_cast<mirror::Object*>(globals.Get(ref));
break;
}
case kWeakGlobal:
@@ -1194,7 +1204,7 @@
JavaVMExt* vm = Runtime::Current()->GetJavaVM();
IndirectReferenceTable& weak_globals = vm->weak_globals;
MutexLock mu(const_cast<Thread*>(this), vm->weak_globals_lock);
- result = const_cast<Object*>(weak_globals.Get(ref));
+ result = const_cast<mirror::Object*>(weak_globals.Get(ref));
if (result == kClearedJniWeakGlobal) {
// This is a special case where it's okay to return NULL.
return NULL;
@@ -1206,10 +1216,10 @@
// TODO: make stack indirect reference table lookup more efficient
// Check if this is a local reference in the SIRT
if (SirtContains(obj)) {
- result = *reinterpret_cast<Object**>(obj); // Read from SIRT
+ result = *reinterpret_cast<mirror::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.
- result = reinterpret_cast<Object*>(obj);
+ result = reinterpret_cast<mirror::Object*>(obj);
} else {
result = kInvalidIndirectRefObject;
}
@@ -1272,9 +1282,9 @@
// 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)
- AbstractMethod* m = GetMethod();
+ mirror::AbstractMethod* m = GetMethod();
if (skipping_ && !m->IsRuntimeMethod() &&
- !Throwable::GetJavaLangThrowable()->IsAssignableFrom(m->GetDeclaringClass())) {
+ !mirror::Throwable::GetJavaLangThrowable()->IsAssignableFrom(m->GetDeclaringClass())) {
skipping_ = false;
}
if (!skipping_) {
@@ -1310,14 +1320,14 @@
bool Init(int depth)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// Allocate method trace with an extra slot that will hold the PC trace
- SirtRef<ObjectArray<Object> >
+ SirtRef<mirror::ObjectArray<mirror::Object> >
method_trace(self_,
- Runtime::Current()->GetClassLinker()->AllocObjectArray<Object>(self_,
- depth + 1));
+ Runtime::Current()->GetClassLinker()->AllocObjectArray<mirror::Object>(self_,
+ depth + 1));
if (method_trace.get() == NULL) {
return false;
}
- IntArray* dex_pc_trace = IntArray::Alloc(self_, depth);
+ mirror::IntArray* dex_pc_trace = mirror::IntArray::Alloc(self_, depth);
if (dex_pc_trace == NULL) {
return false;
}
@@ -1347,7 +1357,7 @@
skip_depth_--;
return true;
}
- AbstractMethod* m = GetMethod();
+ mirror::AbstractMethod* m = GetMethod();
if (m->IsRuntimeMethod()) {
return true; // Ignore runtime frames (in particular callee save).
}
@@ -1357,7 +1367,7 @@
return true;
}
- ObjectArray<Object>* GetInternalStackTrace() const {
+ mirror::ObjectArray<mirror::Object>* GetInternalStackTrace() const {
return method_trace_;
}
@@ -1368,9 +1378,9 @@
// Current position down stack trace.
uint32_t count_;
// Array of dex PC values.
- IntArray* dex_pc_trace_;
+ mirror::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_;
+ mirror::ObjectArray<mirror::Object>* method_trace_;
};
jobject Thread::CreateInternalStackTrace(const ScopedObjectAccessUnchecked& soa) const {
@@ -1387,7 +1397,7 @@
return NULL; // Allocation failed.
}
build_trace_visitor.WalkStack();
- ObjectArray<Object>* trace = build_trace_visitor.GetInternalStackTrace();
+ mirror::ObjectArray<mirror::Object>* trace = build_trace_visitor.GetInternalStackTrace();
if (kIsDebugBuild) {
for (int32_t i = 0; i < trace->GetLength(); ++i) {
CHECK(trace->Get(i) != NULL);
@@ -1401,18 +1411,19 @@
// Transition into runnable state to work on Object*/Array*
ScopedObjectAccess soa(env);
// Decode the internal stack trace into the depth, method trace and PC trace
- ObjectArray<Object>* method_trace = soa.Decode<ObjectArray<Object>*>(internal);
+ mirror::ObjectArray<mirror::Object>* method_trace =
+ soa.Decode<mirror::ObjectArray<mirror::Object>*>(internal);
int32_t depth = method_trace->GetLength() - 1;
- IntArray* pc_trace = down_cast<IntArray*>(method_trace->Get(depth));
+ mirror::IntArray* pc_trace = down_cast<mirror::IntArray*>(method_trace->Get(depth));
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
jobjectArray result;
- ObjectArray<StackTraceElement>* java_traces;
+ mirror::ObjectArray<mirror::StackTraceElement>* java_traces;
if (output_array != NULL) {
// Reuse the array we were given.
result = output_array;
- java_traces = soa.Decode<ObjectArray<StackTraceElement>*>(output_array);
+ java_traces = soa.Decode<mirror::ObjectArray<mirror::StackTraceElement>*>(output_array);
// ...adjusting the number of frames we'll write to not exceed the array length.
depth = std::min(depth, java_traces->GetLength());
} else {
@@ -1431,7 +1442,7 @@
MethodHelper mh;
for (int32_t i = 0; i < depth; ++i) {
// Prepare parameters for StackTraceElement(String cls, String method, String file, int line)
- AbstractMethod* method = down_cast<AbstractMethod*>(method_trace->Get(i));
+ mirror::AbstractMethod* method = down_cast<mirror::AbstractMethod*>(method_trace->Get(i));
mh.ChangeMethod(method);
uint32_t dex_pc = pc_trace->Get(i);
int32_t line_number = mh.GetLineNumFromDexPC(dex_pc);
@@ -1440,27 +1451,28 @@
const char* descriptor = mh.GetDeclaringClassDescriptor();
CHECK(descriptor != NULL);
std::string class_name(PrettyDescriptor(descriptor));
- SirtRef<String> class_name_object(soa.Self(),
- String::AllocFromModifiedUtf8(soa.Self(),
- class_name.c_str()));
+ SirtRef<mirror::String> class_name_object(soa.Self(),
+ mirror::String::AllocFromModifiedUtf8(soa.Self(),
+ class_name.c_str()));
if (class_name_object.get() == NULL) {
return NULL;
}
const char* method_name = mh.GetName();
CHECK(method_name != NULL);
- SirtRef<String> method_name_object(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(),
- method_name));
+ SirtRef<mirror::String> method_name_object(soa.Self(),
+ mirror::String::AllocFromModifiedUtf8(soa.Self(),
+ method_name));
if (method_name_object.get() == NULL) {
return NULL;
}
const char* source_file = mh.GetDeclaringClassSourceFile();
- SirtRef<String> source_name_object(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(),
- source_file));
- StackTraceElement* obj = StackTraceElement::Alloc(soa.Self(),
- class_name_object.get(),
- method_name_object.get(),
- source_name_object.get(),
- line_number);
+ SirtRef<mirror::String> source_name_object(soa.Self(), mirror::String::AllocFromModifiedUtf8(soa.Self(),
+ source_file));
+ mirror::StackTraceElement* obj = mirror::StackTraceElement::Alloc(soa.Self(),
+ class_name_object.get(),
+ method_name_object.get(),
+ source_name_object.get(),
+ line_number);
if (obj == NULL) {
return NULL;
}
@@ -1520,10 +1532,11 @@
env, reinterpret_cast<jthrowable>(env->AllocObject(exception_class.get())));
if (exception.get() != NULL) {
ScopedObjectAccessUnchecked soa(env);
- Throwable* t = reinterpret_cast<Throwable*>(soa.Self()->DecodeJObject(exception.get()));
- t->SetDetailMessage(String::AllocFromModifiedUtf8(soa.Self(), msg));
+ mirror::Throwable* t =
+ reinterpret_cast<mirror::Throwable*>(soa.Self()->DecodeJObject(exception.get()));
+ t->SetDetailMessage(mirror::String::AllocFromModifiedUtf8(soa.Self(), msg));
if (cause != NULL) {
- t->SetCause(soa.Decode<Throwable*>(cause));
+ t->SetCause(soa.Decode<mirror::Throwable*>(cause));
}
soa.Self()->SetException(t);
} else {
@@ -1691,7 +1704,7 @@
static const bool kDebugExceptionDelivery = false;
class CatchBlockStackVisitor : public StackVisitor {
public:
- CatchBlockStackVisitor(Thread* self, Throwable* exception)
+ CatchBlockStackVisitor(Thread* self, mirror::Throwable* exception)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
: StackVisitor(self, self->GetLongJumpContext()),
self_(self), exception_(exception), to_find_(exception->GetClass()), throw_method_(NULL),
@@ -1708,7 +1721,7 @@
bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* method = GetMethod();
+ mirror::AbstractMethod* 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_quick_frame_pc_ = GetCurrentQuickFramePc();
@@ -1751,7 +1764,7 @@
}
void DoLongJump() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* catch_method = *handler_quick_frame_;
+ mirror::AbstractMethod* catch_method = *handler_quick_frame_;
if (kDebugExceptionDelivery) {
if (catch_method == NULL) {
LOG(INFO) << "Handler is upcall";
@@ -1777,14 +1790,14 @@
private:
Thread* self_;
- Throwable* exception_;
+ mirror::Throwable* exception_;
// The type of the exception catch block to find.
- Class* to_find_;
- AbstractMethod* throw_method_;
+ mirror::Class* to_find_;
+ mirror::AbstractMethod* throw_method_;
JDWP::FrameId throw_frame_id_;
uint32_t throw_dex_pc_;
// Quick frame with found handler or last frame if no handler found.
- AbstractMethod** handler_quick_frame_;
+ mirror::AbstractMethod** handler_quick_frame_;
// PC to branch to for the handler.
uintptr_t handler_quick_frame_pc_;
// Associated dex PC.
@@ -1798,13 +1811,13 @@
};
void Thread::QuickDeliverException() {
- Throwable* exception = GetException(); // Get exception from thread
+ mirror::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
// resolution.
ClearException();
if (kDebugExceptionDelivery) {
- String* msg = exception->GetDetailMessage();
+ mirror::String* msg = exception->GetDetailMessage();
std::string str_msg(msg != NULL ? msg->ToModifiedUtf8() : "");
DumpStack(LOG(INFO) << "Delivering exception: " << PrettyTypeOf(exception)
<< ": " << str_msg << "\n");
@@ -1826,14 +1839,14 @@
return result;
}
-AbstractMethod* Thread::GetCurrentMethod(uint32_t* dex_pc, size_t* frame_id) const {
+mirror::AbstractMethod* Thread::GetCurrentMethod(uint32_t* dex_pc, size_t* frame_id) const {
struct CurrentMethodVisitor : public StackVisitor {
CurrentMethodVisitor(Thread* thread)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
: StackVisitor(thread, NULL), method_(NULL), dex_pc_(0), frame_id_(0) {}
virtual bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* m = GetMethod();
+ mirror::AbstractMethod* m = GetMethod();
if (m->IsRuntimeMethod()) {
// Continue if this is a runtime method.
return true;
@@ -1843,7 +1856,7 @@
frame_id_ = GetFrameId();
return false;
}
- AbstractMethod* method_;
+ mirror::AbstractMethod* method_;
uint32_t dex_pc_;
size_t frame_id_;
};
@@ -1859,7 +1872,7 @@
return visitor.method_;
}
-bool Thread::HoldsLock(Object* object) {
+bool Thread::HoldsLock(mirror::Object* object) {
if (object == NULL) {
return false;
}
@@ -1881,12 +1894,12 @@
}
ShadowFrame* shadow_frame = GetCurrentShadowFrame();
if (shadow_frame != NULL) {
- AbstractMethod* m = shadow_frame->GetMethod();
+ mirror::AbstractMethod* m = shadow_frame->GetMethod();
size_t num_regs = shadow_frame->NumberOfVRegs();
if (m->IsNative() || shadow_frame->HasReferenceArray()) {
// SIRT for JNI or References for interpreter.
for (size_t reg = 0; reg < num_regs; ++reg) {
- Object* ref = shadow_frame->GetVRegReference(reg);
+ mirror::Object* ref = shadow_frame->GetVRegReference(reg);
if (ref != NULL) {
visitor_(ref, reg, this);
}
@@ -1907,7 +1920,7 @@
num_regs = std::min(dex_gc_map.RegWidth() * 8, num_regs);
for (size_t reg = 0; reg < num_regs; ++reg) {
if (TestBitmap(reg, reg_bitmap)) {
- Object* ref = shadow_frame->GetVRegReference(reg);
+ mirror::Object* ref = shadow_frame->GetVRegReference(reg);
if (ref != NULL) {
visitor_(ref, reg, this);
}
@@ -1915,7 +1928,7 @@
}
}
} else {
- AbstractMethod* m = GetMethod();
+ mirror::AbstractMethod* m = GetMethod();
// Process register map (which native and runtime methods don't have)
if (!m->IsNative() && !m->IsRuntimeMethod() && !m->IsProxyMethod()) {
const uint8_t* native_gc_map = m->GetNativeGcMap();
@@ -1934,20 +1947,21 @@
uint32_t fp_spills = m->GetFpSpillMask();
size_t frame_size = m->GetFrameSizeInBytes();
// For all dex registers in the bitmap
- AbstractMethod** cur_quick_frame = GetCurrentQuickFrame();
+ mirror::AbstractMethod** cur_quick_frame = GetCurrentQuickFrame();
DCHECK(cur_quick_frame != NULL);
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;
+ mirror::Object* ref;
if (vmap_table.IsInContext(reg, vmap_offset, kReferenceVReg)) {
uintptr_t val = GetGPR(vmap_table.ComputeRegister(core_spills, vmap_offset,
kReferenceVReg));
- ref = reinterpret_cast<Object*>(val);
+ ref = reinterpret_cast<mirror::Object*>(val);
} else {
- ref = reinterpret_cast<Object*>(GetVReg(cur_quick_frame, code_item, core_spills,
- fp_spills, frame_size, reg));
+ ref = reinterpret_cast<mirror::Object*>(GetVReg(cur_quick_frame, code_item,
+ core_spills, fp_spills, frame_size,
+ reg));
}
if (ref != NULL) {
@@ -1975,46 +1989,46 @@
class RootCallbackVisitor {
public:
- RootCallbackVisitor(Heap::RootVisitor* visitor, void* arg) : visitor_(visitor), arg_(arg) {
+ RootCallbackVisitor(RootVisitor* visitor, void* arg) : visitor_(visitor), arg_(arg) {
}
- void operator()(const Object* obj, size_t, const StackVisitor*) const {
+ void operator()(const mirror::Object* obj, size_t, const StackVisitor*) const {
visitor_(obj, arg_);
}
private:
- Heap::RootVisitor* visitor_;
+ RootVisitor* visitor_;
void* arg_;
};
class VerifyCallbackVisitor {
public:
- VerifyCallbackVisitor(Heap::VerifyRootVisitor* visitor, void* arg)
+ VerifyCallbackVisitor(VerifyRootVisitor* visitor, void* arg)
: visitor_(visitor),
arg_(arg) {
}
- void operator()(const Object* obj, size_t vreg, const StackVisitor* visitor) const {
+ void operator()(const mirror::Object* obj, size_t vreg, const StackVisitor* visitor) const {
visitor_(obj, arg_, vreg, visitor);
}
private:
- Heap::VerifyRootVisitor* const visitor_;
+ VerifyRootVisitor* const visitor_;
void* const arg_;
};
struct VerifyRootWrapperArg {
- Heap::VerifyRootVisitor* visitor;
+ VerifyRootVisitor* visitor;
void* arg;
};
-static void VerifyRootWrapperCallback(const Object* root, void* arg) {
+static void VerifyRootWrapperCallback(const mirror::Object* root, void* arg) {
VerifyRootWrapperArg* wrapperArg = reinterpret_cast<VerifyRootWrapperArg*>(arg);
wrapperArg->visitor(root, wrapperArg->arg, 0, NULL);
}
-void Thread::VerifyRoots(Heap::VerifyRootVisitor* visitor, void* arg) {
+void Thread::VerifyRoots(VerifyRootVisitor* visitor, void* arg) {
// We need to map from a RootVisitor to VerifyRootVisitor, so pass in nulls for arguments we
// don't have.
VerifyRootWrapperArg wrapperArg;
@@ -2043,7 +2057,7 @@
ReleaseLongJumpContext(context);
}
-void Thread::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
+void Thread::VisitRoots(RootVisitor* visitor, void* arg) {
if (opeer_ != NULL) {
visitor(opeer_, arg);
}
diff --git a/src/thread.h b/src/thread.h
index 13e1cab..c63fddf 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -31,19 +31,30 @@
#include "oat/runtime/oat_support_entrypoints.h"
#include "locks.h"
#include "offsets.h"
+#include "root_visitor.h"
#include "runtime_stats.h"
#include "stack.h"
#include "stack_indirect_reference_table.h"
+#include "thread_state.h"
#include "UniquePtr.h"
namespace art {
+namespace mirror {
class AbstractMethod;
class Array;
-class BaseMutex;
class Class;
-class ClassLinker;
class ClassLoader;
+class Object;
+template<class T> class ObjectArray;
+template<class T> class PrimitiveArray;
+typedef PrimitiveArray<int32_t> IntArray;
+class StackTraceElement;
+class StaticStorageBase;
+class Throwable;
+} // namespace mirror
+class BaseMutex;
+class ClassLinker;
class Closure;
class Context;
struct DebugInvokeReq;
@@ -51,20 +62,12 @@
struct JavaVMExt;
struct JNIEnvExt;
class Monitor;
-class Object;
class Runtime;
class ScopedObjectAccess;
class ScopedObjectAccessUnchecked;
class ShadowFrame;
-class StackTraceElement;
-class StaticStorageBase;
class Thread;
class ThreadList;
-class Throwable;
-
-template<class T> class ObjectArray;
-template<class T> class PrimitiveArray;
-typedef PrimitiveArray<int32_t> IntArray;
// Thread priorities. These must match the Thread.MIN_PRIORITY,
// Thread.NORM_PRIORITY, and Thread.MAX_PRIORITY constants.
@@ -74,28 +77,6 @@
kMaxThreadPriority = 10,
};
-enum ThreadState {
- // Thread.State JDWP state
- kTerminated, // TERMINATED TS_ZOMBIE Thread.run has returned, but Thread* still around
- kRunnable, // RUNNABLE TS_RUNNING runnable
- kTimedWaiting, // TIMED_WAITING TS_WAIT in Object.wait() with a timeout
- kSleeping, // TIMED_WAITING TS_SLEEPING in Thread.sleep()
- kBlocked, // BLOCKED TS_MONITOR blocked on a monitor
- kWaiting, // WAITING TS_WAIT in Object.wait()
- kWaitingForGcToComplete, // WAITING TS_WAIT blocked waiting for GC
- kWaitingPerformingGc, // WAITING TS_WAIT performing GC
- kWaitingForDebuggerSend, // WAITING TS_WAIT blocked waiting for events to be sent
- kWaitingForDebuggerToAttach, // WAITING TS_WAIT blocked waiting for debugger to attach
- kWaitingInMainDebuggerLoop, // WAITING TS_WAIT blocking/reading/processing debugger events
- kWaitingForDebuggerSuspension, // WAITING TS_WAIT waiting for debugger suspend all
- kWaitingForJniOnLoad, // WAITING TS_WAIT waiting for execution of dlopen and JNI on load code
- kWaitingForSignalCatcherOutput, // WAITING TS_WAIT waiting for signal catcher IO to complete
- kWaitingInMainSignalCatcherLoop, // WAITING TS_WAIT blocking/reading/processing signals
- kStarting, // NEW TS_WAIT native thread started, not yet ready to run managed code
- kNative, // RUNNABLE TS_RUNNING running in a JNI native method
- kSuspended, // RUNNABLE TS_RUNNING suspended by GC or debugger
-};
-
enum ThreadFlag {
kSuspendRequest = 1, // If set implies that suspend_count_ > 0 and the Thread should enter the
// safepoint handler.
@@ -127,7 +108,8 @@
return reinterpret_cast<Thread*>(thread);
}
- static Thread* FromManagedThread(const ScopedObjectAccessUnchecked& ts, Object* thread_peer)
+ static Thread* FromManagedThread(const ScopedObjectAccessUnchecked& ts,
+ mirror::Object* thread_peer)
EXCLUSIVE_LOCKS_REQUIRED(Locks::thread_list_lock_)
LOCKS_EXCLUDED(Locks::thread_suspend_count_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -245,7 +227,7 @@
return daemon_;
}
- bool HoldsLock(Object*);
+ bool HoldsLock(mirror::Object*);
/*
* Changes the priority of this thread to match that of the java.lang.Thread object.
@@ -272,7 +254,7 @@
}
// Returns the java.lang.Thread's name, or NULL if this Thread* doesn't have a peer.
- String* GetThreadName(const ScopedObjectAccessUnchecked& ts) const
+ mirror::String* GetThreadName(const ScopedObjectAccessUnchecked& ts) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Sets 'name' to the java.lang.Thread's name. This requires no transition to managed code,
@@ -282,7 +264,7 @@
// Sets the thread's name.
void SetThreadName(const char* name) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Object* GetPeer() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ mirror::Object* GetPeer() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
CHECK(jpeer_ == NULL);
return opeer_;
}
@@ -301,13 +283,13 @@
return exception_ != NULL;
}
- Throwable* GetException() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ mirror::Throwable* GetException() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return exception_;
}
void AssertNoPendingException() const;
- void SetException(Throwable* new_exception) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ void SetException(mirror::Throwable* new_exception) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
CHECK(new_exception != NULL);
// TODO: DCHECK(!IsExceptionPending());
exception_ = new_exception;
@@ -317,7 +299,7 @@
exception_ = NULL;
}
- void DeliverException(Throwable* exception) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ void DeliverException(mirror::Throwable* exception) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (exception == NULL) {
ThrowNewException("Ljava/lang/NullPointerException;", "throw with null exception");
} else {
@@ -334,11 +316,11 @@
long_jump_context_ = context;
}
- AbstractMethod* GetCurrentMethod(uint32_t* dex_pc = NULL, size_t* frame_id = NULL) const
+ mirror::AbstractMethod* GetCurrentMethod(uint32_t* dex_pc = NULL, size_t* frame_id = NULL) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void SetTopOfStack(void* stack, uintptr_t pc) {
- AbstractMethod** top_method = reinterpret_cast<AbstractMethod**>(stack);
+ mirror::AbstractMethod** top_method = reinterpret_cast<mirror::AbstractMethod**>(stack);
managed_stack_.SetTopQuickFrame(top_method);
managed_stack_.SetTopQuickFramePc(pc);
}
@@ -369,7 +351,7 @@
//QuickFrameIterator FindExceptionHandler(void* throw_pc, void** handler_pc);
- void* FindExceptionHandlerInMethod(const AbstractMethod* method,
+ void* FindExceptionHandlerInMethod(const mirror::AbstractMethod* method,
void* throw_pc,
const DexFile& dex_file,
ClassLinker* class_linker);
@@ -384,7 +366,7 @@
}
// Convert a jobject into a Object*
- Object* DecodeJObject(jobject obj) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ mirror::Object* DecodeJObject(jobject obj) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Implements java.lang.Thread.interrupted.
bool Interrupted();
@@ -393,11 +375,11 @@
void Interrupt();
void Notify();
- ClassLoader* GetClassLoaderOverride() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ mirror::ClassLoader* GetClassLoaderOverride() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return class_loader_override_;
}
- void SetClassLoaderOverride(ClassLoader* class_loader_override) {
+ void SetClassLoaderOverride(mirror::ClassLoader* class_loader_override) {
class_loader_override_ = class_loader_override;
}
@@ -413,10 +395,10 @@
static jobjectArray InternalStackTraceToStackTraceElementArray(JNIEnv* env, jobject internal,
jobjectArray output_array = NULL, int* stack_depth = NULL);
- void VisitRoots(Heap::RootVisitor* visitor, void* arg)
+ void VisitRoots(RootVisitor* visitor, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void VerifyRoots(Heap::VerifyRootVisitor* visitor, void* arg)
+ void VerifyRoots(VerifyRootVisitor* visitor, void* arg)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
#if VERIFY_OBJECT_ENABLED
@@ -535,7 +517,7 @@
// Is the given obj in this thread's stack indirect reference table?
bool SirtContains(jobject obj) const;
- void SirtVisitRoots(Heap::RootVisitor* visitor, void* arg);
+ void SirtVisitRoots(RootVisitor* visitor, void* arg);
void PushSirt(StackIndirectReferenceTable* sirt) {
sirt->SetLink(top_sirt_);
@@ -692,7 +674,7 @@
byte* card_table_;
// The pending exception or NULL.
- Throwable* exception_;
+ mirror::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.
@@ -711,7 +693,7 @@
// Our managed peer (an instance of java.lang.Thread). The jobject version is used during thread
// start up, until the thread is registered and the local opeer_ is used.
- Object* opeer_;
+ mirror::Object* opeer_;
jobject jpeer_;
// The "lowest addressable byte" of the stack
@@ -740,7 +722,7 @@
// The next thread in the wait set this thread is part of.
Thread* wait_next_;
// If we're blocked in MonitorEnter, this is the object we're trying to lock.
- Object* monitor_enter_object_;
+ mirror::Object* monitor_enter_object_;
friend class Monitor;
friend class MonitorInfo;
@@ -754,7 +736,7 @@
// Needed to get the right ClassLoader in JNI_OnLoad, but also
// useful for testing.
- ClassLoader* class_loader_override_;
+ mirror::ClassLoader* class_loader_override_;
// Thread local, lazily allocated, long jump context. Used to deliver exceptions.
Context* long_jump_context_;
diff --git a/src/thread_list.cc b/src/thread_list.cc
index 13c965c..ea8baac 100644
--- a/src/thread_list.cc
+++ b/src/thread_list.cc
@@ -22,6 +22,7 @@
#include "base/mutex.h"
#include "debugger.h"
+#include "thread.h"
#include "timing_logger.h"
#include "utils.h"
@@ -579,14 +580,14 @@
}
}
-void ThreadList::VisitRoots(Heap::RootVisitor* visitor, void* arg) const {
+void ThreadList::VisitRoots(RootVisitor* visitor, void* arg) const {
MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
(*it)->VisitRoots(visitor, arg);
}
}
-void ThreadList::VerifyRoots(Heap::VerifyRootVisitor* visitor, void* arg) const {
+void ThreadList::VerifyRoots(VerifyRootVisitor* visitor, void* arg) const {
MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
(*it)->VerifyRoots(visitor, arg);
diff --git a/src/thread_list.h b/src/thread_list.h
index 7ded5e3..0470cfc 100644
--- a/src/thread_list.h
+++ b/src/thread_list.h
@@ -18,10 +18,14 @@
#define ART_SRC_THREAD_LIST_H_
#include "base/mutex.h"
-#include "thread.h"
+#include "root_visitor.h"
+
+#include <bitset>
+#include <list>
namespace art {
-
+class Closure;
+class Thread;
class TimingLogger;
class ThreadList {
@@ -84,10 +88,10 @@
LOCKS_EXCLUDED(Locks::mutator_lock_, Locks::thread_list_lock_);
void Unregister(Thread* self) LOCKS_EXCLUDED(Locks::mutator_lock_, Locks::thread_list_lock_);
- void VisitRoots(Heap::RootVisitor* visitor, void* arg) const
+ void VisitRoots(RootVisitor* visitor, void* arg) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void VerifyRoots(Heap::VerifyRootVisitor* visitor, void* arg) const
+ void VerifyRoots(VerifyRootVisitor* visitor, void* arg) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Return a copy of the thread list.
diff --git a/src/thread_state.h b/src/thread_state.h
new file mode 100644
index 0000000..7c4a16f
--- /dev/null
+++ b/src/thread_state.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2013 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_THREAD_STATE_H_
+#define ART_SRC_THREAD_STATE_H_
+
+namespace art {
+
+enum ThreadState {
+ // Thread.State JDWP state
+ kTerminated, // TERMINATED TS_ZOMBIE Thread.run has returned, but Thread* still around
+ kRunnable, // RUNNABLE TS_RUNNING runnable
+ kTimedWaiting, // TIMED_WAITING TS_WAIT in Object.wait() with a timeout
+ kSleeping, // TIMED_WAITING TS_SLEEPING in Thread.sleep()
+ kBlocked, // BLOCKED TS_MONITOR blocked on a monitor
+ kWaiting, // WAITING TS_WAIT in Object.wait()
+ kWaitingForGcToComplete, // WAITING TS_WAIT blocked waiting for GC
+ kWaitingPerformingGc, // WAITING TS_WAIT performing GC
+ kWaitingForDebuggerSend, // WAITING TS_WAIT blocked waiting for events to be sent
+ kWaitingForDebuggerToAttach, // WAITING TS_WAIT blocked waiting for debugger to attach
+ kWaitingInMainDebuggerLoop, // WAITING TS_WAIT blocking/reading/processing debugger events
+ kWaitingForDebuggerSuspension, // WAITING TS_WAIT waiting for debugger suspend all
+ kWaitingForJniOnLoad, // WAITING TS_WAIT waiting for execution of dlopen and JNI on load code
+ kWaitingForSignalCatcherOutput, // WAITING TS_WAIT waiting for signal catcher IO to complete
+ kWaitingInMainSignalCatcherLoop, // WAITING TS_WAIT blocking/reading/processing signals
+ kStarting, // NEW TS_WAIT native thread started, not yet ready to run managed code
+ kNative, // RUNNABLE TS_RUNNING running in a JNI native method
+ kSuspended, // RUNNABLE TS_RUNNING suspended by GC or debugger
+};
+
+} // namespace art
+
+#endif // ART_SRC_THREAD_STATE_H_
diff --git a/src/timing_logger.cc b/src/timing_logger.cc
new file mode 100644
index 0000000..fee7a30
--- /dev/null
+++ b/src/timing_logger.cc
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+#include "timing_logger.h"
+
+#include "base/logging.h"
+#include "utils.h"
+
+#include <cmath>
+#include <iomanip>
+
+namespace art {
+
+void TimingLogger::Dump() const {
+ Dump(LOG(INFO));
+}
+
+void TimingLogger::Dump(std::ostream& os) const {
+ uint64_t largest_time = 0;
+ os << name_ << ": begin\n";
+ for (size_t i = 1; i < times_.size(); ++i) {
+ uint64_t delta_time = times_[i] - times_[i - 1];
+ largest_time = std::max(largest_time, delta_time);
+ }
+ // Compute which type of unit we will use for printing the timings.
+ TimeUnit tu = GetAppropriateTimeUnit(largest_time);
+ uint64_t divisor = GetNsToTimeUnitDivisor(tu);
+ for (size_t i = 1; i < times_.size(); ++i) {
+ uint64_t delta_time = times_[i] - times_[i - 1];
+ if (!precise_ && divisor >= 1000) {
+ // Make the fraction 0.
+ delta_time -= delta_time % (divisor / 1000);
+ }
+ os << name_ << ": " << std::setw(8) << FormatDuration(delta_time, tu) << " " << labels_[i]
+ << "\n";
+ }
+ os << name_ << ": end, " << NsToMs(GetTotalNs()) << " ms\n";
+}
+
+void CumulativeLogger::Dump() const {
+ Dump(LOG(INFO));
+}
+
+void CumulativeLogger::Dump(std::ostream& os) const {
+ os << name_ << ": iterations " << iterations_ << " begin\n";
+ //Find which unit we will use for the timing logger.
+ uint64_t largest_mean = 0;
+ for (size_t i = 0; i < times_.size(); ++i) {
+ // Convert back to nanoseconds from microseconds.
+ uint64_t mean = times_[i] / iterations_;
+ largest_mean = std::max(largest_mean, mean);
+ }
+ // Convert largest mean back to ns
+ TimeUnit tu = GetAppropriateTimeUnit(largest_mean * kAdjust);
+ uint64_t divisor = GetNsToTimeUnitDivisor(tu);
+ for (size_t i = 0; i < times_.size(); ++i) {
+ uint64_t mean_x2 = times_squared_[i] / iterations_;
+ uint64_t mean = times_[i] / iterations_;
+ uint64_t variance = mean_x2 - (mean * mean);
+ uint64_t std_dev = static_cast<uint64_t>(std::sqrt(static_cast<double>(variance)));
+ if (!precise_ && divisor >= 1000) {
+ // Make the fraction 0.
+ mean -= mean % (divisor / 1000);
+ std_dev -= std_dev % (divisor / 1000);
+ }
+ os << StringPrintf("%s: %10s (std_dev %8s) %s\n",
+ name_.c_str(),
+ FormatDuration(mean * kAdjust, tu).c_str(),
+ FormatDuration(std_dev * kAdjust, tu).c_str(),
+ labels_[i].c_str());
+ }
+ uint64_t total_mean_x2 = total_time_squared_;
+ uint64_t mean_total_ns = GetTotalTime();
+ if (iterations_ != 0) {
+ total_mean_x2 /= iterations_;
+ mean_total_ns /= iterations_;
+ }
+ uint64_t total_variance = total_mean_x2 - (mean_total_ns * mean_total_ns);
+ uint64_t total_std_dev = static_cast<uint64_t>(
+ std::sqrt(static_cast<double>(total_variance)));
+ os << name_ << ": end, mean " << PrettyDuration(mean_total_ns * kAdjust)
+ << " std_dev " << PrettyDuration(total_std_dev * kAdjust) << "\n";
+}
+
+} // namespace art
diff --git a/src/timing_logger.h b/src/timing_logger.h
index 3b3dcfc..fc47028 100644
--- a/src/timing_logger.h
+++ b/src/timing_logger.h
@@ -17,10 +17,8 @@
#ifndef ART_SRC_TIMING_LOGGER_H_
#define ART_SRC_TIMING_LOGGER_H_
-#include "base/logging.h"
-#include "utils.h"
+#include "utils.h" // For NanoTime.
-#include <cmath>
#include <stdint.h>
#include <string>
#include <vector>
@@ -47,31 +45,9 @@
labels_.push_back(label);
}
- void Dump() const {
- Dump(LOG(INFO));
- }
+ void Dump() const;
- void Dump(std::ostream& os) const {
- uint64_t largest_time = 0;
- os << name_ << ": begin\n";
- for (size_t i = 1; i < times_.size(); ++i) {
- uint64_t delta_time = times_[i] - times_[i - 1];
- largest_time = std::max(largest_time, delta_time);
- }
- // Compute which type of unit we will use for printing the timings.
- TimeUnit tu = GetAppropriateTimeUnit(largest_time);
- uint64_t divisor = GetNsToTimeUnitDivisor(tu);
- for (size_t i = 1; i < times_.size(); ++i) {
- uint64_t delta_time = times_[i] - times_[i - 1];
- if (!precise_ && divisor >= 1000) {
- // Make the fraction 0.
- delta_time -= delta_time % (divisor / 1000);
- }
- os << name_ << ": " << std::setw(8) << FormatDuration(delta_time, tu) << " " << labels_[i]
- << "\n";
- }
- os << name_ << ": end, " << NsToMs(GetTotalNs()) << " ms\n";
- }
+ void Dump(std::ostream& os) const;
uint64_t GetTotalNs() const {
return times_.back() - times_.front();
@@ -149,50 +125,9 @@
total_time_squared_ += total_time * total_time;
}
- void Dump() const {
- Dump(LOG(INFO));
- }
+ void Dump() const;
- void Dump(std::ostream& os) const {
- os << name_ << ": iterations " << iterations_ << " begin\n";
- //Find which unit we will use for the timing logger.
- uint64_t largest_mean = 0;
- for (size_t i = 0; i < times_.size(); ++i) {
- // Convert back to nanoseconds from microseconds.
- uint64_t mean = times_[i] / iterations_;
- largest_mean = std::max(largest_mean, mean);
- }
- // Convert largest mean back to ns
- TimeUnit tu = GetAppropriateTimeUnit(largest_mean * kAdjust);
- uint64_t divisor = GetNsToTimeUnitDivisor(tu);
- for (size_t i = 0; i < times_.size(); ++i) {
- uint64_t mean_x2 = times_squared_[i] / iterations_;
- uint64_t mean = times_[i] / iterations_;
- uint64_t variance = mean_x2 - (mean * mean);
- uint64_t std_dev = static_cast<uint64_t>(std::sqrt(static_cast<double>(variance)));
- if (!precise_ && divisor >= 1000) {
- // Make the fraction 0.
- mean -= mean % (divisor / 1000);
- std_dev -= std_dev % (divisor / 1000);
- }
- os << StringPrintf("%s: %10s (std_dev %8s) %s\n",
- name_.c_str(),
- FormatDuration(mean * kAdjust, tu).c_str(),
- FormatDuration(std_dev * kAdjust, tu).c_str(),
- labels_[i].c_str());
- }
- uint64_t total_mean_x2 = total_time_squared_;
- uint64_t mean_total_ns = GetTotalTime();
- if (iterations_ != 0) {
- total_mean_x2 /= iterations_;
- mean_total_ns /= iterations_;
- }
- uint64_t total_variance = total_mean_x2 - (mean_total_ns * mean_total_ns);
- uint64_t total_std_dev = static_cast<uint64_t>(
- std::sqrt(static_cast<double>(total_variance)));
- os << name_ << ": end, mean " << PrettyDuration(mean_total_ns * kAdjust)
- << " std_dev " << PrettyDuration(total_std_dev * kAdjust) << "\n";
- }
+ void Dump(std::ostream& os) const;
uint64_t GetTotalNs() const {
return GetTotalTime() * kAdjust;
diff --git a/src/trace.cc b/src/trace.cc
index 7b3cea8..a23d202 100644
--- a/src/trace.cc
+++ b/src/trace.cc
@@ -21,8 +21,10 @@
#include "base/unix_file/fd_file.h"
#include "class_linker.h"
#include "debugger.h"
-#include "dex_cache.h"
#include "instrumentation.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/dex_cache.h"
+#include "mirror/object_array-inl.h"
#if !defined(ART_USE_LLVM_COMPILER)
#include "oat/runtime/oat_support_entrypoints.h"
#endif
@@ -322,7 +324,8 @@
}
}
-void Trace::LogMethodTraceEvent(Thread* self, const AbstractMethod* method, Trace::TraceEvent event) {
+void Trace::LogMethodTraceEvent(Thread* self, const mirror::AbstractMethod* method,
+ Trace::TraceEvent event) {
if (thread_clock_base_map_.find(self) == thread_clock_base_map_.end()) {
uint64_t time = ThreadCpuMicroTime();
thread_clock_base_map_.Put(self, time);
@@ -367,16 +370,17 @@
while (ptr < end) {
uint32_t method_value = ptr[2] | (ptr[3] << 8) | (ptr[4] << 16) | (ptr[5] << 24);
- AbstractMethod* method = reinterpret_cast<AbstractMethod*>(TraceMethodId(method_value));
+ mirror::AbstractMethod* method =
+ reinterpret_cast<mirror::AbstractMethod*>(TraceMethodId(method_value));
visited_methods_.insert(method);
ptr += record_size_;
}
}
void Trace::DumpMethodList(std::ostream& os) {
- typedef std::set<const AbstractMethod*>::const_iterator It; // TODO: C++0x auto
+ typedef std::set<const mirror::AbstractMethod*>::const_iterator It; // TODO: C++0x auto
for (It it = visited_methods_.begin(); it != visited_methods_.end(); ++it) {
- const AbstractMethod* method = *it;
+ const mirror::AbstractMethod* method = *it;
MethodHelper mh(method);
os << StringPrintf("%p\t%s\t%s\t%s\t%s\n", method,
PrettyDescriptor(mh.GetDeclaringClassDescriptor()).c_str(), mh.GetName(),
diff --git a/src/trace.h b/src/trace.h
index e3f254e..1be1cc4 100644
--- a/src/trace.h
+++ b/src/trace.h
@@ -29,7 +29,9 @@
namespace art {
+namespace mirror {
class AbstractMethod;
+} // namespace mirror
class Thread;
enum ProfilerClockSource {
@@ -59,7 +61,7 @@
bool UseWallClock();
bool UseThreadCpuClock();
- void LogMethodTraceEvent(Thread* self, const AbstractMethod* method, TraceEvent event);
+ void LogMethodTraceEvent(Thread* self, const mirror::AbstractMethod* method, TraceEvent event);
private:
explicit Trace(File* trace_file, int buffer_size, int flags);
@@ -73,7 +75,7 @@
void DumpThreadList(std::ostream& os) LOCKS_EXCLUDED(Locks::thread_list_lock_);
// Set of methods visited by the profiler.
- std::set<const AbstractMethod*> visited_methods_;
+ std::set<const mirror::AbstractMethod*> visited_methods_;
// Maps a thread to its clock base.
SafeMap<Thread*, uint64_t> thread_clock_base_map_;
diff --git a/src/utf.cc b/src/utf.cc
index 174fe22..cc7e262 100644
--- a/src/utf.cc
+++ b/src/utf.cc
@@ -17,7 +17,7 @@
#include "utf.h"
#include "base/logging.h"
-#include "object.h"
+#include "mirror/array.h"
namespace art {
@@ -66,7 +66,7 @@
}
}
-int32_t ComputeUtf16Hash(const CharArray* chars, int32_t offset,
+int32_t ComputeUtf16Hash(const mirror::CharArray* chars, int32_t offset,
size_t char_count) {
int32_t hash = 0;
for (size_t i = 0; i < char_count; i++) {
diff --git a/src/utf.h b/src/utf.h
index e95289e..44899bf 100644
--- a/src/utf.h
+++ b/src/utf.h
@@ -29,9 +29,10 @@
* See http://en.wikipedia.org/wiki/UTF-8#Modified_UTF-8 for the details.
*/
namespace art {
-
+namespace mirror {
template<class T> class PrimitiveArray;
typedef PrimitiveArray<uint16_t> CharArray;
+} // namespace mirror
/*
* Returns the number of UTF-16 characters in the given modified UTF-8 string.
@@ -65,7 +66,7 @@
/*
* The java.lang.String hashCode() algorithm.
*/
-int32_t ComputeUtf16Hash(const CharArray* chars, int32_t offset, size_t char_count)
+int32_t ComputeUtf16Hash(const mirror::CharArray* chars, int32_t offset, size_t char_count)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
int32_t ComputeUtf16Hash(const uint16_t* chars, size_t char_count);
diff --git a/src/utils.cc b/src/utils.cc
index e2231c2..6b93da8 100644
--- a/src/utils.cc
+++ b/src/utils.cc
@@ -25,10 +25,17 @@
#include "UniquePtr.h"
#include "base/unix_file/fd_file.h"
-#include "class_loader.h"
-#include "object.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/class.h"
+#include "mirror/class_loader.h"
+#include "mirror/field.h"
+#include "mirror/field-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
+#include "mirror/string.h"
#include "object_utils.h"
#include "os.h"
+#include "utf.h"
#if !defined(HAVE_POSIX_CLOCKS)
#include <sys/time.h>
@@ -220,14 +227,14 @@
}
}
-std::string PrettyDescriptor(const String* java_descriptor) {
+std::string PrettyDescriptor(const mirror::String* java_descriptor) {
if (java_descriptor == NULL) {
return "null";
}
return PrettyDescriptor(java_descriptor->ToModifiedUtf8());
}
-std::string PrettyDescriptor(const Class* klass) {
+std::string PrettyDescriptor(const mirror::Class* klass) {
if (klass == NULL) {
return "null";
}
@@ -288,7 +295,7 @@
return PrettyDescriptor(descriptor_string);
}
-std::string PrettyField(const Field* f, bool with_type) {
+std::string PrettyField(const mirror::Field* f, bool with_type) {
if (f == NULL) {
return "null";
}
@@ -357,7 +364,7 @@
return PrettyDescriptor(return_type);
}
-std::string PrettyMethod(const AbstractMethod* m, bool with_signature) {
+std::string PrettyMethod(const mirror::AbstractMethod* m, bool with_signature) {
if (m == NULL) {
return "null";
}
@@ -390,7 +397,7 @@
return result;
}
-std::string PrettyTypeOf(const Object* obj) {
+std::string PrettyTypeOf(const mirror::Object* obj) {
if (obj == NULL) {
return "null";
}
@@ -406,7 +413,7 @@
return result;
}
-std::string PrettyClass(const Class* c) {
+std::string PrettyClass(const mirror::Class* c) {
if (c == NULL) {
return "null";
}
@@ -417,7 +424,7 @@
return result;
}
-std::string PrettyClassAndClassLoader(const Class* c) {
+std::string PrettyClassAndClassLoader(const mirror::Class* c) {
if (c == NULL) {
return "null";
}
@@ -613,7 +620,7 @@
return descriptor;
}
-std::string JniShortName(const AbstractMethod* m) {
+std::string JniShortName(const mirror::AbstractMethod* m) {
MethodHelper mh(m);
std::string class_name(mh.GetDeclaringClassDescriptor());
// Remove the leading 'L' and trailing ';'...
@@ -632,7 +639,7 @@
return short_name;
}
-std::string JniLongName(const AbstractMethod* m) {
+std::string JniLongName(const mirror::AbstractMethod* m) {
std::string long_name;
long_name += JniShortName(m);
long_name += "__";
diff --git a/src/utils.h b/src/utils.h
index 640743c..f3c9b7a 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -30,12 +30,15 @@
namespace art {
-class Class;
class DexFile;
+
+namespace mirror {
+class Class;
class Field;
class AbstractMethod;
class Object;
class String;
+} // namespace mirror
enum TimeUnit {
kTimeUnitNanosecond,
@@ -172,21 +175,21 @@
// Returns a human-readable equivalent of 'descriptor'. So "I" would be "int",
// "[[I" would be "int[][]", "[Ljava/lang/String;" would be
// "java.lang.String[]", and so forth.
-std::string PrettyDescriptor(const String* descriptor);
+std::string PrettyDescriptor(const mirror::String* descriptor);
std::string PrettyDescriptor(const std::string& descriptor);
std::string PrettyDescriptor(Primitive::Type type);
-std::string PrettyDescriptor(const Class* klass)
+std::string PrettyDescriptor(const mirror::Class* klass)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Returns a human-readable signature for 'f'. Something like "a.b.C.f" or
// "int a.b.C.f" (depending on the value of 'with_type').
-std::string PrettyField(const Field* f, bool with_type = true)
+std::string PrettyField(const mirror::Field* f, bool with_type = true)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
std::string PrettyField(uint32_t field_idx, const DexFile& dex_file, bool with_type = true);
// Returns a human-readable signature for 'm'. Something like "a.b.C.m" or
// "a.b.C.m(II)V" (depending on the value of 'with_signature').
-std::string PrettyMethod(const AbstractMethod* m, bool with_signature = true)
+std::string PrettyMethod(const mirror::AbstractMethod* m, bool with_signature = true)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
std::string PrettyMethod(uint32_t method_idx, const DexFile& dex_file, bool with_signature = true);
@@ -194,7 +197,7 @@
// So given an instance of java.lang.String, the output would
// be "java.lang.String". Given an array of int, the output would be "int[]".
// Given String.class, the output would be "java.lang.Class<java.lang.String>".
-std::string PrettyTypeOf(const Object* obj)
+std::string PrettyTypeOf(const mirror::Object* obj)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Returns a human-readable form of the type at an index in the specified dex file.
@@ -203,11 +206,11 @@
// Returns a human-readable form of the name of the given class.
// Given String.class, the output would be "java.lang.Class<java.lang.String>".
-std::string PrettyClass(const Class* c)
+std::string PrettyClass(const mirror::Class* c)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Returns a human-readable form of the name of the given class with its class loader.
-std::string PrettyClassAndClassLoader(const Class* c)
+std::string PrettyClassAndClassLoader(const mirror::Class* c)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Returns a human-readable size string such as "1MB".
@@ -250,10 +253,10 @@
bool IsValidMemberName(const char* s);
// Returns the JNI native function name for the non-overloaded method 'm'.
-std::string JniShortName(const AbstractMethod* m)
+std::string JniShortName(const mirror::AbstractMethod* m)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Returns the JNI native function name for the overloaded method 'm'.
-std::string JniLongName(const AbstractMethod* m)
+std::string JniLongName(const mirror::AbstractMethod* m)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
bool ReadFileToString(const std::string& file_name, std::string* result);
diff --git a/src/utils_test.cc b/src/utils_test.cc
index f1983be..0966e71 100644
--- a/src/utils_test.cc
+++ b/src/utils_test.cc
@@ -14,8 +14,12 @@
* limitations under the License.
*/
-#include "object.h"
#include "common_test.h"
+#include "mirror/array.h"
+#include "mirror/array-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
+#include "mirror/string.h"
#include "scoped_thread_state_change.h"
#include "sirt_ref.h"
#include "utils.h"
@@ -89,15 +93,15 @@
ScopedObjectAccess soa(Thread::Current());
EXPECT_EQ("null", PrettyTypeOf(NULL));
- SirtRef<String> s(soa.Self(), String::AllocFromModifiedUtf8(soa.Self(), ""));
+ SirtRef<mirror::String> s(soa.Self(), mirror::String::AllocFromModifiedUtf8(soa.Self(), ""));
EXPECT_EQ("java.lang.String", PrettyTypeOf(s.get()));
- SirtRef<ShortArray> a(soa.Self(), ShortArray::Alloc(soa.Self(), 2));
+ SirtRef<mirror::ShortArray> a(soa.Self(), mirror::ShortArray::Alloc(soa.Self(), 2));
EXPECT_EQ("short[]", PrettyTypeOf(a.get()));
- Class* c = class_linker_->FindSystemClass("[Ljava/lang/String;");
+ mirror::Class* c = class_linker_->FindSystemClass("[Ljava/lang/String;");
ASSERT_TRUE(c != NULL);
- Object* o = ObjectArray<String>::Alloc(soa.Self(), c, 0);
+ mirror::Object* o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0);
EXPECT_EQ("java.lang.String[]", PrettyTypeOf(o));
EXPECT_EQ("java.lang.Class<java.lang.String[]>", PrettyTypeOf(o->GetClass()));
}
@@ -105,18 +109,18 @@
TEST_F(UtilsTest, PrettyClass) {
ScopedObjectAccess soa(Thread::Current());
EXPECT_EQ("null", PrettyClass(NULL));
- Class* c = class_linker_->FindSystemClass("[Ljava/lang/String;");
+ mirror::Class* c = class_linker_->FindSystemClass("[Ljava/lang/String;");
ASSERT_TRUE(c != NULL);
- Object* o = ObjectArray<String>::Alloc(soa.Self(), c, 0);
+ mirror::Object* o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0);
EXPECT_EQ("java.lang.Class<java.lang.String[]>", PrettyClass(o->GetClass()));
}
TEST_F(UtilsTest, PrettyClassAndClassLoader) {
ScopedObjectAccess soa(Thread::Current());
EXPECT_EQ("null", PrettyClassAndClassLoader(NULL));
- Class* c = class_linker_->FindSystemClass("[Ljava/lang/String;");
+ mirror::Class* c = class_linker_->FindSystemClass("[Ljava/lang/String;");
ASSERT_TRUE(c != NULL);
- Object* o = ObjectArray<String>::Alloc(soa.Self(), c, 0);
+ mirror::Object* o = mirror::ObjectArray<mirror::String>::Alloc(soa.Self(), c, 0);
EXPECT_EQ("java.lang.Class<java.lang.String[],null>", PrettyClassAndClassLoader(o->GetClass()));
}
@@ -124,9 +128,9 @@
ScopedObjectAccess soa(Thread::Current());
EXPECT_EQ("null", PrettyField(NULL));
- Class* java_lang_String = class_linker_->FindSystemClass("Ljava/lang/String;");
+ mirror::Class* java_lang_String = class_linker_->FindSystemClass("Ljava/lang/String;");
- Field* f;
+ mirror::Field* f;
f = java_lang_String->FindDeclaredInstanceField("count", "I");
EXPECT_EQ("int java.lang.String.count", PrettyField(f));
EXPECT_EQ("java.lang.String.count", PrettyField(f, false));
@@ -193,9 +197,9 @@
TEST_F(UtilsTest, JniShortName_JniLongName) {
ScopedObjectAccess soa(Thread::Current());
- Class* c = class_linker_->FindSystemClass("Ljava/lang/String;");
+ mirror::Class* c = class_linker_->FindSystemClass("Ljava/lang/String;");
ASSERT_TRUE(c != NULL);
- AbstractMethod* m;
+ mirror::AbstractMethod* m;
m = c->FindVirtualMethod("charAt", "(I)C");
ASSERT_TRUE(m != NULL);
diff --git a/src/verifier/method_verifier.cc b/src/verifier/method_verifier.cc
index 7afa6d4..bcac374 100644
--- a/src/verifier/method_verifier.cc
+++ b/src/verifier/method_verifier.cc
@@ -22,13 +22,20 @@
#include "base/stringpiece.h"
#include "class_linker.h"
#include "compiler.h"
-#include "dex_cache.h"
#include "dex_file.h"
#include "dex_instruction.h"
#include "dex_instruction_visitor.h"
+#include "gc/card_table-inl.h"
#include "indenter.h"
#include "intern_table.h"
#include "leb128.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/class.h"
+#include "mirror/class-inl.h"
+#include "mirror/dex_cache.h"
+#include "mirror/field-inl.h"
+#include "mirror/object-inl.h"
+#include "mirror/object_array-inl.h"
#include "object_utils.h"
#include "runtime.h"
#include "verifier/dex_gc_map.h"
@@ -167,11 +174,12 @@
}
}
-MethodVerifier::FailureKind MethodVerifier::VerifyClass(const Class* klass, std::string& error) {
+MethodVerifier::FailureKind MethodVerifier::VerifyClass(const mirror::Class* klass,
+ std::string& error) {
if (klass->IsVerified()) {
return kNoFailure;
}
- Class* super = klass->GetSuperClass();
+ mirror::Class* super = klass->GetSuperClass();
if (super == NULL && StringPiece(ClassHelper(klass).GetDescriptor()) != "Ljava/lang/Object;") {
error = "Verifier rejected class ";
error += PrettyDescriptor(klass);
@@ -199,7 +207,10 @@
}
MethodVerifier::FailureKind MethodVerifier::VerifyClass(const DexFile* dex_file,
- DexCache* dex_cache, ClassLoader* class_loader, uint32_t class_def_idx, std::string& error) {
+ mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader,
+ uint32_t class_def_idx,
+ std::string& error) {
const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_idx);
const byte* class_data = dex_file->GetClassData(class_def);
if (class_data == NULL) {
@@ -224,7 +235,8 @@
}
previous_direct_method_idx = method_idx;
InvokeType type = it.GetMethodInvokeType(class_def);
- AbstractMethod* method = linker->ResolveMethod(*dex_file, method_idx, dex_cache, class_loader, NULL, type);
+ mirror::AbstractMethod* method =
+ linker->ResolveMethod(*dex_file, method_idx, dex_cache, class_loader, NULL, type);
if (method == NULL) {
DCHECK(Thread::Current()->IsExceptionPending());
// We couldn't resolve the method, but continue regardless.
@@ -258,7 +270,8 @@
}
previous_virtual_method_idx = method_idx;
InvokeType type = it.GetMethodInvokeType(class_def);
- AbstractMethod* method = linker->ResolveMethod(*dex_file, method_idx, dex_cache, class_loader, NULL, type);
+ mirror::AbstractMethod* method =
+ linker->ResolveMethod(*dex_file, method_idx, dex_cache, class_loader, NULL, type);
if (method == NULL) {
DCHECK(Thread::Current()->IsExceptionPending());
// We couldn't resolve the method, but continue regardless.
@@ -288,9 +301,14 @@
}
}
-MethodVerifier::FailureKind MethodVerifier::VerifyMethod(uint32_t method_idx, const DexFile* dex_file,
- DexCache* dex_cache, ClassLoader* class_loader, uint32_t class_def_idx,
- const DexFile::CodeItem* code_item, AbstractMethod* method, uint32_t method_access_flags) {
+MethodVerifier::FailureKind MethodVerifier::VerifyMethod(uint32_t method_idx,
+ const DexFile* dex_file,
+ mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader,
+ uint32_t class_def_idx,
+ const DexFile::CodeItem* code_item,
+ mirror::AbstractMethod* method,
+ uint32_t method_access_flags) {
MethodVerifier::FailureKind result = kNoFailure;
uint64_t start_ns = NanoTime();
@@ -326,9 +344,10 @@
}
void MethodVerifier::VerifyMethodAndDump(std::ostream& os, uint32_t dex_method_idx,
- const DexFile* dex_file, DexCache* dex_cache,
- ClassLoader* class_loader, uint32_t class_def_idx,
- const DexFile::CodeItem* code_item, AbstractMethod* method,
+ const DexFile* dex_file, mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader, uint32_t class_def_idx,
+ const DexFile::CodeItem* code_item,
+ mirror::AbstractMethod* method,
uint32_t method_access_flags) {
MethodVerifier verifier(dex_file, dex_cache, class_loader, class_def_idx, code_item,
dex_method_idx, method, method_access_flags, true);
@@ -339,11 +358,12 @@
}
std::vector<int32_t> MethodVerifier::DescribeVRegs(uint32_t dex_method_idx,
- const DexFile* dex_file, DexCache* dex_cache,
- ClassLoader* class_loader,
+ const DexFile* dex_file,
+ mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader,
uint32_t class_def_idx,
const DexFile::CodeItem* code_item,
- AbstractMethod* method,
+ mirror::AbstractMethod* method,
uint32_t method_access_flags, uint32_t dex_pc) {
MethodVerifier verifier(dex_file, dex_cache, class_loader, class_def_idx, code_item,
dex_method_idx, method, method_access_flags, true);
@@ -351,9 +371,11 @@
return verifier.DescribeVRegs(dex_pc);
}
-MethodVerifier::MethodVerifier(const DexFile* dex_file, DexCache* dex_cache,
- ClassLoader* class_loader, uint32_t class_def_idx, const DexFile::CodeItem* code_item,
- uint32_t dex_method_idx, AbstractMethod* method, uint32_t method_access_flags,
+MethodVerifier::MethodVerifier(const DexFile* dex_file, mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader, uint32_t class_def_idx,
+ const DexFile::CodeItem* code_item,
+ uint32_t dex_method_idx, mirror::AbstractMethod* method,
+ uint32_t method_access_flags,
bool can_load_classes)
: reg_types_(can_load_classes),
work_insn_idx_(-1),
@@ -374,7 +396,7 @@
can_load_classes_(can_load_classes) {
}
-void MethodVerifier::FindLocksAtDexPc(AbstractMethod* m, uint32_t dex_pc,
+void MethodVerifier::FindLocksAtDexPc(mirror::AbstractMethod* m, uint32_t dex_pc,
std::vector<uint32_t>& monitor_enter_dex_pcs) {
MethodHelper mh(m);
MethodVerifier verifier(&mh.GetDexFile(), mh.GetDexCache(), mh.GetClassLoader(),
@@ -569,8 +591,9 @@
// Ensure exception types are resolved so that they don't need resolution to be delivered,
// unresolved exception types will be ignored by exception delivery
if (iterator.GetHandlerTypeIndex() != DexFile::kDexNoIndex16) {
- Class* exception_type = linker->ResolveType(*dex_file_, iterator.GetHandlerTypeIndex(),
- dex_cache_, class_loader_);
+ mirror::Class* exception_type = linker->ResolveType(*dex_file_,
+ iterator.GetHandlerTypeIndex(),
+ dex_cache_, class_loader_);
if (exception_type == NULL) {
DCHECK(Thread::Current()->IsExceptionPending());
Thread::Current()->ClearException();
@@ -1960,7 +1983,8 @@
dec_insn.opcode == Instruction::INVOKE_SUPER_RANGE);
bool is_super = (dec_insn.opcode == Instruction::INVOKE_SUPER ||
dec_insn.opcode == Instruction::INVOKE_SUPER_RANGE);
- AbstractMethod* called_method = VerifyInvocationArgs(dec_insn, METHOD_VIRTUAL, is_range, is_super);
+ mirror::AbstractMethod* called_method = VerifyInvocationArgs(dec_insn, METHOD_VIRTUAL,
+ is_range, is_super);
const char* descriptor;
if (called_method == NULL) {
uint32_t method_idx = dec_insn.vB;
@@ -1982,7 +2006,8 @@
case Instruction::INVOKE_DIRECT:
case Instruction::INVOKE_DIRECT_RANGE: {
bool is_range = (dec_insn.opcode == Instruction::INVOKE_DIRECT_RANGE);
- AbstractMethod* called_method = VerifyInvocationArgs(dec_insn, METHOD_DIRECT, is_range, false);
+ mirror::AbstractMethod* called_method = VerifyInvocationArgs(dec_insn, METHOD_DIRECT,
+ is_range, false);
const char* return_type_descriptor;
bool is_constructor;
if (called_method == NULL) {
@@ -2048,7 +2073,7 @@
case Instruction::INVOKE_STATIC:
case Instruction::INVOKE_STATIC_RANGE: {
bool is_range = (dec_insn.opcode == Instruction::INVOKE_STATIC_RANGE);
- AbstractMethod* called_method = VerifyInvocationArgs(dec_insn, METHOD_STATIC, is_range, false);
+ mirror::AbstractMethod* called_method = VerifyInvocationArgs(dec_insn, METHOD_STATIC, is_range, false);
const char* descriptor;
if (called_method == NULL) {
uint32_t method_idx = dec_insn.vB;
@@ -2070,9 +2095,9 @@
case Instruction::INVOKE_INTERFACE:
case Instruction::INVOKE_INTERFACE_RANGE: {
bool is_range = (dec_insn.opcode == Instruction::INVOKE_INTERFACE_RANGE);
- AbstractMethod* abs_method = VerifyInvocationArgs(dec_insn, METHOD_INTERFACE, is_range, false);
+ mirror::AbstractMethod* abs_method = VerifyInvocationArgs(dec_insn, METHOD_INTERFACE, is_range, false);
if (abs_method != NULL) {
- Class* called_interface = abs_method->GetDeclaringClass();
+ mirror::Class* called_interface = abs_method->GetDeclaringClass();
if (!called_interface->IsInterface() && !called_interface->IsObjectClass()) {
Fail(VERIFY_ERROR_CLASS_CHANGE) << "expected interface class in invoke-interface '"
<< PrettyMethod(abs_method) << "'";
@@ -2558,7 +2583,7 @@
const RegType& MethodVerifier::ResolveClassAndCheckAccess(uint32_t class_idx) {
const char* descriptor = dex_file_->StringByTypeIdx(class_idx);
const RegType& referrer = GetDeclaringClass();
- Class* klass = dex_cache_->GetResolvedType(class_idx);
+ mirror::Class* klass = dex_cache_->GetResolvedType(class_idx);
const RegType& result =
klass != NULL ? reg_types_.FromClass(klass, klass->IsFinal())
: reg_types_.FromDescriptor(class_loader_, descriptor, false);
@@ -2621,7 +2646,8 @@
return *common_super;
}
-AbstractMethod* MethodVerifier::ResolveMethodAndCheckAccess(uint32_t dex_method_idx, MethodType method_type) {
+mirror::AbstractMethod* MethodVerifier::ResolveMethodAndCheckAccess(uint32_t dex_method_idx,
+ MethodType method_type) {
const DexFile::MethodId& method_id = dex_file_->GetMethodId(dex_method_idx);
const RegType& klass_type = ResolveClassAndCheckAccess(method_id.class_idx_);
if (klass_type.IsConflict()) {
@@ -2633,9 +2659,9 @@
if (klass_type.IsUnresolvedTypes()) {
return NULL; // Can't resolve Class so no more to do here
}
- Class* klass = klass_type.GetClass();
+ mirror::Class* klass = klass_type.GetClass();
const RegType& referrer = GetDeclaringClass();
- AbstractMethod* res_method = dex_cache_->GetResolvedMethod(dex_method_idx);
+ mirror::AbstractMethod* res_method = dex_cache_->GetResolvedMethod(dex_method_idx);
if (res_method == NULL) {
const char* name = dex_file_->GetMethodName(method_id);
std::string signature(dex_file_->CreateMethodSignature(method_id.proto_idx_, NULL));
@@ -2712,11 +2738,12 @@
return res_method;
}
-AbstractMethod* MethodVerifier::VerifyInvocationArgs(const DecodedInstruction& dec_insn,
- MethodType method_type, bool is_range, bool is_super) {
+mirror::AbstractMethod* MethodVerifier::VerifyInvocationArgs(const DecodedInstruction& dec_insn,
+ MethodType method_type, bool is_range,
+ bool is_super) {
// Resolve the method. This could be an abstract or concrete method depending on what sort of call
// we're making.
- AbstractMethod* res_method = ResolveMethodAndCheckAccess(dec_insn.vB, method_type);
+ mirror::AbstractMethod* res_method = ResolveMethodAndCheckAccess(dec_insn.vB, method_type);
if (res_method == NULL) { // error or class is unresolved
return NULL;
}
@@ -2732,7 +2759,7 @@
<< " to super " << PrettyMethod(res_method);
return NULL;
}
- Class* super_klass = super.GetClass();
+ mirror::Class* super_klass = super.GetClass();
if (res_method->GetMethodIndex() >= super_klass->GetVTable()->GetLength()) {
MethodHelper mh(res_method);
Fail(VERIFY_ERROR_NO_METHOD) << "invalid invoke-super from "
@@ -2771,7 +2798,7 @@
return NULL;
}
if (method_type != METHOD_INTERFACE && !actual_arg_type.IsZero()) {
- Class* klass = res_method->GetDeclaringClass();
+ mirror::Class* klass = res_method->GetDeclaringClass();
const RegType& res_method_class = reg_types_.FromClass(klass, klass->IsFinal());
if (!res_method_class.IsAssignableFrom(actual_arg_type)) {
Fail(VERIFY_ERROR_BAD_CLASS_SOFT) << "'this' argument '" << actual_arg_type
@@ -2935,7 +2962,7 @@
}
}
-Field* MethodVerifier::GetStaticField(int field_idx) {
+mirror::Field* MethodVerifier::GetStaticField(int field_idx) {
const DexFile::FieldId& field_id = dex_file_->GetFieldId(field_idx);
// Check access to class
const RegType& klass_type = ResolveClassAndCheckAccess(field_id.class_idx_);
@@ -2948,7 +2975,7 @@
if (klass_type.IsUnresolvedTypes()) {
return NULL; // Can't resolve Class so no more to do here, will do checking at runtime.
}
- Field* field = Runtime::Current()->GetClassLinker()->ResolveFieldJLS(*dex_file_, field_idx,
+ mirror::Field* field = Runtime::Current()->GetClassLinker()->ResolveFieldJLS(*dex_file_, field_idx,
dex_cache_, class_loader_);
if (field == NULL) {
LOG(INFO) << "unable to resolve static field " << field_idx << " ("
@@ -2970,7 +2997,7 @@
}
}
-Field* MethodVerifier::GetInstanceField(const RegType& obj_type, int field_idx) {
+mirror::Field* MethodVerifier::GetInstanceField(const RegType& obj_type, int field_idx) {
const DexFile::FieldId& field_id = dex_file_->GetFieldId(field_idx);
// Check access to class
const RegType& klass_type = ResolveClassAndCheckAccess(field_id.class_idx_);
@@ -2983,7 +3010,7 @@
if (klass_type.IsUnresolvedTypes()) {
return NULL; // Can't resolve Class so no more to do here
}
- Field* field = Runtime::Current()->GetClassLinker()->ResolveFieldJLS(*dex_file_, field_idx,
+ mirror::Field* field = Runtime::Current()->GetClassLinker()->ResolveFieldJLS(*dex_file_, field_idx,
dex_cache_, class_loader_);
if (field == NULL) {
LOG(INFO) << "unable to resolve instance field " << field_idx << " ("
@@ -3005,7 +3032,7 @@
// Cannot infer and check type, however, access will cause null pointer exception
return field;
} else {
- Class* klass = field->GetDeclaringClass();
+ mirror::Class* klass = field->GetDeclaringClass();
const RegType& field_klass = reg_types_.FromClass(klass, klass->IsFinal());
if (obj_type.IsUninitializedTypes() &&
(!IsConstructor() || GetDeclaringClass().Equals(obj_type) ||
@@ -3032,7 +3059,7 @@
void MethodVerifier::VerifyISGet(const DecodedInstruction& dec_insn,
const RegType& insn_type, bool is_primitive, bool is_static) {
uint32_t field_idx = is_static ? dec_insn.vB : dec_insn.vC;
- Field* field;
+ mirror::Field* field;
if (is_static) {
field = GetStaticField(field_idx);
} else {
@@ -3040,7 +3067,7 @@
field = GetInstanceField(object_type, field_idx);
}
const char* descriptor;
- ClassLoader* loader;
+ mirror::ClassLoader* loader;
if (field != NULL) {
descriptor = FieldHelper(field).GetTypeDescriptor();
loader = field->GetDeclaringClass()->GetClassLoader();
@@ -3085,7 +3112,7 @@
void MethodVerifier::VerifyISPut(const DecodedInstruction& dec_insn,
const RegType& insn_type, bool is_primitive, bool is_static) {
uint32_t field_idx = is_static ? dec_insn.vB : dec_insn.vC;
- Field* field;
+ mirror::Field* field;
if (is_static) {
field = GetStaticField(field_idx);
} else {
@@ -3093,7 +3120,7 @@
field = GetInstanceField(object_type, field_idx);
}
const char* descriptor;
- ClassLoader* loader;
+ mirror::ClassLoader* loader;
if (field != NULL) {
descriptor = FieldHelper(field).GetTypeDescriptor();
loader = field->GetDeclaringClass()->GetClassLoader();
@@ -3215,7 +3242,7 @@
const RegType& MethodVerifier::GetDeclaringClass() {
if (foo_method_ != NULL) {
- Class* klass = foo_method_->GetDeclaringClass();
+ mirror::Class* klass = foo_method_->GetDeclaringClass();
return reg_types_.FromClass(klass, klass->IsFinal());
} else {
const DexFile::MethodId& method_id = dex_file_->GetMethodId(dex_method_idx_);
diff --git a/src/verifier/method_verifier.h b/src/verifier/method_verifier.h
index 7779efe..a36a1f9 100644
--- a/src/verifier/method_verifier.h
+++ b/src/verifier/method_verifier.h
@@ -28,7 +28,7 @@
#include "compiler.h"
#include "dex_file.h"
#include "dex_instruction.h"
-#include "object.h"
+#include "mirror/object.h"
#include "reg_type.h"
#include "reg_type_cache.h"
#include "register_line.h"
@@ -156,25 +156,25 @@
};
/* Verify a class. Returns "kNoFailure" on success. */
- static FailureKind VerifyClass(const Class* klass, std::string& error)
+ static FailureKind VerifyClass(const mirror::Class* klass, std::string& error)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- static FailureKind VerifyClass(const DexFile* dex_file, DexCache* dex_cache,
- ClassLoader* class_loader, uint32_t class_def_idx,
+ static FailureKind VerifyClass(const DexFile* dex_file, mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader, uint32_t class_def_idx,
std::string& error)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
static void VerifyMethodAndDump(std::ostream& os, uint32_t method_idx, const DexFile* dex_file,
- DexCache* dex_cache, ClassLoader* class_loader,
+ mirror::DexCache* dex_cache, mirror::ClassLoader* class_loader,
uint32_t class_def_idx, const DexFile::CodeItem* code_item,
- AbstractMethod* method, uint32_t method_access_flags)
+ mirror::AbstractMethod* method, uint32_t method_access_flags)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
static std::vector<int32_t> DescribeVRegs(uint32_t dex_method_idx,
- const DexFile* dex_file, DexCache* dex_cache,
- ClassLoader* class_loader,
+ const DexFile* dex_file, mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader,
uint32_t class_def_idx,
const DexFile::CodeItem* code_item,
- AbstractMethod* method,
+ mirror::AbstractMethod* method,
uint32_t method_access_flags, uint32_t dex_pc)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -209,7 +209,7 @@
// Fills 'monitor_enter_dex_pcs' with the dex pcs of the monitor-enter instructions corresponding
// to the locks held at 'dex_pc' in 'm'.
- static void FindLocksAtDexPc(AbstractMethod* m, uint32_t dex_pc,
+ static void FindLocksAtDexPc(mirror::AbstractMethod* m, uint32_t dex_pc,
std::vector<uint32_t>& monitor_enter_dex_pcs)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -229,9 +229,11 @@
}
private:
- explicit MethodVerifier(const DexFile* dex_file, DexCache* dex_cache,
- ClassLoader* class_loader, uint32_t class_def_idx, const DexFile::CodeItem* code_item,
- uint32_t method_idx, AbstractMethod* method, uint32_t access_flags, bool can_load_classes)
+ explicit MethodVerifier(const DexFile* dex_file, mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader, uint32_t class_def_idx,
+ const DexFile::CodeItem* code_item,
+ uint32_t method_idx, mirror::AbstractMethod* method, uint32_t access_flags,
+ bool can_load_classes)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Adds the given string to the beginning of the last failure message.
@@ -251,9 +253,11 @@
* (3) Iterate through the method, checking type safety and looking
* for code flow problems.
*/
- static FailureKind VerifyMethod(uint32_t method_idx, const DexFile* dex_file, DexCache* dex_cache,
- ClassLoader* class_loader, uint32_t class_def_idx, const DexFile::CodeItem* code_item,
- AbstractMethod* method, uint32_t method_access_flags)
+ static FailureKind VerifyMethod(uint32_t method_idx, const DexFile* dex_file,
+ mirror::DexCache* dex_cache,
+ mirror::ClassLoader* class_loader, uint32_t class_def_idx,
+ const DexFile::CodeItem* code_item,
+ mirror::AbstractMethod* method, uint32_t method_access_flags)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Run verification on the method. Returns true if verification completes and false if the input
@@ -477,11 +481,11 @@
bool is_primitive) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Lookup instance field and fail for resolution violations
- Field* GetInstanceField(const RegType& obj_type, int field_idx)
+ mirror::Field* GetInstanceField(const RegType& obj_type, int field_idx)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Lookup static field and fail for resolution violations
- Field* GetStaticField(int field_idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ mirror::Field* GetStaticField(int field_idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Perform verification of an iget or sget instruction.
void VerifyISGet(const DecodedInstruction& insn, const RegType& insn_type,
@@ -511,7 +515,7 @@
* the referrer can access the resolved method.
* Does not throw exceptions.
*/
- AbstractMethod* ResolveMethodAndCheckAccess(uint32_t method_idx, MethodType method_type)
+ mirror::AbstractMethod* ResolveMethodAndCheckAccess(uint32_t method_idx, MethodType method_type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
/*
@@ -536,7 +540,7 @@
* Returns the resolved method on success, NULL on failure (with *failure
* set appropriately).
*/
- AbstractMethod* VerifyInvocationArgs(const DecodedInstruction& dec_insn,
+ mirror::AbstractMethod* VerifyInvocationArgs(const DecodedInstruction& dec_insn,
MethodType method_type, bool is_range, bool is_super)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -594,7 +598,7 @@
void ComputeGcMapSizes(size_t* gc_points, size_t* ref_bitmap_bits, size_t* log2_max_gc_pc);
// Describe VRegs at the given dex pc.
- std::vector<int32_t> DescribeVRegs(uint32_t dex_pc);
+ std::vector<int32_t> DescribeVRegs(uint32_t dex_pc) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
InsnFlags* CurrentInsnFlags();
@@ -639,13 +643,13 @@
uint32_t dex_method_idx_; // The method we're working on.
// Its object representation if known.
- AbstractMethod* foo_method_ GUARDED_BY(Locks::mutator_lock_);
+ mirror::AbstractMethod* foo_method_ GUARDED_BY(Locks::mutator_lock_);
uint32_t method_access_flags_; // Method's access flags.
const DexFile* dex_file_; // The dex file containing the method.
// The dex_cache for the declaring class of the method.
- DexCache* dex_cache_ GUARDED_BY(Locks::mutator_lock_);
+ mirror::DexCache* dex_cache_ GUARDED_BY(Locks::mutator_lock_);
// The class loader for the declaring class of the method.
- ClassLoader* class_loader_ GUARDED_BY(Locks::mutator_lock_);
+ mirror::ClassLoader* class_loader_ GUARDED_BY(Locks::mutator_lock_);
uint32_t class_def_idx_; // The class def index of the declaring class of the method.
const DexFile::CodeItem* code_item_; // The code item containing the code for the method.
UniquePtr<InsnFlags[]> insn_flags_; // Instruction widths and flags, one entry per code unit.
diff --git a/src/verifier/method_verifier_test.cc b/src/verifier/method_verifier_test.cc
index 8d4c513..5cb3974 100644
--- a/src/verifier/method_verifier_test.cc
+++ b/src/verifier/method_verifier_test.cc
@@ -30,7 +30,7 @@
void VerifyClass(const std::string& descriptor)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
ASSERT_TRUE(descriptor != NULL);
- Class* klass = class_linker_->FindSystemClass(descriptor.c_str());
+ mirror::Class* klass = class_linker_->FindSystemClass(descriptor.c_str());
// Verify the class
std::string error_msg;
diff --git a/src/verifier/reg_type.cc b/src/verifier/reg_type.cc
index ab1da1e..56de179 100644
--- a/src/verifier/reg_type.cc
+++ b/src/verifier/reg_type.cc
@@ -16,9 +16,14 @@
#include "reg_type.h"
+#include "mirror/class.h"
+#include "mirror/class-inl.h"
+#include "mirror/object-inl.h"
#include "object_utils.h"
#include "reg_type_cache.h"
+#include <limits>
+
namespace art {
namespace verifier {
@@ -165,7 +170,7 @@
const RegType& RegType::GetSuperClass(RegTypeCache* cache) const {
if (!IsUnresolvedTypes()) {
- Class* super_klass = GetClass()->GetSuperClass();
+ mirror::Class* super_klass = GetClass()->GetSuperClass();
if (super_klass != NULL) {
return cache->FromClass(super_klass, IsPreciseReference());
} else {
@@ -198,7 +203,7 @@
}
}
-bool RegType::CanAccessMember(Class* klass, uint32_t access_flags) const {
+bool RegType::CanAccessMember(mirror::Class* klass, uint32_t access_flags) const {
if (access_flags & kAccPublic) {
return true;
}
@@ -209,6 +214,62 @@
}
}
+bool RegType::IsObjectArrayTypes() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ if (IsUnresolvedTypes() && !IsUnresolvedMergedReference() && !IsUnresolvedSuperClass()) {
+ // Primitive arrays will always resolve
+ DCHECK(descriptor_[1] == 'L' || descriptor_[1] == '[');
+ return descriptor_[0] == '[';
+ } else if (HasClass()) {
+ mirror::Class* type = GetClass();
+ return type->IsArrayClass() && !type->GetComponentType()->IsPrimitive();
+ } else {
+ return false;
+ }
+}
+
+bool RegType::IsConstantByte() const {
+ return IsConstant() &&
+ ConstantValue() >= std::numeric_limits<jbyte>::min() &&
+ ConstantValue() <= std::numeric_limits<jbyte>::max();
+}
+
+bool RegType::IsConstantShort() const {
+ return IsConstant() &&
+ ConstantValue() >= std::numeric_limits<jshort>::min() &&
+ ConstantValue() <= std::numeric_limits<jshort>::max();
+}
+
+bool RegType::IsConstantChar() const {
+ return IsConstant() && ConstantValue() >= 0 &&
+ ConstantValue() <= std::numeric_limits<jchar>::max();
+}
+
+bool RegType::IsJavaLangObject() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ return IsReference() && GetClass()->IsObjectClass();
+}
+
+bool RegType::IsArrayTypes() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ if (IsUnresolvedTypes() && !IsUnresolvedMergedReference() && !IsUnresolvedSuperClass()) {
+ return descriptor_[0] == '[';
+ } else if (HasClass()) {
+ return GetClass()->IsArrayClass();
+ } else {
+ return false;
+ }
+}
+
+bool RegType::IsJavaLangObjectArray() const {
+ if (HasClass()) {
+ mirror::Class* type = GetClass();
+ return type->IsArrayClass() && type->GetComponentType()->IsObjectClass();
+ }
+ return false;
+}
+
+bool RegType::IsInstantiableTypes() const {
+ return IsUnresolvedTypes() || (IsNonZeroReferenceTypes() && GetClass()->IsInstantiable());
+}
+
bool RegType::IsAssignableFrom(const RegType& src) const {
if (Equals(src)) {
return true;
@@ -363,11 +424,11 @@
// with itself, 0 or Object are handled above.
return reg_types->Conflict();
} else { // Two reference types, compute Join
- Class* c1 = GetClass();
- Class* c2 = incoming_type.GetClass();
+ mirror::Class* c1 = GetClass();
+ mirror::Class* c2 = incoming_type.GetClass();
DCHECK(c1 != NULL && !c1->IsPrimitive());
DCHECK(c2 != NULL && !c2->IsPrimitive());
- Class* join_class = ClassJoin(c1, c2);
+ mirror::Class* join_class = ClassJoin(c1, c2);
if (c1 == join_class && !IsPreciseReference()) {
return *this;
} else if (c2 == join_class && !incoming_type.IsPreciseReference()) {
@@ -382,7 +443,7 @@
}
// See comment in reg_type.h
-Class* RegType::ClassJoin(Class* s, Class* t) {
+mirror::Class* RegType::ClassJoin(mirror::Class* s, mirror::Class* t) {
DCHECK(!s->IsPrimitive()) << PrettyClass(s);
DCHECK(!t->IsPrimitive()) << PrettyClass(t);
if (s == t) {
@@ -392,21 +453,21 @@
} else if (t->IsAssignableFrom(s)) {
return t;
} else if (s->IsArrayClass() && t->IsArrayClass()) {
- Class* s_ct = s->GetComponentType();
- Class* t_ct = t->GetComponentType();
+ mirror::Class* s_ct = s->GetComponentType();
+ mirror::Class* t_ct = t->GetComponentType();
if (s_ct->IsPrimitive() || t_ct->IsPrimitive()) {
// Given the types aren't the same, if either array is of primitive types then the only
// common parent is java.lang.Object
- Class* result = s->GetSuperClass(); // short-cut to java.lang.Object
+ mirror::Class* result = s->GetSuperClass(); // short-cut to java.lang.Object
DCHECK(result->IsObjectClass());
return result;
}
- Class* common_elem = ClassJoin(s_ct, t_ct);
+ mirror::Class* common_elem = ClassJoin(s_ct, t_ct);
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- ClassLoader* class_loader = s->GetClassLoader();
+ mirror::ClassLoader* class_loader = s->GetClassLoader();
std::string descriptor("[");
descriptor += ClassHelper(common_elem).GetDescriptor();
- Class* array_class = class_linker->FindClass(descriptor.c_str(), class_loader);
+ mirror::Class* array_class = class_linker->FindClass(descriptor.c_str(), class_loader);
DCHECK(array_class != NULL);
return array_class;
} else {
@@ -433,8 +494,44 @@
}
}
-std::ostream& operator<<(std::ostream& os, const RegType& rhs)
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+void RegType::CheckInvariants() const {
+ bool checked = false;
+ if (IsConstant() || IsConstantLo() || IsConstantHi()) {
+ // Constants: allocation_pc_or_constant_or_merged_types_ will hold the constant value, nothing
+ // else should be defined.
+ CHECK(descriptor_.empty()) << *this;
+ CHECK(klass_ == NULL) << *this;
+ checked = true;
+ }
+ if (IsUnresolvedTypes()) {
+ if (IsUnresolvedMergedReference()) {
+ // Unresolved merged types: allocation pc/merged types should be defined.
+ CHECK(descriptor_.empty()) << *this;
+ CHECK(klass_ == NULL) << *this;
+ CHECK_NE(allocation_pc_or_constant_or_merged_types_, 0U) << *this;
+ } else {
+ // Unresolved types: have a descriptor and no allocation pc/merged types.
+ CHECK(!descriptor_.empty()) << *this;
+ CHECK(klass_ == NULL) << *this;
+ if (!IsUnresolvedAndUninitializedReference()) {
+ CHECK_EQ(allocation_pc_or_constant_or_merged_types_, 0U) << *this;
+ }
+ }
+ checked = true;
+ }
+ if (IsReferenceTypes() && !checked) {
+ // A resolved reference type.
+ CHECK(descriptor_.empty()) << *this;
+ CHECK(klass_ != NULL) << *this;
+ CHECK(klass_->IsClass()) << *this;
+ if (!IsUninitializedReference()) {
+ CHECK_EQ(allocation_pc_or_constant_or_merged_types_, 0U) << *this;
+ }
+ }
+ CHECK(checked = true);
+}
+
+std::ostream& operator<<(std::ostream& os, const RegType& rhs) {
os << rhs.Dump();
return os;
}
diff --git a/src/verifier/reg_type.h b/src/verifier/reg_type.h
index 65ee88a..dc9a33a 100644
--- a/src/verifier/reg_type.h
+++ b/src/verifier/reg_type.h
@@ -18,11 +18,18 @@
#define ART_SRC_VERIFIER_REG_TYPE_H_
#include "base/macros.h"
-#include "object.h"
+#include "primitive.h"
+
+#include "jni.h"
#include <stdint.h>
+#include <set>
+#include <string>
namespace art {
+namespace mirror {
+class Class;
+} // namespace mirror
namespace verifier {
class RegTypeCache;
@@ -189,20 +196,9 @@
bool IsConstantBoolean() const {
return IsConstant() && ConstantValue() >= 0 && ConstantValue() <= 1;
}
- bool IsConstantByte() const {
- return IsConstant() &&
- ConstantValue() >= std::numeric_limits<jbyte>::min() &&
- ConstantValue() <= std::numeric_limits<jbyte>::max();
- }
- bool IsConstantShort() const {
- return IsConstant() &&
- ConstantValue() >= std::numeric_limits<jshort>::min() &&
- ConstantValue() <= std::numeric_limits<jshort>::max();
- }
- bool IsConstantChar() const {
- return IsConstant() && ConstantValue() >= 0 &&
- ConstantValue() <= std::numeric_limits<jchar>::max();
- }
+ bool IsConstantByte() const;
+ bool IsConstantShort() const;
+ bool IsConstantChar() const;
bool IsReferenceTypes() const {
return IsNonZeroReferenceTypes() || IsZero();
@@ -261,38 +257,17 @@
return IsReference() || IsPreciseReference();
}
- Class* GetClass() const {
+ mirror::Class* GetClass() const {
DCHECK(!IsUnresolvedReference());
DCHECK(klass_ != NULL);
return klass_;
}
- bool IsJavaLangObject() const {
- return IsReference() && GetClass()->IsObjectClass();
- }
+ bool IsJavaLangObject() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool IsArrayTypes() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- if (IsUnresolvedTypes() && !IsUnresolvedMergedReference() && !IsUnresolvedSuperClass()) {
- return descriptor_[0] == '[';
- } else if (HasClass()) {
- return GetClass()->IsArrayClass();
- } else {
- return false;
- }
- }
+ bool IsArrayTypes() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool IsObjectArrayTypes() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- if (IsUnresolvedTypes() && !IsUnresolvedMergedReference() && !IsUnresolvedSuperClass()) {
- // Primitive arrays will always resolve
- DCHECK(descriptor_[1] == 'L' || descriptor_[1] == '[');
- return descriptor_[0] == '[';
- } else if (HasClass()) {
- Class* type = GetClass();
- return type->IsArrayClass() && !type->GetComponentType()->IsPrimitive();
- } else {
- return false;
- }
- }
+ bool IsObjectArrayTypes() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Primitive::Type GetPrimitiveType() const {
if (IsNonZeroReferenceTypes()) {
@@ -317,17 +292,9 @@
}
}
- bool IsJavaLangObjectArray() const {
- if (HasClass()) {
- Class* type = GetClass();
- return type->IsArrayClass() && type->GetComponentType()->IsObjectClass();
- }
- return false;
- }
+ bool IsJavaLangObjectArray() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool IsInstantiableTypes() const {
- return IsUnresolvedTypes() || (IsNonZeroReferenceTypes() && GetClass()->IsInstantiable());
- }
+ bool IsInstantiableTypes() const;
std::string GetDescriptor() const {
DCHECK(IsUnresolvedTypes() && !IsUnresolvedMergedReference() && !IsUnresolvedSuperClass());
@@ -364,7 +331,7 @@
bool CanAccess(const RegType& other) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Can this type access a member with the given properties?
- bool CanAccessMember(Class* klass, uint32_t access_flags) const
+ bool CanAccessMember(mirror::Class* klass, uint32_t access_flags) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Can this type be assigned by src?
@@ -393,47 +360,48 @@
*
* [1] Java bytecode verification: algorithms and formalizations, Xavier Leroy
*/
- static Class* ClassJoin(Class* s, Class* t)
+ static mirror::Class* ClassJoin(mirror::Class* s, mirror::Class* t)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
private:
friend class RegTypeCache;
- RegType(Type type, Class* klass,
+ RegType(Type type, mirror::Class* klass,
uint32_t allocation_pc_or_constant_or_merged_types, uint16_t cache_id)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
: type_(type), klass_(klass),
allocation_pc_or_constant_or_merged_types_(allocation_pc_or_constant_or_merged_types),
cache_id_(cache_id) {
- DCHECK(IsConstant() || IsConstantLo() || IsConstantHi() ||
- IsUninitializedTypes() || IsUnresolvedMergedReference() || IsUnresolvedSuperClass() ||
- allocation_pc_or_constant_or_merged_types == 0);
- if (!IsConstant() && !IsLongConstant() && !IsLongConstantHigh() && !IsUndefined() &&
- !IsConflict() && !IsUnresolvedMergedReference() && !IsUnresolvedSuperClass()) {
- DCHECK(klass_ != NULL);
- DCHECK(klass_->IsClass());
- DCHECK(!IsUnresolvedTypes());
- }
+#ifndef NDEBUG
+ CheckInvariants();
+#endif
}
RegType(Type type, const std::string& descriptor, uint32_t allocation_pc, uint16_t cache_id)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
: type_(type),
klass_(NULL),
descriptor_(descriptor),
allocation_pc_or_constant_or_merged_types_(allocation_pc),
cache_id_(cache_id) {
+#ifndef NDEBUG
+ CheckInvariants();
+#endif
}
+ void CheckInvariants() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+
const Type type_; // The current type of the register
- // If known the type of the register...
- Class* klass_;
+ // For reference types, if known the type of the register...
+ mirror::Class* klass_;
// ...else a String for the descriptor.
std::string descriptor_;
// Overloaded field that:
// - if IsConstant() holds a 32bit constant value
- // - is IsReference() holds the allocation_pc or kInitArgAddr for an initialized reference or
- // kUninitThisArgAddr for an uninitialized this ptr
+ // - is IsUninitializedReference()/IsUnresolvedAndUninitializedReference() holds the pc the
+ // instance in the register was being allocated.
const uint32_t allocation_pc_or_constant_or_merged_types_;
// A RegType cache densely encodes types, this is the location in the cache for this type
@@ -441,7 +409,8 @@
DISALLOW_COPY_AND_ASSIGN(RegType);
};
-std::ostream& operator<<(std::ostream& os, const RegType& rhs);
+std::ostream& operator<<(std::ostream& os, const RegType& rhs)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
} // namespace verifier
} // namespace art
diff --git a/src/verifier/reg_type_cache.cc b/src/verifier/reg_type_cache.cc
index 3bf5ad8..6ca54de 100644
--- a/src/verifier/reg_type_cache.cc
+++ b/src/verifier/reg_type_cache.cc
@@ -16,6 +16,8 @@
#include "reg_type_cache.h"
+#include "mirror/class-inl.h"
+#include "mirror/object-inl.h"
#include "object_utils.h"
namespace art {
@@ -57,7 +59,7 @@
}
}
-const RegType& RegTypeCache::FromDescriptor(ClassLoader* loader, const char* descriptor,
+const RegType& RegTypeCache::FromDescriptor(mirror::ClassLoader* loader, const char* descriptor,
bool precise) {
return From(RegTypeFromDescriptor(descriptor), loader, descriptor, precise);
}
@@ -67,14 +69,14 @@
return (entry->IsPreciseReference() == precise) || (entry->GetClass()->IsFinal() && !precise);
}
-const RegType& RegTypeCache::From(RegType::Type type, ClassLoader* loader, const char* descriptor,
- bool precise) {
+const RegType& RegTypeCache::From(RegType::Type type, mirror::ClassLoader* loader,
+ const char* descriptor, bool precise) {
if (type <= RegType::kRegTypeLastFixedLocation) {
// entries should be sized greater than primitive types
DCHECK_GT(entries_.size(), static_cast<size_t>(type));
RegType* entry = entries_[type];
if (entry == NULL) {
- Class* c = NULL;
+ mirror::Class* c = NULL;
if (strlen(descriptor) != 0) {
c = Runtime::Current()->GetClassLinker()->FindSystemClass(descriptor);
}
@@ -100,7 +102,7 @@
}
}
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- Class* c;
+ mirror::Class* c;
if (can_load_classes_) {
c = class_linker->FindClass(descriptor, loader);
} else {
@@ -125,7 +127,8 @@
DCHECK(!Thread::Current()->IsExceptionPending());
}
if (IsValidDescriptor(descriptor)) {
- RegType* entry = new RegType(RegType::kRegTypeUnresolvedReference, descriptor, 0, entries_.size());
+ RegType* entry =
+ new RegType(RegType::kRegTypeUnresolvedReference, descriptor, 0, entries_.size());
entries_.push_back(entry);
return *entry;
} else {
@@ -137,7 +140,7 @@
}
}
-const RegType& RegTypeCache::FromClass(Class* klass, bool precise) {
+const RegType& RegTypeCache::FromClass(mirror::Class* klass, bool precise) {
if (klass->IsPrimitive()) {
RegType::Type type = RegTypeFromPrimitiveType(klass->GetPrimitiveType());
// entries should be sized greater than primitive types
@@ -233,7 +236,7 @@
entry = new RegType(RegType::kRegTypeUnresolvedAndUninitializedReference,
descriptor, allocation_pc, entries_.size());
} else {
- Class* klass = type.GetClass();
+ mirror::Class* klass = type.GetClass();
for (size_t i = RegType::kRegTypeLastFixedLocation + 1; i < entries_.size(); i++) {
RegType* cur_entry = entries_[i];
if (cur_entry->IsUninitializedReference() &&
@@ -261,7 +264,7 @@
}
entry = new RegType(RegType::kRegTypeUnresolvedReference, descriptor, 0, entries_.size());
} else {
- Class* klass = uninit_type.GetClass();
+ mirror::Class* klass = uninit_type.GetClass();
for (size_t i = RegType::kRegTypeLastFixedLocation + 1; i < entries_.size(); i++) {
RegType* cur_entry = entries_[i];
if (cur_entry->IsPreciseReference() && cur_entry->GetClass() == klass) {
@@ -274,6 +277,18 @@
return *entry;
}
+const RegType& RegTypeCache::ByteConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ return FromCat1Const(std::numeric_limits<jbyte>::min(), false);
+}
+
+const RegType& RegTypeCache::ShortConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ return FromCat1Const(std::numeric_limits<jshort>::min(), false);
+}
+
+const RegType& RegTypeCache::IntConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ return FromCat1Const(std::numeric_limits<jint>::max(), false);
+}
+
const RegType& RegTypeCache::UninitializedThisArgument(const RegType& type) {
// TODO: implement descriptor version.
RegType* entry;
@@ -289,7 +304,7 @@
entry = new RegType(RegType::kRegTypeUnresolvedAndUninitializedThisReference, descriptor, 0,
entries_.size());
} else {
- Class* klass = type.GetClass();
+ mirror::Class* klass = type.GetClass();
for (size_t i = RegType::kRegTypeLastFixedLocation + 1; i < entries_.size(); i++) {
RegType* cur_entry = entries_[i];
if (cur_entry->IsUninitializedThisReference() && cur_entry->GetClass() == klass) {
@@ -320,7 +335,8 @@
}
const RegType& RegTypeCache::FromCat1Const(int32_t value, bool precise) {
- RegType::Type wanted_type = precise ? RegType::kRegTypePreciseConst : RegType::kRegTypeImpreciseConst;
+ RegType::Type wanted_type =
+ precise ? RegType::kRegTypePreciseConst : RegType::kRegTypeImpreciseConst;
for (size_t i = RegType::kRegTypeLastFixedLocation + 1; i < entries_.size(); i++) {
RegType* cur_entry = entries_[i];
if (cur_entry->GetType() == wanted_type && cur_entry->ConstantValue() == value) {
@@ -333,7 +349,8 @@
}
const RegType& RegTypeCache::FromCat2ConstLo(int32_t value, bool precise) {
- RegType::Type wanted_type = precise ? RegType::kRegTypePreciseConstLo : RegType::kRegTypeImpreciseConstLo;
+ RegType::Type wanted_type =
+ precise ? RegType::kRegTypePreciseConstLo : RegType::kRegTypeImpreciseConstLo;
for (size_t i = RegType::kRegTypeLastFixedLocation + 1; i < entries_.size(); i++) {
RegType* cur_entry = entries_[i];
if (cur_entry->GetType() == wanted_type && cur_entry->ConstantValueLo() == value) {
@@ -346,7 +363,8 @@
}
const RegType& RegTypeCache::FromCat2ConstHi(int32_t value, bool precise) {
- RegType::Type wanted_type = precise ? RegType::kRegTypePreciseConstHi : RegType::kRegTypeImpreciseConstHi;
+ RegType::Type wanted_type =
+ precise ? RegType::kRegTypePreciseConstHi : RegType::kRegTypeImpreciseConstHi;
for (size_t i = RegType::kRegTypeLastFixedLocation + 1; i < entries_.size(); i++) {
RegType* cur_entry = entries_[i];
if (cur_entry->GetType() == wanted_type && cur_entry->ConstantValueHi() == value) {
@@ -358,14 +376,14 @@
return *entry;
}
-const RegType& RegTypeCache::GetComponentType(const RegType& array, ClassLoader* loader) {
+const RegType& RegTypeCache::GetComponentType(const RegType& array, mirror::ClassLoader* loader) {
CHECK(array.IsArrayTypes());
if (array.IsUnresolvedTypes()) {
std::string descriptor(array.GetDescriptor());
std::string component(descriptor.substr(1, descriptor.size() - 1));
return FromDescriptor(loader, component.c_str(), false);
} else {
- Class* klass = array.GetClass()->GetComponentType();
+ mirror::Class* klass = array.GetClass()->GetComponentType();
return FromClass(klass, klass->IsFinal());
}
}
diff --git a/src/verifier/reg_type_cache.h b/src/verifier/reg_type_cache.h
index 54f42fd..adab18c 100644
--- a/src/verifier/reg_type_cache.h
+++ b/src/verifier/reg_type_cache.h
@@ -21,7 +21,13 @@
#include "base/stl_util.h"
#include "reg_type.h"
+#include <vector>
+
namespace art {
+namespace mirror {
+class Class;
+class ClassLoader;
+} // namespace mirror
namespace verifier {
class RegTypeCache {
@@ -41,20 +47,25 @@
return *result;
}
- const RegType& From(RegType::Type type, ClassLoader* loader, const char* descriptor, bool precise)
+ const RegType& From(RegType::Type type, mirror::ClassLoader* loader, const char* descriptor,
+ bool precise)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- const RegType& FromClass(Class* klass, bool precise)
+ const RegType& FromClass(mirror::Class* klass, bool precise)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
const RegType& FromCat1Const(int32_t value, bool precise)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- const RegType& FromCat2ConstLo(int32_t value, bool precise);
- const RegType& FromCat2ConstHi(int32_t value, bool precise);
- const RegType& FromDescriptor(ClassLoader* loader, const char* descriptor, bool precise)
+ const RegType& FromCat2ConstLo(int32_t value, bool precise)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ const RegType& FromCat2ConstHi(int32_t value, bool precise)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ const RegType& FromDescriptor(mirror::ClassLoader* loader, const char* descriptor, bool precise)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
const RegType& FromType(RegType::Type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- const RegType& FromUnresolvedMerge(const RegType& left, const RegType& right);
- const RegType& FromUnresolvedSuperClass(const RegType& child);
+ const RegType& FromUnresolvedMerge(const RegType& left, const RegType& right)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ const RegType& FromUnresolvedSuperClass(const RegType& child)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
const RegType& Boolean() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return FromType(RegType::kRegTypeBoolean);
@@ -117,25 +128,22 @@
return FromCat1Const(0, true);
}
- const RegType& Uninitialized(const RegType& type, uint32_t allocation_pc);
+ const RegType& Uninitialized(const RegType& type, uint32_t allocation_pc)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Create an uninitialized 'this' argument for the given type.
- const RegType& UninitializedThisArgument(const RegType& type);
- const RegType& FromUninitialized(const RegType& uninit_type);
+ const RegType& UninitializedThisArgument(const RegType& type)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ const RegType& FromUninitialized(const RegType& uninit_type)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Representatives of various constant types. When merging constants we can't infer a type,
// (an int may later be used as a float) so we select these representative values meaning future
// merges won't know the exact constant value but have some notion of its size.
- const RegType& ByteConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return FromCat1Const(std::numeric_limits<jbyte>::min(), false);
- }
- const RegType& ShortConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return FromCat1Const(std::numeric_limits<jshort>::min(), false);
- }
- const RegType& IntConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return FromCat1Const(std::numeric_limits<jint>::max(), false);
- }
+ const RegType& ByteConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ const RegType& ShortConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ const RegType& IntConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- const RegType& GetComponentType(const RegType& array, ClassLoader* loader)
+ const RegType& GetComponentType(const RegType& array, mirror::ClassLoader* loader)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void Dump(std::ostream& os) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
diff --git a/src/verifier/register_line.h b/src/verifier/register_line.h
index c6c19f8..8253f51 100644
--- a/src/verifier/register_line.h
+++ b/src/verifier/register_line.h
@@ -23,6 +23,7 @@
#include "dex_instruction.h"
#include "reg_type.h"
#include "safe_map.h"
+#include "UniquePtr.h"
namespace art {
namespace verifier {
@@ -135,7 +136,8 @@
* reference type. This is called when an appropriate constructor is invoked -- all copies of
* the reference must be marked as initialized.
*/
- void MarkRefsAsInitialized(const RegType& uninit_type);
+ void MarkRefsAsInitialized(const RegType& uninit_type)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
/*
* Check constraints on constructor return. Specifically, make sure that the "this" argument got
@@ -245,10 +247,10 @@
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Verify/push monitor onto the monitor stack, locking the value in reg_idx at location insn_idx.
- void PushMonitor(uint32_t reg_idx, int32_t insn_idx);
+ void PushMonitor(uint32_t reg_idx, int32_t insn_idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Verify/pop monitor from monitor stack ensuring that we believe the monitor is locked
- void PopMonitor(uint32_t reg_idx);
+ void PopMonitor(uint32_t reg_idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Stack of currently held monitors and where they were locked
size_t MonitorStackDepth() const {
diff --git a/src/well_known_classes.cc b/src/well_known_classes.cc
index 9752c74..5012f1b 100644
--- a/src/well_known_classes.cc
+++ b/src/well_known_classes.cc
@@ -19,6 +19,7 @@
#include <stdlib.h>
#include "base/logging.h"
+#include "mirror/class.h"
#include "ScopedLocalRef.h"
#include "thread.h"
@@ -198,8 +199,8 @@
java_lang_Runtime_nativeLoad = CacheMethod(env, java_lang_Runtime.get(), true, "nativeLoad", "(Ljava/lang/String;Ljava/lang/ClassLoader;Ljava/lang/String;)Ljava/lang/String;");
}
-Class* WellKnownClasses::ToClass(jclass global_jclass) {
- return reinterpret_cast<Class*>(Thread::Current()->DecodeJObject(global_jclass));
+mirror::Class* WellKnownClasses::ToClass(jclass global_jclass) {
+ return reinterpret_cast<mirror::Class*>(Thread::Current()->DecodeJObject(global_jclass));
}
} // namespace art
diff --git a/src/well_known_classes.h b/src/well_known_classes.h
index 10afca9..92a207a 100644
--- a/src/well_known_classes.h
+++ b/src/well_known_classes.h
@@ -21,8 +21,9 @@
#include "jni.h"
namespace art {
-
+namespace mirror {
class Class;
+} // namespace mirror
// Various classes used in JNI. We cache them so we don't have to keep looking
// them up. Similar to libcore's JniConstants (except there's no overlap, so
@@ -33,7 +34,7 @@
static void Init(JNIEnv* env); // Run before native methods are registered.
static void LateInit(JNIEnv* env); // Run after native methods are registered.
- static Class* ToClass(jclass global_jclass)
+ static mirror::Class* ToClass(jclass global_jclass)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
static jclass com_android_dex_Dex;
diff --git a/test/ReferenceMap/stack_walk_refmap_jni.cc b/test/ReferenceMap/stack_walk_refmap_jni.cc
index 60182e2..5109b82 100644
--- a/test/ReferenceMap/stack_walk_refmap_jni.cc
+++ b/test/ReferenceMap/stack_walk_refmap_jni.cc
@@ -19,7 +19,9 @@
#include "UniquePtr.h"
#include "class_linker.h"
#include "gc_map.h"
-#include "object.h"
+#include "mirror/abstract_method.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object_array-inl.h"
#include "object_utils.h"
#include "scoped_thread_state_change.h"
#include "thread.h"
@@ -48,7 +50,7 @@
}
bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* m = GetMethod();
+ mirror::AbstractMethod* m = GetMethod();
if (!m || m->IsNative() || m->IsRuntimeMethod() || IsShadowFrame()) {
return true;
}
diff --git a/test/StackWalk/stack_walk_jni.cc b/test/StackWalk/stack_walk_jni.cc
index dccd69f..a16d896 100644
--- a/test/StackWalk/stack_walk_jni.cc
+++ b/test/StackWalk/stack_walk_jni.cc
@@ -19,7 +19,9 @@
#include "UniquePtr.h"
#include "class_linker.h"
#include "gc_map.h"
-#include "object.h"
+#include "mirror/abstract_method.h"
+#include "mirror/abstract_method-inl.h"
+#include "mirror/object_array-inl.h"
#include "object_utils.h"
#include "jni.h"
#include "scoped_thread_state_change.h"
@@ -46,7 +48,7 @@
}
bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- AbstractMethod* m = GetMethod();
+ mirror::AbstractMethod* m = GetMethod();
CHECK(m != NULL);
LOG(INFO) << "At " << PrettyMethod(m, false);
