Change dex cache to be java object instead of array, add pointer to dex file in dex cache.
Generic clean up to facilitate having GDB macros for Pretty* helper functions.
Improved cleanliness of DexCache since having it as an object array was not the best solution.
Fixed a bug in InOrderWalk caused by ResolveType sometimes allocating classes.
Rename C++ Method to AbstractMethod and add two new classes Constructor, Method which both inherit from AbstractMethod.
Rename done to have the C++ code be closer to the java code.
Change-Id: I4995b4c5e47a3822192b08afa24a639d3b1f4da9
diff --git a/src/check_jni.cc b/src/check_jni.cc
index c53a1e3..5146039 100644
--- a/src/check_jni.cc
+++ b/src/check_jni.cc
@@ -36,7 +36,7 @@
static void JniAbort(const char* jni_function_name, const char* msg) {
Thread* self = Thread::Current();
ScopedObjectAccess soa(self);
- Method* current_method = self->GetCurrentMethod();
+ AbstractMethod* current_method = self->GetCurrentMethod();
std::ostringstream os;
os << "JNI DETECTED ERROR IN APPLICATION: " << msg;
@@ -123,7 +123,7 @@
NULL
};
-static bool ShouldTrace(JavaVMExt* vm, const Method* method)
+static bool ShouldTrace(JavaVMExt* vm, const 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
@@ -276,7 +276,7 @@
*/
void CheckSig(jmethodID mid, const char* expectedType, bool isStatic)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* m = CheckMethodID(mid);
+ AbstractMethod* m = CheckMethodID(mid);
if (m == NULL) {
return;
}
@@ -324,7 +324,7 @@
*/
void CheckStaticMethod(jclass java_class, jmethodID mid)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- const Method* m = CheckMethodID(mid);
+ const AbstractMethod* m = CheckMethodID(mid);
if (m == NULL) {
return;
}
@@ -344,7 +344,7 @@
*/
void CheckVirtualMethod(jobject java_object, jmethodID mid)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- const Method* m = CheckMethodID(mid);
+ const AbstractMethod* m = CheckMethodID(mid);
if (m == NULL) {
return;
}
@@ -395,7 +395,7 @@
SHARED_LOCKS_REQUIRED (Locks::mutator_lock_) {
va_list ap;
- const Method* traceMethod = NULL;
+ const 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.
@@ -481,7 +481,7 @@
StringAppendF(&msg, "%d", i);
} else if (ch == 'm') { // jmethodID
jmethodID mid = va_arg(ap, jmethodID);
- Method* m = reinterpret_cast<Method*>(mid);
+ AbstractMethod* m = reinterpret_cast<AbstractMethod*>(mid);
msg += PrettyMethod(m);
if (!entry) {
StringAppendF(&msg, " (%p)", mid);
@@ -702,12 +702,12 @@
return f;
}
- Method* CheckMethodID(jmethodID mid) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ AbstractMethod* CheckMethodID(jmethodID mid) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (mid == NULL) {
JniAbortF(function_name_, "jmethodID was NULL");
return NULL;
}
- Method* m = soa_.DecodeMethod(mid);
+ AbstractMethod* m = soa_.DecodeMethod(mid);
if (!Runtime::Current()->GetHeap()->IsHeapAddress(m) || !m->IsMethod()) {
JniAbortF(function_name_, "invalid jmethodID: %p", mid);
return NULL;
diff --git a/src/class_linker.cc b/src/class_linker.cc
index f9fbc58..c7c3a33 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -166,11 +166,16 @@
"[Ljava/lang/Class;",
"[Ljava/lang/Object;",
"Ljava/lang/String;",
+ "Ljava/lang/DexCache;",
"Ljava/lang/ref/Reference;",
"Ljava/lang/reflect/Constructor;",
"Ljava/lang/reflect/Field;",
+ "Ljava/lang/reflect/AbstractMethod;",
"Ljava/lang/reflect/Method;",
"Ljava/lang/reflect/Proxy;",
+ "[Ljava/lang/String;",
+ "[Ljava/lang/reflect/Field;",
+ "[Ljava/lang/reflect/AbstractMethod;",
"Ljava/lang/ClassLoader;",
"Ljava/lang/Throwable;",
"Ljava/lang/ClassNotFoundException;",
@@ -294,19 +299,17 @@
// now that these are registered, we can use AllocClass() and AllocObjectArray
- // setup boot_class_path_ and register class_path now that we can
- // use AllocObjectArray to create DexCache instances
- CHECK_NE(0U, boot_class_path.size());
- for (size_t i = 0; i != boot_class_path.size(); ++i) {
- const DexFile* dex_file = boot_class_path[i];
- CHECK(dex_file != NULL);
- AppendToBootClassPath(*dex_file);
- }
+ // Setup DexCache. This can not be done later since AppendToBootClassPath calls AllocDexCache.
+ SirtRef<Class> java_lang_DexCache(AllocClass(java_lang_Class.get(), sizeof(DexCacheClass)));
+ SetClassRoot(kJavaLangDexCache, java_lang_DexCache.get());
+ java_lang_DexCache->SetObjectSize(sizeof(DexCacheClass));
+ java_lang_DexCache->SetStatus(Class::kStatusResolved);
- // Constructor, Field, and Method are necessary so that FindClass can link members
- SirtRef<Class> java_lang_reflect_Constructor(AllocClass(java_lang_Class.get(), sizeof(MethodClass)));
+ // Constructor, Field, Method, and AbstractMethod are necessary so that FindClass can link members.
+ SirtRef<Class> java_lang_reflect_Constructor(AllocClass(java_lang_Class.get(),
+ sizeof(MethodClass)));
CHECK(java_lang_reflect_Constructor.get() != NULL);
- java_lang_reflect_Constructor->SetObjectSize(sizeof(Method));
+ java_lang_reflect_Constructor->SetObjectSize(sizeof(Constructor));
SetClassRoot(kJavaLangReflectConstructor, java_lang_reflect_Constructor.get());
java_lang_reflect_Constructor->SetStatus(Class::kStatusResolved);
@@ -322,7 +325,37 @@
java_lang_reflect_Method->SetObjectSize(sizeof(Method));
SetClassRoot(kJavaLangReflectMethod, java_lang_reflect_Method.get());
java_lang_reflect_Method->SetStatus(Class::kStatusResolved);
- Method::SetClasses(java_lang_reflect_Constructor.get(), java_lang_reflect_Method.get());
+
+ SirtRef<Class> java_lang_reflect_AbstractMethod(AllocClass(java_lang_Class.get(),
+ sizeof(MethodClass)));
+ CHECK(java_lang_reflect_AbstractMethod.get() != NULL);
+ java_lang_reflect_AbstractMethod->SetObjectSize(sizeof(AbstractMethod));
+ SetClassRoot(kJavaLangReflectAbstractMethod, java_lang_reflect_AbstractMethod.get());
+ java_lang_reflect_AbstractMethod->SetStatus(Class::kStatusResolved);
+ 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(AllocClass(java_lang_Class.get(), sizeof(Class)));
+ object_array_string->SetComponentType(java_lang_String.get());
+ SetClassRoot(kJavaLangStringArrayClass, object_array_string.get());
+
+ SirtRef<Class> object_array_field(AllocClass(java_lang_Class.get(), sizeof(Class)));
+ object_array_field->SetComponentType(java_lang_reflect_Field.get());
+ SetClassRoot(kJavaLangReflectFieldArrayClass, object_array_field.get());
+
+ SirtRef<Class> object_array_abstract_method(AllocClass(java_lang_Class.get(), sizeof(Class)));
+ object_array_abstract_method->SetComponentType(java_lang_reflect_AbstractMethod.get());
+ SetClassRoot(kJavaLangReflectAbstractMethodArrayClass, object_array_abstract_method.get());
+
+ // setup boot_class_path_ and register class_path now that we can
+ // use AllocObjectArray to create DexCache instances
+ // Needs to be after String, Field, Method arrays since AllocDexCache uses these roots.
+ CHECK_NE(0U, boot_class_path.size());
+ for (size_t i = 0; i != boot_class_path.size(); ++i) {
+ const DexFile* dex_file = boot_class_path[i];
+ CHECK(dex_file != NULL);
+ AppendToBootClassPath(*dex_file);
+ }
// now we can use FindSystemClass
@@ -330,7 +363,7 @@
InitializePrimitiveClass(char_class.get(), Primitive::kPrimChar);
SetClassRoot(kPrimitiveChar, char_class.get()); // needs descriptor
- // Object and String need to be rerun through FindSystemClass to finish init
+ // 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;");
CHECK_EQ(java_lang_Object.get(), Object_class);
@@ -339,6 +372,11 @@
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.get(), String_class);
+ CHECK_EQ(java_lang_DexCache.get(), DexCache_class);
+ CHECK_EQ(java_lang_DexCache->GetObjectSize(), sizeof(DexCache));
// Setup the primitive array type classes - can't be done until Object has a vtable
SetClassRoot(kBooleanArrayClass, FindSystemClass("[Z"));
@@ -394,6 +432,16 @@
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;");
+ 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;");
+ 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;");
CHECK_EQ(java_lang_reflect_Constructor.get(), Constructor_class);
@@ -402,9 +450,15 @@
Class* Field_class = FindSystemClass("Ljava/lang/reflect/Field;");
CHECK_EQ(java_lang_reflect_Field.get(), Field_class);
- java_lang_reflect_Method->SetStatus(Class::kStatusNotReady);
- Class* Method_class = FindSystemClass("Ljava/lang/reflect/Method;");
- CHECK_EQ(java_lang_reflect_Method.get(), Method_class);
+ Class* String_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangStringArrayClass]);
+ CHECK_EQ(object_array_string.get(), String_array_class);
+
+ Class* Field_array_class = FindSystemClass(class_roots_descriptors_[kJavaLangReflectFieldArrayClass]);
+ CHECK_EQ(object_array_field.get(), Field_array_class);
+
+ Class* Abstract_method_array_class =
+ FindSystemClass(class_roots_descriptors_[kJavaLangReflectAbstractMethodArrayClass]);
+ CHECK_EQ(object_array_abstract_method.get(), Abstract_method_array_class);
// End of special init trickery, subsequent classes may be loaded via FindSystemClass
@@ -935,7 +989,8 @@
DCHECK(array_iftable_ == GetClassRoot(kBooleanArrayClass)->GetIfTable());
// String class root was set above
Field::SetClass(GetClassRoot(kJavaLangReflectField));
- Method::SetClasses(GetClassRoot(kJavaLangReflectConstructor), GetClassRoot(kJavaLangReflectMethod));
+ AbstractMethod::SetClasses(GetClassRoot(kJavaLangReflectConstructor),
+ GetClassRoot(kJavaLangReflectMethod));
BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
ByteArray::SetArrayClass(GetClassRoot(kByteArrayClass));
CharArray::SetArrayClass(GetClassRoot(kCharArrayClass));
@@ -1034,7 +1089,7 @@
ClassLinker::~ClassLinker() {
String::ResetClass();
Field::ResetClass();
- Method::ResetClasses();
+ AbstractMethod::ResetClasses();
BooleanArray::ResetArrayClass();
ByteArray::ResetArrayClass();
CharArray::ResetArrayClass();
@@ -1050,7 +1105,10 @@
}
DexCache* ClassLinker::AllocDexCache(const DexFile& dex_file) {
- SirtRef<DexCache> dex_cache(down_cast<DexCache*>(AllocObjectArray<Object>(DexCache::LengthAsArray())));
+ Heap* heap = Runtime::Current()->GetHeap();
+ Class* dex_cache_class = GetClassRoot(kJavaLangDexCache);
+ SirtRef<DexCache> dex_cache(
+ down_cast<DexCache*>(heap->AllocObject(dex_cache_class, dex_cache_class->GetObjectSize())));
if (dex_cache.get() == NULL) {
return NULL;
}
@@ -1058,7 +1116,7 @@
if (location.get() == NULL) {
return NULL;
}
- SirtRef<ObjectArray<String> > strings(AllocObjectArray<String>(dex_file.NumStringIds()));
+ SirtRef<ObjectArray<String> > strings(AllocStringArray(dex_file.NumStringIds()));
if (strings.get() == NULL) {
return NULL;
}
@@ -1066,11 +1124,11 @@
if (types.get() == NULL) {
return NULL;
}
- SirtRef<ObjectArray<Method> > methods(AllocObjectArray<Method>(dex_file.NumMethodIds()));
+ SirtRef<ObjectArray<AbstractMethod> > methods(AllocMethodArray(dex_file.NumMethodIds()));
if (methods.get() == NULL) {
return NULL;
}
- SirtRef<ObjectArray<Field> > fields(AllocObjectArray<Field>(dex_file.NumFieldIds()));
+ SirtRef<ObjectArray<Field> > fields(AllocFieldArray(dex_file.NumFieldIds()));
if (fields.get() == NULL) {
return NULL;
}
@@ -1079,7 +1137,8 @@
return NULL;
}
- dex_cache->Init(location.get(),
+ dex_cache->Init(&dex_file,
+ location.get(),
strings.get(),
types.get(),
methods.get(),
@@ -1117,6 +1176,10 @@
return down_cast<Method*>(GetClassRoot(kJavaLangReflectMethod)->AllocObject());
}
+Constructor* ClassLinker::AllocConstructor() {
+ return down_cast<Constructor*>(GetClassRoot(kJavaLangReflectConstructor)->AllocObject());
+}
+
ObjectArray<StackTraceElement>* ClassLinker::AllocStackTraceElementArray(size_t length) {
return ObjectArray<StackTraceElement>::Alloc(
GetClassRoot(kJavaLangStackTraceElementArrayClass),
@@ -1255,10 +1318,14 @@
klass.reset(GetClassRoot(kJavaLangClass));
} else if (descriptor == "Ljava/lang/String;") {
klass.reset(GetClassRoot(kJavaLangString));
- } else if (descriptor == "Ljava/lang/reflect/Constructor;") {
- klass.reset(GetClassRoot(kJavaLangReflectConstructor));
+ } else if (descriptor == "Ljava/lang/DexCache;") {
+ klass.reset(GetClassRoot(kJavaLangDexCache));
} else if (descriptor == "Ljava/lang/reflect/Field;") {
klass.reset(GetClassRoot(kJavaLangReflectField));
+ } else if (descriptor == "Ljava/lang/reflect/AbstractMethod;") {
+ klass.reset(GetClassRoot(kJavaLangReflectAbstractMethod));
+ } else if (descriptor == "Ljava/lang/reflect/Constructor;") {
+ klass.reset(GetClassRoot(kJavaLangReflectConstructor));
} else if (descriptor == "Ljava/lang/reflect/Method;") {
klass.reset(GetClassRoot(kJavaLangReflectMethod));
} else {
@@ -1373,7 +1440,7 @@
return oat_class;
}
-const OatFile::OatMethod ClassLinker::GetOatMethodFor(const Method* method) {
+const OatFile::OatMethod ClassLinker::GetOatMethodFor(const 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();
@@ -1403,7 +1470,7 @@
}
// Special case to get oat code without overwriting a trampoline.
-const void* ClassLinker::GetOatCodeFor(const Method* method) {
+const void* ClassLinker::GetOatCodeFor(const AbstractMethod* method) {
CHECK(Runtime::Current()->IsCompiler() || method->GetDeclaringClass()->IsInitializing());
return GetOatMethodFor(method).GetCode();
}
@@ -1435,7 +1502,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()) {
- Method* method = klass->GetDirectMethod(i);
+ AbstractMethod* method = klass->GetDirectMethod(i);
if (Runtime::Current()->IsMethodTracingActive()) {
Trace* tracer = Runtime::Current()->GetTracer();
if (tracer->GetSavedCodeFromMap(method) == trampoline) {
@@ -1454,7 +1521,7 @@
}
}
-static void LinkCode(SirtRef<Method>& method, const OatFile::OatClass* oat_class,
+static void LinkCode(SirtRef<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.
@@ -1535,17 +1602,16 @@
// Load methods.
if (it.NumDirectMethods() != 0) {
// TODO: append direct methods to class object
- klass->SetDirectMethods(AllocObjectArray<Method>(it.NumDirectMethods()));
+ klass->SetDirectMethods(AllocObjectArray<AbstractMethod>(it.NumDirectMethods()));
}
if (it.NumVirtualMethods() != 0) {
// TODO: append direct methods to class object
- klass->SetVirtualMethods(AllocObjectArray<Method>(it.NumVirtualMethods()));
+ klass->SetVirtualMethods(AllocObjectArray<AbstractMethod>(it.NumVirtualMethods()));
}
size_t class_def_method_index = 0;
for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
- SirtRef<Method> method(AllocMethod());
+ SirtRef<AbstractMethod> method(LoadMethod(dex_file, it, klass));
klass->SetDirectMethod(i, method.get());
- LoadMethod(dex_file, it, klass, method);
if (oat_class.get() != NULL) {
LinkCode(method, oat_class.get(), class_def_method_index);
}
@@ -1553,9 +1619,8 @@
class_def_method_index++;
}
for (size_t i = 0; it.HasNextVirtualMethod(); i++, it.Next()) {
- SirtRef<Method> method(AllocMethod());
+ SirtRef<AbstractMethod> method(LoadMethod(dex_file, it, klass));
klass->SetVirtualMethod(i, method.get());
- LoadMethod(dex_file, it, klass, method);
DCHECK_EQ(class_def_method_index, it.NumDirectMethods() + i);
if (oat_class.get() != NULL) {
LinkCode(method, oat_class.get(), class_def_method_index);
@@ -1573,18 +1638,23 @@
dst->SetAccessFlags(it.GetMemberAccessFlags());
}
-void ClassLinker::LoadMethod(const DexFile& dex_file, const ClassDataItemIterator& it,
- SirtRef<Class>& klass, SirtRef<Method>& dst) {
+AbstractMethod* ClassLinker::LoadMethod(const DexFile& dex_file, const ClassDataItemIterator& it,
+ SirtRef<Class>& klass) {
uint32_t dex_method_idx = it.GetMemberIndex();
- dst->SetDexMethodIndex(dex_method_idx);
const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method_idx);
- dst->SetDeclaringClass(klass.get());
-
-
StringPiece method_name(dex_file.GetMethodName(method_id));
+
+ AbstractMethod* dst = NULL;
if (method_name == "<init>") {
- dst->SetClass(GetClassRoot(kJavaLangReflectConstructor));
+ dst = AllocConstructor();
+ } else {
+ dst = AllocMethod();
}
+ DCHECK(dst->IsMethod()) << PrettyDescriptor(dst->GetClass());
+
+ const char* old_cause = Thread::Current()->StartAssertNoThreadSuspension("LoadMethod");
+ dst->SetDexMethodIndex(dex_method_idx);
+ dst->SetDeclaringClass(klass.get());
if (method_name == "finalize") {
// Create the prototype for a signature of "()V"
@@ -1623,6 +1693,11 @@
dst->SetDexCacheResolvedMethods(klass->GetDexCache()->GetResolvedMethods());
dst->SetDexCacheResolvedTypes(klass->GetDexCache()->GetResolvedTypes());
dst->SetDexCacheInitializedStaticStorage(klass->GetDexCache()->GetInitializedStaticStorage());
+
+ CHECK(dst->IsMethod());
+
+ Thread::Current()->EndAssertNoThreadSuspension(old_cause);
+ return dst;
}
void ClassLinker::AppendToBootClassPath(const DexFile& dex_file) {
@@ -1638,8 +1713,8 @@
bool ClassLinker::IsDexFileRegisteredLocked(const DexFile& dex_file) const {
dex_lock_.AssertHeld();
- for (size_t i = 0; i != dex_files_.size(); ++i) {
- if (dex_files_[i] == &dex_file) {
+ for (size_t i = 0; i != dex_caches_.size(); ++i) {
+ if (dex_caches_[i]->GetDexFile() == &dex_file) {
return true;
}
}
@@ -1655,8 +1730,8 @@
dex_lock_.AssertHeld();
CHECK(dex_cache.get() != NULL) << dex_file.GetLocation();
CHECK(dex_cache->GetLocation()->Equals(dex_file.GetLocation()));
- dex_files_.push_back(&dex_file);
dex_caches_.push_back(dex_cache.get());
+ dex_cache->SetDexFile(&dex_file);
}
void ClassLinker::RegisterDexFile(const DexFile& dex_file) {
@@ -1684,30 +1759,29 @@
RegisterDexFileLocked(dex_file, dex_cache);
}
+// TODO: Remove.
const DexFile& ClassLinker::FindDexFile(const DexCache* dex_cache) const {
CHECK(dex_cache != NULL);
- MutexLock mu(dex_lock_);
- for (size_t i = 0; i != dex_caches_.size(); ++i) {
- if (dex_caches_[i] == dex_cache) {
- return *dex_files_[i];
- }
+ const DexFile* dex_file = dex_cache->GetDexFile();
+ if (dex_file == NULL) {
+ LOG(FATAL) << "DexCache has no DexFile " << dex_cache->GetLocation()->ToModifiedUtf8();
}
- LOG(FATAL) << "Failed to find DexFile for DexCache " << dex_cache->GetLocation()->ToModifiedUtf8();
- return *dex_files_[-1];
+ return *dex_file;
}
DexCache* ClassLinker::FindDexCache(const DexFile& dex_file) const {
MutexLock mu(dex_lock_);
- for (size_t i = 0; i != dex_files_.size(); ++i) {
- if (dex_files_[i] == &dex_file) {
- return dex_caches_[i];
+ for (size_t i = 0; i != dex_caches_.size(); ++i) {
+ DexCache* dex_cache = dex_caches_[i];
+ if (dex_cache->GetDexFile() == &dex_file) {
+ return dex_cache;
}
}
LOG(FATAL) << "Failed to find DexCache for DexFile " << dex_file.GetLocation();
return NULL;
}
-void ClassLinker::FixupDexCaches(Method* resolution_method) const {
+void ClassLinker::FixupDexCaches(AbstractMethod* resolution_method) const {
MutexLock mu(dex_lock_);
for (size_t i = 0; i != dex_caches_.size(); ++i) {
dex_caches_[i]->Fixup(resolution_method);
@@ -1788,6 +1862,12 @@
new_class.reset(GetClassRoot(kClassArrayClass));
} else if (descriptor == "[Ljava/lang/Object;") {
new_class.reset(GetClassRoot(kObjectArrayClass));
+ } else if (descriptor == class_roots_descriptors_[kJavaLangStringArrayClass]) {
+ new_class.reset(GetClassRoot(kJavaLangStringArrayClass));
+ } else if (descriptor == class_roots_descriptors_[kJavaLangReflectFieldArrayClass]) {
+ new_class.reset(GetClassRoot(kJavaLangReflectFieldArrayClass));
+ } else if (descriptor == class_roots_descriptors_[kJavaLangReflectAbstractMethodArrayClass]) {
+ new_class.reset(GetClassRoot(kJavaLangReflectAbstractMethodArrayClass));
} else if (descriptor == "[C") {
new_class.reset(GetClassRoot(kCharArrayClass));
} else if (descriptor == "[I") {
@@ -2164,7 +2244,7 @@
}
}
-void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, Method* method) {
+void ClassLinker::ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, AbstractMethod* method) {
// similar to DexVerifier::ScanTryCatchBlocks and dex2oat's ResolveExceptionsForMethod.
const DexFile::CodeItem* code_item = dex_file.GetCodeItem(method->GetCodeItemOffset());
if (code_item == NULL) {
@@ -2193,11 +2273,11 @@
}
}
-static void CheckProxyConstructor(Method* constructor);
-static void CheckProxyMethod(Method* method, SirtRef<Method>& prototype);
+static void CheckProxyConstructor(AbstractMethod* constructor);
+static void CheckProxyMethod(AbstractMethod* method, SirtRef<AbstractMethod>& prototype);
Class* ClassLinker::CreateProxyClass(String* name, ObjectArray<Class>* interfaces,
- ClassLoader* loader, ObjectArray<Method>* methods,
+ ClassLoader* loader, ObjectArray<AbstractMethod>* methods,
ObjectArray<ObjectArray<Class> >* throws) {
SirtRef<Class> klass(AllocClass(GetClassRoot(kJavaLangClass), sizeof(SynthesizedProxyClass)));
CHECK(klass.get() != NULL);
@@ -2231,14 +2311,14 @@
throws_sfield->SetAccessFlags(kAccStatic | kAccPublic | kAccFinal);
// Proxies have 1 direct method, the constructor
- klass->SetDirectMethods(AllocObjectArray<Method>(1));
+ klass->SetDirectMethods(AllocObjectArray<AbstractMethod>(1));
klass->SetDirectMethod(0, CreateProxyConstructor(klass, proxy_class));
// Create virtual method using specified prototypes
size_t num_virtual_methods = methods->GetLength();
- klass->SetVirtualMethods(AllocObjectArray<Method>(num_virtual_methods));
+ klass->SetVirtualMethods(AllocObjectArray<AbstractMethod>(num_virtual_methods));
for (size_t i = 0; i < num_virtual_methods; ++i) {
- SirtRef<Method> prototype(methods->Get(i));
+ SirtRef<AbstractMethod> prototype(methods->Get(i));
klass->SetVirtualMethod(i, CreateProxyMethod(klass, prototype));
}
@@ -2263,7 +2343,7 @@
CHECK(klass->GetIFields() == NULL);
CheckProxyConstructor(klass->GetDirectMethod(0));
for (size_t i = 0; i < num_virtual_methods; ++i) {
- SirtRef<Method> prototype(methods->Get(i));
+ SirtRef<AbstractMethod> prototype(methods->Get(i));
CheckProxyMethod(klass->GetVirtualMethod(i), prototype);
}
@@ -2289,7 +2369,7 @@
return DotToDescriptor(name->ToModifiedUtf8().c_str());
}
-Method* ClassLinker::FindMethodForProxy(const Class* proxy_class, const Method* proxy_method) {
+AbstractMethod* ClassLinker::FindMethodForProxy(const Class* proxy_class, const AbstractMethod* proxy_method) {
DCHECK(proxy_class->IsProxyClass());
DCHECK(proxy_method->IsProxyMethod());
// Locate the dex cache of the original interface/Object
@@ -2306,27 +2386,27 @@
}
CHECK(dex_cache != NULL);
uint32_t method_idx = proxy_method->GetDexMethodIndex();
- Method* resolved_method = dex_cache->GetResolvedMethod(method_idx);
+ AbstractMethod* resolved_method = dex_cache->GetResolvedMethod(method_idx);
CHECK(resolved_method != NULL);
return resolved_method;
}
-Method* ClassLinker::CreateProxyConstructor(SirtRef<Class>& klass, Class* proxy_class) {
+AbstractMethod* ClassLinker::CreateProxyConstructor(SirtRef<Class>& klass, Class* proxy_class) {
// Create constructor for Proxy that must initialize h
- ObjectArray<Method>* proxy_direct_methods = proxy_class->GetDirectMethods();
+ ObjectArray<AbstractMethod>* proxy_direct_methods = proxy_class->GetDirectMethods();
CHECK_EQ(proxy_direct_methods->GetLength(), 15);
- Method* proxy_constructor = proxy_direct_methods->Get(2);
+ 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)
- Method* constructor = down_cast<Method*>(proxy_constructor->Clone());
+ AbstractMethod* constructor = down_cast<AbstractMethod*>(proxy_constructor->Clone());
// 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(Method* constructor)
+static void CheckProxyConstructor(AbstractMethod* constructor)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
CHECK(constructor->IsConstructor());
MethodHelper mh(constructor);
@@ -2335,14 +2415,14 @@
DCHECK(constructor->IsPublic());
}
-Method* ClassLinker::CreateProxyMethod(SirtRef<Class>& klass, SirtRef<Method>& prototype) {
+AbstractMethod* ClassLinker::CreateProxyMethod(SirtRef<Class>& klass, SirtRef<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
- Method* method = down_cast<Method*>(prototype->Clone());
+ AbstractMethod* method = down_cast<AbstractMethod*>(prototype->Clone());
// 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
@@ -2351,7 +2431,7 @@
// At runtime the method looks like a reference and argument saving method, clone the code
// related parameters from this method.
- Method* refs_and_args = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
+ 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());
@@ -2365,7 +2445,7 @@
return method;
}
-static void CheckProxyMethod(Method* method, SirtRef<Method>& prototype)
+static void CheckProxyMethod(AbstractMethod* method, SirtRef<AbstractMethod>& prototype)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// Basic sanity
CHECK(!prototype->IsFinal());
@@ -2395,7 +2475,7 @@
Thread* self = Thread::Current();
- Method* clinit = NULL;
+ AbstractMethod* clinit = NULL;
{
// see JLS 3rd edition, 12.4.2 "Detailed Initialization Procedure" for the locking protocol
ObjectLock lock(klass);
@@ -2555,7 +2635,7 @@
klass->GetClassLoader() != klass->GetSuperClass()->GetClassLoader()) {
const Class* super = klass->GetSuperClass();
for (int i = super->GetVTable()->GetLength() - 1; i >= 0; --i) {
- const Method* method = klass->GetVTable()->Get(i);
+ const 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",
@@ -2570,7 +2650,7 @@
Class* interface = interface_entry->GetInterface();
if (klass->GetClassLoader() != interface->GetClassLoader()) {
for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
- const Method* method = interface_entry->GetMethodArray()->Get(j);
+ const AbstractMethod* method = interface_entry->GetMethodArray()->Get(j);
if (!IsSameMethodSignatureInDifferentClassContexts(method, interface,
method->GetDeclaringClass())) {
ThrowLinkageError("Class %s method %s resolves differently in interface %s",
@@ -2587,7 +2667,7 @@
// 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 Method* method,
+bool ClassLinker::IsSameMethodSignatureInDifferentClassContexts(const AbstractMethod* method,
const Class* klass1,
const Class* klass2) {
if (klass1 == klass2) {
@@ -2872,16 +2952,16 @@
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<Method> > vtable(klass->GetSuperClass()->GetVTable()->CopyOf(max_count));
+ SirtRef<ObjectArray<AbstractMethod> > vtable(klass->GetSuperClass()->GetVTable()->CopyOf(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) {
- Method* local_method = klass->GetVirtualMethodDuringLinking(i);
+ AbstractMethod* local_method = klass->GetVirtualMethodDuringLinking(i);
local_mh.ChangeMethod(local_method);
size_t j = 0;
for (; j < actual_count; ++j) {
- Method* super_method = vtable->Get(j);
+ 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())) {
@@ -2925,9 +3005,9 @@
ThrowClassFormatError("Too many methods: %d", num_virtual_methods);
return false;
}
- SirtRef<ObjectArray<Method> > vtable(AllocObjectArray<Method>(num_virtual_methods));
+ SirtRef<ObjectArray<AbstractMethod> > vtable(AllocObjectArray<AbstractMethod>(num_virtual_methods));
for (size_t i = 0; i < num_virtual_methods; ++i) {
- Method* virtual_method = klass->GetVirtualMethodDuringLinking(i);
+ AbstractMethod* virtual_method = klass->GetVirtualMethodDuringLinking(i);
vtable->Set(i, virtual_method);
virtual_method->SetMethodIndex(i & 0xFFFF);
}
@@ -3021,17 +3101,17 @@
if (klass->IsInterface() /*|| super_ifcount == ifcount*/) {
return true;
}
- std::vector<Method*> miranda_list;
+ std::vector<AbstractMethod*> miranda_list;
MethodHelper vtable_mh(NULL, this);
MethodHelper interface_mh(NULL, this);
for (size_t i = 0; i < ifcount; ++i) {
InterfaceEntry* interface_entry = iftable->Get(i);
Class* interface = interface_entry->GetInterface();
- ObjectArray<Method>* method_array = AllocObjectArray<Method>(interface->NumVirtualMethods());
+ ObjectArray<AbstractMethod>* method_array = AllocObjectArray<AbstractMethod>(interface->NumVirtualMethods());
interface_entry->SetMethodArray(method_array);
- ObjectArray<Method>* vtable = klass->GetVTableDuringLinking();
+ ObjectArray<AbstractMethod>* vtable = klass->GetVTableDuringLinking();
for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
- Method* interface_method = interface->GetVirtualMethod(j);
+ 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
@@ -3043,7 +3123,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) {
- Method* vtable_method = vtable->Get(k);
+ AbstractMethod* vtable_method = vtable->Get(k);
vtable_mh.ChangeMethod(vtable_method);
if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
if (!vtable_method->IsPublic()) {
@@ -3056,9 +3136,9 @@
}
}
if (k < 0) {
- SirtRef<Method> miranda_method(NULL);
+ SirtRef<AbstractMethod> miranda_method(NULL);
for (size_t mir = 0; mir < miranda_list.size(); mir++) {
- Method* mir_method = miranda_list[mir];
+ AbstractMethod* mir_method = miranda_list[mir];
vtable_mh.ChangeMethod(mir_method);
if (interface_mh.HasSameNameAndSignature(&vtable_mh)) {
miranda_method.reset(miranda_list[mir]);
@@ -3067,7 +3147,7 @@
}
if (miranda_method.get() == NULL) {
// point the interface table at a phantom slot
- miranda_method.reset(down_cast<Method*>(interface_method->Clone()));
+ miranda_method.reset(down_cast<AbstractMethod*>(interface_method->Clone()));
miranda_list.push_back(miranda_method.get());
}
method_array->Set(j, miranda_method.get());
@@ -3078,16 +3158,16 @@
int old_method_count = klass->NumVirtualMethods();
int new_method_count = old_method_count + miranda_list.size();
klass->SetVirtualMethods((old_method_count == 0)
- ? AllocObjectArray<Method>(new_method_count)
+ ? AllocObjectArray<AbstractMethod>(new_method_count)
: klass->GetVirtualMethods()->CopyOf(new_method_count));
- SirtRef<ObjectArray<Method> > vtable(klass->GetVTableDuringLinking());
+ SirtRef<ObjectArray<AbstractMethod> > vtable(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(new_vtable_count));
for (size_t i = 0; i < miranda_list.size(); ++i) {
- Method* method = miranda_list[i];
+ 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));
@@ -3098,7 +3178,7 @@
klass->SetVTable(vtable.get());
}
- ObjectArray<Method>* vtable = klass->GetVTableDuringLinking();
+ ObjectArray<AbstractMethod>* vtable = klass->GetVTableDuringLinking();
for (int i = 0; i < vtable->GetLength(); ++i) {
CHECK(vtable->Get(i) != NULL);
}
@@ -3396,15 +3476,15 @@
return resolved;
}
-Method* ClassLinker::ResolveMethod(const DexFile& dex_file,
+AbstractMethod* ClassLinker::ResolveMethod(const DexFile& dex_file,
uint32_t method_idx,
DexCache* dex_cache,
ClassLoader* class_loader,
- const Method* referrer,
+ const AbstractMethod* referrer,
InvokeType type) {
DCHECK(dex_cache != NULL);
// Check for hit in the dex cache.
- Method* resolved = dex_cache->GetResolvedMethod(method_idx);
+ AbstractMethod* resolved = dex_cache->GetResolvedMethod(method_idx);
if (resolved != NULL) {
return resolved;
}
@@ -3608,7 +3688,7 @@
return resolved;
}
-const char* ClassLinker::MethodShorty(uint32_t method_idx, Method* referrer, uint32_t* length) {
+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 DexFile& dex_file = FindDexFile(dex_cache);
diff --git a/src/class_linker.h b/src/class_linker.h
index 3cee7f0..67c2fbe 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -98,7 +98,7 @@
// 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 Method* referrer)
+ 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)) {
@@ -129,7 +129,7 @@
// 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 Method* referrer)
+ 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)) {
@@ -170,17 +170,17 @@
// 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.
- Method* ResolveMethod(const DexFile& dex_file,
+ AbstractMethod* ResolveMethod(const DexFile& dex_file,
uint32_t method_idx,
DexCache* dex_cache,
ClassLoader* class_loader,
- const Method* referrer,
+ const AbstractMethod* referrer,
InvokeType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* ResolveMethod(uint32_t method_idx, const Method* referrer, InvokeType type)
+ AbstractMethod* ResolveMethod(uint32_t method_idx, const AbstractMethod* referrer, InvokeType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* resolved_method = referrer->GetDexCacheResolvedMethods()->Get(method_idx);
+ 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();
@@ -191,7 +191,7 @@
return resolved_method;
}
- Field* ResolveField(uint32_t field_idx, const Method* referrer, bool is_static)
+ 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);
@@ -228,7 +228,7 @@
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Get shorty from method index without resolution. Used to do handlerization.
- const char* MethodShorty(uint32_t method_idx, Method* referrer, uint32_t* length)
+ const char* MethodShorty(uint32_t method_idx, AbstractMethod* referrer, uint32_t* length)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Returns true on success, false if there's an exception pending.
@@ -273,7 +273,7 @@
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
bool IsDexFileRegistered(const DexFile& dex_file) const
LOCKS_EXCLUDED(dex_lock_);
- void FixupDexCaches(Method* resolution_method) const
+ void FixupDexCaches(AbstractMethod* resolution_method) const
LOCKS_EXCLUDED(dex_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -323,6 +323,22 @@
return ObjectArray<Class>::Alloc(GetClassRoot(kClassArrayClass), length);
}
+ ObjectArray<String>* AllocStringArray(size_t length)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ return ObjectArray<String>::Alloc(GetClassRoot(kJavaLangStringArrayClass), length);
+ }
+
+ ObjectArray<AbstractMethod>* AllocMethodArray(size_t length)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ return ObjectArray<AbstractMethod>::Alloc(
+ GetClassRoot(kJavaLangReflectAbstractMethodArrayClass), length);
+ }
+
+ ObjectArray<Field>* AllocFieldArray(size_t length)
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ return ObjectArray<Field>::Alloc(GetClassRoot(kJavaLangReflectFieldArrayClass), length);
+ }
+
ObjectArray<StackTraceElement>* AllocStackTraceElementArray(size_t length)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -332,20 +348,20 @@
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, Method* klass)
+ void ResolveMethodExceptionHandlerTypes(const DexFile& dex_file, AbstractMethod* klass)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Class* CreateProxyClass(String* name, ObjectArray<Class>* interfaces, ClassLoader* loader,
- ObjectArray<Method>* methods, ObjectArray<ObjectArray<Class> >* throws)
+ ObjectArray<AbstractMethod>* methods, ObjectArray<ObjectArray<Class> >* throws)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
std::string GetDescriptorForProxy(const Class* proxy_class)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* FindMethodForProxy(const Class* proxy_class, const Method* proxy_method)
+ AbstractMethod* FindMethodForProxy(const Class* proxy_class, const 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 Method* method)
+ const void* GetOatCodeFor(const AbstractMethod* method)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Relocate the OatFiles (ELF images)
@@ -357,7 +373,7 @@
private:
explicit ClassLinker(InternTable*);
- const OatFile::OatMethod GetOatMethodFor(const Method* method)
+ const OatFile::OatMethod GetOatMethodFor(const AbstractMethod* method)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Initialize class linker by bootstraping from dex files
@@ -386,6 +402,7 @@
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Field* AllocField() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Method* AllocMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ Constructor* AllocConstructor() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
InterfaceEntry* AllocInterfaceEntry(Class* interface)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -422,8 +439,8 @@
void LoadField(const DexFile& dex_file, const ClassDataItemIterator& it, SirtRef<Class>& klass,
SirtRef<Field>& dst);
- void LoadMethod(const DexFile& dex_file, const ClassDataItemIterator& dex_method,
- SirtRef<Class>& klass, SirtRef<Method>& dst)
+ AbstractMethod* LoadMethod(const DexFile& dex_file, const ClassDataItemIterator& dex_method,
+ SirtRef<Class>& klass)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void FixupStaticTrampolines(Class* klass)
@@ -462,7 +479,7 @@
const Class* klass2)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- bool IsSameMethodSignatureInDifferentClassContexts(const Method* descriptor,
+ bool IsSameMethodSignatureInDifferentClassContexts(const AbstractMethod* descriptor,
const Class* klass1,
const Class* klass2)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -518,15 +535,14 @@
EXCLUSIVE_LOCKS_REQUIRED(dex_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* CreateProxyConstructor(SirtRef<Class>& klass, Class* proxy_class)
+ AbstractMethod* CreateProxyConstructor(SirtRef<Class>& klass, Class* proxy_class)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* CreateProxyMethod(SirtRef<Class>& klass, SirtRef<Method>& prototype)
+ AbstractMethod* CreateProxyMethod(SirtRef<Class>& klass, SirtRef<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<const DexFile*> dex_files_ GUARDED_BY(dex_lock_);
std::vector<DexCache*> dex_caches_ GUARDED_BY(dex_lock_);
std::vector<const OatFile*> oat_files_ GUARDED_BY(dex_lock_);
@@ -551,11 +567,16 @@
kClassArrayClass,
kObjectArrayClass,
kJavaLangString,
+ kJavaLangDexCache,
kJavaLangRefReference,
kJavaLangReflectConstructor,
kJavaLangReflectField,
+ kJavaLangReflectAbstractMethod,
kJavaLangReflectMethod,
kJavaLangReflectProxy,
+ kJavaLangStringArrayClass,
+ kJavaLangReflectFieldArrayClass,
+ kJavaLangReflectAbstractMethodArrayClass,
kJavaLangClassLoader,
kJavaLangThrowable,
kJavaLangClassNotFoundException,
diff --git a/src/class_linker_test.cc b/src/class_linker_test.cc
index a0b4f1c..106598e 100644
--- a/src/class_linker_test.cc
+++ b/src/class_linker_test.cc
@@ -135,7 +135,7 @@
EXPECT_STREQ(kh.GetDescriptor(), "Ljava/io/Serializable;");
}
- void AssertMethod(Method* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ void AssertMethod(AbstractMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
MethodHelper mh(method);
EXPECT_TRUE(method != NULL);
EXPECT_TRUE(method->GetClass() != NULL);
@@ -232,14 +232,14 @@
EXPECT_TRUE(klass->CanAccess(klass));
for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
- Method* method = klass->GetDirectMethod(i);
+ AbstractMethod* method = klass->GetDirectMethod(i);
AssertMethod(method);
EXPECT_TRUE(method->IsDirect());
EXPECT_EQ(klass, method->GetDeclaringClass());
}
for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
- Method* method = klass->GetVirtualMethod(i);
+ AbstractMethod* method = klass->GetVirtualMethod(i);
AssertMethod(method);
EXPECT_FALSE(method->IsDirect());
EXPECT_TRUE(method->GetDeclaringClass()->IsAssignableFrom(klass));
@@ -325,7 +325,7 @@
class_linker_->VisitRoots(TestRootVisitor, NULL);
// Verify the dex cache has resolution methods in all resolved method slots
DexCache* dex_cache = class_linker_->FindDexCache(*dex);
- ObjectArray<Method>* resolved_methods = dex_cache->GetResolvedMethods();
+ ObjectArray<AbstractMethod>* resolved_methods = dex_cache->GetResolvedMethods();
for (size_t i = 0; i < static_cast<size_t>(resolved_methods->GetLength()); i++) {
EXPECT_TRUE(resolved_methods->Get(i) != NULL);
}
@@ -452,36 +452,41 @@
};
};
-struct MethodOffsets : public CheckOffsets<Method> {
- MethodOffsets() : CheckOffsets<Method>(false, "Ljava/lang/reflect/Method;") {
+struct AbstractMethodOffsets : public CheckOffsets<AbstractMethod> {
+ AbstractMethodOffsets() : CheckOffsets<AbstractMethod>(false, "Ljava/lang/reflect/AbstractMethod;") {
// alphabetical references
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, declaring_class_), "declaringClass"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_initialized_static_storage_), "dexCacheInitializedStaticStorage"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_resolved_methods_), "dexCacheResolvedMethods"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_resolved_types_), "dexCacheResolvedTypes"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_strings_), "dexCacheStrings"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, declaring_class_), "declaringClass"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, dex_cache_initialized_static_storage_), "dexCacheInitializedStaticStorage"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, dex_cache_resolved_methods_), "dexCacheResolvedMethods"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, dex_cache_resolved_types_), "dexCacheResolvedTypes"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, dex_cache_strings_), "dexCacheStrings"));
// alphabetical 32-bit
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, access_flags_), "accessFlags"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, code_), "code"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, code_item_offset_), "codeItemOffset"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, core_spill_mask_), "coreSpillMask"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, fp_spill_mask_), "fpSpillMask"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, frame_size_in_bytes_), "frameSizeInBytes"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, native_gc_map_), "gcMap"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, invoke_stub_), "invokeStub"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, mapping_table_), "mappingTable"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, method_dex_index_), "methodDexIndex"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, method_index_), "methodIndex"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, native_method_), "nativeMethod"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, vmap_table_), "vmapTable"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, access_flags_), "accessFlags"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, code_), "code"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, code_item_offset_), "codeItemOffset"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, core_spill_mask_), "coreSpillMask"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, fp_spill_mask_), "fpSpillMask"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, frame_size_in_bytes_), "frameSizeInBytes"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, native_gc_map_), "gcMap"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, invoke_stub_), "invokeStub"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, mapping_table_), "mappingTable"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, method_dex_index_), "methodDexIndex"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, method_index_), "methodIndex"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, native_method_), "nativeMethod"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AbstractMethod, vmap_table_), "vmapTable"));
};
};
-struct ConstructorOffsets : public MethodOffsets {
- ConstructorOffsets() : MethodOffsets() {
- // We use Method* for both java.lang.reflect.Constructor and java.lang.reflect.Method.
- class_descriptor = "Ljava/lang/reflect/Constructor;";
+struct ConstructorOffsets : public CheckOffsets<Constructor> {
+ // java.lang.reflect.Constructor is a subclass of java.lang.reflect.AbstractMethod
+ ConstructorOffsets() : CheckOffsets<Constructor>(false, "Ljava/lang/reflect/Constructor;") {
+ }
+};
+
+struct MethodOffsets : public CheckOffsets<Method> {
+ // java.lang.reflect.Method is a subclass of java.lang.reflect.AbstractMethod
+ MethodOffsets() : CheckOffsets<Method>(false, "Ljava/lang/reflect/Method;") {
}
};
@@ -604,6 +609,19 @@
};
};
+struct DexCacheOffsets : public CheckOffsets<DexCache> {
+ DexCacheOffsets() : CheckOffsets<DexCache>(false, "Ljava/lang/DexCache;") {
+ // alphabetical references
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(DexCache, initialized_static_storage_), "initializedStaticStorage"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(DexCache, location_), "location"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(DexCache, resolved_fields_), "resolvedFields"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(DexCache, resolved_methods_), "resolvedMethods"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(DexCache, resolved_types_), "resolvedTypes"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(DexCache, strings_), "strings"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(DexCache, dex_file_), "dexFile"));
+ };
+};
+
// C++ fields must exactly match the fields in the Java classes. If this fails,
// reorder the fields in the C++ class. Managed class fields are ordered by
// ClassLinker::LinkFields.
@@ -611,14 +629,16 @@
ScopedObjectAccess soa(Thread::Current());
EXPECT_TRUE(ObjectOffsets().Check());
EXPECT_TRUE(ConstructorOffsets().Check());
- EXPECT_TRUE(FieldOffsets().Check());
EXPECT_TRUE(MethodOffsets().Check());
+ EXPECT_TRUE(FieldOffsets().Check());
+ EXPECT_TRUE(AbstractMethodOffsets().Check());
EXPECT_TRUE(ClassOffsets().Check());
EXPECT_TRUE(StringOffsets().Check());
EXPECT_TRUE(ThrowableOffsets().Check());
EXPECT_TRUE(StackTraceElementOffsets().Check());
EXPECT_TRUE(ClassLoaderOffsets().Check());
EXPECT_TRUE(ProxyOffsets().Check());
+ EXPECT_TRUE(DexCacheOffsets().Check());
EXPECT_TRUE(ClassClassOffsets().Check());
EXPECT_TRUE(StringClassOffsets().Check());
@@ -844,7 +864,7 @@
// Static final primitives that are initialized by a compile-time constant
// expression resolve to a copy of a constant value from the constant pool.
// So <clinit> should be null.
- Method* clinit = statics->FindDirectMethod("<clinit>", "()V");
+ AbstractMethod* clinit = statics->FindDirectMethod("<clinit>", "()V");
EXPECT_TRUE(clinit == NULL);
EXPECT_EQ(9U, statics->NumStaticFields());
@@ -931,15 +951,15 @@
EXPECT_TRUE(K->IsAssignableFrom(B));
EXPECT_TRUE(J->IsAssignableFrom(B));
- Method* Ii = I->FindVirtualMethod("i", "()V");
- Method* Jj1 = J->FindVirtualMethod("j1", "()V");
- Method* Jj2 = J->FindVirtualMethod("j2", "()V");
- Method* Kj1 = K->FindInterfaceMethod("j1", "()V");
- Method* Kj2 = K->FindInterfaceMethod("j2", "()V");
- Method* Kk = K->FindInterfaceMethod("k", "()V");
- Method* Ai = A->FindVirtualMethod("i", "()V");
- Method* Aj1 = A->FindVirtualMethod("j1", "()V");
- Method* Aj2 = A->FindVirtualMethod("j2", "()V");
+ AbstractMethod* Ii = I->FindVirtualMethod("i", "()V");
+ AbstractMethod* Jj1 = J->FindVirtualMethod("j1", "()V");
+ AbstractMethod* Jj2 = J->FindVirtualMethod("j2", "()V");
+ AbstractMethod* Kj1 = K->FindInterfaceMethod("j1", "()V");
+ AbstractMethod* Kj2 = K->FindInterfaceMethod("j2", "()V");
+ AbstractMethod* Kk = K->FindInterfaceMethod("k", "()V");
+ AbstractMethod* Ai = A->FindVirtualMethod("i", "()V");
+ AbstractMethod* Aj1 = A->FindVirtualMethod("j1", "()V");
+ AbstractMethod* Aj2 = A->FindVirtualMethod("j2", "()V");
ASSERT_TRUE(Ii != NULL);
ASSERT_TRUE(Jj1 != NULL);
ASSERT_TRUE(Jj2 != NULL);
@@ -984,8 +1004,8 @@
CHECK(dex_file != NULL);
Class* klass = class_linker_->FindClass("LStaticsFromCode;", class_loader.get());
- Method* clinit = klass->FindDirectMethod("<clinit>", "()V");
- Method* getS0 = klass->FindDirectMethod("getS0", "()Ljava/lang/Object;");
+ AbstractMethod* clinit = klass->FindDirectMethod("<clinit>", "()V");
+ AbstractMethod* getS0 = klass->FindDirectMethod("getS0", "()Ljava/lang/Object;");
const DexFile::StringId* string_id = dex_file->FindStringId("LStaticsFromCode;");
ASSERT_TRUE(string_id != NULL);
const DexFile::TypeId* type_id = dex_file->FindTypeId(dex_file->GetIndexForStringId(*string_id));
diff --git a/src/common_test.h b/src/common_test.h
index dee40e3..6994ac3 100644
--- a/src/common_test.h
+++ b/src/common_test.h
@@ -193,7 +193,7 @@
const uint32_t* mapping_table,
const uint16_t* vmap_table,
const uint8_t* gc_map,
- const Method::InvokeStub* invoke_stub) {
+ const AbstractMethod::InvokeStub* invoke_stub) {
return OatFile::OatMethod(NULL,
reinterpret_cast<uint32_t>(code),
frame_size_in_bytes,
@@ -209,7 +209,7 @@
);
}
- void MakeExecutable(Method* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ void MakeExecutable(AbstractMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
CHECK(method != NULL);
MethodHelper mh(method);
@@ -219,8 +219,8 @@
const std::vector<uint8_t>& invoke_stub = compiled_invoke_stub->GetCode();
MakeExecutable(invoke_stub);
- const Method::InvokeStub* method_invoke_stub =
- reinterpret_cast<const Method::InvokeStub*>(
+ const AbstractMethod::InvokeStub* method_invoke_stub =
+ reinterpret_cast<const AbstractMethod::InvokeStub*>(
CompiledCode::CodePointer(&invoke_stub[0],
compiled_invoke_stub->GetInstructionSet()));
@@ -479,7 +479,7 @@
}
}
- void CompileMethod(Method* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ void CompileMethod(AbstractMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
CHECK(method != NULL);
compiler_->CompileOne(method);
MakeExecutable(method);
@@ -495,7 +495,7 @@
std::string class_descriptor(DotToDescriptor(class_name));
Class* klass = class_linker_->FindClass(class_descriptor.c_str(), class_loader);
CHECK(klass != NULL) << "Class not found " << class_name;
- Method* method = klass->FindDirectMethod(method_name, signature);
+ AbstractMethod* method = klass->FindDirectMethod(method_name, signature);
CHECK(method != NULL) << "Direct method not found: "
<< class_name << "." << method_name << signature;
CompileMethod(method);
@@ -509,7 +509,7 @@
std::string class_descriptor(DotToDescriptor(class_name));
Class* klass = class_linker_->FindClass(class_descriptor.c_str(), class_loader);
CHECK(klass != NULL) << "Class not found " << class_name;
- Method* method = klass->FindVirtualMethod(method_name, signature);
+ 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 758e03b..7ab5614 100644
--- a/src/common_throws.cc
+++ b/src/common_throws.cc
@@ -26,7 +26,7 @@
namespace art {
-static void AddReferrerLocation(std::ostream& os, const Method* referrer)
+static void AddReferrerLocation(std::ostream& os, const AbstractMethod* referrer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (referrer != NULL) {
ClassHelper kh(referrer->GetDeclaringClass());
@@ -58,7 +58,7 @@
Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;", msg.str().c_str());
}
-void ThrowNullPointerExceptionForMethodAccess(Method* caller, uint32_t method_idx,
+void ThrowNullPointerExceptionForMethodAccess(AbstractMethod* caller, uint32_t method_idx,
InvokeType type) {
DexCache* dex_cache = caller->GetDeclaringClass()->GetDexCache();
const DexFile& dex_file = Runtime::Current()->GetClassLinker()->FindDexFile(dex_cache);
@@ -68,7 +68,7 @@
Thread::Current()->ThrowNewException("Ljava/lang/NullPointerException;", msg.str().c_str());
}
-void ThrowNullPointerExceptionFromDexPC(Method* throw_method, uint32_t dex_pc) {
+void ThrowNullPointerExceptionFromDexPC(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]);
@@ -155,8 +155,8 @@
}
void ThrowIllegalAccessErrorClassForMethodDispatch(Class* referrer, Class* accessed,
- const Method* caller,
- const Method* called,
+ const AbstractMethod* caller,
+ const AbstractMethod* called,
InvokeType type) {
std::ostringstream msg;
msg << "Illegal class access ('" << PrettyDescriptor(referrer) << "' attempting to access '"
@@ -166,7 +166,7 @@
Thread::Current()->ThrowNewException("Ljava/lang/IllegalAccessError;", msg.str().c_str());
}
-void ThrowIllegalAccessErrorMethod(Class* referrer, Method* accessed) {
+void ThrowIllegalAccessErrorMethod(Class* referrer, AbstractMethod* accessed) {
std::ostringstream msg;
msg << "Method '" << PrettyMethod(accessed) << "' is inaccessible to class '"
<< PrettyDescriptor(referrer) << "'";
@@ -182,7 +182,7 @@
Thread::Current()->ThrowNewException("Ljava/lang/IllegalAccessError;", msg.str().c_str());
}
-void ThrowIllegalAccessErrorFinalField(const Method* referrer, Field* accessed) {
+void ThrowIllegalAccessErrorFinalField(const AbstractMethod* referrer, Field* accessed) {
std::ostringstream msg;
msg << "Final field '" << PrettyField(accessed, false) << "' cannot be written to by method '"
<< PrettyMethod(referrer) << "'";
@@ -193,7 +193,7 @@
// IncompatibleClassChangeError
void ThrowIncompatibleClassChangeError(InvokeType expected_type, InvokeType found_type,
- Method* method, const Method* referrer) {
+ AbstractMethod* method, const 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;
@@ -202,9 +202,9 @@
msg.str().c_str());
}
-void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(const Method* interface_method,
+void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(const AbstractMethod* interface_method,
Object* this_object,
- const Method* referrer) {
+ const AbstractMethod* referrer) {
// Referrer is calling interface_method on this_object, however, the interface_method isn't
// implemented by this_object.
CHECK(this_object != NULL);
@@ -219,7 +219,7 @@
}
void ThrowIncompatibleClassChangeErrorField(const Field* resolved_field, bool is_static,
- const Method* referrer) {
+ const AbstractMethod* referrer) {
std::ostringstream msg;
msg << "Expected '" << PrettyField(resolved_field) << "' to be a "
<< (is_static ? "static" : "instance") << " field" << " rather than a "
@@ -232,7 +232,7 @@
// NoSuchMethodError
void ThrowNoSuchMethodError(InvokeType type, Class* c, const StringPiece& name,
- const StringPiece& signature, const Method* referrer) {
+ const StringPiece& signature, const AbstractMethod* referrer) {
std::ostringstream msg;
ClassHelper kh(c);
msg << "No " << type << " method " << name << signature
@@ -241,7 +241,7 @@
Thread::Current()->ThrowNewException("Ljava/lang/NoSuchMethodError;", msg.str().c_str());
}
-void ThrowNoSuchMethodError(uint32_t method_idx, const Method* referrer) {
+void ThrowNoSuchMethodError(uint32_t method_idx, const AbstractMethod* referrer) {
DexCache* dex_cache = referrer->GetDeclaringClass()->GetDexCache();
const DexFile& dex_file = Runtime::Current()->GetClassLinker()->FindDexFile(dex_cache);
std::ostringstream msg;
diff --git a/src/common_throws.h b/src/common_throws.h
index ca2211f..e0766b6 100644
--- a/src/common_throws.h
+++ b/src/common_throws.h
@@ -27,10 +27,10 @@
void ThrowNullPointerExceptionForFieldAccess(Field* field, bool is_read)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-void ThrowNullPointerExceptionForMethodAccess(Method* caller, uint32_t method_idx, InvokeType type)
+void ThrowNullPointerExceptionForMethodAccess(AbstractMethod* caller, uint32_t method_idx, InvokeType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-void ThrowNullPointerExceptionFromDexPC(Method* throw_method, uint32_t dex_pc)
+void ThrowNullPointerExceptionFromDexPC(AbstractMethod* throw_method, uint32_t dex_pc)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// IllegalAccessError
@@ -39,41 +39,41 @@
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void ThrowIllegalAccessErrorClassForMethodDispatch(Class* referrer, Class* accessed,
- const Method* caller, const Method* called,
+ const AbstractMethod* caller, const AbstractMethod* called,
InvokeType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-void ThrowIllegalAccessErrorMethod(Class* referrer, Method* accessed)
+void ThrowIllegalAccessErrorMethod(Class* referrer, AbstractMethod* accessed)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void ThrowIllegalAccessErrorField(Class* referrer, Field* accessed)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-void ThrowIllegalAccessErrorFinalField(const Method* referrer, Field* accessed)
+void ThrowIllegalAccessErrorFinalField(const AbstractMethod* referrer, Field* accessed)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// IncompatibleClassChangeError
void ThrowIncompatibleClassChangeError(InvokeType expected_type, InvokeType found_type,
- Method* method, const Method* referrer)
+ AbstractMethod* method, const AbstractMethod* referrer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(const Method* interface_method,
+void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(const AbstractMethod* interface_method,
Object* this_object,
- const Method* referrer)
+ const AbstractMethod* referrer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void ThrowIncompatibleClassChangeErrorField(const Field* resolved_field, bool is_static,
- const Method* referrer)
+ const AbstractMethod* referrer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// NoSuchMethodError
void ThrowNoSuchMethodError(InvokeType type, Class* c, const StringPiece& name,
- const StringPiece& signature, const Method* referrer)
+ const StringPiece& signature, const AbstractMethod* referrer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-void ThrowNoSuchMethodError(uint32_t method_idx, const Method* referrer)
+void ThrowNoSuchMethodError(uint32_t method_idx, const AbstractMethod* referrer)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
} // namespace art
diff --git a/src/compiler.cc b/src/compiler.cc
index abbb939..e8bc390 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -498,7 +498,7 @@
}
}
-void Compiler::CompileOne(const Method* method) {
+void Compiler::CompileOne(const AbstractMethod* method) {
DCHECK(!Runtime::Current()->IsStarted());
Thread* self = Thread::Current();
jobject class_loader;
@@ -682,7 +682,7 @@
class_loader, false);
}
-static Method* ComputeMethodReferencedFromCompilingMethod(ScopedObjectAccess& soa,
+static AbstractMethod* ComputeMethodReferencedFromCompilingMethod(ScopedObjectAccess& soa,
OatCompilationUnit* mUnit,
uint32_t method_idx,
InvokeType type)
@@ -822,7 +822,7 @@
return false; // Incomplete knowledge needs slow path.
}
-void Compiler::GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type, Method* method,
+void Compiler::GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type, AbstractMethod* method,
uintptr_t& direct_code, uintptr_t& direct_method) {
direct_code = 0;
direct_method = 0;
@@ -866,7 +866,7 @@
vtable_idx = -1;
direct_code = 0;
direct_method = 0;
- Method* resolved_method =
+ 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
@@ -1156,7 +1156,7 @@
it.Next();
}
while (it.HasNextDirectMethod()) {
- Method* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
+ AbstractMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
class_loader, NULL, it.GetMethodInvokeType(class_def));
if (method == NULL) {
CHECK(self->IsExceptionPending());
@@ -1165,7 +1165,7 @@
it.Next();
}
while (it.HasNextVirtualMethod()) {
- Method* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
+ AbstractMethod* method = class_linker->ResolveMethod(dex_file, it.GetMemberIndex(), dex_cache,
class_loader, NULL, it.GetMethodInvokeType(class_def));
if (method == NULL) {
CHECK(self->IsExceptionPending());
diff --git a/src/compiler.h b/src/compiler.h
index 759fcd3..a238b88 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -56,7 +56,7 @@
LOCKS_EXCLUDED(Locks::mutator_lock_);
// Compile a single Method
- void CompileOne(const Method* method)
+ void CompileOne(const AbstractMethod* method)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
bool IsDebuggingSupported() {
@@ -229,7 +229,7 @@
private:
// Compute constant code and method pointers when possible
- void GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type, Method* method,
+ void GetCodeAndMethodForDirectCall(InvokeType type, InvokeType sharp_type, AbstractMethod* method,
uintptr_t& direct_code, uintptr_t& direct_method)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -350,11 +350,11 @@
CompilerEnableAutoElfLoadingFn compiler_enable_auto_elf_loading_;
typedef const void* (*CompilerGetMethodCodeAddrFn)
- (const Compiler& compiler, const CompiledMethod* cm, const Method* method);
+ (const Compiler& compiler, const CompiledMethod* cm, const AbstractMethod* method);
CompilerGetMethodCodeAddrFn compiler_get_method_code_addr_;
- typedef const Method::InvokeStub* (*CompilerGetMethodInvokeStubAddrFn)
- (const Compiler& compiler, const CompiledInvokeStub* cm, const Method* method);
+ typedef const AbstractMethod::InvokeStub* (*CompilerGetMethodInvokeStubAddrFn)
+ (const Compiler& compiler, const CompiledInvokeStub* cm, const AbstractMethod* method);
CompilerGetMethodInvokeStubAddrFn compiler_get_method_invoke_stub_addr_;
#endif
diff --git a/src/compiler/codegen/GenCommon.cc b/src/compiler/codegen/GenCommon.cc
index 5593151..99a76da 100644
--- a/src/compiler/codegen/GenCommon.cc
+++ b/src/compiler/codegen/GenCommon.cc
@@ -698,7 +698,7 @@
RegLocation rlMethod = loadCurrMethod(cUnit);
rBase = oatAllocTemp(cUnit);
loadWordDisp(cUnit, rlMethod.lowReg,
- Method::DeclaringClassOffset().Int32Value(), rBase);
+ AbstractMethod::DeclaringClassOffset().Int32Value(), rBase);
if (oatIsTemp(cUnit, rlMethod.lowReg)) {
oatFreeTemp(cUnit, rlMethod.lowReg);
}
@@ -716,7 +716,7 @@
rBase = rARG0;
oatLockTemp(cUnit, rBase);
loadWordDisp(cUnit, rMethod,
- Method::DexCacheInitializedStaticStorageOffset().Int32Value(),
+ AbstractMethod::DexCacheInitializedStaticStorageOffset().Int32Value(),
rBase);
loadWordDisp(cUnit, rBase,
Array::DataOffset(sizeof(Object*)).Int32Value() +
@@ -793,7 +793,7 @@
RegLocation rlMethod = loadCurrMethod(cUnit);
rBase = oatAllocTemp(cUnit);
loadWordDisp(cUnit, rlMethod.lowReg,
- Method::DeclaringClassOffset().Int32Value(), rBase);
+ AbstractMethod::DeclaringClassOffset().Int32Value(), rBase);
} else {
// Medium path, static storage base in a different class which
// requires checks that the other class is initialized
@@ -808,7 +808,7 @@
rBase = rARG0;
oatLockTemp(cUnit, rBase);
loadWordDisp(cUnit, rMethod,
- Method::DexCacheInitializedStaticStorageOffset().Int32Value(),
+ AbstractMethod::DexCacheInitializedStaticStorageOffset().Int32Value(),
rBase);
loadWordDisp(cUnit, rBase,
Array::DataOffset(sizeof(Object*)).Int32Value() +
@@ -1142,7 +1142,7 @@
} else {
// We're don't need access checks, load type from dex cache
int32_t dex_cache_offset =
- Method::DexCacheResolvedTypesOffset().Int32Value();
+ AbstractMethod::DexCacheResolvedTypesOffset().Int32Value();
loadWordDisp(cUnit, rlMethod.lowReg, dex_cache_offset, resReg);
int32_t offset_of_type =
Array::DataOffset(sizeof(Class*)).Int32Value() + (sizeof(Class*)
@@ -1197,7 +1197,7 @@
oatLockCallTemps(cUnit); // Using explicit registers
loadCurrMethodDirect(cUnit, rARG2);
loadWordDisp(cUnit, rARG2,
- Method::DexCacheStringsOffset().Int32Value(), rARG0);
+ AbstractMethod::DexCacheStringsOffset().Int32Value(), rARG0);
// Might call out to helper, which will return resolved string in rRET0
#if !defined(TARGET_X86)
int rTgt = loadHelper(cUnit, ENTRYPOINT_OFFSET(pResolveStringFromCode));
@@ -1233,7 +1233,7 @@
int resReg = oatAllocTemp(cUnit);
RegLocation rlResult = oatEvalLoc(cUnit, rlDest, kCoreReg, true);
loadWordDisp(cUnit, rlMethod.lowReg,
- Method::DexCacheStringsOffset().Int32Value(), resReg);
+ AbstractMethod::DexCacheStringsOffset().Int32Value(), resReg);
loadWordDisp(cUnit, resReg, offset_of_string, rlResult.lowReg);
storeValue(cUnit, rlDest, rlResult);
}
@@ -1287,7 +1287,7 @@
// Load dex cache entry into classReg (rARG2)
loadValueDirectFixed(cUnit, rlSrc, rARG0); // rARG0 <= ref
loadWordDisp(cUnit, rARG1,
- Method::DexCacheResolvedTypesOffset().Int32Value(), classReg);
+ AbstractMethod::DexCacheResolvedTypesOffset().Int32Value(), classReg);
int32_t offset_of_type =
Array::DataOffset(sizeof(Class*)).Int32Value() + (sizeof(Class*)
* type_idx);
@@ -1369,7 +1369,7 @@
} else {
// Load dex cache entry into classReg (rARG2)
loadWordDisp(cUnit, rARG1,
- Method::DexCacheResolvedTypesOffset().Int32Value(), classReg);
+ AbstractMethod::DexCacheResolvedTypesOffset().Int32Value(), classReg);
int32_t offset_of_type =
Array::DataOffset(sizeof(Class*)).Int32Value() +
(sizeof(Class*) * type_idx);
diff --git a/src/compiler/codegen/GenInvoke.cc b/src/compiler/codegen/GenInvoke.cc
index ba580f8..3cc7c93 100644
--- a/src/compiler/codegen/GenInvoke.cc
+++ b/src/compiler/codegen/GenInvoke.cc
@@ -193,7 +193,7 @@
break;
case 1: // Get method->dex_cache_resolved_methods_
loadWordDisp(cUnit, rARG0,
- Method::DexCacheResolvedMethodsOffset().Int32Value(),
+ AbstractMethod::DexCacheResolvedMethodsOffset().Int32Value(),
rARG0);
// Set up direct code if known.
if (directCode != 0) {
@@ -224,7 +224,7 @@
#if !defined(TARGET_X86)
case 3: // Grab the code from the method*
if (directCode == 0) {
- loadWordDisp(cUnit, rARG0, Method::GetCodeOffset().Int32Value(),
+ loadWordDisp(cUnit, rARG0, AbstractMethod::GetCodeOffset().Int32Value(),
rINVOKE_TGT);
}
break;
@@ -273,7 +273,7 @@
break;
#if !defined(TARGET_X86)
case 4: // Get the compiled code address [uses rARG0, sets rINVOKE_TGT]
- loadWordDisp(cUnit, rARG0, Method::GetCodeOffset().Int32Value(),
+ loadWordDisp(cUnit, rARG0, AbstractMethod::GetCodeOffset().Int32Value(),
rINVOKE_TGT);
break;
#endif
diff --git a/src/compiler/codegen/MethodCodegenDriver.cc b/src/compiler/codegen/MethodCodegenDriver.cc
index 7d612b0..8269f8b 100644
--- a/src/compiler/codegen/MethodCodegenDriver.cc
+++ b/src/compiler/codegen/MethodCodegenDriver.cc
@@ -129,7 +129,7 @@
callInst = opReg(cUnit, kOpBlx, rINVOKE_TGT);
#else
if (fastPath && info->type != kInterface) {
- callInst = opMem(cUnit, kOpBlx, rARG0, Method::GetCodeOffset().Int32Value());
+ callInst = opMem(cUnit, kOpBlx, rARG0, AbstractMethod::GetCodeOffset().Int32Value());
} else {
int trampoline = 0;
switch (info->type) {
diff --git a/src/compiler_llvm/compiler_llvm.h b/src/compiler_llvm/compiler_llvm.h
index e9ccd4d..39223ef 100644
--- a/src/compiler_llvm/compiler_llvm.h
+++ b/src/compiler_llvm/compiler_llvm.h
@@ -36,7 +36,7 @@
class CompiledMethod;
class Compiler;
class OatCompilationUnit;
- class Method;
+ class AbstractMethod;
}
diff --git a/src/compiler_llvm/gbc_expander.cc b/src/compiler_llvm/gbc_expander.cc
index d482526..bcca08d 100644
--- a/src/compiler_llvm/gbc_expander.cc
+++ b/src/compiler_llvm/gbc_expander.cc
@@ -655,7 +655,7 @@
llvm::Value*
GBCExpanderPass::EmitLoadDexCacheStaticStorageFieldAddr(uint32_t type_idx) {
llvm::Value* static_storage_dex_cache_addr =
- EmitLoadDexCacheAddr(art::Method::DexCacheInitializedStaticStorageOffset());
+ EmitLoadDexCacheAddr(art::AbstractMethod::DexCacheInitializedStaticStorageOffset());
llvm::Value* type_idx_value = irb_.getPtrEquivInt(type_idx);
@@ -665,7 +665,7 @@
llvm::Value*
GBCExpanderPass::EmitLoadDexCacheResolvedTypeFieldAddr(uint32_t type_idx) {
llvm::Value* resolved_type_dex_cache_addr =
- EmitLoadDexCacheAddr(art::Method::DexCacheResolvedTypesOffset());
+ EmitLoadDexCacheAddr(art::AbstractMethod::DexCacheResolvedTypesOffset());
llvm::Value* type_idx_value = irb_.getPtrEquivInt(type_idx);
@@ -675,7 +675,7 @@
llvm::Value* GBCExpanderPass::
EmitLoadDexCacheResolvedMethodFieldAddr(uint32_t method_idx) {
llvm::Value* resolved_method_dex_cache_addr =
- EmitLoadDexCacheAddr(art::Method::DexCacheResolvedMethodsOffset());
+ EmitLoadDexCacheAddr(art::AbstractMethod::DexCacheResolvedMethodsOffset());
llvm::Value* method_idx_value = irb_.getPtrEquivInt(method_idx);
@@ -685,7 +685,7 @@
llvm::Value* GBCExpanderPass::
EmitLoadDexCacheStringFieldAddr(uint32_t string_idx) {
llvm::Value* string_dex_cache_addr =
- EmitLoadDexCacheAddr(art::Method::DexCacheStringsOffset());
+ EmitLoadDexCacheAddr(art::AbstractMethod::DexCacheStringsOffset());
llvm::Value* string_idx_value = irb_.getPtrEquivInt(string_idx);
@@ -983,7 +983,7 @@
llvm::Value*
GBCExpanderPass::Expand_LoadDeclaringClassSSB(llvm::Value* method_object_addr) {
return irb_.LoadFromObjectOffset(method_object_addr,
- art::Method::DeclaringClassOffset().Int32Value(),
+ art::AbstractMethod::DeclaringClassOffset().Int32Value(),
irb_.getJObjectTy(),
kTBAAConstJObject);
}
@@ -1035,7 +1035,7 @@
llvm::Value* code_addr =
irb_.LoadFromObjectOffset(callee_method_object_addr,
- art::Method::GetCodeOffset().Int32Value(),
+ art::AbstractMethod::GetCodeOffset().Int32Value(),
callee_method_type->getPointerTo(),
kTBAAJRuntime);
@@ -1710,7 +1710,7 @@
static_storage_addr =
irb_.LoadFromObjectOffset(method_object_addr,
- art::Method::DeclaringClassOffset().Int32Value(),
+ art::AbstractMethod::DeclaringClassOffset().Int32Value(),
irb_.getJObjectTy(),
kTBAAConstJObject);
} else {
@@ -1791,7 +1791,7 @@
static_storage_addr =
irb_.LoadFromObjectOffset(method_object_addr,
- art::Method::DeclaringClassOffset().Int32Value(),
+ art::AbstractMethod::DeclaringClassOffset().Int32Value(),
irb_.getJObjectTy(),
kTBAAConstJObject);
} else {
@@ -2168,7 +2168,7 @@
} else {
code_addr =
irb_.LoadFromObjectOffset(callee_method_object_addr,
- art::Method::GetCodeOffset().Int32Value(),
+ art::AbstractMethod::GetCodeOffset().Int32Value(),
GetFunctionType(callee_method_idx, is_static)->getPointerTo(),
kTBAAJRuntime);
}
diff --git a/src/compiler_llvm/jni_compiler.cc b/src/compiler_llvm/jni_compiler.cc
index 8bb8b87..5bc3bfc 100644
--- a/src/compiler_llvm/jni_compiler.cc
+++ b/src/compiler_llvm/jni_compiler.cc
@@ -80,7 +80,7 @@
// Load class object
this_object_or_class_object =
irb_.LoadFromObjectOffset(method_object_addr,
- Method::DeclaringClassOffset().Int32Value(),
+ AbstractMethod::DeclaringClassOffset().Int32Value(),
irb_.getJObjectTy(),
kTBAAConstJObject);
}
@@ -124,7 +124,7 @@
// Get callee code_addr
llvm::Value* code_addr =
irb_.LoadFromObjectOffset(method_object_addr,
- Method::NativeMethodOffset().Int32Value(),
+ AbstractMethod::NativeMethodOffset().Int32Value(),
GetFunctionType(method_idx_, is_static, true)->getPointerTo(),
kTBAAJRuntime);
diff --git a/src/compiler_llvm/jni_compiler.h b/src/compiler_llvm/jni_compiler.h
index 80494b6..c428775 100644
--- a/src/compiler_llvm/jni_compiler.h
+++ b/src/compiler_llvm/jni_compiler.h
@@ -26,7 +26,7 @@
class Compiler;
class DexCache;
class DexFile;
- class Method;
+ class AbstractMethod;
class OatCompilationUnit;
}
diff --git a/src/compiler_llvm/method_compiler.cc b/src/compiler_llvm/method_compiler.cc
index a74a6a4..61fffbe 100644
--- a/src/compiler_llvm/method_compiler.cc
+++ b/src/compiler_llvm/method_compiler.cc
@@ -2547,7 +2547,7 @@
static_storage_addr =
irb_.LoadFromObjectOffset(method_object_addr,
- Method::DeclaringClassOffset().Int32Value(),
+ AbstractMethod::DeclaringClassOffset().Int32Value(),
irb_.getJObjectTy(),
kTBAAConstJObject);
} else {
@@ -2626,7 +2626,7 @@
static_storage_addr =
irb_.LoadFromObjectOffset(method_object_addr,
- Method::DeclaringClassOffset().Int32Value(),
+ AbstractMethod::DeclaringClassOffset().Int32Value(),
irb_.getJObjectTy(),
kTBAAConstJObject);
} else {
@@ -2815,7 +2815,7 @@
} else {
code_addr =
irb_.LoadFromObjectOffset(callee_method_object_addr,
- Method::GetCodeOffset().Int32Value(),
+ AbstractMethod::GetCodeOffset().Int32Value(),
GetFunctionType(callee_method_idx, is_static)->getPointerTo(),
kTBAAJRuntime);
}
@@ -3479,7 +3479,7 @@
llvm::Value* MethodCompiler::
EmitLoadDexCacheStaticStorageFieldAddr(uint32_t type_idx) {
llvm::Value* static_storage_dex_cache_addr =
- EmitLoadDexCacheAddr(Method::DexCacheInitializedStaticStorageOffset());
+ EmitLoadDexCacheAddr(AbstractMethod::DexCacheInitializedStaticStorageOffset());
llvm::Value* type_idx_value = irb_.getPtrEquivInt(type_idx);
@@ -3490,7 +3490,7 @@
llvm::Value* MethodCompiler::
EmitLoadDexCacheResolvedTypeFieldAddr(uint32_t type_idx) {
llvm::Value* resolved_type_dex_cache_addr =
- EmitLoadDexCacheAddr(Method::DexCacheResolvedTypesOffset());
+ EmitLoadDexCacheAddr(AbstractMethod::DexCacheResolvedTypesOffset());
llvm::Value* type_idx_value = irb_.getPtrEquivInt(type_idx);
@@ -3501,7 +3501,7 @@
llvm::Value* MethodCompiler::
EmitLoadDexCacheResolvedMethodFieldAddr(uint32_t method_idx) {
llvm::Value* resolved_method_dex_cache_addr =
- EmitLoadDexCacheAddr(Method::DexCacheResolvedMethodsOffset());
+ EmitLoadDexCacheAddr(AbstractMethod::DexCacheResolvedMethodsOffset());
llvm::Value* method_idx_value = irb_.getPtrEquivInt(method_idx);
@@ -3512,7 +3512,7 @@
llvm::Value* MethodCompiler::
EmitLoadDexCacheStringFieldAddr(uint32_t string_idx) {
llvm::Value* string_dex_cache_addr =
- EmitLoadDexCacheAddr(Method::DexCacheStringsOffset());
+ EmitLoadDexCacheAddr(AbstractMethod::DexCacheStringsOffset());
llvm::Value* string_idx_value = irb_.getPtrEquivInt(string_idx);
diff --git a/src/compiler_llvm/runtime_support_llvm.h b/src/compiler_llvm/runtime_support_llvm.h
index c900717..626fe4f 100644
--- a/src/compiler_llvm/runtime_support_llvm.h
+++ b/src/compiler_llvm/runtime_support_llvm.h
@@ -26,7 +26,7 @@
//----------------------------------------------------------------------------
ShadowFrame* art_push_shadow_frame_from_code(Thread* thread, ShadowFrame* new_shadow_frame,
- Method* method, uint32_t size);
+ AbstractMethod* method, uint32_t size);
void art_pop_shadow_frame_from_code(void*);
@@ -49,7 +49,7 @@
void art_throw_exception_from_code(Object* exception);
-int32_t art_find_catch_block_from_code(Method* current_method,
+int32_t art_find_catch_block_from_code(AbstractMethod* current_method,
uint32_t ti_offset);
diff --git a/src/compiler_llvm/stub_compiler.cc b/src/compiler_llvm/stub_compiler.cc
index 46c6f21..3ac5f2a 100644
--- a/src/compiler_llvm/stub_compiler.cc
+++ b/src/compiler_llvm/stub_compiler.cc
@@ -142,7 +142,7 @@
// Invoke managed method now!
llvm::Value* code_field_offset_value =
- irb_.getPtrEquivInt(Method::GetCodeOffset().Int32Value());
+ irb_.getPtrEquivInt(AbstractMethod::GetCodeOffset().Int32Value());
llvm::Value* code_field_addr =
irb_.CreatePtrDisp(method_object_addr, code_field_offset_value,
diff --git a/src/compiler_test.cc b/src/compiler_test.cc
index 98b2142..f513511 100644
--- a/src/compiler_test.cc
+++ b/src/compiler_test.cc
@@ -106,7 +106,7 @@
}
EXPECT_EQ(dex->NumMethodIds(), dex_cache->NumResolvedMethods());
for (size_t i = 0; i < dex_cache->NumResolvedMethods(); i++) {
- Method* method = dex_cache->GetResolvedMethod(i);
+ AbstractMethod* method = dex_cache->GetResolvedMethod(i);
EXPECT_TRUE(method != NULL) << "method_idx=" << i
<< " " << dex->GetMethodDeclaringClassDescriptor(dex->GetMethodId(i))
<< " " << dex->GetMethodName(dex->GetMethodId(i));
diff --git a/src/debugger.cc b/src/debugger.cc
index 87ad446..8b87945 100644
--- a/src/debugger.cc
+++ b/src/debugger.cc
@@ -95,7 +95,7 @@
};
struct AllocRecordStackTraceElement {
- Method* method;
+ AbstractMethod* method;
uint32_t dex_pc;
int32_t LineNumber() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -119,9 +119,9 @@
};
struct Breakpoint {
- Method* method;
+ AbstractMethod* method;
uint32_t dex_pc;
- Breakpoint(Method* method, uint32_t dex_pc) : method(method), dex_pc(dex_pc) {}
+ Breakpoint(AbstractMethod* method, uint32_t dex_pc) : method(method), dex_pc(dex_pc) {}
};
static std::ostream& operator<<(std::ostream& os, const Breakpoint& rhs)
@@ -138,7 +138,7 @@
JDWP::JdwpStepSize step_size;
JDWP::JdwpStepDepth step_depth;
- const Method* method;
+ const AbstractMethod* method;
int32_t line_number; // Or -1 for native methods.
std::set<uint32_t> dex_pcs;
int stack_depth;
@@ -181,7 +181,7 @@
static std::vector<Breakpoint> gBreakpoints GUARDED_BY(gBreakpointsLock);
static SingleStepControl gSingleStepControl GUARDED_BY(gBreakpointsLock);
-static bool IsBreakpoint(Method* m, uint32_t dex_pc)
+static bool IsBreakpoint(AbstractMethod* m, uint32_t dex_pc)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
MutexLock mu(gBreakpointsLock);
for (size_t i = 0; i < gBreakpoints.size(); ++i) {
@@ -928,7 +928,7 @@
#endif
}
-static JDWP::MethodId ToMethodId(const Method* m)
+static JDWP::MethodId ToMethodId(const AbstractMethod* m)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#ifdef MOVING_GARBAGE_COLLECTOR
UNIMPLEMENTED(FATAL);
@@ -946,16 +946,16 @@
#endif
}
-static Method* FromMethodId(JDWP::MethodId mid)
+static AbstractMethod* FromMethodId(JDWP::MethodId mid)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#ifdef MOVING_GARBAGE_COLLECTOR
UNIMPLEMENTED(FATAL);
#else
- return reinterpret_cast<Method*>(static_cast<uintptr_t>(mid));
+ return reinterpret_cast<AbstractMethod*>(static_cast<uintptr_t>(mid));
#endif
}
-static void SetLocation(JDWP::JdwpLocation& location, Method* m, uint32_t dex_pc)
+static void SetLocation(JDWP::JdwpLocation& location, AbstractMethod* m, uint32_t dex_pc)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (m == NULL) {
memset(&location, 0, sizeof(location));
@@ -970,7 +970,7 @@
std::string Dbg::GetMethodName(JDWP::RefTypeId, JDWP::MethodId methodId)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* m = FromMethodId(methodId);
+ AbstractMethod* m = FromMethodId(methodId);
return MethodHelper(m).GetName();
}
@@ -1012,7 +1012,7 @@
return newSlot;
}
-static uint16_t DemangleSlot(uint16_t slot, Method* m)
+static uint16_t DemangleSlot(uint16_t slot, AbstractMethod* m)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (slot == kEclipseWorkaroundSlot) {
return 0;
@@ -1065,7 +1065,7 @@
expandBufAdd4BE(pReply, direct_method_count + virtual_method_count);
for (size_t i = 0; i < direct_method_count + virtual_method_count; ++i) {
- Method* m = (i < direct_method_count) ? c->GetDirectMethod(i) : c->GetVirtualMethod(i - direct_method_count);
+ 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());
@@ -1109,7 +1109,7 @@
return true;
}
};
- Method* m = FromMethodId(methodId);
+ AbstractMethod* m = FromMethodId(methodId);
MethodHelper mh(m);
uint64_t start, end;
if (m->IsNative()) {
@@ -1163,7 +1163,7 @@
++pContext->variable_count;
}
};
- Method* m = FromMethodId(methodId);
+ AbstractMethod* m = FromMethodId(methodId);
MethodHelper mh(m);
const DexFile::CodeItem* code_item = mh.GetCodeItem();
@@ -1676,7 +1676,7 @@
if (frame_id != GetFrameId()) {
return true; // continue
}
- Method* m = GetMethod();
+ AbstractMethod* m = GetMethod();
if (m->IsNative() || m->IsStatic()) {
this_object = NULL;
} else {
@@ -1690,7 +1690,7 @@
JDWP::FrameId frame_id;
};
-static Object* GetThis(Thread* self, Method* m, size_t frame_id)
+static Object* GetThis(Thread* self, 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()) {
@@ -1742,7 +1742,7 @@
return true; // Not our frame, carry on.
}
// TODO: check that the tag is compatible with the actual type of the slot!
- Method* m = GetMethod();
+ AbstractMethod* m = GetMethod();
uint16_t reg = DemangleSlot(slot_, m);
switch (tag_) {
@@ -1861,7 +1861,7 @@
return true; // Not our frame, carry on.
}
// TODO: check that the tag is compatible with the actual type of the slot!
- Method* m = GetMethod();
+ AbstractMethod* m = GetMethod();
uint16_t reg = DemangleSlot(slot_, m);
switch (tag_) {
@@ -1920,7 +1920,7 @@
visitor.WalkStack();
}
-void Dbg::PostLocationEvent(const Method* m, int dex_pc, Object* this_object, int event_flags) {
+void Dbg::PostLocationEvent(const AbstractMethod* m, int dex_pc, Object* this_object, int event_flags) {
Class* c = m->GetDeclaringClass();
JDWP::JdwpLocation location;
@@ -1942,8 +1942,8 @@
}
void Dbg::PostException(Thread* thread,
- JDWP::FrameId throw_frame_id, Method* throw_method, uint32_t throw_dex_pc,
- Method* catch_method, uint32_t catch_dex_pc, Throwable* exception) {
+ JDWP::FrameId throw_frame_id, AbstractMethod* throw_method, uint32_t throw_dex_pc,
+ AbstractMethod* catch_method, uint32_t catch_dex_pc, Throwable* exception) {
if (!IsDebuggerActive()) {
return;
}
@@ -1993,7 +1993,7 @@
}
size_t frame_id;
- Method* m = self->GetCurrentMethod(NULL, &frame_id);
+ AbstractMethod* m = self->GetCurrentMethod(NULL, &frame_id);
//LOG(INFO) << "UpdateDebugger " << PrettyMethod(m) << "@" << dex_pc << " frame " << frame_id;
if (dex_pc == -1) {
@@ -2097,14 +2097,14 @@
void Dbg::WatchLocation(const JDWP::JdwpLocation* location) {
MutexLock mu(gBreakpointsLock);
- Method* m = FromMethodId(location->method_id);
+ 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(gBreakpointsLock);
- Method* m = FromMethodId(location->method_id);
+ 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];
@@ -2150,7 +2150,7 @@
// annotalysis.
bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
gBreakpointsLock.AssertHeld();
- const Method* m = GetMethod();
+ const AbstractMethod* m = GetMethod();
if (!m->IsRuntimeMethod()) {
++gSingleStepControl.stack_depth;
if (gSingleStepControl.method == NULL) {
@@ -2215,7 +2215,7 @@
uint32_t last_pc;
};
gSingleStepControl.dex_pcs.clear();
- const Method* m = gSingleStepControl.method;
+ const AbstractMethod* m = gSingleStepControl.method;
if (m->IsNative()) {
gSingleStepControl.line_number = -1;
} else {
@@ -2352,7 +2352,7 @@
return status;
}
- Method* m = FromMethodId(methodId);
+ AbstractMethod* m = FromMethodId(methodId);
if (m->IsStatic() != (receiver == NULL)) {
return JDWP::ERR_INVALID_METHODID;
}
@@ -2461,9 +2461,9 @@
soa.Self()->ClearException();
// Translate the method through the vtable, unless the debugger wants to suppress it.
- Method* m = pReq->method_;
+ AbstractMethod* m = pReq->method_;
if ((pReq->options_ & JDWP::INVOKE_NONVIRTUAL) == 0 && pReq->receiver_ != NULL) {
- Method* actual_method = pReq->class_->FindVirtualMethodForVirtualOrInterface(pReq->method_);
+ 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;
@@ -3128,7 +3128,7 @@
if (depth >= kMaxAllocRecordStackDepth) {
return false;
}
- Method* m = GetMethod();
+ AbstractMethod* m = GetMethod();
if (!m->IsRuntimeMethod()) {
record->stack[depth].method = m;
record->stack[depth].dex_pc = GetDexPc();
@@ -3211,7 +3211,7 @@
<< PrettyClass(record->type);
for (size_t stack_frame = 0; stack_frame < kMaxAllocRecordStackDepth; ++stack_frame) {
- const Method* m = record->stack[stack_frame].method;
+ const AbstractMethod* m = record->stack[stack_frame].method;
if (m == NULL) {
break;
}
@@ -3330,7 +3330,7 @@
MethodHelper mh;
for (size_t i = 0; i < kMaxAllocRecordStackDepth; i++) {
- Method* m = record->stack[i].method;
+ 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 43590f8..c577590 100644
--- a/src/debugger.h
+++ b/src/debugger.h
@@ -56,7 +56,7 @@
Object* receiver_; /* not used for ClassType.InvokeMethod */
Object* thread_;
Class* class_;
- Method* method_;
+ AbstractMethod* method_;
uint32_t arg_count_;
uint64_t* arg_values_; /* will be NULL if arg_count_ == 0 */
uint32_t options_;
@@ -281,10 +281,10 @@
kMethodEntry = 0x04,
kMethodExit = 0x08,
};
- static void PostLocationEvent(const Method* method, int pcOffset, Object* thisPtr, int eventFlags)
+ static void PostLocationEvent(const AbstractMethod* method, int pcOffset, Object* thisPtr, int eventFlags)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- static void PostException(Thread* thread, JDWP::FrameId throw_frame_id, Method* throw_method,
- uint32_t throw_dex_pc, Method* catch_method, uint32_t catch_dex_pc,
+ 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)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
static void PostThreadStart(Thread* t)
diff --git a/src/dex2oat.cc b/src/dex2oat.cc
index 2a6a220..05ff0c0 100644
--- a/src/dex2oat.cc
+++ b/src/dex2oat.cc
@@ -375,12 +375,12 @@
reinterpret_cast<std::set<std::pair<uint16_t, const DexFile*> >*>(arg);
MethodHelper mh;
for (size_t i = 0; i < c->NumVirtualMethods(); ++i) {
- Method* m = c->GetVirtualMethod(i);
+ AbstractMethod* m = c->GetVirtualMethod(i);
mh.ChangeMethod(m);
ResolveExceptionsForMethod(&mh, *exceptions_to_resolve);
}
for (size_t i = 0; i < c->NumDirectMethods(); ++i) {
- Method* m = c->GetDirectMethod(i);
+ AbstractMethod* m = c->GetDirectMethod(i);
mh.ChangeMethod(m);
ResolveExceptionsForMethod(&mh, *exceptions_to_resolve);
}
diff --git a/src/dex_cache.cc b/src/dex_cache.cc
index 02a8a55..adb889b 100644
--- a/src/dex_cache.cc
+++ b/src/dex_cache.cc
@@ -23,29 +23,34 @@
namespace art {
-void DexCache::Init(String* location,
+void DexCache::Init(const DexFile* dex_file,
+ String* location,
ObjectArray<String>* strings,
ObjectArray<Class>* resolved_types,
- ObjectArray<Method>* resolved_methods,
+ ObjectArray<AbstractMethod>* resolved_methods,
ObjectArray<Field>* resolved_fields,
ObjectArray<StaticStorageBase>* initialized_static_storage) {
+ CHECK(dex_file != NULL);
CHECK(location != NULL);
CHECK(strings != NULL);
CHECK(resolved_types != NULL);
CHECK(resolved_methods != NULL);
CHECK(resolved_fields != NULL);
CHECK(initialized_static_storage != NULL);
- Set(kLocation, location);
- Set(kStrings, strings);
- Set(kResolvedTypes, resolved_types);
- Set(kResolvedMethods, resolved_methods);
- Set(kResolvedFields, resolved_fields);
- Set(kInitializedStaticStorage, initialized_static_storage);
+
+ SetFieldPtr(OFFSET_OF_OBJECT_MEMBER(DexCache, dex_file_), dex_file, false);
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(DexCache, location_), location, false);
+ SetFieldObject(StringsOffset(), strings, false);
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(DexCache, resolved_types_), resolved_types, false);
+ SetFieldObject(ResolvedMethodsOffset(), resolved_methods, false);
+ SetFieldObject(ResolvedFieldsOffset(), resolved_fields, false);
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(DexCache, initialized_static_storage_),
+ initialized_static_storage, false);
Runtime* runtime = Runtime::Current();
if (runtime->HasResolutionMethod()) {
// Initialize the resolve methods array to contain trampolines for resolution.
- Method* trampoline = runtime->GetResolutionMethod();
+ AbstractMethod* trampoline = runtime->GetResolutionMethod();
size_t length = resolved_methods->GetLength();
for (size_t i = 0; i < length; i++) {
resolved_methods->SetWithoutChecks(i, trampoline);
@@ -53,10 +58,10 @@
}
}
-void DexCache::Fixup(Method* trampoline) {
+void DexCache::Fixup(AbstractMethod* trampoline) {
// Fixup the resolve methods array to contain trampoline for resolution.
CHECK(trampoline != NULL);
- ObjectArray<Method>* resolved_methods = down_cast<ObjectArray<Method>*>(Get(kResolvedMethods));
+ ObjectArray<AbstractMethod>* resolved_methods = GetResolvedMethods();
size_t length = resolved_methods->GetLength();
for (size_t i = 0; i < length; i++) {
if (resolved_methods->GetWithoutChecks(i) == NULL) {
diff --git a/src/dex_cache.h b/src/dex_cache.h
index a08c644..8d88dc6 100644
--- a/src/dex_cache.h
+++ b/src/dex_cache.h
@@ -27,39 +27,42 @@
class Class;
class Field;
class ImageWriter;
-class Method;
+class AbstractMethod;
class String;
union JValue;
-class MANAGED DexCache : public ObjectArray<Object> {
+class MANAGED DexCacheClass : public Class {
+ private:
+ DISALLOW_IMPLICIT_CONSTRUCTORS(DexCacheClass);
+};
+
+class MANAGED DexCache : public Object {
public:
- void Init(String* location,
+ void Init(const DexFile* dex_file,
+ String* location,
ObjectArray<String>* strings,
ObjectArray<Class>* types,
- ObjectArray<Method>* methods,
+ ObjectArray<AbstractMethod>* methods,
ObjectArray<Field>* fields,
ObjectArray<StaticStorageBase>* initialized_static_storage)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void Fixup(Method* trampoline) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ void Fixup(AbstractMethod* trampoline) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
String* GetLocation() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return Get(kLocation)->AsString();
+ return GetFieldObject<String*>(OFFSET_OF_OBJECT_MEMBER(DexCache, location_), false);
}
static MemberOffset StringsOffset() {
- return MemberOffset(DataOffset(sizeof(Object*)).Int32Value() +
- kStrings * sizeof(Object*));
+ return OFFSET_OF_OBJECT_MEMBER(DexCache, strings_);
}
static MemberOffset ResolvedFieldsOffset() {
- return MemberOffset(DataOffset(sizeof(Object*)).Int32Value() +
- kResolvedFields * sizeof(Object*));
+ return OFFSET_OF_OBJECT_MEMBER(DexCache, resolved_fields_);
}
static MemberOffset ResolvedMethodsOffset() {
- return MemberOffset(DataOffset(sizeof(Object*)).Int32Value() +
- kResolvedMethods * sizeof(Object*));
+ return OFFSET_OF_OBJECT_MEMBER(DexCache, resolved_methods_);
}
size_t NumStrings() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -103,9 +106,9 @@
GetResolvedTypes()->Set(type_idx, resolved);
}
- Method* GetResolvedMethod(uint32_t method_idx) const
+ AbstractMethod* GetResolvedMethod(uint32_t method_idx) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* method = GetResolvedMethods()->Get(method_idx);
+ 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());
@@ -115,7 +118,7 @@
}
}
- void SetResolvedMethod(uint32_t method_idx, Method* resolved)
+ void SetResolvedMethod(uint32_t method_idx, AbstractMethod* resolved)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
GetResolvedMethods()->Set(method_idx, resolved);
}
@@ -132,47 +135,49 @@
ObjectArray<String>* GetStrings() const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return static_cast<ObjectArray<String>*>(GetNonNull(kStrings));
- }
- ObjectArray<Class>* GetResolvedTypes() const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return static_cast<ObjectArray<Class>*>(GetNonNull(kResolvedTypes));
- }
- ObjectArray<Method>* GetResolvedMethods() const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return static_cast<ObjectArray<Method>*>(GetNonNull(kResolvedMethods));
- }
- ObjectArray<Field>* GetResolvedFields() const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return static_cast<ObjectArray<Field>*>(GetNonNull(kResolvedFields));
- }
- ObjectArray<StaticStorageBase>* GetInitializedStaticStorage() const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- return static_cast<ObjectArray<StaticStorageBase>*>(GetNonNull(kInitializedStaticStorage));
+ return GetFieldObject< ObjectArray<String>* >(StringsOffset(), false);
}
- static size_t LengthAsArray() {
- return kMax;
+ ObjectArray<Class>* GetResolvedTypes() const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ return GetFieldObject< ObjectArray<Class>* >(
+ OFFSET_OF_OBJECT_MEMBER(DexCache, resolved_types_), false);
+ }
+
+ ObjectArray<AbstractMethod>* GetResolvedMethods() const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ return GetFieldObject< ObjectArray<AbstractMethod>* >(ResolvedMethodsOffset(), false);
+ }
+
+ ObjectArray<Field>* GetResolvedFields() const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ return GetFieldObject< ObjectArray<Field>* >(ResolvedFieldsOffset(), false);
+ }
+
+ ObjectArray<StaticStorageBase>* GetInitializedStaticStorage() const
+ SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ return GetFieldObject< ObjectArray<StaticStorageBase>* >(
+ OFFSET_OF_OBJECT_MEMBER(DexCache, initialized_static_storage_), false);
+ }
+
+ const DexFile* GetDexFile() const {
+ return GetFieldPtr<const DexFile*>(OFFSET_OF_OBJECT_MEMBER(DexCache, dex_file_), false);
+ }
+
+ void SetDexFile(const DexFile* dex_file) {
+ return SetFieldPtr(OFFSET_OF_OBJECT_MEMBER(DexCache, dex_file_), dex_file, false);
}
private:
- enum ArrayIndex {
- kLocation = 0,
- kStrings = 1,
- kResolvedTypes = 2,
- kResolvedMethods = 3,
- kResolvedFields = 4,
- kInitializedStaticStorage = 5,
- kMax = 6,
- };
+ ObjectArray<StaticStorageBase>* initialized_static_storage_;
+ String* location_;
+ ObjectArray<Object>* resolved_fields_;
+ ObjectArray<AbstractMethod>* resolved_methods_;
+ ObjectArray<Class>* resolved_types_;
+ ObjectArray<String>* strings_;
+ uint32_t dex_file_;
- Object* GetNonNull(ArrayIndex array_index) const
- SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Object* obj = Get(array_index);
- DCHECK(obj != NULL);
- return obj;
- }
-
+ friend struct DexCacheOffsets; // for verifying offset information
DISALLOW_IMPLICIT_CONSTRUCTORS(DexCache);
};
diff --git a/src/dex_file.cc b/src/dex_file.cc
index e763e67..9717134 100644
--- a/src/dex_file.cc
+++ b/src/dex_file.cc
@@ -588,7 +588,7 @@
return descriptor;
}
-int32_t DexFile::GetLineNumFromPC(const Method* method, uint32_t rel_pc) const {
+int32_t DexFile::GetLineNumFromPC(const 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) {
diff --git a/src/dex_file.h b/src/dex_file.h
index 7d39945..d28e684 100644
--- a/src/dex_file.h
+++ b/src/dex_file.h
@@ -775,7 +775,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 Method* method, uint32_t rel_pc) const
+ int32_t GetLineNumFromPC(const 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,
diff --git a/src/exception_test.cc b/src/exception_test.cc
index 6a58210..46184c5 100644
--- a/src/exception_test.cc
+++ b/src/exception_test.cc
@@ -74,8 +74,8 @@
std::vector<uint32_t> fake_mapping_data_;
std::vector<uint16_t> fake_vmap_table_data_;
- Method* method_f_;
- Method* method_g_;
+ AbstractMethod* method_f_;
+ AbstractMethod* method_g_;
private:
Class* my_klass_;
diff --git a/src/greenland/arm/arm_invoke_stub_compiler.cc b/src/greenland/arm/arm_invoke_stub_compiler.cc
index f14b35f..2360ed7 100644
--- a/src/greenland/arm/arm_invoke_stub_compiler.cc
+++ b/src/greenland/arm/arm_invoke_stub_compiler.cc
@@ -137,7 +137,7 @@
}
// Load the code pointer we are about to call.
- __ LoadFromOffset(kLoadWord, IP, R0, Method::GetCodeOffset().Int32Value());
+ __ LoadFromOffset(kLoadWord, IP, R0, AbstractMethod::GetCodeOffset().Int32Value());
// Do the call.
__ blx(IP);
diff --git a/src/greenland/runtime/support_alloc.cc b/src/greenland/runtime/support_alloc.cc
index 5198903..dd7850d 100644
--- a/src/greenland/runtime/support_alloc.cc
+++ b/src/greenland/runtime/support_alloc.cc
@@ -25,28 +25,28 @@
namespace {
Object* art_alloc_array_from_code(uint32_t type_idx,
- Method* referrer,
+ AbstractMethod* referrer,
uint32_t length,
Thread* thread) {
return AllocArrayFromCode(type_idx, referrer, length, thread, false);
}
Object* art_alloc_array_from_code_with_access_check(uint32_t type_idx,
- Method* referrer,
+ AbstractMethod* referrer,
uint32_t length,
Thread* thread) {
return AllocArrayFromCode(type_idx, referrer, length, thread, true);
}
Object* art_check_and_alloc_array_from_code(uint32_t type_idx,
- Method* referrer,
+ AbstractMethod* referrer,
uint32_t length,
Thread* thread) {
return CheckAndAllocArrayFromCode(type_idx, referrer, length, thread, false);
}
Object* art_check_and_alloc_array_from_code_with_access_check(uint32_t type_idx,
- Method* referrer,
+ AbstractMethod* referrer,
uint32_t length,
Thread* thread) {
return CheckAndAllocArrayFromCode(type_idx, referrer, length, thread, true);
diff --git a/src/greenland/runtime/support_dexcache.cc b/src/greenland/runtime/support_dexcache.cc
index 903e5cc..9d36aad 100644
--- a/src/greenland/runtime/support_dexcache.cc
+++ b/src/greenland/runtime/support_dexcache.cc
@@ -24,7 +24,7 @@
namespace {
-Object* art_resolve_string(Method* referrer, uint32_t string_idx) {
+Object* art_resolve_string(AbstractMethod* referrer, uint32_t string_idx) {
return ResolveStringFromCode(referrer, string_idx);
}
diff --git a/src/greenland/runtime/support_exception.cc b/src/greenland/runtime/support_exception.cc
index 2470051..4bc910a 100644
--- a/src/greenland/runtime/support_exception.cc
+++ b/src/greenland/runtime/support_exception.cc
@@ -25,7 +25,7 @@
namespace {
-int32_t art_find_catch_block(Method* current_method, uint32_t ti_offset) {
+int32_t art_find_catch_block(AbstractMethod* current_method, uint32_t ti_offset) {
Thread* thread = art_get_current_thread();
Class* exception_type = thread->GetException()->GetClass();
MethodHelper mh(current_method);
@@ -66,7 +66,7 @@
Thread* thread = art_get_current_thread();
NthCallerVisitor visitor(0);
thread->WalkStack(&visitor);
- Method* throw_method = visitor.caller;
+ AbstractMethod* throw_method = visitor.caller;
ThrowNullPointerExceptionFromDexPC(thread, throw_method, dex_pc);
}
diff --git a/src/greenland/runtime/support_field.cc b/src/greenland/runtime/support_field.cc
index 523740f..e5fa814 100644
--- a/src/greenland/runtime/support_field.cc
+++ b/src/greenland/runtime/support_field.cc
@@ -24,7 +24,7 @@
namespace {
-Object* art_get_obj_static_from_code(uint32_t field_idx, Method* referrer) {
+Object* art_get_obj_static_from_code(uint32_t field_idx, AbstractMethod* referrer) {
Field* field = FindFieldFast(field_idx, referrer, false, false, sizeof(Object*));
if (LIKELY(field != NULL)) {
return field->GetObj(NULL);
diff --git a/src/greenland/runtime_entry_points.h b/src/greenland/runtime_entry_points.h
index 8cd8ce44..9ee053e 100644
--- a/src/greenland/runtime_entry_points.h
+++ b/src/greenland/runtime_entry_points.h
@@ -27,7 +27,7 @@
namespace art {
-class Method;
+class AbstractMethod;
class Object;
class Thread;
@@ -40,36 +40,36 @@
//----------------------------------------------------------------------------
// Exception
//----------------------------------------------------------------------------
- int32_t (*FindCatchBlock)(Method* current_method, uint32_t ti_offset);
+ int32_t (*FindCatchBlock)(AbstractMethod* current_method, uint32_t ti_offset);
void (*ThrowIndexOutOfBounds)(int32_t length, int32_t index);
void (*ThrowNullPointerException)(unsigned dex_pc);
//----------------------------------------------------------------------------
// Alloc
//----------------------------------------------------------------------------
- Object* (*AllocArray)(uint32_t type_idx, Method* referrer,
+ Object* (*AllocArray)(uint32_t type_idx, AbstractMethod* referrer,
uint32_t length, Thread* thread);
- Object* (*AllocArrayWithAccessCheck)(uint32_t type_idx, Method* referrer,
+ Object* (*AllocArrayWithAccessCheck)(uint32_t type_idx, AbstractMethod* referrer,
uint32_t length, Thread* thread);
- Object* (*CheckAndAllocArray)(uint32_t type_idx, Method* referrer,
+ Object* (*CheckAndAllocArray)(uint32_t type_idx, AbstractMethod* referrer,
uint32_t length, Thread* thread);
Object* (*CheckAndAllocArrayWithAccessCheck)(uint32_t type_idx,
- Method* referrer,
+ AbstractMethod* referrer,
uint32_t length,
Thread* thread);
//----------------------------------------------------------------------------
// DexCache
//----------------------------------------------------------------------------
- Object* (*ResolveString)(Method* referrer, uint32_t string_idx);
+ Object* (*ResolveString)(AbstractMethod* referrer, uint32_t string_idx);
//----------------------------------------------------------------------------
// Field
//----------------------------------------------------------------------------
- Object* (*GetObjectStatic)(uint32_t field_idx, Method* referrer);
+ Object* (*GetObjectStatic)(uint32_t field_idx, AbstractMethod* referrer);
//----------------------------------------------------------------------------
// Cast
diff --git a/src/greenland/x86/x86_invoke_stub_compiler.cc b/src/greenland/x86/x86_invoke_stub_compiler.cc
index 18a7765..872a9da 100644
--- a/src/greenland/x86/x86_invoke_stub_compiler.cc
+++ b/src/greenland/x86/x86_invoke_stub_compiler.cc
@@ -128,7 +128,7 @@
}
}
- __ call(Address(EAX, Method::GetCodeOffset())); // Call code off of method
+ __ call(Address(EAX, 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/image_writer.cc b/src/image_writer.cc
index 4eec311..2ec47ec 100644
--- a/src/image_writer.cc
+++ b/src/image_writer.cc
@@ -235,7 +235,7 @@
class_linker->RemoveClass((*it).c_str(), NULL);
}
- Method* resolution_method = runtime->GetResolutionMethod();
+ AbstractMethod* resolution_method = runtime->GetResolutionMethod();
typedef Set::const_iterator CacheIt; // TODO: C++0x auto
for (CacheIt it = dex_caches_.begin(), end = dex_caches_.end(); it != end; ++it) {
DexCache* dex_cache = *it;
@@ -247,7 +247,7 @@
}
}
for (size_t i = 0; i < dex_cache->NumResolvedMethods(); i++) {
- Method* method = dex_cache->GetResolvedMethod(i);
+ AbstractMethod* method = dex_cache->GetResolvedMethod(i);
if (method != NULL && !IsImageClass(method->GetDeclaringClass())) {
dex_cache->SetResolvedMethod(i, resolution_method);
}
@@ -398,12 +398,15 @@
heap->FlushAllocStack();
}
- // TODO: Image spaces only?
{
- for (SpaceVec::const_iterator cur = spaces.begin(); cur != spaces.end(); ++cur) {
- (*cur)->GetLiveBitmap()->InOrderWalk(CalculateNewObjectOffsetsCallback, this);
+ // TODO: Image spaces only?
+ // TODO: Add InOrderWalk to heap bitmap.
+ const char* old = Thread::Current()->StartAssertNoThreadSuspension("ImageWriter");
+ for (SpaceVec::const_iterator it = spaces.begin(); it != spaces.end(); ++it) {
+ (*it)->GetLiveBitmap()->InOrderWalk(CalculateNewObjectOffsetsCallback, this);
DCHECK_LT(image_end_, image_->Size());
}
+ Thread::Current()->EndAssertNoThreadSuspension(old);
}
// Note that image_top_ is left at end of used space
@@ -421,6 +424,7 @@
void ImageWriter::CopyAndFixupObjects()
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ const char* old_cause = Thread::Current()->StartAssertNoThreadSuspension("ImageWriter");
Heap* heap = Runtime::Current()->GetHeap();
// TODO: heap validation can't handle this fix up pass
heap->DisableObjectValidation();
@@ -428,6 +432,7 @@
ReaderMutexLock mu(*Locks::heap_bitmap_lock_);
heap->FlushAllocStack();
heap->GetLiveBitmap()->Walk(CopyAndFixupObjectsCallback, this);
+ Thread::Current()->EndAssertNoThreadSuspension(old_cause);
}
void ImageWriter::CopyAndFixupObjectsCallback(Object* object, void* arg) {
@@ -461,7 +466,7 @@
} else if (orig->IsObjectArray()) {
FixupObjectArray(orig->AsObjectArray<Object>(), down_cast<ObjectArray<Object>*>(copy));
} else if (orig->IsMethod()) {
- FixupMethod(orig->AsMethod(), down_cast<Method*>(copy));
+ FixupMethod(orig->AsMethod(), down_cast<AbstractMethod*>(copy));
} else {
FixupInstanceFields(orig, copy);
}
@@ -472,7 +477,7 @@
FixupStaticFields(orig, copy);
}
-void ImageWriter::FixupMethod(const Method* orig, Method* copy) {
+void ImageWriter::FixupMethod(const AbstractMethod* orig, AbstractMethod* copy) {
FixupInstanceFields(orig, copy);
// OatWriter replaces the code_ and invoke_stub_ with offset values.
@@ -481,7 +486,7 @@
// 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<Method::InvokeStub*>(const_cast<byte*>(invoke_stub));
+ copy->invoke_stub_ = 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
@@ -603,12 +608,12 @@
}
}
-static Method* GetReferrerMethod(const Compiler::PatchInformation* patch)
+static AbstractMethod* GetReferrerMethod(const Compiler::PatchInformation* patch)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
ScopedObjectAccessUnchecked soa(Thread::Current());
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
DexCache* dex_cache = class_linker->FindDexCache(patch->GetDexFile());
- Method* method = class_linker->ResolveMethod(patch->GetDexFile(),
+ AbstractMethod* method = class_linker->ResolveMethod(patch->GetDexFile(),
patch->GetReferrerMethodIdx(),
dex_cache,
NULL,
@@ -625,11 +630,11 @@
return method;
}
-static Method* GetTargetMethod(const Compiler::PatchInformation* patch)
+static AbstractMethod* GetTargetMethod(const Compiler::PatchInformation* patch)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
DexCache* dex_cache = class_linker->FindDexCache(patch->GetDexFile());
- Method* method = class_linker->ResolveMethod(patch->GetDexFile(),
+ AbstractMethod* method = class_linker->ResolveMethod(patch->GetDexFile(),
patch->GetTargetMethodIdx(),
dex_cache,
NULL,
@@ -652,7 +657,7 @@
const std::vector<const Compiler::PatchInformation*>& code_to_patch = compiler.GetCodeToPatch();
for (size_t i = 0; i < code_to_patch.size(); i++) {
const Compiler::PatchInformation* patch = code_to_patch[i];
- Method* target = GetTargetMethod(patch);
+ AbstractMethod* target = GetTargetMethod(patch);
uint32_t code = reinterpret_cast<uint32_t>(class_linker->GetOatCodeFor(target));
uint32_t code_base = reinterpret_cast<uint32_t>(&oat_file_->GetOatHeader());
uint32_t code_offset = code - code_base;
@@ -663,14 +668,14 @@
= compiler.GetMethodsToPatch();
for (size_t i = 0; i < methods_to_patch.size(); i++) {
const Compiler::PatchInformation* patch = methods_to_patch[i];
- Method* target = GetTargetMethod(patch);
+ AbstractMethod* target = GetTargetMethod(patch);
SetPatchLocation(patch, reinterpret_cast<uint32_t>(GetImageAddress(target)));
}
}
void ImageWriter::SetPatchLocation(const Compiler::PatchInformation* patch, uint32_t value) {
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- Method* method = GetReferrerMethod(patch);
+ AbstractMethod* method = GetReferrerMethod(patch);
// Goodbye const, we are about to modify some code.
void* code = const_cast<void*>(class_linker->GetOatCodeFor(method));
// TODO: make this Thumb2 specific
diff --git a/src/image_writer.h b/src/image_writer.h
index 8e8d106..5a8da1b 100644
--- a/src/image_writer.h
+++ b/src/image_writer.h
@@ -140,7 +140,7 @@
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void FixupClass(const Class* orig, Class* copy)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void FixupMethod(const Method* orig, Method* copy)
+ void FixupMethod(const AbstractMethod* orig, AbstractMethod* copy)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void FixupObject(const Object* orig, Object* copy)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
diff --git a/src/jdwp/jdwp.h b/src/jdwp/jdwp.h
index 54e5cc7..3186006 100644
--- a/src/jdwp/jdwp.h
+++ b/src/jdwp/jdwp.h
@@ -31,7 +31,7 @@
namespace art {
-class Method;
+class AbstractMethod;
class Thread;
namespace JDWP {
diff --git a/src/jni_compiler_test.cc b/src/jni_compiler_test.cc
index e0320b3..31b14c9 100644
--- a/src/jni_compiler_test.cc
+++ b/src/jni_compiler_test.cc
@@ -44,7 +44,7 @@
ScopedObjectAccess soa(Thread::Current());
// Compile the native method before starting the runtime
Class* c = class_linker_->FindClass("LMyClassNatives;", soa.Decode<ClassLoader*>(class_loader));
- Method* method;
+ AbstractMethod* method;
if (direct) {
method = c->FindDirectMethod(method_name, method_sig);
} else {
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 6230a66..8c67fb4 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -93,7 +93,7 @@
class ArgArray {
public:
- explicit ArgArray(Method* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ explicit ArgArray(AbstractMethod* method) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
MethodHelper mh(method);
shorty_ = mh.GetShorty();
shorty_len_ = mh.GetShortyLength();
@@ -200,7 +200,7 @@
return reinterpret_cast<jweak>(ref);
}
-static void CheckMethodArguments(Method* m, JValue* args)
+static void CheckMethodArguments(AbstractMethod* m, JValue* args)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
MethodHelper mh(m);
ObjectArray<Class>* parameter_types = mh.GetParameterTypes();
@@ -226,7 +226,7 @@
}
static JValue InvokeWithArgArray(const ScopedObjectAccess& soa, Object* receiver,
- Method* method, JValue* args)
+ AbstractMethod* method, JValue* args)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (UNLIKELY(soa.Env()->check_jni)) {
CheckMethodArguments(method, args);
@@ -240,13 +240,13 @@
jmethodID mid, va_list args)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Object* receiver = soa.Decode<Object*>(obj);
- Method* method = soa.DecodeMethod(mid);
+ AbstractMethod* method = soa.DecodeMethod(mid);
ArgArray arg_array(method);
arg_array.BuildArgArray(soa, args);
return InvokeWithArgArray(soa, receiver, method, arg_array.get());
}
-static Method* FindVirtualMethod(Object* receiver, Method* method)
+static AbstractMethod* FindVirtualMethod(Object* receiver, AbstractMethod* method)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(method);
}
@@ -255,7 +255,7 @@
jobject obj, jmethodID mid, jvalue* args)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Object* receiver = soa.Decode<Object*>(obj);
- Method* method = FindVirtualMethod(receiver, soa.DecodeMethod(mid));
+ AbstractMethod* method = FindVirtualMethod(receiver, soa.DecodeMethod(mid));
ArgArray arg_array(method);
arg_array.BuildArgArray(soa, args);
return InvokeWithArgArray(soa, receiver, method, arg_array.get());
@@ -265,7 +265,7 @@
jobject obj, jmethodID mid, va_list args)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Object* receiver = soa.Decode<Object*>(obj);
- Method* method = FindVirtualMethod(receiver, soa.DecodeMethod(mid));
+ AbstractMethod* method = FindVirtualMethod(receiver, soa.DecodeMethod(mid));
ArgArray arg_array(method);
arg_array.BuildArgArray(soa, args);
return InvokeWithArgArray(soa, receiver, method, arg_array.get());
@@ -310,7 +310,7 @@
return NULL;
}
- Method* method = NULL;
+ AbstractMethod* method = NULL;
if (is_static) {
method = c->FindDirectMethod(name, sig);
} else {
@@ -332,7 +332,7 @@
static ClassLoader* GetClassLoader(Thread* self)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* method = self->GetCurrentMethod();
+ AbstractMethod* method = self->GetCurrentMethod();
if (method == NULL || PrettyMethod(method, false) == "java.lang.Runtime.nativeLoad") {
return self->GetClassLoaderOverride();
}
@@ -614,7 +614,7 @@
}
// See section 11.3 "Linking Native Methods" of the JNI spec.
- void* FindNativeMethod(const Method* m, std::string& detail)
+ void* FindNativeMethod(const AbstractMethod* m, std::string& detail)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
std::string jni_short_name(JniShortName(m));
std::string jni_long_name(JniLongName(m));
@@ -652,13 +652,13 @@
JValue InvokeWithJValues(const ScopedObjectAccess& soa, jobject obj, jmethodID mid,
jvalue* args) {
Object* receiver = soa.Decode<Object*>(obj);
- Method* method = soa.DecodeMethod(mid);
+ AbstractMethod* method = soa.DecodeMethod(mid);
ArgArray arg_array(method);
arg_array.BuildArgArray(soa, args);
return InvokeWithArgArray(soa, receiver, method, arg_array.get());
}
-JValue InvokeWithJValues(const ScopedObjectAccess& soa, Object* receiver, Method* m,
+JValue InvokeWithJValues(const ScopedObjectAccess& soa, Object* receiver, AbstractMethod* m,
JValue* args)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return InvokeWithArgArray(soa, receiver, m, args);
@@ -692,7 +692,7 @@
static jmethodID FromReflectedMethod(JNIEnv* env, jobject java_method) {
ScopedObjectAccess soa(env);
- Method* method = soa.Decode<Method*>(java_method);
+ AbstractMethod* method = soa.Decode<AbstractMethod*>(java_method);
return soa.EncodeMethod(method);
}
@@ -704,7 +704,7 @@
static jobject ToReflectedMethod(JNIEnv* env, jclass, jmethodID mid, jboolean) {
ScopedObjectAccess soa(env);
- Method* method = soa.DecodeMethod(mid);
+ AbstractMethod* method = soa.DecodeMethod(mid);
return soa.AddLocalReference<jobject>(method);
}
@@ -2125,7 +2125,7 @@
++sig;
}
- Method* m = c->FindDirectMethod(name, sig);
+ AbstractMethod* m = c->FindDirectMethod(name, sig);
if (m == NULL) {
m = c->FindVirtualMethod(name, sig);
}
@@ -2153,13 +2153,13 @@
VLOG(jni) << "[Unregistering JNI native methods for " << PrettyClass(c) << "]";
for (size_t i = 0; i < c->NumDirectMethods(); ++i) {
- Method* m = c->GetDirectMethod(i);
+ AbstractMethod* m = c->GetDirectMethod(i);
if (m->IsNative()) {
m->UnregisterNative(soa.Self());
}
}
for (size_t i = 0; i < c->NumVirtualMethods(); ++i) {
- Method* m = c->GetVirtualMethod(i);
+ AbstractMethod* m = c->GetVirtualMethod(i);
if (m->IsNative()) {
m->UnregisterNative(soa.Self());
}
@@ -2939,7 +2939,7 @@
return result;
}
-void* JavaVMExt::FindCodeForNativeMethod(Method* m) {
+void* JavaVMExt::FindCodeForNativeMethod(AbstractMethod* m) {
CHECK(m->IsNative());
Class* c = m->GetDeclaringClass();
diff --git a/src/jni_internal.h b/src/jni_internal.h
index 6833c2a..c683464 100644
--- a/src/jni_internal.h
+++ b/src/jni_internal.h
@@ -42,7 +42,7 @@
class Field;
union JValue;
class Libraries;
-class Method;
+class AbstractMethod;
class ScopedObjectAccess;
class Thread;
@@ -55,7 +55,7 @@
size_t NumArgArrayBytes(const char* shorty, uint32_t shorty_len);
JValue InvokeWithJValues(const ScopedObjectAccess&, jobject obj, jmethodID mid, jvalue* args)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-JValue InvokeWithJValues(const ScopedObjectAccess&, Object* receiver, Method* m, JValue* args)
+JValue InvokeWithJValues(const ScopedObjectAccess&, Object* receiver, AbstractMethod* m, JValue* args)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
int ThrowNewException(JNIEnv* env, jclass exception_class, const char* msg, jobject cause);
@@ -77,7 +77,7 @@
* 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(Method* m)
+ void* FindCodeForNativeMethod(AbstractMethod* m)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void DumpForSigQuit(std::ostream& os);
diff --git a/src/jni_internal_test.cc b/src/jni_internal_test.cc
index 5db258d..329b51c 100644
--- a/src/jni_internal_test.cc
+++ b/src/jni_internal_test.cc
@@ -68,7 +68,7 @@
CommonTest::TearDown();
}
- Method::InvokeStub* DoCompile(Method*& method, Object*& receiver, bool is_static,
+ AbstractMethod::InvokeStub* DoCompile(AbstractMethod*& method, 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";
@@ -91,24 +91,24 @@
receiver = (is_static ? NULL : c->AllocObject());
- Method::InvokeStub* stub = method->GetInvokeStub();
+ AbstractMethod::InvokeStub* stub = method->GetInvokeStub();
CHECK(stub != NULL);
return stub;
}
void InvokeNopMethod(bool is_static) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* method;
+ AbstractMethod* method;
Object* receiver;
- Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "nop", "()V");
+ 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_) {
- Method* method;
+ AbstractMethod* method;
Object* receiver;
- Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "identity", "(B)B");
+ AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "identity", "(B)B");
JValue args[1];
JValue result;
@@ -136,9 +136,9 @@
void InvokeIdentityIntMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* method;
+ AbstractMethod* method;
Object* receiver;
- Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "identity", "(I)I");
+ AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "identity", "(I)I");
JValue args[1];
JValue result;
@@ -166,9 +166,9 @@
void InvokeIdentityDoubleMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* method;
+ AbstractMethod* method;
Object* receiver;
- Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "identity", "(D)D");
+ AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "identity", "(D)D");
JValue args[1];
JValue result;
@@ -196,9 +196,9 @@
void InvokeSumIntIntMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* method;
+ AbstractMethod* method;
Object* receiver;
- Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(II)I");
+ AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(II)I");
JValue result;
result.SetI(-1);
@@ -235,9 +235,9 @@
void InvokeSumIntIntIntMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* method;
+ AbstractMethod* method;
Object* receiver;
- Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(III)I");
+ AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(III)I");
JValue result;
result.SetI(-1);
@@ -279,9 +279,9 @@
void InvokeSumIntIntIntIntMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* method;
+ AbstractMethod* method;
Object* receiver;
- Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(IIII)I");
+ AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(IIII)I");
JValue result;
result.SetI(-1);
@@ -328,9 +328,9 @@
void InvokeSumIntIntIntIntIntMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* method;
+ AbstractMethod* method;
Object* receiver;
- Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(IIIII)I");
+ AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(IIIII)I");
JValue result;
result.SetI(-1.0);
@@ -382,9 +382,9 @@
void InvokeSumDoubleDoubleMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* method;
+ AbstractMethod* method;
Object* receiver;
- Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(DD)D");
+ AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(DD)D");
JValue args[2];
JValue result;
@@ -422,9 +422,9 @@
void InvokeSumDoubleDoubleDoubleMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* method;
+ AbstractMethod* method;
Object* receiver;
- Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(DDD)D");
+ AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(DDD)D");
JValue args[3];
JValue result;
@@ -453,9 +453,9 @@
void InvokeSumDoubleDoubleDoubleDoubleMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* method;
+ AbstractMethod* method;
Object* receiver;
- Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(DDDD)D");
+ AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(DDDD)D");
JValue args[4];
JValue result;
@@ -487,9 +487,9 @@
void InvokeSumDoubleDoubleDoubleDoubleDoubleMethod(bool is_static)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* method;
+ AbstractMethod* method;
Object* receiver;
- Method::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(DDDDD)D");
+ AbstractMethod::InvokeStub* stub = DoCompile(method, receiver, is_static, "sum", "(DDDDD)D");
JValue args[5];
JValue result;
@@ -1388,10 +1388,10 @@
Class* klass = class_linker_->FindClass("LMain;", class_loader.get());
ASSERT_TRUE(klass != NULL);
- Method* method = klass->FindDirectMethod("main", "([Ljava/lang/String;)V");
+ AbstractMethod* method = klass->FindDirectMethod("main", "([Ljava/lang/String;)V");
ASSERT_TRUE(method != NULL);
- Method::InvokeStub* stub = method->GetInvokeStub();
+ AbstractMethod::InvokeStub* stub = method->GetInvokeStub();
JValue args[1];
args[0].SetL(NULL);
diff --git a/src/monitor.cc b/src/monitor.cc
index 6b7fbf1..6a18a90 100644
--- a/src/monitor.cc
+++ b/src/monitor.cc
@@ -205,7 +205,7 @@
uint64_t waitStart = 0;
uint64_t waitEnd = 0;
uint32_t wait_threshold = lock_profiling_threshold_;
- const Method* current_locking_method = NULL;
+ const AbstractMethod* current_locking_method = NULL;
uint32_t current_locking_dex_pc = 0;
{
ScopedThreadStateChange tsc(self, kBlocked);
@@ -461,7 +461,7 @@
int prev_lock_count = lock_count_;
lock_count_ = 0;
owner_ = NULL;
- const Method* saved_method = locking_method_;
+ const AbstractMethod* saved_method = locking_method_;
locking_method_ = NULL;
uintptr_t saved_dex_pc = locking_dex_pc_;
locking_dex_pc_ = 0;
@@ -918,7 +918,7 @@
}
void Monitor::DescribeLocks(std::ostream& os, StackVisitor* stack_visitor) {
- Method* m = stack_visitor->GetMethod();
+ AbstractMethod* m = stack_visitor->GetMethod();
CHECK(m != NULL);
// Native methods are an easy special case.
@@ -982,7 +982,7 @@
}
}
-void Monitor::TranslateLocation(const Method* method, uint32_t dex_pc,
+void Monitor::TranslateLocation(const 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) {
diff --git a/src/monitor.h b/src/monitor.h
index de70803..4a62728 100644
--- a/src/monitor.h
+++ b/src/monitor.h
@@ -56,7 +56,7 @@
#define LW_LOCK_OWNER_SHIFT 3
#define LW_LOCK_OWNER(x) (((x) >> LW_LOCK_OWNER_SHIFT) & LW_LOCK_OWNER_MASK)
-class Method;
+class AbstractMethod;
class Object;
class Thread;
class StackVisitor;
@@ -132,7 +132,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 Method* method, uint32_t pc,
+ void TranslateLocation(const AbstractMethod* method, uint32_t pc,
const char*& source_file, uint32_t& line_number) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -156,7 +156,7 @@
// Method and dex pc where the lock owner acquired the lock, used when lock
// sampling is enabled. locking_method_ may be null if the lock is currently
// unlocked, or if the lock is acquired by the system when the stack is empty.
- const Method* locking_method_ GUARDED_BY(monitor_lock_);
+ const AbstractMethod* locking_method_ GUARDED_BY(monitor_lock_);
uint32_t locking_dex_pc_ GUARDED_BY(monitor_lock_);
friend class MonitorList;
diff --git a/src/monitor_android.cc b/src/monitor_android.cc
index ce42ee7..6e22237 100644
--- a/src/monitor_android.cc
+++ b/src/monitor_android.cc
@@ -79,7 +79,7 @@
// Emit the source code file name, <= 37 bytes.
uintptr_t pc;
- Method* m = self->GetCurrentMethod(&pc);
+ AbstractMethod* m = self->GetCurrentMethod(&pc);
const char* filename;
uint32_t line_number;
TranslateLocation(m, pc, filename, line_number);
diff --git a/src/native/java_lang_Class.cc b/src/native/java_lang_Class.cc
index 68fc97e..c023b7e 100644
--- a/src/native/java_lang_Class.cc
+++ b/src/native/java_lang_Class.cc
@@ -105,7 +105,7 @@
};
#define ToArray(a, b, c) WorkAroundGccAnnotalysisBug::ToArray(a, b, c)
-static bool IsVisibleConstructor(Method* m, bool public_only) {
+static bool IsVisibleConstructor(AbstractMethod* m, bool public_only) {
if (public_only && !m->IsPublic()) {
return false;
}
@@ -118,9 +118,9 @@
static jobjectArray Class_getDeclaredConstructors(JNIEnv* env, jclass javaClass, jboolean publicOnly) {
ScopedObjectAccess soa(env);
Class* c = DecodeClass(soa, javaClass);
- std::vector<Method*> constructors;
+ std::vector<AbstractMethod*> constructors; // TODO: Use Constructor instead of AbstractMethod
for (size_t i = 0; i < c->NumDirectMethods(); ++i) {
- Method* m = c->GetDirectMethod(i);
+ AbstractMethod* m = c->GetDirectMethod(i);
if (IsVisibleConstructor(m, publicOnly)) {
constructors.push_back(m);
}
@@ -173,7 +173,7 @@
return ToArray(soa, "java/lang/reflect/Field", fields);
}
-static bool IsVisibleMethod(Method* m, bool public_only) {
+static bool IsVisibleMethod(AbstractMethod* m, bool public_only) {
if (public_only && !m->IsPublic()) {
return false;
}
@@ -193,10 +193,10 @@
return NULL;
}
- std::vector<Method*> methods;
+ std::vector<AbstractMethod*> methods;
MethodHelper mh;
for (size_t i = 0; i < c->NumVirtualMethods(); ++i) {
- Method* m = c->GetVirtualMethod(i);
+ AbstractMethod* m = c->GetVirtualMethod(i);
mh.ChangeMethod(m);
if (IsVisibleMethod(m, publicOnly)) {
if (mh.GetReturnType() == NULL || mh.GetParameterTypes() == NULL) {
@@ -210,7 +210,7 @@
}
}
for (size_t i = 0; i < c->NumDirectMethods(); ++i) {
- Method* m = c->GetDirectMethod(i);
+ AbstractMethod* m = c->GetDirectMethod(i);
mh.ChangeMethod(m);
if (IsVisibleMethod(m, publicOnly)) {
if (mh.GetReturnType() == NULL || mh.GetParameterTypes() == NULL) {
@@ -260,16 +260,17 @@
return true;
}
-static Method* FindConstructorOrMethodInArray(ObjectArray<Method>* methods, const std::string& name,
- ObjectArray<Class>* arg_array)
+static AbstractMethod* FindConstructorOrMethodInArray(ObjectArray<AbstractMethod>* methods,
+ const std::string& name,
+ ObjectArray<Class>* arg_array)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (methods == NULL) {
return NULL;
}
- Method* result = NULL;
+ AbstractMethod* result = NULL;
MethodHelper mh;
for (int32_t i = 0; i < methods->GetLength(); ++i) {
- Method* method = methods->Get(i);
+ AbstractMethod* method = methods->Get(i);
mh.ChangeMethod(method);
if (method->IsMiranda() || !MethodMatches(&mh, name, arg_array)) {
continue;
@@ -295,7 +296,7 @@
std::string name(soa.Decode<String*>(javaName)->ToModifiedUtf8());
ObjectArray<Class>* arg_array = soa.Decode<ObjectArray<Class>*>(javaArgs);
- Method* m = FindConstructorOrMethodInArray(c->GetDirectMethods(), name, arg_array);
+ AbstractMethod* m = FindConstructorOrMethodInArray(c->GetDirectMethods(), name, arg_array);
if (m == NULL) {
m = FindConstructorOrMethodInArray(c->GetVirtualMethods(), name, arg_array);
}
@@ -375,7 +376,7 @@
return NULL;
}
- Method* init = c->FindDeclaredDirectMethod("<init>", "()V");
+ AbstractMethod* init = c->FindDeclaredDirectMethod("<init>", "()V");
if (init == NULL) {
soa.Self()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
"Class %s has no default <init>()V constructor", PrettyDescriptor(ClassHelper(c).GetDescriptor()).c_str());
diff --git a/src/native/java_lang_reflect_Constructor.cc b/src/native/java_lang_reflect_Constructor.cc
index a6bd450..44b459d 100644
--- a/src/native/java_lang_reflect_Constructor.cc
+++ b/src/native/java_lang_reflect_Constructor.cc
@@ -32,7 +32,7 @@
*/
static jobject Constructor_newInstance(JNIEnv* env, jobject javaMethod, jobjectArray javaArgs) {
ScopedObjectAccess soa(env);
- Method* m = soa.Decode<Object*>(javaMethod)->AsMethod();
+ AbstractMethod* m = soa.Decode<Object*>(javaMethod)->AsMethod();
Class* c = m->GetDeclaringClass();
if (c->IsAbstract()) {
soa.Self()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
diff --git a/src/native/java_lang_reflect_Method.cc b/src/native/java_lang_reflect_Method.cc
index 2a6ee50..63a277b 100644
--- a/src/native/java_lang_reflect_Method.cc
+++ b/src/native/java_lang_reflect_Method.cc
@@ -30,7 +30,7 @@
static jobject Method_getExceptionTypesNative(JNIEnv* env, jobject javaMethod) {
ScopedObjectAccess soa(env);
- Method* proxy_method = soa.Decode<Object*>(javaMethod)->AsMethod();
+ AbstractMethod* proxy_method = soa.Decode<Object*>(javaMethod)->AsMethod();
CHECK(proxy_method->GetDeclaringClass()->IsProxyClass());
SynthesizedProxyClass* proxy_class =
down_cast<SynthesizedProxyClass*>(proxy_method->GetDeclaringClass());
@@ -49,7 +49,7 @@
static jobject Method_findOverriddenMethodNative(JNIEnv* env, jobject javaMethod) {
ScopedObjectAccess soa(env);
- Method* method = soa.Decode<Object*>(javaMethod)->AsMethod();
+ AbstractMethod* method = soa.Decode<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 81e3f169..a567268 100644
--- a/src/native/java_lang_reflect_Proxy.cc
+++ b/src/native/java_lang_reflect_Proxy.cc
@@ -27,7 +27,7 @@
String* name = soa.Decode<String*>(javaName);
ObjectArray<Class>* interfaces = soa.Decode<ObjectArray<Class>*>(javaInterfaces);
ClassLoader* loader = soa.Decode<ClassLoader*>(javaLoader);
- ObjectArray<Method>* methods = soa.Decode<ObjectArray<Method>*>(javaMethods);
+ ObjectArray<AbstractMethod>* methods = soa.Decode<ObjectArray<AbstractMethod>*>(javaMethods);
ObjectArray<ObjectArray<Class> >* throws = soa.Decode<ObjectArray<ObjectArray<Class> >*>(javaThrows);
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Class* result = class_linker->CreateProxyClass(name, interfaces, loader, methods, throws);
diff --git a/src/nth_caller_visitor.h b/src/nth_caller_visitor.h
index 0f29ae7..6b3894e 100644
--- a/src/nth_caller_visitor.h
+++ b/src/nth_caller_visitor.h
@@ -38,7 +38,7 @@
size_t n;
size_t count;
- Method* caller;
+ AbstractMethod* caller;
};
} // namespace art
diff --git a/src/oat/jni/arm/jni_internal_arm.cc b/src/oat/jni/arm/jni_internal_arm.cc
index bbbe6ad..5220669 100644
--- a/src/oat/jni/arm/jni_internal_arm.cc
+++ b/src/oat/jni/arm/jni_internal_arm.cc
@@ -129,7 +129,7 @@
}
// Load the code pointer we are about to call.
- __ LoadFromOffset(kLoadWord, IP, R0, Method::GetCodeOffset().Int32Value());
+ __ LoadFromOffset(kLoadWord, IP, R0, 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 dc1bfc7..7b710c5 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(), Method::DeclaringClassOffset());
+ mr_conv->MethodRegister(), 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(), Method::NativeMethodOffset(),
+ __ Call(main_jni_conv->MethodStackOffset(), 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 0a2ab1d..ea2d7a1 100644
--- a/src/oat/jni/mips/jni_internal_mips.cc
+++ b/src/oat/jni/mips/jni_internal_mips.cc
@@ -123,7 +123,7 @@
}
// Load the code pointer we are about to call.
- __ LoadFromOffset(kLoadWord, T9, A0, Method::GetCodeOffset().Int32Value());
+ __ LoadFromOffset(kLoadWord, T9, A0, 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 498ca43..a9d4004 100644
--- a/src/oat/jni/x86/jni_internal_x86.cc
+++ b/src/oat/jni/x86/jni_internal_x86.cc
@@ -125,7 +125,7 @@
}
}
- __ call(Address(EAX, Method::GetCodeOffset())); // Call code off of method
+ __ call(Address(EAX, 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/arm/context_arm.cc b/src/oat/runtime/arm/context_arm.cc
index 2959ef6..057f41e 100644
--- a/src/oat/runtime/arm/context_arm.cc
+++ b/src/oat/runtime/arm/context_arm.cc
@@ -34,7 +34,7 @@
}
void ArmContext::FillCalleeSaves(const StackVisitor& fr) {
- Method* method = fr.GetMethod();
+ 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 df26e21..7981466 100644
--- a/src/oat/runtime/arm/oat_support_entrypoints_arm.cc
+++ b/src/oat/runtime/arm/oat_support_entrypoints_arm.cc
@@ -33,7 +33,7 @@
extern "C" void art_check_cast_from_code(void*, void*);
// Debug entrypoints.
-extern void DebugMe(Method* method, uint32_t info);
+extern void DebugMe(AbstractMethod* method, uint32_t info);
extern "C" void art_update_debugger(void*, void*, int32_t, void*);
// DexCache entrypoints.
@@ -122,7 +122,7 @@
extern "C" int32_t art_string_compareto(void*, void*);
// Invoke entrypoints.
-const void* UnresolvedDirectMethodTrampolineFromCode(Method*, Method**, Thread*,
+const void* UnresolvedDirectMethodTrampolineFromCode(AbstractMethod*, 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*);
@@ -136,7 +136,7 @@
extern "C" void art_test_suspend();
// Throw entrypoints.
-extern void ThrowAbstractMethodErrorFromCode(Method* method, Thread* thread, Method** sp);
+extern void ThrowAbstractMethodErrorFromCode(AbstractMethod* method, Thread* thread, 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 d3c94a8..dca6d02 100644
--- a/src/oat/runtime/arm/stub_arm.cc
+++ b/src/oat/runtime/arm/stub_arm.cc
@@ -89,7 +89,7 @@
return resolution_trampoline.get();
}
-typedef void (*ThrowAme)(Method*, Thread*);
+typedef void (*ThrowAme)(AbstractMethod*, Thread*);
ByteArray* CreateAbstractMethodErrorStub() {
UniquePtr<ArmAssembler> assembler(static_cast<ArmAssembler*>(Assembler::Create(kArm)));
diff --git a/src/oat/runtime/callee_save_frame.h b/src/oat/runtime/callee_save_frame.h
index 9288a95..28bcda6 100644
--- a/src/oat/runtime/callee_save_frame.h
+++ b/src/oat/runtime/callee_save_frame.h
@@ -21,10 +21,10 @@
namespace art {
-class Method;
+class AbstractMethod;
// Place a special frame at the TOS that will save the callee saves for the given type.
-static void FinishCalleeSaveFrameSetup(Thread* self, Method** sp, Runtime::CalleeSaveType type)
+static void FinishCalleeSaveFrameSetup(Thread* self, AbstractMethod** sp, Runtime::CalleeSaveType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// Be aware the store below may well stomp on an incoming argument.
Locks::mutator_lock_->AssertSharedHeld();
diff --git a/src/oat/runtime/mips/context_mips.cc b/src/oat/runtime/mips/context_mips.cc
index ded9085..1a4cb5d 100644
--- a/src/oat/runtime/mips/context_mips.cc
+++ b/src/oat/runtime/mips/context_mips.cc
@@ -35,7 +35,7 @@
}
void MipsContext::FillCalleeSaves(const StackVisitor& fr) {
- Method* method = fr.GetMethod();
+ 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/mips/oat_support_entrypoints_mips.cc b/src/oat/runtime/mips/oat_support_entrypoints_mips.cc
index 71ea0ef..e39ec81 100644
--- a/src/oat/runtime/mips/oat_support_entrypoints_mips.cc
+++ b/src/oat/runtime/mips/oat_support_entrypoints_mips.cc
@@ -33,7 +33,7 @@
extern "C" void art_check_cast_from_code(void*, void*);
// Debug entrypoints.
-extern void DebugMe(Method* method, uint32_t info);
+extern void DebugMe(AbstractMethod* method, uint32_t info);
extern "C" void art_update_debugger(void*, void*, int32_t, void*);
// DexCache entrypoints.
@@ -121,7 +121,7 @@
extern "C" int32_t art_string_compareto(void*, void*);
// Invoke entrypoints.
-const void* UnresolvedDirectMethodTrampolineFromCode(Method*, Method**, Thread*,
+const void* UnresolvedDirectMethodTrampolineFromCode(AbstractMethod*, 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*);
@@ -135,7 +135,7 @@
extern "C" void art_test_suspend();
// Throw entrypoints.
-extern void ThrowAbstractMethodErrorFromCode(Method* method, Thread* thread, Method** sp);
+extern void ThrowAbstractMethodErrorFromCode(AbstractMethod* method, Thread* thread, 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/mips/stub_mips.cc b/src/oat/runtime/mips/stub_mips.cc
index 301fafe..8ab3f8d 100644
--- a/src/oat/runtime/mips/stub_mips.cc
+++ b/src/oat/runtime/mips/stub_mips.cc
@@ -125,7 +125,7 @@
return resolution_trampoline.get();
}
-typedef void (*ThrowAme)(Method*, Thread*);
+typedef void (*ThrowAme)(AbstractMethod*, Thread*);
ByteArray* CreateAbstractMethodErrorStub() {
UniquePtr<MipsAssembler> assembler(static_cast<MipsAssembler*>(Assembler::Create(kMips)));
diff --git a/src/oat/runtime/oat_support_entrypoints.h b/src/oat/runtime/oat_support_entrypoints.h
index a069522..ab35450 100644
--- a/src/oat/runtime/oat_support_entrypoints.h
+++ b/src/oat/runtime/oat_support_entrypoints.h
@@ -27,7 +27,7 @@
class Class;
class DvmDex;
-class Method;
+class AbstractMethod;
class Thread;
struct PACKED EntryPoints {
@@ -45,7 +45,7 @@
void (*pCheckCastFromCode)(void*, void*);
// Debug
- void (*pDebugMe)(Method*, uint32_t);
+ void (*pDebugMe)(AbstractMethod*, uint32_t);
void (*pUpdateDebuggerFromCode)(void*, void*, int32_t, void*);
// DexCache
@@ -126,7 +126,7 @@
void* (*pMemcpy)(void*, const void*, size_t);
// Invocation
- const void* (*pUnresolvedDirectMethodTrampolineFromCode)(Method*, Method**, Thread*,
+ const void* (*pUnresolvedDirectMethodTrampolineFromCode)(AbstractMethod*, AbstractMethod**, Thread*,
Runtime::TrampolineType);
void (*pInvokeDirectTrampolineWithAccessCheck)(uint32_t, void*);
void (*pInvokeInterfaceTrampoline)(uint32_t, void*);
@@ -141,7 +141,7 @@
// Throws
void (*pDeliverException)(void*);
- void (*pThrowAbstractMethodErrorFromCode)(Method* m, Thread* thread, Method** sp);
+ void (*pThrowAbstractMethodErrorFromCode)(AbstractMethod* m, Thread* thread, AbstractMethod** sp);
void (*pThrowArrayBoundsFromCode)(int32_t, int32_t);
void (*pThrowDivZeroFromCode)();
void (*pThrowNoSuchMethodFromCode)(int32_t);
diff --git a/src/oat/runtime/support_alloc.cc b/src/oat/runtime/support_alloc.cc
index fb83fad..fd7fb65 100644
--- a/src/oat/runtime/support_alloc.cc
+++ b/src/oat/runtime/support_alloc.cc
@@ -19,45 +19,47 @@
namespace art {
-extern "C" Object* artAllocObjectFromCode(uint32_t type_idx, Method* method,
- Thread* self, Method** sp)
+extern "C" Object* artAllocObjectFromCode(uint32_t type_idx, AbstractMethod* method,
+ Thread* self, 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, Method* method,
- Thread* self, Method** sp)
+extern "C" Object* artAllocObjectFromCodeWithAccessCheck(uint32_t type_idx, AbstractMethod* method,
+ Thread* self, 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, Method* method, int32_t component_count,
- Thread* self, Method** sp)
+extern "C" Array* artAllocArrayFromCode(uint32_t type_idx, AbstractMethod* method, int32_t component_count,
+ Thread* self, AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
return AllocArrayFromCode(type_idx, method, component_count, false);
}
-extern "C" Array* artAllocArrayFromCodeWithAccessCheck(uint32_t type_idx, Method* method,
+extern "C" Array* artAllocArrayFromCodeWithAccessCheck(uint32_t type_idx, AbstractMethod* method,
int32_t component_count,
- Thread* self, Method** sp)
+ Thread* self, AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
return AllocArrayFromCode(type_idx, method, component_count, true);
}
-extern "C" Array* artCheckAndAllocArrayFromCode(uint32_t type_idx, Method* method,
- int32_t component_count, Thread* self, Method** sp)
+extern "C" Array* artCheckAndAllocArrayFromCode(uint32_t type_idx, AbstractMethod* method,
+ int32_t component_count, Thread* self,
+ 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, Method* method,
+extern "C" Array* artCheckAndAllocArrayFromCodeWithAccessCheck(uint32_t type_idx,
+ AbstractMethod* method,
int32_t component_count,
- Thread* self, Method** sp)
+ Thread* self, 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 45a3e60..16eddc4 100644
--- a/src/oat/runtime/support_cast.cc
+++ b/src/oat/runtime/support_cast.cc
@@ -28,7 +28,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, Method** sp)
+extern "C" int artCheckCastFromCode(const Class* a, const Class* b, Thread* self,
+ AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(a->IsClass()) << PrettyClass(a);
DCHECK(b->IsClass()) << PrettyClass(b);
@@ -47,7 +48,7 @@
// 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, Method** sp)
+ Thread* self, 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
diff --git a/src/oat/runtime/support_debug.cc b/src/oat/runtime/support_debug.cc
index 9eaf55b..e2ca493 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, Method** sp)
+extern "C" void artUpdateDebuggerFromCode(int32_t dex_pc, Thread* self, 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(Method* method, uint32_t info)
+extern void DebugMe(AbstractMethod* method, uint32_t info)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
LOG(INFO) << "DebugMe";
if (method != NULL) {
diff --git a/src/oat/runtime/support_dexcache.cc b/src/oat/runtime/support_dexcache.cc
index 98cce55..10c7930 100644
--- a/src/oat/runtime/support_dexcache.cc
+++ b/src/oat/runtime/support_dexcache.cc
@@ -19,8 +19,8 @@
namespace art {
-extern "C" Class* artInitializeStaticStorageFromCode(uint32_t type_idx, const Method* referrer,
- Thread* self, Method** sp)
+extern "C" Class* artInitializeStaticStorageFromCode(uint32_t type_idx, const AbstractMethod* referrer,
+ Thread* self, 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,8 +29,8 @@
return ResolveVerifyAndClinit(type_idx, referrer, self, true, false);
}
-extern "C" Class* artInitializeTypeFromCode(uint32_t type_idx, const Method* referrer, Thread* self,
- Method** sp)
+extern "C" Class* artInitializeTypeFromCode(uint32_t type_idx, const AbstractMethod* referrer,
+ Thread* self, AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// Called when method->dex_cache_resolved_types_[] misses.
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
@@ -38,8 +38,9 @@
}
extern "C" Class* artInitializeTypeAndVerifyAccessFromCode(uint32_t type_idx,
- const Method* referrer, Thread* self,
- Method** sp)
+ const AbstractMethod* referrer,
+ Thread* self,
+ 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.
@@ -47,8 +48,8 @@
return ResolveVerifyAndClinit(type_idx, referrer, self, false, true);
}
-extern "C" String* artResolveStringFromCode(Method* referrer, int32_t string_idx,
- Thread* self, Method** sp)
+extern "C" String* artResolveStringFromCode(AbstractMethod* referrer, int32_t string_idx,
+ Thread* self, 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 90a99da..53b53b2 100644
--- a/src/oat/runtime/support_field.cc
+++ b/src/oat/runtime/support_field.cc
@@ -21,8 +21,8 @@
namespace art {
-extern "C" uint32_t artGet32StaticFromCode(uint32_t field_idx, const Method* referrer,
- Thread* self, Method** sp)
+extern "C" uint32_t artGet32StaticFromCode(uint32_t field_idx, const AbstractMethod* referrer,
+ Thread* self, AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(int32_t));
if (LIKELY(field != NULL)) {
@@ -36,8 +36,8 @@
return 0; // Will throw exception by checking with Thread::Current
}
-extern "C" uint64_t artGet64StaticFromCode(uint32_t field_idx, const Method* referrer,
- Thread* self, Method** sp)
+extern "C" uint64_t artGet64StaticFromCode(uint32_t field_idx, const AbstractMethod* referrer,
+ Thread* self, AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(int64_t));
if (LIKELY(field != NULL)) {
@@ -51,8 +51,8 @@
return 0; // Will throw exception by checking with Thread::Current
}
-extern "C" Object* artGetObjStaticFromCode(uint32_t field_idx, const Method* referrer,
- Thread* self, Method** sp)
+extern "C" Object* artGetObjStaticFromCode(uint32_t field_idx, const AbstractMethod* referrer,
+ Thread* self, AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Field* field = FindFieldFast(field_idx, referrer, StaticObjectRead, sizeof(Object*));
if (LIKELY(field != NULL)) {
@@ -67,7 +67,8 @@
}
extern "C" uint32_t artGet32InstanceFromCode(uint32_t field_idx, Object* obj,
- const Method* referrer, Thread* self, Method** sp)
+ const AbstractMethod* referrer, Thread* self,
+ AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(int32_t));
if (LIKELY(field != NULL && obj != NULL)) {
@@ -86,7 +87,8 @@
}
extern "C" uint64_t artGet64InstanceFromCode(uint32_t field_idx, Object* obj,
- const Method* referrer, Thread* self, Method** sp)
+ const AbstractMethod* referrer, Thread* self,
+ AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(int64_t));
if (LIKELY(field != NULL && obj != NULL)) {
@@ -105,7 +107,8 @@
}
extern "C" Object* artGetObjInstanceFromCode(uint32_t field_idx, Object* obj,
- const Method* referrer, Thread* self, Method** sp)
+ const AbstractMethod* referrer, Thread* self,
+ AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Field* field = FindFieldFast(field_idx, referrer, InstanceObjectRead, sizeof(Object*));
if (LIKELY(field != NULL && obj != NULL)) {
@@ -124,7 +127,8 @@
}
extern "C" int artSet32StaticFromCode(uint32_t field_idx, uint32_t new_value,
- const Method* referrer, Thread* self, Method** sp)
+ const AbstractMethod* referrer, Thread* self,
+ AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite, sizeof(int32_t));
if (LIKELY(field != NULL)) {
@@ -140,8 +144,8 @@
return -1; // failure
}
-extern "C" int artSet64StaticFromCode(uint32_t field_idx, const Method* referrer,
- uint64_t new_value, Thread* self, Method** sp)
+extern "C" int artSet64StaticFromCode(uint32_t field_idx, const AbstractMethod* referrer,
+ uint64_t new_value, Thread* self, AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite, sizeof(int64_t));
if (LIKELY(field != NULL)) {
@@ -158,7 +162,8 @@
}
extern "C" int artSetObjStaticFromCode(uint32_t field_idx, Object* new_value,
- const Method* referrer, Thread* self, Method** sp)
+ const AbstractMethod* referrer, Thread* self,
+ AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Field* field = FindFieldFast(field_idx, referrer, StaticObjectWrite, sizeof(Object*));
if (LIKELY(field != NULL)) {
@@ -177,7 +182,8 @@
}
extern "C" int artSet32InstanceFromCode(uint32_t field_idx, Object* obj, uint32_t new_value,
- const Method* referrer, Thread* self, Method** sp)
+ const AbstractMethod* referrer, Thread* self,
+ AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite, sizeof(int32_t));
if (LIKELY(field != NULL && obj != NULL)) {
@@ -198,10 +204,10 @@
}
extern "C" int artSet64InstanceFromCode(uint32_t field_idx, Object* obj, uint64_t new_value,
- Thread* self, Method** sp)
+ Thread* self, AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* callee_save = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsOnly);
- Method* referrer = sp[callee_save->GetFrameSizeInBytes() / sizeof(Method*)];
+ 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));
if (LIKELY(field != NULL && obj != NULL)) {
field->Set64(obj, new_value);
@@ -222,7 +228,8 @@
}
extern "C" int artSetObjInstanceFromCode(uint32_t field_idx, Object* obj, Object* new_value,
- const Method* referrer, Thread* self, Method** sp)
+ const AbstractMethod* referrer, Thread* self,
+ AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Field* field = FindFieldFast(field_idx, referrer, InstanceObjectWrite, sizeof(Object*));
if (LIKELY(field != NULL && obj != NULL)) {
diff --git a/src/oat/runtime/support_fillarray.cc b/src/oat/runtime/support_fillarray.cc
index 62b9cf9..9c6231f 100644
--- a/src/oat/runtime/support_fillarray.cc
+++ b/src/oat/runtime/support_fillarray.cc
@@ -37,7 +37,7 @@
*/
extern "C" int artHandleFillArrayDataFromCode(Array* array,
const Instruction::ArrayDataPayload* payload,
- Thread* self, Method** sp)
+ Thread* self, 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_invoke.cc b/src/oat/runtime/support_invoke.cc
index 540e46b..87497cc 100644
--- a/src/oat/runtime/support_invoke.cc
+++ b/src/oat/runtime/support_invoke.cc
@@ -19,10 +19,10 @@
namespace art {
-static uint64_t artInvokeCommon(uint32_t method_idx, Object* this_object, Method* caller_method,
- Thread* self, Method** sp, bool access_check, InvokeType type)
+static uint64_t artInvokeCommon(uint32_t method_idx, Object* this_object, AbstractMethod* caller_method,
+ Thread* self, AbstractMethod** sp, bool access_check, InvokeType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* method = FindMethodFast(method_idx, this_object, caller_method, access_check, type);
+ AbstractMethod* method = FindMethodFast(method_idx, this_object, caller_method, access_check, type);
if (UNLIKELY(method == NULL)) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsAndArgs);
if (UNLIKELY(this_object == NULL && type != kDirect && type != kStatic)) {
@@ -54,16 +54,17 @@
// See comments in runtime_support_asm.S
extern "C" uint64_t artInvokeInterfaceTrampoline(uint32_t method_idx, Object* this_object,
- Method* caller_method, Thread* self,
- Method** sp)
+ AbstractMethod* caller_method, Thread* self,
+ AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return artInvokeCommon(method_idx, this_object, caller_method, self, sp, false, kInterface);
}
extern "C" uint64_t artInvokeInterfaceTrampolineWithAccessCheck(uint32_t method_idx,
Object* this_object,
- Method* caller_method, Thread* self,
- Method** sp)
+ AbstractMethod* caller_method,
+ Thread* self,
+ AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return artInvokeCommon(method_idx, this_object, caller_method, self, sp, true, kInterface);
}
@@ -71,32 +72,36 @@
extern "C" uint64_t artInvokeDirectTrampolineWithAccessCheck(uint32_t method_idx,
Object* this_object,
- Method* caller_method, Thread* self,
- Method** sp)
+ AbstractMethod* caller_method,
+ Thread* self,
+ 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,
- Method* caller_method, Thread* self,
- Method** sp)
+ AbstractMethod* caller_method,
+ Thread* self,
+ 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,
- Method* caller_method, Thread* self,
- Method** sp)
+ AbstractMethod* caller_method,
+ Thread* self,
+ 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,
- Method* caller_method, Thread* self,
- Method** sp)
+ AbstractMethod* caller_method,
+ Thread* self,
+ 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 2c6f766..6116d56 100644
--- a/src/oat/runtime/support_jni.cc
+++ b/src/oat/runtime/support_jni.cc
@@ -28,7 +28,7 @@
DCHECK(Thread::Current() == self);
ScopedObjectAccess soa(self);
- Method* method = self->GetCurrentMethod();
+ AbstractMethod* method = self->GetCurrentMethod();
DCHECK(method != NULL);
// Lookup symbol address for method, on failure we'll return NULL with an
@@ -136,7 +136,7 @@
// | unused |
// | unused |
// | unused | <- sp
- Method* jni_method = self->GetCurrentMethod();
+ 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 9d44e55..f3a3106 100644
--- a/src/oat/runtime/support_locks.cc
+++ b/src/oat/runtime/support_locks.cc
@@ -19,7 +19,7 @@
namespace art {
-extern "C" int artUnlockObjectFromCode(Object* obj, Thread* self, Method** sp)
+extern "C" int artUnlockObjectFromCode(Object* obj, Thread* self, AbstractMethod** sp)
UNLOCK_FUNCTION(monitor_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
DCHECK(obj != NULL); // Assumed to have been checked before entry
@@ -27,7 +27,7 @@
return obj->MonitorExit(self) ? 0 /* Success */ : -1 /* Failure */;
}
-extern "C" void artLockObjectFromCode(Object* obj, Thread* thread, Method** sp)
+extern "C" void artLockObjectFromCode(Object* obj, Thread* thread, 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 8c40aba..4ff2e5f 100644
--- a/src/oat/runtime/support_proxy.cc
+++ b/src/oat/runtime/support_proxy.cc
@@ -46,11 +46,11 @@
// which is responsible for recording callee save registers. We explicitly handlerize incoming
// reference arguments (so they survive GC) and create a boxed argument array. Finally we invoke
// the invocation handler which is a field within the proxy object receiver.
-extern "C" void artProxyInvokeHandler(Method* proxy_method, Object* receiver,
+extern "C" void artProxyInvokeHandler(AbstractMethod* proxy_method, Object* receiver,
Thread* self, byte* stack_args)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
// Register the top of the managed stack
- Method** proxy_sp = reinterpret_cast<Method**>(stack_args - SP_OFFSET_IN_BYTES);
+ AbstractMethod** proxy_sp = reinterpret_cast<AbstractMethod**>(stack_args - SP_OFFSET_IN_BYTES);
DCHECK_EQ(*proxy_sp, proxy_method);
self->SetTopOfStack(proxy_sp, 0);
DCHECK_EQ(proxy_method->GetFrameSizeInBytes(), FRAME_SIZE_IN_BYTES);
@@ -112,7 +112,7 @@
args_jobj[2].l = soa.AddLocalReference<jobjectArray>(args);
}
// Convert proxy method into expected interface method
- Method* interface_method = proxy_method->FindOverriddenMethod();
+ AbstractMethod* interface_method = proxy_method->FindOverriddenMethod();
DCHECK(interface_method != NULL);
DCHECK(!interface_method->IsProxyMethod()) << PrettyMethod(interface_method);
args_jobj[1].l = soa.AddLocalReference<jobject>(interface_method);
diff --git a/src/oat/runtime/support_stubs.cc b/src/oat/runtime/support_stubs.cc
index 5df7da3..fa8356e 100644
--- a/src/oat/runtime/support_stubs.cc
+++ b/src/oat/runtime/support_stubs.cc
@@ -32,7 +32,7 @@
#if !defined(ART_USE_LLVM_COMPILER)
// Lazily resolve a method. Called by stub code.
-const void* UnresolvedDirectMethodTrampolineFromCode(Method* called, Method** sp, Thread* thread,
+const void* UnresolvedDirectMethodTrampolineFromCode(AbstractMethod* called, AbstractMethod** sp, Thread* thread,
Runtime::TrampolineType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
#if defined(__arm__)
@@ -52,7 +52,7 @@
// | R0 |
// | Method* | <- sp
DCHECK_EQ(48U, Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes());
- Method** caller_sp = reinterpret_cast<Method**>(reinterpret_cast<byte*>(sp) + 48);
+ AbstractMethod** caller_sp = reinterpret_cast<AbstractMethod**>(reinterpret_cast<byte*>(sp) + 48);
uintptr_t* regs = reinterpret_cast<uintptr_t*>(reinterpret_cast<byte*>(sp) + kPointerSize);
uintptr_t caller_pc = regs[10];
#elif defined(__i386__)
@@ -71,12 +71,12 @@
// | ECX | arg1
// | EAX/Method* | <- sp
DCHECK_EQ(32U, Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs)->GetFrameSizeInBytes());
- Method** caller_sp = reinterpret_cast<Method**>(reinterpret_cast<byte*>(sp) + 32);
+ AbstractMethod** caller_sp = reinterpret_cast<AbstractMethod**>(reinterpret_cast<byte*>(sp) + 32);
uintptr_t* regs = reinterpret_cast<uintptr_t*>(reinterpret_cast<byte*>(sp));
uintptr_t caller_pc = regs[7];
#else
UNIMPLEMENTED(FATAL);
- Method** caller_sp = NULL;
+ AbstractMethod** caller_sp = NULL;
uintptr_t* regs = NULL;
uintptr_t caller_pc = 0;
#endif
@@ -88,7 +88,7 @@
// Compute details about the called method (avoid GCs)
ClassLinker* linker = Runtime::Current()->GetClassLinker();
- Method* caller = *caller_sp;
+ AbstractMethod* caller = *caller_sp;
InvokeType invoke_type;
uint32_t dex_method_idx;
#if !defined(__i386__)
@@ -227,11 +227,11 @@
return code;
}
#else // ART_USE_LLVM_COMPILER
-const void* UnresolvedDirectMethodTrampolineFromCode(Method* called, Method** called_addr,
+const void* UnresolvedDirectMethodTrampolineFromCode(AbstractMethod* called, AbstractMethod** called_addr,
Thread* thread, Runtime::TrampolineType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
uint32_t dex_pc;
- Method* caller = thread->GetCurrentMethod(&dex_pc);
+ AbstractMethod* caller = thread->GetCurrentMethod(&dex_pc);
ClassLinker* linker = Runtime::Current()->GetClassLinker();
InvokeType invoke_type;
@@ -321,7 +321,7 @@
#if !defined(ART_USE_LLVM_COMPILER)
// Called by the AbstractMethodError. Called by stub code.
-extern void ThrowAbstractMethodErrorFromCode(Method* method, Thread* thread, Method** sp)
+extern void ThrowAbstractMethodErrorFromCode(AbstractMethod* method, Thread* thread, AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
thread->ThrowNewExceptionF("Ljava/lang/AbstractMethodError;",
@@ -329,7 +329,7 @@
thread->DeliverException();
}
#else // ART_USE_LLVM_COMPILER
-extern void ThrowAbstractMethodErrorFromCode(Method* method, Thread* thread, Method**)
+extern void ThrowAbstractMethodErrorFromCode(AbstractMethod* method, Thread* thread, 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 20fe3e5..2eef424 100644
--- a/src/oat/runtime/support_thread.cc
+++ b/src/oat/runtime/support_thread.cc
@@ -27,7 +27,7 @@
thread->FullSuspendCheck();
}
-extern "C" void artTestSuspendFromCode(Thread* thread, Method** sp)
+extern "C" void artTestSuspendFromCode(Thread* thread, 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 6e1e101..12295b1 100644
--- a/src/oat/runtime/support_throw.cc
+++ b/src/oat/runtime/support_throw.cc
@@ -23,14 +23,15 @@
namespace art {
// Deliver an exception that's pending on thread helping set up a callee save frame on the way.
-extern "C" void artDeliverPendingExceptionFromCode(Thread* thread, Method** sp)
+extern "C" void artDeliverPendingExceptionFromCode(Thread* thread, AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
thread->DeliverException();
}
// Called by generated call to throw an exception.
-extern "C" void artDeliverExceptionFromCode(Throwable* exception, Thread* thread, Method** sp)
+extern "C" void artDeliverExceptionFromCode(Throwable* exception, Thread* thread,
+ AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
/*
* exception may be NULL, in which case this routine should
@@ -49,17 +50,19 @@
}
// Called by generated call to throw a NPE exception.
-extern "C" void artThrowNullPointerExceptionFromCode(Thread* self, Method** sp)
+extern "C" void artThrowNullPointerExceptionFromCode(Thread* self,
+ AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
uint32_t dex_pc;
- Method* throw_method = self->GetCurrentMethod(&dex_pc);
+ AbstractMethod* throw_method = self->GetCurrentMethod(&dex_pc);
ThrowNullPointerExceptionFromDexPC(throw_method, dex_pc);
self->DeliverException();
}
// Called by generated call to throw an arithmetic divide by zero exception.
-extern "C" void artThrowDivZeroFromCode(Thread* thread, Method** sp)
+extern "C" void artThrowDivZeroFromCode(Thread* thread,
+ AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
thread->ThrowNewException("Ljava/lang/ArithmeticException;", "divide by zero");
@@ -67,7 +70,8 @@
}
// Called by generated call to throw an array index out of bounds exception.
-extern "C" void artThrowArrayBoundsFromCode(int index, int limit, Thread* thread, Method** sp)
+extern "C" void artThrowArrayBoundsFromCode(int index, int limit, Thread* thread,
+ AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
thread->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
@@ -75,7 +79,7 @@
thread->DeliverException();
}
-extern "C" void artThrowStackOverflowFromCode(Thread* thread, Method** sp)
+extern "C" void artThrowStackOverflowFromCode(Thread* thread, AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(thread, sp, Runtime::kSaveAll);
// Remove extra entry pushed onto second stack during method tracing.
@@ -89,10 +93,11 @@
thread->DeliverException();
}
-extern "C" void artThrowNoSuchMethodFromCode(int32_t method_idx, Thread* self, Method** sp)
+extern "C" void artThrowNoSuchMethodFromCode(int32_t method_idx, Thread* self,
+ AbstractMethod** sp)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kSaveAll);
- Method* method = self->GetCurrentMethod();
+ AbstractMethod* method = self->GetCurrentMethod();
ThrowNoSuchMethodError(method_idx, method);
self->DeliverException();
}
diff --git a/src/oat/runtime/support_trace.cc b/src/oat/runtime/support_trace.cc
index c6fbfef..67317a9 100644
--- a/src/oat/runtime/support_trace.cc
+++ b/src/oat/runtime/support_trace.cc
@@ -20,7 +20,7 @@
namespace art {
-extern "C" const void* artTraceMethodEntryFromCode(Method* method, Thread* self, uintptr_t lr) {
+extern "C" const void* artTraceMethodEntryFromCode(AbstractMethod* method, Thread* self, uintptr_t lr) {
Trace* tracer = Runtime::Current()->GetTracer();
TraceStackFrame trace_frame = TraceStackFrame(method, lr);
self->PushTraceStackFrame(trace_frame);
@@ -33,7 +33,7 @@
extern "C" uintptr_t artTraceMethodExitFromCode() {
Trace* tracer = Runtime::Current()->GetTracer();
TraceStackFrame trace_frame = Thread::Current()->PopTraceStackFrame();
- Method* method = trace_frame.method_;
+ AbstractMethod* method = trace_frame.method_;
uintptr_t lr = trace_frame.return_pc_;
tracer->LogMethodTraceEvent(Thread::Current(), method, Trace::kMethodTraceExit);
diff --git a/src/oat/runtime/x86/context_x86.cc b/src/oat/runtime/x86/context_x86.cc
index 4d84f2b..4ff2283 100644
--- a/src/oat/runtime/x86/context_x86.cc
+++ b/src/oat/runtime/x86/context_x86.cc
@@ -32,7 +32,7 @@
}
void X86Context::FillCalleeSaves(const StackVisitor& fr) {
- Method* method = fr.GetMethod();
+ 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 9ff4a07..b4eaf60 100644
--- a/src/oat/runtime/x86/oat_support_entrypoints_x86.cc
+++ b/src/oat/runtime/x86/oat_support_entrypoints_x86.cc
@@ -33,7 +33,7 @@
extern "C" void art_check_cast_from_code(void*, void*);
// Debug entrypoints.
-extern void DebugMe(Method* method, uint32_t info);
+extern void DebugMe(AbstractMethod* method, uint32_t info);
// DexCache entrypoints.
extern "C" void* art_initialize_static_storage_from_code(uint32_t, void*);
@@ -97,7 +97,7 @@
extern "C" void* art_memcpy(void*, const void*, size_t);
// Invoke entrypoints.
-const void* UnresolvedDirectMethodTrampolineFromCode(Method*, Method**, Thread*,
+const void* UnresolvedDirectMethodTrampolineFromCode(AbstractMethod*, 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*);
@@ -111,7 +111,7 @@
extern "C" void art_test_suspend();
// Throw entrypoints.
-extern void ThrowAbstractMethodErrorFromCode(Method* method, Thread* thread, Method** sp);
+extern void ThrowAbstractMethodErrorFromCode(AbstractMethod* method, Thread* thread, 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 74e0f39..97b686f 100644
--- a/src/oat/runtime/x86/stub_x86.cc
+++ b/src/oat/runtime/x86/stub_x86.cc
@@ -99,7 +99,7 @@
return resolution_trampoline.get();
}
-typedef void (*ThrowAme)(Method*, Thread*);
+typedef void (*ThrowAme)(AbstractMethod*, Thread*);
ByteArray* CreateAbstractMethodErrorStub() {
UniquePtr<X86Assembler> assembler(static_cast<X86Assembler*>(Assembler::Create(kX86)));
diff --git a/src/oat_file.cc b/src/oat_file.cc
index 2a21baa..93ff7a6 100644
--- a/src/oat_file.cc
+++ b/src/oat_file.cc
@@ -334,9 +334,9 @@
return reinterpret_cast<uint32_t*>(code)[-1];
}
-Method::InvokeStub* OatFile::OatMethod::GetInvokeStub() const {
+AbstractMethod::InvokeStub* OatFile::OatMethod::GetInvokeStub() const {
const byte* stub = GetOatPointer<const byte*>(invoke_stub_offset_);
- return reinterpret_cast<Method::InvokeStub*>(const_cast<byte*>(stub));
+ return reinterpret_cast<AbstractMethod::InvokeStub*>(const_cast<byte*>(stub));
}
uint32_t OatFile::OatMethod::GetInvokeStubSize() const {
@@ -355,7 +355,7 @@
}
#endif
-void OatFile::OatMethod::LinkMethodPointers(Method* method) const {
+void OatFile::OatMethod::LinkMethodPointers(AbstractMethod* method) const {
CHECK(method != NULL);
method->SetCode(GetCode());
method->SetFrameSizeInBytes(frame_size_in_bytes_);
@@ -367,7 +367,7 @@
method->SetInvokeStub(GetInvokeStub());
}
-void OatFile::OatMethod::LinkMethodOffsets(Method* method) const {
+void OatFile::OatMethod::LinkMethodOffsets(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 91df927..de7cf14 100644
--- a/src/oat_file.h
+++ b/src/oat_file.h
@@ -65,10 +65,10 @@
class OatMethod {
public:
// Link Method for execution using the contents of this OatMethod
- void LinkMethodPointers(Method* method) const;
+ void LinkMethodPointers(AbstractMethod* method) const;
// Link Method for image writing using the contents of this OatMethod
- void LinkMethodOffsets(Method* method) const;
+ void LinkMethodOffsets(AbstractMethod* method) const;
uint32_t GetCodeOffset() const {
return code_offset_;
@@ -108,7 +108,7 @@
return GetOatPointer<const uint8_t*>(native_gc_map_offset_);
}
- Method::InvokeStub* GetInvokeStub() const;
+ AbstractMethod::InvokeStub* GetInvokeStub() const;
uint32_t GetInvokeStubSize() const;
#if defined(ART_USE_LLVM_COMPILER)
diff --git a/src/oat_test.cc b/src/oat_test.cc
index 0886864..ae4aae2 100644
--- a/src/oat_test.cc
+++ b/src/oat_test.cc
@@ -23,7 +23,7 @@
class OatTest : public CommonTest {
protected:
- void CheckMethod(Method* method,
+ void CheckMethod(AbstractMethod* method,
const OatFile::OatMethod& oat_method,
const DexFile* dex_file)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
diff --git a/src/oat_writer.cc b/src/oat_writer.cc
index 2eb80ec..2969c21 100644
--- a/src/oat_writer.cc
+++ b/src/oat_writer.cc
@@ -397,7 +397,7 @@
DexCache* dex_cache = linker->FindDexCache(*dex_file);
// Unchecked as we hold mutator_lock_ on entry.
ScopedObjectAccessUnchecked soa(Thread::Current());
- Method* method = linker->ResolveMethod(*dex_file, method_idx, dex_cache,
+ AbstractMethod* method = linker->ResolveMethod(*dex_file, method_idx, dex_cache,
soa.Decode<ClassLoader*>(class_loader_), NULL, type);
CHECK(method != NULL);
method->SetFrameSizeInBytes(frame_size_in_bytes);
diff --git a/src/oatdump.cc b/src/oatdump.cc
index d3bebfd..88d6976 100644
--- a/src/oatdump.cc
+++ b/src/oatdump.cc
@@ -156,7 +156,7 @@
return oat_file_.GetOatHeader().GetInstructionSet();
}
- const void* GetOatCode(Method* m) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ const void* GetOatCode(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];
@@ -611,7 +611,7 @@
Field* field = value->AsField();
StringAppendF(&summary, "%p Field: %s\n", field, PrettyField(field).c_str());
} else if (value->IsMethod()) {
- Method* method = value->AsMethod();
+ AbstractMethod* method = value->AsMethod();
StringAppendF(&summary, "%p Method: %s\n", method, PrettyMethod(method).c_str());
} else {
StringAppendF(&summary, "%p %s\n", value, PrettyDescriptor(type).c_str());
@@ -666,7 +666,7 @@
return image_space_.Contains(object);
}
- const void* GetOatCodeBegin(Method* m)
+ const void* GetOatCodeBegin(AbstractMethod* m)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Runtime* runtime = Runtime::Current();
const void* code = m->GetCode();
@@ -679,7 +679,7 @@
return code;
}
- uint32_t GetOatCodeSize(Method* m)
+ uint32_t GetOatCodeSize(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) {
@@ -688,7 +688,7 @@
return oat_code_begin[-1];
}
- const void* GetOatCodeEnd(Method* m)
+ const void* GetOatCodeEnd(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) {
@@ -768,7 +768,7 @@
}
}
} else if (obj->IsMethod()) {
- Method* method = obj->AsMethod();
+ AbstractMethod* method = obj->AsMethod();
if (method->IsNative()) {
DCHECK(method->GetNativeGcMap() == NULL) << PrettyMethod(method);
DCHECK(method->GetMappingTable() == NULL) << PrettyMethod(method);
@@ -895,7 +895,7 @@
size_t dex_instruction_bytes;
- std::vector<Method*> method_outlier;
+ std::vector<AbstractMethod*> method_outlier;
std::vector<size_t> method_outlier_size;
std::vector<double> method_outlier_expansion;
@@ -947,7 +947,7 @@
return (static_cast<double>(size) / static_cast<double>(object_bytes)) * 100;
}
- void ComputeOutliers(size_t total_size, double expansion, Method* method) {
+ void ComputeOutliers(size_t total_size, double expansion, 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 49c0706..8908abb 100644
--- a/src/oatexec.cc
+++ b/src/oatexec.cc
@@ -40,7 +40,8 @@
}
// We now have a Method instance. We need to call its
// getModifiers() method.
- jmethodID mid = env->GetMethodID(WellKnownClasses::java_lang_reflect_Method, "getModifiers", "()I");
+ jmethodID mid = env->GetMethodID(WellKnownClasses::java_lang_reflect_AbstractMethod,
+ "getModifiers", "()I");
if (mid == NULL) {
fprintf(stderr, "Failed to find java.lang.reflect.Method.getModifiers\n");
return false;
diff --git a/src/object.cc b/src/object.cc
index f2043b1..e4b5f98 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -313,10 +313,10 @@
}
// TODO: get global references for these
-Class* Method::java_lang_reflect_Constructor_ = NULL;
-Class* Method::java_lang_reflect_Method_ = NULL;
+Class* AbstractMethod::java_lang_reflect_Constructor_ = NULL;
+Class* AbstractMethod::java_lang_reflect_Method_ = NULL;
-InvokeType Method::GetInvokeType() const {
+InvokeType AbstractMethod::GetInvokeType() const {
// TODO: kSuper?
if (GetDeclaringClass()->IsInterface()) {
return kInterface;
@@ -329,7 +329,7 @@
}
}
-void Method::SetClasses(Class* java_lang_reflect_Constructor, Class* java_lang_reflect_Method) {
+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;
@@ -339,7 +339,7 @@
java_lang_reflect_Method_ = java_lang_reflect_Method;
}
-void Method::ResetClasses() {
+void AbstractMethod::ResetClasses() {
CHECK(java_lang_reflect_Constructor_ != NULL);
java_lang_reflect_Constructor_ = NULL;
@@ -347,48 +347,48 @@
java_lang_reflect_Method_ = NULL;
}
-ObjectArray<String>* Method::GetDexCacheStrings() const {
+ObjectArray<String>* AbstractMethod::GetDexCacheStrings() const {
return GetFieldObject<ObjectArray<String>*>(
- OFFSET_OF_OBJECT_MEMBER(Method, dex_cache_strings_), false);
+ OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_strings_), false);
}
-void Method::SetDexCacheStrings(ObjectArray<String>* new_dex_cache_strings) {
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Method, dex_cache_strings_),
+void AbstractMethod::SetDexCacheStrings(ObjectArray<String>* new_dex_cache_strings) {
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_strings_),
new_dex_cache_strings, false);
}
-ObjectArray<Method>* Method::GetDexCacheResolvedMethods() const {
- return GetFieldObject<ObjectArray<Method>*>(
- OFFSET_OF_OBJECT_MEMBER(Method, dex_cache_resolved_methods_), false);
+ObjectArray<AbstractMethod>* AbstractMethod::GetDexCacheResolvedMethods() const {
+ return GetFieldObject<ObjectArray<AbstractMethod>*>(
+ OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_methods_), false);
}
-void Method::SetDexCacheResolvedMethods(ObjectArray<Method>* new_dex_cache_methods) {
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Method, dex_cache_resolved_methods_),
+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>* Method::GetDexCacheResolvedTypes() const {
+ObjectArray<Class>* AbstractMethod::GetDexCacheResolvedTypes() const {
return GetFieldObject<ObjectArray<Class>*>(
- OFFSET_OF_OBJECT_MEMBER(Method, dex_cache_resolved_types_), false);
+ OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_types_), false);
}
-void Method::SetDexCacheResolvedTypes(ObjectArray<Class>* new_dex_cache_classes) {
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Method, dex_cache_resolved_types_),
+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>* Method::GetDexCacheInitializedStaticStorage() const {
+ObjectArray<StaticStorageBase>* AbstractMethod::GetDexCacheInitializedStaticStorage() const {
return GetFieldObject<ObjectArray<StaticStorageBase>*>(
- OFFSET_OF_OBJECT_MEMBER(Method, dex_cache_initialized_static_storage_),
+ OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_initialized_static_storage_),
false);
}
-void Method::SetDexCacheInitializedStaticStorage(ObjectArray<StaticStorageBase>* new_value) {
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Method, dex_cache_initialized_static_storage_),
+void AbstractMethod::SetDexCacheInitializedStaticStorage(ObjectArray<StaticStorageBase>* new_value) {
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_initialized_static_storage_),
new_value, false);
}
-size_t Method::NumArgRegisters(const StringPiece& shorty) {
+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) {
@@ -402,19 +402,19 @@
return num_registers;
}
-bool Method::IsProxyMethod() const {
+bool AbstractMethod::IsProxyMethod() const {
return GetDeclaringClass()->IsProxyClass();
}
-Method* Method::FindOverriddenMethod() const {
+AbstractMethod* AbstractMethod::FindOverriddenMethod() const {
if (IsStatic()) {
return NULL;
}
Class* declaring_class = GetDeclaringClass();
Class* super_class = declaring_class->GetSuperClass();
uint16_t method_index = GetMethodIndex();
- ObjectArray<Method>* super_class_vtable = super_class->GetVTable();
- Method* result = NULL;
+ 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()) {
@@ -433,7 +433,7 @@
InterfaceEntry* entry = iftable->Get(i);
Class* interface = entry->GetInterface();
for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
- Method* interface_method = interface->GetVirtualMethod(j);
+ AbstractMethod* interface_method = interface->GetVirtualMethod(j);
interface_mh.ChangeMethod(interface_method);
if (mh.HasSameNameAndSignature(&interface_mh)) {
result = interface_method;
@@ -450,7 +450,8 @@
return result;
}
-static const void* GetOatCode(const Method* m) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+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.
@@ -464,11 +465,11 @@
return code;
}
-uintptr_t Method::NativePcOffset(const uintptr_t pc) const {
+uintptr_t AbstractMethod::NativePcOffset(const uintptr_t pc) const {
return pc - reinterpret_cast<uintptr_t>(GetOatCode(this));
}
-uint32_t Method::ToDexPc(const uintptr_t pc) const {
+uint32_t AbstractMethod::ToDexPc(const uintptr_t pc) const {
#if !defined(ART_USE_LLVM_COMPILER)
const uint32_t* mapping_table = GetMappingTable();
if (mapping_table == NULL) {
@@ -491,7 +492,7 @@
#endif
}
-uintptr_t Method::ToNativePc(const uint32_t dex_pc) const {
+uintptr_t AbstractMethod::ToNativePc(const uint32_t dex_pc) const {
const uint32_t* mapping_table = GetMappingTable();
if (mapping_table == NULL) {
DCHECK_EQ(dex_pc, 0U);
@@ -509,7 +510,7 @@
return 0;
}
-uint32_t Method::FindCatchBlock(Class* exception_type, uint32_t dex_pc) const {
+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
@@ -533,7 +534,7 @@
return DexFile::kDexNoIndex;
}
-void Method::Invoke(Thread* self, Object* receiver, JValue* args, JValue* result) const {
+void AbstractMethod::Invoke(Thread* self, Object* receiver, JValue* args, JValue* result) const {
if (kIsDebugBuild) {
self->AssertThreadSuspensionIsAllowable();
MutexLock mu(*Locks::thread_suspend_count_lock_);
@@ -546,7 +547,7 @@
// Call the invoke stub associated with the method.
// Pass everything as arguments.
- Method::InvokeStub* stub = GetInvokeStub();
+ AbstractMethod::InvokeStub* stub = GetInvokeStub();
bool have_executable_code = (GetCode() != NULL);
@@ -574,23 +575,23 @@
self->PopManagedStackFragment(fragment);
}
-bool Method::IsRegistered() const {
- void* native_method = GetFieldPtr<void*>(OFFSET_OF_OBJECT_MEMBER(Method, native_method_), false);
+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 Method::RegisterNative(Thread* self, const void* native_method) {
+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(Method, native_method_),
+ 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(Method, native_method_),
+ 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
@@ -598,18 +599,18 @@
// 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(Method, native_method_),
+ 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(Method, native_gc_map_),
+ SetFieldPtr<const uint8_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_gc_map_),
reinterpret_cast<const uint8_t*>(native_method), false);
}
#endif
}
-void Method::UnregisterNative(Thread* self) {
+void AbstractMethod::UnregisterNative(Thread* self) {
CHECK(IsNative()) << PrettyMethod(this);
// restore stub to lookup native pointer via dlsym
RegisterNative(self, Runtime::Current()->GetJniDlsymLookupStub()->GetData());
@@ -931,7 +932,7 @@
SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, class_loader_), new_class_loader, false);
}
-Method* Class::FindVirtualMethodForInterface(Method* method) {
+AbstractMethod* Class::FindVirtualMethodForInterface(AbstractMethod* method) {
Class* declaring_class = method->GetDeclaringClass();
DCHECK(declaring_class != NULL) << PrettyClass(this);
DCHECK(declaring_class->IsInterface()) << PrettyMethod(method);
@@ -947,9 +948,9 @@
return NULL;
}
-Method* Class::FindInterfaceMethod(const StringPiece& name, const StringPiece& signature) const {
+AbstractMethod* Class::FindInterfaceMethod(const StringPiece& name, const StringPiece& signature) const {
// Check the current class before checking the interfaces.
- Method* method = FindDeclaredVirtualMethod(name, signature);
+ AbstractMethod* method = FindDeclaredVirtualMethod(name, signature);
if (method != NULL) {
return method;
}
@@ -965,9 +966,9 @@
return NULL;
}
-Method* Class::FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
+AbstractMethod* Class::FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
// Check the current class before checking the interfaces.
- Method* method = FindDeclaredVirtualMethod(dex_cache, dex_method_idx);
+ AbstractMethod* method = FindDeclaredVirtualMethod(dex_cache, dex_method_idx);
if (method != NULL) {
return method;
}
@@ -984,10 +985,10 @@
}
-Method* Class::FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature) const {
+AbstractMethod* Class::FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature) const {
MethodHelper mh;
for (size_t i = 0; i < NumDirectMethods(); ++i) {
- Method* method = GetDirectMethod(i);
+ AbstractMethod* method = GetDirectMethod(i);
mh.ChangeMethod(method);
if (name == mh.GetName() && signature == mh.GetSignature()) {
return method;
@@ -996,10 +997,10 @@
return NULL;
}
-Method* Class::FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
+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) {
- Method* method = GetDirectMethod(i);
+ AbstractMethod* method = GetDirectMethod(i);
if (method->GetDexMethodIndex() == dex_method_idx) {
return method;
}
@@ -1008,9 +1009,9 @@
return NULL;
}
-Method* Class::FindDirectMethod(const StringPiece& name, const StringPiece& signature) const {
+AbstractMethod* Class::FindDirectMethod(const StringPiece& name, const StringPiece& signature) const {
for (const Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) {
- Method* method = klass->FindDeclaredDirectMethod(name, signature);
+ AbstractMethod* method = klass->FindDeclaredDirectMethod(name, signature);
if (method != NULL) {
return method;
}
@@ -1018,9 +1019,9 @@
return NULL;
}
-Method* Class::FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
+AbstractMethod* Class::FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
for (const Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) {
- Method* method = klass->FindDeclaredDirectMethod(dex_cache, dex_method_idx);
+ AbstractMethod* method = klass->FindDeclaredDirectMethod(dex_cache, dex_method_idx);
if (method != NULL) {
return method;
}
@@ -1028,11 +1029,11 @@
return NULL;
}
-Method* Class::FindDeclaredVirtualMethod(const StringPiece& name,
+AbstractMethod* Class::FindDeclaredVirtualMethod(const StringPiece& name,
const StringPiece& signature) const {
MethodHelper mh;
for (size_t i = 0; i < NumVirtualMethods(); ++i) {
- Method* method = GetVirtualMethod(i);
+ AbstractMethod* method = GetVirtualMethod(i);
mh.ChangeMethod(method);
if (name == mh.GetName() && signature == mh.GetSignature()) {
return method;
@@ -1041,10 +1042,10 @@
return NULL;
}
-Method* Class::FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
+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) {
- Method* method = GetVirtualMethod(i);
+ AbstractMethod* method = GetVirtualMethod(i);
if (method->GetDexMethodIndex() == dex_method_idx) {
return method;
}
@@ -1053,9 +1054,9 @@
return NULL;
}
-Method* Class::FindVirtualMethod(const StringPiece& name, const StringPiece& signature) const {
+AbstractMethod* Class::FindVirtualMethod(const StringPiece& name, const StringPiece& signature) const {
for (const Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) {
- Method* method = klass->FindDeclaredVirtualMethod(name, signature);
+ AbstractMethod* method = klass->FindDeclaredVirtualMethod(name, signature);
if (method != NULL) {
return method;
}
@@ -1063,9 +1064,9 @@
return NULL;
}
-Method* Class::FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
+AbstractMethod* Class::FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const {
for (const Class* klass = this; klass != NULL; klass = klass->GetSuperClass()) {
- Method* method = klass->FindDeclaredVirtualMethod(dex_cache, dex_method_idx);
+ AbstractMethod* method = klass->FindDeclaredVirtualMethod(dex_cache, dex_method_idx);
if (method != NULL) {
return method;
}
@@ -1495,7 +1496,7 @@
IntArray* pc_trace = down_cast<IntArray*>(method_trace->Get(depth));
MethodHelper mh;
for (int32_t i = 0; i < depth; ++i) {
- Method* method = down_cast<Method*>(method_trace->Get(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);
diff --git a/src/object.h b/src/object.h
index 5d19ffc..5a9a825 100644
--- a/src/object.h
+++ b/src/object.h
@@ -46,7 +46,8 @@
class Field;
class InterfaceEntry;
class Monitor;
-class Method;
+class Member;
+class AbstractMethod;
class Object;
class StaticStorageBase;
class String;
@@ -250,14 +251,14 @@
bool IsMethod() const;
- Method* AsMethod() {
+ AbstractMethod* AsMethod() {
DCHECK(IsMethod());
- return down_cast<Method*>(this);
+ return down_cast<AbstractMethod*>(this);
}
- const Method* AsMethod() const {
+ const AbstractMethod* AsMethod() const {
DCHECK(IsMethod());
- return down_cast<const Method*>(this);
+ return down_cast<const AbstractMethod*>(this);
}
bool IsField() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -506,10 +507,10 @@
};
// C++ mirror of java.lang.reflect.Method and java.lang.reflect.Constructor
-class MANAGED Method : public Object {
+class MANAGED AbstractMethod : public Object {
public:
// A function that invokes a method with an array of its arguments.
- typedef void InvokeStub(const Method* method,
+ typedef void InvokeStub(const AbstractMethod* method,
Object* obj,
Thread* thread,
JValue* args,
@@ -520,13 +521,13 @@
void SetDeclaringClass(Class *new_declaring_class);
static MemberOffset DeclaringClassOffset() {
- return MemberOffset(OFFSETOF_MEMBER(Method, declaring_class_));
+ return MemberOffset(OFFSETOF_MEMBER(AbstractMethod, declaring_class_));
}
uint32_t GetAccessFlags() const;
void SetAccessFlags(uint32_t new_access_flags) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(Method, access_flags_), new_access_flags, false);
+ SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, access_flags_), new_access_flags, false);
}
// Approximate what kind of method call would be used for this method.
@@ -598,19 +599,19 @@
}
void SetMethodIndex(uint16_t new_method_index) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(Method, method_index_), new_method_index, false);
+ SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_index_), new_method_index, false);
}
static MemberOffset MethodIndexOffset() {
- return OFFSET_OF_OBJECT_MEMBER(Method, method_index_);
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_index_);
}
uint32_t GetCodeItemOffset() const {
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, code_item_offset_), false);
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, code_item_offset_), false);
}
void SetCodeItemOffset(uint32_t new_code_off) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(Method, code_item_offset_), new_code_off, false);
+ 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
@@ -619,31 +620,31 @@
uint32_t GetDexMethodIndex() const;
void SetDexMethodIndex(uint32_t new_idx) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(Method, method_dex_index_), new_idx, false);
+ SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_dex_index_), new_idx, false);
}
ObjectArray<String>* GetDexCacheStrings() const;
void SetDexCacheStrings(ObjectArray<String>* new_dex_cache_strings);
static MemberOffset DexCacheStringsOffset() {
- return OFFSET_OF_OBJECT_MEMBER(Method, dex_cache_strings_);
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_strings_);
}
static MemberOffset DexCacheResolvedMethodsOffset() {
- return OFFSET_OF_OBJECT_MEMBER(Method, dex_cache_resolved_methods_);
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_methods_);
}
static MemberOffset DexCacheResolvedTypesOffset() {
- return OFFSET_OF_OBJECT_MEMBER(Method, dex_cache_resolved_types_);
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, dex_cache_resolved_types_);
}
static MemberOffset DexCacheInitializedStaticStorageOffset() {
- return OFFSET_OF_OBJECT_MEMBER(Method,
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod,
dex_cache_initialized_static_storage_);
}
- ObjectArray<Method>* GetDexCacheResolvedMethods() const;
- void SetDexCacheResolvedMethods(ObjectArray<Method>* new_dex_cache_methods);
+ ObjectArray<AbstractMethod>* GetDexCacheResolvedMethods() const;
+ void SetDexCacheResolvedMethods(ObjectArray<AbstractMethod>* new_dex_cache_methods);
ObjectArray<Class>* GetDexCacheResolvedTypes() const;
void SetDexCacheResolvedTypes(ObjectArray<Class>* new_dex_cache_types);
@@ -652,17 +653,17 @@
void SetDexCacheInitializedStaticStorage(ObjectArray<StaticStorageBase>* new_value);
// Find the method that this method overrides
- Method* FindOverriddenMethod() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ AbstractMethod* FindOverriddenMethod() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
void Invoke(Thread* self, Object* receiver, JValue* args, JValue* result) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
const void* GetCode() const {
- return GetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(Method, code_), false);
+ return GetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, code_), false);
}
void SetCode(const void* code) {
- SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(Method, code_), code, false);
+ SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, code_), code, false);
}
uint32_t GetCodeSize() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -704,7 +705,7 @@
}
static MemberOffset GetCodeOffset() {
- return OFFSET_OF_OBJECT_MEMBER(Method, code_);
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, code_);
}
const uint32_t* GetMappingTable() const {
@@ -724,11 +725,11 @@
}
const uint32_t* GetMappingTableRaw() const {
- return GetFieldPtr<const uint32_t*>(OFFSET_OF_OBJECT_MEMBER(Method, mapping_table_), false);
+ 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(Method, mapping_table_),
+ SetFieldPtr<const uint32_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, mapping_table_),
mapping_table, false);
}
@@ -744,11 +745,11 @@
// 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(Method, vmap_table_), false);
+ 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(Method, vmap_table_), vmap_table, false);
+ SetFieldPtr<const uint16_t*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, vmap_table_), vmap_table, false);
}
uint32_t GetOatVmapTableOffset() const {
@@ -762,10 +763,11 @@
}
const uint8_t* GetNativeGcMap() const {
- return GetFieldPtr<uint8_t*>(OFFSET_OF_OBJECT_MEMBER(Method, native_gc_map_), false);
+ 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(Method, native_gc_map_), data, false);
+ 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.
@@ -781,14 +783,14 @@
size_t GetFrameSizeInBytes() const {
DCHECK_EQ(sizeof(size_t), sizeof(uint32_t));
- size_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(Method, frame_size_in_bytes_), false);
+ 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(Method, frame_size_in_bytes_),
+ SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, frame_size_in_bytes_),
new_frame_size_in_bytes, false);
}
@@ -804,7 +806,7 @@
void UnregisterNative(Thread* self) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
static MemberOffset NativeMethodOffset() {
- return OFFSET_OF_OBJECT_MEMBER(Method, native_method_);
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, native_method_);
}
const void* GetNativeMethod() const {
@@ -814,13 +816,13 @@
// Native to managed invocation stub entry point
InvokeStub* GetInvokeStub() const {
InvokeStub* result = GetFieldPtr<InvokeStub*>(
- OFFSET_OF_OBJECT_MEMBER(Method, invoke_stub_), false);
+ 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(Method, invoke_stub_),
+ SetFieldPtr<InvokeStub*>(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, invoke_stub_),
invoke_stub, false);
}
@@ -845,29 +847,29 @@
}
static MemberOffset GetInvokeStubOffset() {
- return OFFSET_OF_OBJECT_MEMBER(Method, invoke_stub_);
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, invoke_stub_);
}
static MemberOffset GetMethodIndexOffset() {
- return OFFSET_OF_OBJECT_MEMBER(Method, method_index_);
+ return OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_index_);
}
uint32_t GetCoreSpillMask() const {
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, core_spill_mask_), false);
+ 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(Method, core_spill_mask_), core_spill_mask, false);
+ SetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, core_spill_mask_), core_spill_mask, false);
}
uint32_t GetFpSpillMask() const {
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, fp_spill_mask_), false);
+ 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(Method, fp_spill_mask_), fp_spill_mask, false);
+ 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
@@ -923,7 +925,7 @@
static void ResetClasses();
- private:
+ protected:
// Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
// The class we are a part of
Class* declaring_class_;
@@ -991,8 +993,18 @@
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(Method);
+ DISALLOW_IMPLICIT_CONSTRUCTORS(AbstractMethod);
+};
+
+class MANAGED Method : public AbstractMethod {
+
+};
+
+class MANAGED Constructor : public AbstractMethod {
+
};
class MANAGED Array : public Object {
@@ -1536,29 +1548,29 @@
void SetDexCache(DexCache* new_dex_cache);
- ObjectArray<Method>* GetDirectMethods() const {
+ ObjectArray<AbstractMethod>* GetDirectMethods() const {
DCHECK(IsLoaded() || IsErroneous());
- return GetFieldObject<ObjectArray<Method>*>(
+ return GetFieldObject<ObjectArray<AbstractMethod>*>(
OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_), false);
}
- void SetDirectMethods(ObjectArray<Method>* new_direct_methods) {
- DCHECK(NULL == GetFieldObject<ObjectArray<Method>*>(
+ void SetDirectMethods(ObjectArray<AbstractMethod>* new_direct_methods) {
+ 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);
}
- Method* GetDirectMethod(int32_t i) const
+ AbstractMethod* GetDirectMethod(int32_t i) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
return GetDirectMethods()->Get(i);
}
- void SetDirectMethod(uint32_t i, Method* f) // TODO: uint16_t
+ void SetDirectMethod(uint32_t i, AbstractMethod* f) // TODO: uint16_t
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_){
- ObjectArray<Method>* direct_methods =
- GetFieldObject<ObjectArray<Method>*>(
+ ObjectArray<AbstractMethod>* direct_methods =
+ GetFieldObject<ObjectArray<AbstractMethod>*>(
OFFSET_OF_OBJECT_MEMBER(Class, direct_methods_), false);
direct_methods->Set(i, f);
}
@@ -1568,13 +1580,13 @@
return (GetDirectMethods() != NULL) ? GetDirectMethods()->GetLength() : 0;
}
- ObjectArray<Method>* GetVirtualMethods() const {
+ ObjectArray<AbstractMethod>* GetVirtualMethods() const {
DCHECK(IsLoaded() || IsErroneous());
- return GetFieldObject<ObjectArray<Method>*>(
+ return GetFieldObject<ObjectArray<AbstractMethod>*>(
OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_), false);
}
- void SetVirtualMethods(ObjectArray<Method>* new_virtual_methods) {
+ void 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());
@@ -1587,37 +1599,37 @@
return (GetVirtualMethods() != NULL) ? GetVirtualMethods()->GetLength() : 0;
}
- Method* GetVirtualMethod(uint32_t i) const
+ AbstractMethod* GetVirtualMethod(uint32_t i) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(IsResolved() || IsErroneous());
return GetVirtualMethods()->Get(i);
}
- Method* GetVirtualMethodDuringLinking(uint32_t i) const
+ AbstractMethod* GetVirtualMethodDuringLinking(uint32_t i) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(IsLoaded() || IsErroneous());
return GetVirtualMethods()->Get(i);
}
- void SetVirtualMethod(uint32_t i, Method* f) // TODO: uint16_t
+ void SetVirtualMethod(uint32_t i, AbstractMethod* f) // TODO: uint16_t
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- ObjectArray<Method>* virtual_methods =
- GetFieldObject<ObjectArray<Method>*>(
+ ObjectArray<AbstractMethod>* virtual_methods =
+ GetFieldObject<ObjectArray<AbstractMethod>*>(
OFFSET_OF_OBJECT_MEMBER(Class, virtual_methods_), false);
virtual_methods->Set(i, f);
}
- ObjectArray<Method>* GetVTable() const {
+ ObjectArray<AbstractMethod>* GetVTable() const {
DCHECK(IsResolved() || IsErroneous());
- return GetFieldObject<ObjectArray<Method>*>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
+ return GetFieldObject<ObjectArray<AbstractMethod>*>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
}
- ObjectArray<Method>* GetVTableDuringLinking() const {
+ ObjectArray<AbstractMethod>* GetVTableDuringLinking() const {
DCHECK(IsLoaded() || IsErroneous());
- return GetFieldObject<ObjectArray<Method>*>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
+ return GetFieldObject<ObjectArray<AbstractMethod>*>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), false);
}
- void SetVTable(ObjectArray<Method>* new_vtable) {
+ void SetVTable(ObjectArray<AbstractMethod>* new_vtable) {
SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), new_vtable, false);
}
@@ -1628,7 +1640,7 @@
// Given a method implemented by this class but potentially from a
// super class, return the specific implementation
// method for this class.
- Method* FindVirtualMethodForVirtual(Method* method)
+ AbstractMethod* FindVirtualMethodForVirtual(AbstractMethod* method)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(!method->GetDeclaringClass()->IsInterface());
// The argument method may from a super class.
@@ -1639,16 +1651,16 @@
// Given a method implemented by this class, but potentially from a
// super class or interface, return the specific implementation
// method for this class.
- Method* FindVirtualMethodForInterface(Method* method)
+ AbstractMethod* FindVirtualMethodForInterface(AbstractMethod* method)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* FindInterfaceMethod(const StringPiece& name, const StringPiece& descriptor) const
+ AbstractMethod* FindInterfaceMethod(const StringPiece& name, const StringPiece& descriptor) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+ AbstractMethod* FindInterfaceMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* FindVirtualMethodForVirtualOrInterface(Method* method)
+ AbstractMethod* FindVirtualMethodForVirtualOrInterface(AbstractMethod* method)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (method->IsDirect()) {
return method;
@@ -1659,28 +1671,28 @@
return FindVirtualMethodForVirtual(method);
}
- Method* FindDeclaredVirtualMethod(const StringPiece& name, const StringPiece& signature) const
+ AbstractMethod* FindDeclaredVirtualMethod(const StringPiece& name, const StringPiece& signature) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+ AbstractMethod* FindDeclaredVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* FindVirtualMethod(const StringPiece& name, const StringPiece& descriptor) const
+ AbstractMethod* FindVirtualMethod(const StringPiece& name, const StringPiece& descriptor) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+ AbstractMethod* FindVirtualMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature) const
+ AbstractMethod* FindDeclaredDirectMethod(const StringPiece& name, const StringPiece& signature) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+ AbstractMethod* FindDeclaredDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* FindDirectMethod(const StringPiece& name, const StringPiece& signature) const
+ AbstractMethod* FindDirectMethod(const StringPiece& name, const StringPiece& signature) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
+ AbstractMethod* FindDirectMethod(const DexCache* dex_cache, uint32_t dex_method_idx) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
int32_t GetIfTableCount() const {
@@ -1894,7 +1906,7 @@
DexCache* dex_cache_;
// static, private, and <init> methods
- ObjectArray<Method>* direct_methods_;
+ ObjectArray<AbstractMethod>* direct_methods_;
// instance fields
//
@@ -1936,13 +1948,13 @@
Class* verify_error_class_;
// virtual methods defined in this class; invoked through vtable
- ObjectArray<Method>* virtual_methods_;
+ 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<Method>* vtable_;
+ ObjectArray<AbstractMethod>* vtable_;
// access flags; low 16 bits are defined by VM spec
uint32_t access_flags_;
@@ -2043,7 +2055,9 @@
inline bool Object::IsMethod() const {
Class* c = GetClass();
- return c == Method::GetMethodClass() || c == Method::GetConstructorClass();
+ return
+ c == AbstractMethod::GetMethodClass() ||
+ c == AbstractMethod::GetConstructorClass();
}
inline bool Object::IsReferenceInstance() const {
@@ -2076,7 +2090,7 @@
result = GetClass()->GetObjectSize();
}
DCHECK(!IsField() || result == sizeof(Field));
- DCHECK(!IsMethod() || result == sizeof(Method));
+ DCHECK(!IsMethod() || result == sizeof(AbstractMethod));
return result;
}
@@ -2091,15 +2105,15 @@
SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Field, declaring_class_), new_declaring_class, false);
}
-inline Class* Method::GetDeclaringClass() const {
- Class* result = GetFieldObject<Class*>(OFFSET_OF_OBJECT_MEMBER(Method, 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 Method::SetDeclaringClass(Class *new_declaring_class) {
- SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Method, declaring_class_), new_declaring_class, false);
+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 {
@@ -2421,27 +2435,27 @@
DCHECK(IsLoaded() || IsErroneous() ||
this == String::GetJavaLangString() ||
this == Field::GetJavaLangReflectField() ||
- this == Method::GetConstructorClass() ||
- this == Method::GetMethodClass());
+ this == AbstractMethod::GetConstructorClass() ||
+ this == AbstractMethod::GetMethodClass());
return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, access_flags_), false);
}
-inline uint32_t Method::GetAccessFlags() const {
+inline uint32_t AbstractMethod::GetAccessFlags() const {
DCHECK(GetDeclaringClass()->IsIdxLoaded() || GetDeclaringClass()->IsErroneous());
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, access_flags_), false);
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, access_flags_), false);
}
-inline uint16_t Method::GetMethodIndex() const {
+inline uint16_t AbstractMethod::GetMethodIndex() const {
DCHECK(GetDeclaringClass()->IsResolved() || GetDeclaringClass()->IsErroneous());
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, method_index_), false);
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_index_), false);
}
-inline uint32_t Method::GetDexMethodIndex() const {
+inline uint32_t AbstractMethod::GetDexMethodIndex() const {
DCHECK(GetDeclaringClass()->IsLoaded() || GetDeclaringClass()->IsErroneous());
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, method_dex_index_), false);
+ return GetField32(OFFSET_OF_OBJECT_MEMBER(AbstractMethod, method_dex_index_), false);
}
-inline bool Method::CheckIncompatibleClassChange(InvokeType type) {
+inline bool AbstractMethod::CheckIncompatibleClassChange(InvokeType type) {
switch (type) {
case kStatic:
return !IsStatic();
@@ -2463,7 +2477,7 @@
}
}
-inline void Method::AssertPcIsWithinCode(uintptr_t pc) const {
+inline void AbstractMethod::AssertPcIsWithinCode(uintptr_t pc) const {
if (!kIsDebugBuild) {
return;
}
@@ -2599,21 +2613,21 @@
}
size_t GetMethodArrayCount() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- ObjectArray<Method>* method_array = down_cast<ObjectArray<Method>*>(Get(kMethodArray));
+ ObjectArray<AbstractMethod>* method_array = down_cast<ObjectArray<AbstractMethod>*>(Get(kMethodArray));
if (method_array == NULL) {
return 0;
}
return method_array->GetLength();
}
- ObjectArray<Method>* GetMethodArray() const
+ ObjectArray<AbstractMethod>* GetMethodArray() const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- ObjectArray<Method>* method_array = down_cast<ObjectArray<Method>*>(Get(kMethodArray));
+ ObjectArray<AbstractMethod>* method_array = down_cast<ObjectArray<AbstractMethod>*>(Get(kMethodArray));
DCHECK(method_array != NULL);
return method_array;
}
- void SetMethodArray(ObjectArray<Method>* new_ma)
+ void SetMethodArray(ObjectArray<AbstractMethod>* new_ma)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(new_ma != NULL);
DCHECK(Get(kMethodArray) == NULL);
diff --git a/src/object_test.cc b/src/object_test.cc
index 081be4b..3dfa0a9 100644
--- a/src/object_test.cc
+++ b/src/object_test.cc
@@ -190,7 +190,7 @@
// pretend we are trying to call 'new char[3]' from String.toCharArray
ScopedObjectAccess soa(Thread::Current());
Class* java_util_Arrays = class_linker_->FindSystemClass("Ljava/util/Arrays;");
- Method* sort = java_util_Arrays->FindDirectMethod("sort", "([I)V");
+ AbstractMethod* sort = java_util_Arrays->FindDirectMethod("sort", "([I)V");
const DexFile::StringId* string_id = java_lang_dex_file_->FindStringId("[I");
ASSERT_TRUE(string_id != NULL);
const DexFile::TypeId* type_id = java_lang_dex_file_->FindTypeId(
@@ -213,7 +213,7 @@
Class* klass =
class_linker_->FindClass("LStaticsFromCode;", soa.Decode<ClassLoader*>(class_loader));
- Method* clinit = klass->FindDirectMethod("<clinit>", "()V");
+ AbstractMethod* clinit = klass->FindDirectMethod("<clinit>", "()V");
const DexFile::StringId* klass_string_id = dex_file->FindStringId("LStaticsFromCode;");
ASSERT_TRUE(klass_string_id != NULL);
const DexFile::TypeId* klass_type_id = dex_file->FindTypeId(
@@ -331,29 +331,29 @@
Class* klass2 = linker->FindClass("LProtoCompare2;", class_loader_2.get());
ASSERT_TRUE(klass2 != NULL);
- Method* m1_1 = klass1->GetVirtualMethod(0);
+ AbstractMethod* m1_1 = klass1->GetVirtualMethod(0);
MethodHelper mh(m1_1);
EXPECT_STREQ(mh.GetName(), "m1");
- Method* m2_1 = klass1->GetVirtualMethod(1);
+ AbstractMethod* m2_1 = klass1->GetVirtualMethod(1);
mh.ChangeMethod(m2_1);
EXPECT_STREQ(mh.GetName(), "m2");
- Method* m3_1 = klass1->GetVirtualMethod(2);
+ AbstractMethod* m3_1 = klass1->GetVirtualMethod(2);
mh.ChangeMethod(m3_1);
EXPECT_STREQ(mh.GetName(), "m3");
- Method* m4_1 = klass1->GetVirtualMethod(3);
+ AbstractMethod* m4_1 = klass1->GetVirtualMethod(3);
mh.ChangeMethod(m4_1);
EXPECT_STREQ(mh.GetName(), "m4");
- Method* m1_2 = klass2->GetVirtualMethod(0);
+ AbstractMethod* m1_2 = klass2->GetVirtualMethod(0);
mh.ChangeMethod(m1_2);
EXPECT_STREQ(mh.GetName(), "m1");
- Method* m2_2 = klass2->GetVirtualMethod(1);
+ AbstractMethod* m2_2 = klass2->GetVirtualMethod(1);
mh.ChangeMethod(m2_2);
EXPECT_STREQ(mh.GetName(), "m2");
- Method* m3_2 = klass2->GetVirtualMethod(2);
+ AbstractMethod* m3_2 = klass2->GetVirtualMethod(2);
mh.ChangeMethod(m3_2);
EXPECT_STREQ(mh.GetName(), "m3");
- Method* m4_2 = klass2->GetVirtualMethod(3);
+ AbstractMethod* m4_2 = klass2->GetVirtualMethod(3);
mh.ChangeMethod(m4_2);
EXPECT_STREQ(mh.GetName(), "m4");
diff --git a/src/object_utils.h b/src/object_utils.h
index f6158f3..035f689 100644
--- a/src/object_utils.h
+++ b/src/object_utils.h
@@ -199,13 +199,10 @@
}
const DexFile& GetDexFile() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- const DexFile* result = dex_file_;
- if (result == NULL) {
- const DexCache* dex_cache = GetDexCache();
- result = &GetClassLinker()->FindDexFile(dex_cache);
- dex_file_ = result;
+ if (dex_file_ == NULL) {
+ dex_file_ = GetDexCache()->GetDexFile();
}
- return *result;
+ return *dex_file_;
}
DexCache* GetDexCache() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -366,13 +363,10 @@
return result;
}
const DexFile& GetDexFile() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- const DexFile* result = dex_file_;
- if (result == NULL) {
- const DexCache* dex_cache = GetDexCache();
- result = &GetClassLinker()->FindDexFile(dex_cache);
- dex_file_ = result;
+ if (dex_file_ == NULL) {
+ dex_file_ = GetDexCache()->GetDexFile();
}
- return *result;
+ return *dex_file_;
}
ClassLinker* class_linker_;
@@ -390,21 +384,21 @@
: class_linker_(NULL), dex_cache_(NULL), dex_file_(NULL), method_(NULL), shorty_(NULL),
shorty_len_(0) {}
- explicit MethodHelper(const Method* m)
+ explicit MethodHelper(const 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 Method* m, ClassLinker* l)
+ MethodHelper(const 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(Method* new_m) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+ void ChangeMethod(AbstractMethod* new_m) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
DCHECK(new_m != NULL);
if (dex_cache_ != NULL) {
Class* klass = new_m->GetDeclaringClass();
@@ -675,12 +669,12 @@
private:
// Set the method_ field, for proxy methods looking up the interface method via the resolved
// methods table.
- void SetMethod(const Method* method)
+ void SetMethod(const AbstractMethod* method)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (method != NULL) {
Class* klass = method->GetDeclaringClass();
if (klass->IsProxyClass()) {
- Method* interface_method =
+ AbstractMethod* interface_method =
method->GetDexCacheResolvedMethods()->Get(method->GetDexMethodIndex());
CHECK(interface_method != NULL);
CHECK(interface_method == GetClassLinker()->FindMethodForProxy(klass, method));
@@ -702,7 +696,7 @@
ClassLinker* class_linker_;
DexCache* dex_cache_;
const DexFile* dex_file_;
- const Method* method_;
+ const AbstractMethod* method_;
const char* shorty_;
uint32_t shorty_len_;
diff --git a/src/reflection.cc b/src/reflection.cc
index 7f1d4d1..7d73ae2 100644
--- a/src/reflection.cc
+++ b/src/reflection.cc
@@ -28,7 +28,7 @@
jobject InvokeMethod(const ScopedObjectAccess& soa, jobject javaMethod, jobject javaReceiver,
jobject javaArgs) {
jmethodID mid = soa.Env()->FromReflectedMethod(javaMethod);
- Method* m = soa.DecodeMethod(mid);
+ AbstractMethod* m = soa.DecodeMethod(mid);
Class* declaring_class = m->GetDeclaringClass();
if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(declaring_class, true, true)) {
@@ -243,7 +243,7 @@
soa.DecodeMethod(m)->Invoke(soa.Self(), NULL, args, &value);
}
-static std::string UnboxingFailureKind(Method* m, int index, Field* f)
+static std::string UnboxingFailureKind(AbstractMethod* m, int index, Field* f)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (m != NULL && index != -1) {
++index; // Humans count from 1.
@@ -255,7 +255,7 @@
return "result";
}
-static bool UnboxPrimitive(Object* o, Class* dst_class, JValue& unboxed_value, Method* m,
+static bool UnboxPrimitive(Object* o, Class* dst_class, JValue& unboxed_value, AbstractMethod* m,
int index, Field* f)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (!dst_class->IsPrimitive()) {
@@ -326,7 +326,7 @@
boxed_value, unboxed_value);
}
-bool UnboxPrimitiveForArgument(Object* o, Class* dst_class, JValue& unboxed_value, Method* m, size_t index) {
+bool UnboxPrimitiveForArgument(Object* o, Class* dst_class, JValue& unboxed_value, AbstractMethod* m, size_t index) {
CHECK(m != NULL);
return UnboxPrimitive(o, dst_class, unboxed_value, m, index, NULL);
}
diff --git a/src/reflection.h b/src/reflection.h
index 93219f8..b61acda 100644
--- a/src/reflection.h
+++ b/src/reflection.h
@@ -25,13 +25,13 @@
class Class;
class Field;
union JValue;
-class Method;
+class AbstractMethod;
class Object;
class ScopedObjectAccess;
void BoxPrimitive(Primitive::Type src_class, JValue& value)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-bool UnboxPrimitiveForArgument(Object* o, Class* dst_class, JValue& unboxed_value, Method* m,
+bool UnboxPrimitiveForArgument(Object* o, Class* dst_class, JValue& unboxed_value, AbstractMethod* m,
size_t index)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
bool UnboxPrimitiveForField(Object* o, Class* dst_class, JValue& unboxed_value, Field* f)
diff --git a/src/runtime.cc b/src/runtime.cc
index f37788d..8262f8a 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -556,7 +556,7 @@
Class* class_loader_class = soa.Decode<Class*>(WellKnownClasses::java_lang_ClassLoader);
CHECK(Runtime::Current()->GetClassLinker()->EnsureInitialized(class_loader_class, true, true));
- Method* getSystemClassLoader = class_loader_class->FindDirectMethod("getSystemClassLoader", "()Ljava/lang/ClassLoader;");
+ AbstractMethod* getSystemClassLoader = class_loader_class->FindDirectMethod("getSystemClassLoader", "()Ljava/lang/ClassLoader;");
CHECK(getSystemClassLoader != NULL);
ClassLoader* class_loader =
@@ -960,9 +960,9 @@
resolution_stub_array_[type] = resolution_stub_array;
}
-Method* Runtime::CreateResolutionMethod() {
- Class* method_class = Method::GetMethodClass();
- SirtRef<Method> method(down_cast<Method*>(method_class->AllocObject()));
+AbstractMethod* Runtime::CreateResolutionMethod() {
+ Class* method_class = AbstractMethod::GetMethodClass();
+ SirtRef<AbstractMethod> method(down_cast<AbstractMethod*>(method_class->AllocObject()));
method->SetDeclaringClass(method_class);
// TODO: use a special method for resolution method saves
method->SetDexMethodIndex(DexFile::kDexNoIndex16);
@@ -972,9 +972,9 @@
return method.get();
}
-Method* Runtime::CreateCalleeSaveMethod(InstructionSet instruction_set, CalleeSaveType type) {
- Class* method_class = Method::GetMethodClass();
- SirtRef<Method> method(down_cast<Method*>(method_class->AllocObject()));
+AbstractMethod* Runtime::CreateCalleeSaveMethod(InstructionSet instruction_set, CalleeSaveType type) {
+ Class* method_class = AbstractMethod::GetMethodClass();
+ SirtRef<AbstractMethod> method(down_cast<AbstractMethod*>(method_class->AllocObject()));
method->SetDeclaringClass(method_class);
// TODO: use a special method for callee saves
method->SetDexMethodIndex(DexFile::kDexNoIndex16);
@@ -1046,7 +1046,7 @@
return method.get();
}
-void Runtime::SetCalleeSaveMethod(Method* method, CalleeSaveType type) {
+void Runtime::SetCalleeSaveMethod(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 4dcefb5..5f277a1 100644
--- a/src/runtime.h
+++ b/src/runtime.h
@@ -48,7 +48,7 @@
class Heap;
class InternTable;
struct JavaVMExt;
-class Method;
+class AbstractMethod;
class MonitorList;
class SignalCatcher;
class String;
@@ -254,7 +254,7 @@
void SetResolutionStubArray(ByteArray* resolution_stub_array, TrampolineType type);
// Returns a special method that calls into a trampoline for runtime method resolution
- Method* GetResolutionMethod() const {
+ AbstractMethod* GetResolutionMethod() const {
CHECK(HasResolutionMethod());
return resolution_method_;
}
@@ -263,11 +263,11 @@
return resolution_method_ != NULL;
}
- void SetResolutionMethod(Method* method) {
+ void SetResolutionMethod(AbstractMethod* method) {
resolution_method_ = method;
}
- Method* CreateResolutionMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ AbstractMethod* CreateResolutionMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Returns a special method that describes all callee saves being spilled to the stack.
enum CalleeSaveType {
@@ -281,20 +281,20 @@
return callee_save_methods_[type] != NULL;
}
- Method* GetCalleeSaveMethod(CalleeSaveType type) const {
+ AbstractMethod* GetCalleeSaveMethod(CalleeSaveType type) const {
CHECK(HasCalleeSaveMethod(type));
return callee_save_methods_[type];
}
- void SetCalleeSaveMethod(Method* method, CalleeSaveType type);
+ void SetCalleeSaveMethod(AbstractMethod* method, CalleeSaveType type);
- Method* CreateCalleeSaveMethod(InstructionSet instruction_set, CalleeSaveType type)
+ AbstractMethod* CreateCalleeSaveMethod(InstructionSet instruction_set, CalleeSaveType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* CreateRefOnlyCalleeSaveMethod(InstructionSet instruction_set)
+ AbstractMethod* CreateRefOnlyCalleeSaveMethod(InstructionSet instruction_set)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* CreateRefAndArgsCalleeSaveMethod(InstructionSet instruction_set)
+ AbstractMethod* CreateRefAndArgsCalleeSaveMethod(InstructionSet instruction_set)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
int32_t GetStat(int kind);
@@ -398,9 +398,9 @@
ByteArray* resolution_stub_array_[kLastTrampolineMethodType];
- Method* callee_save_methods_[kLastCalleeSaveType];
+ AbstractMethod* callee_save_methods_[kLastCalleeSaveType];
- Method* resolution_method_;
+ AbstractMethod* resolution_method_;
// As returned by ClassLoader.getSystemClassLoader()
ClassLoader* system_class_loader_;
diff --git a/src/runtime_support.cc b/src/runtime_support.cc
index 01bdf9a..4af6fe5 100644
--- a/src/runtime_support.cc
+++ b/src/runtime_support.cc
@@ -90,7 +90,7 @@
namespace art {
// Helper function to allocate array for FILLED_NEW_ARRAY.
-Array* CheckAndAllocArrayFromCode(uint32_t type_idx, Method* method, int32_t component_count,
+Array* CheckAndAllocArrayFromCode(uint32_t type_idx, AbstractMethod* method, int32_t component_count,
Thread* self, bool access_check) {
if (UNLIKELY(component_count < 0)) {
self->ThrowNewExceptionF("Ljava/lang/NegativeArraySizeException;", "%d", component_count);
@@ -128,7 +128,7 @@
}
}
-Field* FindFieldFromCode(uint32_t field_idx, const Method* referrer, Thread* self,
+Field* FindFieldFromCode(uint32_t field_idx, const AbstractMethod* referrer, Thread* self,
FindFieldType type, size_t expected_size) {
bool is_primitive;
bool is_set;
@@ -208,11 +208,11 @@
}
// Slow path method resolution
-Method* FindMethodFromCode(uint32_t method_idx, Object* this_object, const Method* referrer,
+AbstractMethod* FindMethodFromCode(uint32_t method_idx, Object* this_object, const AbstractMethod* referrer,
Thread* self, bool access_check, InvokeType type) {
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
bool is_direct = type == kStatic || type == kDirect;
- Method* resolved_method = class_linker->ResolveMethod(method_idx, referrer, type);
+ 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.
@@ -221,7 +221,7 @@
if (is_direct) {
return resolved_method;
} else if (type == kInterface) {
- Method* interface_method =
+ AbstractMethod* interface_method =
this_object->GetClass()->FindVirtualMethodForInterface(resolved_method);
if (UNLIKELY(interface_method == NULL)) {
ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(resolved_method, this_object,
@@ -231,7 +231,7 @@
return interface_method;
}
} else {
- ObjectArray<Method>* vtable;
+ ObjectArray<AbstractMethod>* vtable;
uint16_t vtable_index = resolved_method->GetMethodIndex();
if (type == kSuper) {
vtable = referrer->GetDeclaringClass()->GetSuperClass()->GetVTable();
@@ -273,7 +273,7 @@
if (is_direct) {
return resolved_method;
} else if (type == kInterface) {
- Method* interface_method =
+ AbstractMethod* interface_method =
this_object->GetClass()->FindVirtualMethodForInterface(resolved_method);
if (UNLIKELY(interface_method == NULL)) {
ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(resolved_method, this_object,
@@ -283,7 +283,7 @@
return interface_method;
}
} else {
- ObjectArray<Method>* vtable;
+ ObjectArray<AbstractMethod>* vtable;
uint16_t vtable_index = resolved_method->GetMethodIndex();
if (type == kSuper) {
Class* super_class = referring_class->GetSuperClass();
@@ -310,7 +310,7 @@
}
}
-Class* ResolveVerifyAndClinit(uint32_t type_idx, const Method* referrer, Thread* self,
+Class* ResolveVerifyAndClinit(uint32_t type_idx, const 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);
diff --git a/src/runtime_support.h b/src/runtime_support.h
index 16f0d2e..b4a23ff 100644
--- a/src/runtime_support.h
+++ b/src/runtime_support.h
@@ -41,14 +41,14 @@
class Array;
class Class;
class Field;
-class Method;
+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, Method* method, Thread* self,
+static inline Object* AllocObjectFromCode(uint32_t type_idx, AbstractMethod* method, Thread* self,
bool access_check)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Class* klass = method->GetDexCacheResolvedTypes()->Get(type_idx);
@@ -83,7 +83,7 @@
// 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, Method* method, int32_t component_count,
+static inline Array* AllocArrayFromCode(uint32_t type_idx, AbstractMethod* method, int32_t component_count,
bool access_check)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
if (UNLIKELY(component_count < 0)) {
@@ -110,7 +110,7 @@
return Array::Alloc(klass, component_count);
}
-extern Array* CheckAndAllocArrayFromCode(uint32_t type_idx, Method* method, int32_t component_count,
+extern Array* CheckAndAllocArrayFromCode(uint32_t type_idx, AbstractMethod* method, int32_t component_count,
Thread* self, bool access_check)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -127,12 +127,12 @@
};
// Slow field find that can initialize classes and may throw exceptions.
-extern Field* FindFieldFromCode(uint32_t field_idx, const Method* referrer, Thread* self,
+extern Field* FindFieldFromCode(uint32_t field_idx, const 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 Method* referrer,
+static inline Field* FindFieldFast(uint32_t field_idx, const AbstractMethod* referrer,
FindFieldType type, size_t expected_size)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Field* resolved_field = referrer->GetDeclaringClass()->GetDexCache()->GetResolvedField(field_idx);
@@ -181,14 +181,14 @@
}
// Fast path method resolution that can't throw exceptions.
-static inline Method* FindMethodFast(uint32_t method_idx, Object* this_object,
- const Method* referrer, bool access_check, InvokeType type)
+static inline AbstractMethod* FindMethodFast(uint32_t method_idx, Object* this_object,
+ const 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;
}
- Method* resolved_method =
+ AbstractMethod* resolved_method =
referrer->GetDeclaringClass()->GetDexCache()->GetResolvedMethod(method_idx);
if (UNLIKELY(resolved_method == NULL)) {
return NULL;
@@ -221,15 +221,15 @@
}
}
-extern Method* FindMethodFromCode(uint32_t method_idx, Object* this_object, const Method* referrer,
+extern AbstractMethod* FindMethodFromCode(uint32_t method_idx, Object* this_object, const AbstractMethod* referrer,
Thread* self, bool access_check, InvokeType type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-extern Class* ResolveVerifyAndClinit(uint32_t type_idx, const Method* referrer, Thread* self,
+extern Class* ResolveVerifyAndClinit(uint32_t type_idx, const AbstractMethod* referrer, Thread* self,
bool can_run_clinit, bool verify_access)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
-static inline String* ResolveStringFromCode(const Method* referrer, uint32_t string_idx)
+static inline String* ResolveStringFromCode(const 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);
@@ -268,7 +268,7 @@
PrettyMethod(self->GetCurrentMethod()).c_str());
}
// Make sure that the result is an instance of the type this method was expected to return.
- Method* m = self->GetCurrentMethod();
+ AbstractMethod* m = self->GetCurrentMethod();
MethodHelper mh(m);
Class* return_type = mh.GetReturnType();
diff --git a/src/scoped_thread_state_change.h b/src/scoped_thread_state_change.h
index 68fbf69..c9b353f 100644
--- a/src/scoped_thread_state_change.h
+++ b/src/scoped_thread_state_change.h
@@ -227,7 +227,7 @@
return reinterpret_cast<jfieldID>(field);
}
- Method* DecodeMethod(jmethodID mid) const
+ AbstractMethod* DecodeMethod(jmethodID mid) const
LOCKS_EXCLUDED(JavaVMExt::globals_lock,
JavaVMExt::weak_globals_lock)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -237,10 +237,10 @@
// TODO: we should make these unique weak globals if Method instances can ever move.
UNIMPLEMENTED(WARNING);
#endif
- return reinterpret_cast<Method*>(mid);
+ return reinterpret_cast<AbstractMethod*>(mid);
}
- jmethodID EncodeMethod(Method* method) const
+ jmethodID EncodeMethod(AbstractMethod* method) const
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Locks::mutator_lock_->AssertSharedHeld();
DCHECK_EQ(thread_state_, kRunnable); // Don't work with raw objects in non-runnable states.
diff --git a/src/space.cc b/src/space.cc
index 19e9e5c..f61f872 100644
--- a/src/space.cc
+++ b/src/space.cc
@@ -431,14 +431,14 @@
down_cast<ByteArray*>(resolution_stub_array), Runtime::kUnknownMethod);
Object* resolution_method = image_header.GetImageRoot(ImageHeader::kResolutionMethod);
- runtime->SetResolutionMethod(down_cast<Method*>(resolution_method));
+ runtime->SetResolutionMethod(down_cast<AbstractMethod*>(resolution_method));
Object* callee_save_method = image_header.GetImageRoot(ImageHeader::kCalleeSaveMethod);
- runtime->SetCalleeSaveMethod(down_cast<Method*>(callee_save_method), Runtime::kSaveAll);
+ runtime->SetCalleeSaveMethod(down_cast<AbstractMethod*>(callee_save_method), Runtime::kSaveAll);
callee_save_method = image_header.GetImageRoot(ImageHeader::kRefsOnlySaveMethod);
- runtime->SetCalleeSaveMethod(down_cast<Method*>(callee_save_method), Runtime::kRefsOnly);
+ runtime->SetCalleeSaveMethod(down_cast<AbstractMethod*>(callee_save_method), Runtime::kRefsOnly);
callee_save_method = image_header.GetImageRoot(ImageHeader::kRefsAndArgsSaveMethod);
- runtime->SetCalleeSaveMethod(down_cast<Method*>(callee_save_method), Runtime::kRefsAndArgs);
+ runtime->SetCalleeSaveMethod(down_cast<AbstractMethod*>(callee_save_method), Runtime::kRefsAndArgs);
ImageSpace* space = new ImageSpace(image_file_name, map.release());
if (VLOG_IS_ON(heap) || VLOG_IS_ON(startup)) {
diff --git a/src/space_bitmap.cc b/src/space_bitmap.cc
index cd07a81..d117c21 100644
--- a/src/space_bitmap.cc
+++ b/src/space_bitmap.cc
@@ -177,7 +177,7 @@
for (int32_t i = 0; i < fields->GetLength(); i++) {
Field* field = fields->Get(i);
FieldHelper fh(field);
- if (!fh.GetType()->IsPrimitive()) {
+ if (!fh.IsPrimitiveType()) {
Object* value = field->GetObj(obj);
if (value != NULL) {
WalkFieldsInOrder(visited, callback, value, arg);
@@ -207,7 +207,7 @@
for (int32_t i = 0; i < fields->GetLength(); i++) {
Field* field = fields->Get(i);
FieldHelper fh(field);
- if (!fh.GetType()->IsPrimitive()) {
+ if (!fh.IsPrimitiveType()) {
Object* value = field->GetObj(NULL);
if (value != NULL) {
WalkFieldsInOrder(visited, callback, value, arg);
diff --git a/src/stack.cc b/src/stack.cc
index c13aaf4..2567c50 100644
--- a/src/stack.cc
+++ b/src/stack.cc
@@ -80,7 +80,7 @@
}
-uint32_t StackVisitor::GetVReg(Method* m, int vreg) const {
+uint32_t StackVisitor::GetVReg(AbstractMethod* m, int vreg) const {
if (cur_quick_frame_ != NULL) {
DCHECK(context_ != NULL); // You can't reliably read registers without a context.
DCHECK(m == GetMethod());
@@ -115,7 +115,7 @@
}
}
-void StackVisitor::SetVReg(Method* m, int vreg, uint32_t new_value) {
+void StackVisitor::SetVReg(AbstractMethod* m, int vreg, uint32_t new_value) {
if (cur_quick_frame_ != NULL) {
DCHECK(context_ != NULL); // You can't reliably write registers without a context.
DCHECK(m == GetMethod());
@@ -144,14 +144,14 @@
}
uintptr_t StackVisitor::GetReturnPc() const {
- Method** sp = GetCurrentQuickFrame();
+ AbstractMethod** sp = GetCurrentQuickFrame();
CHECK(sp != NULL);
byte* pc_addr = reinterpret_cast<byte*>(sp) + GetMethod()->GetReturnPcOffsetInBytes();
return *reinterpret_cast<uintptr_t*>(pc_addr);
}
void StackVisitor::SetReturnPc(uintptr_t new_ret_pc) {
- Method** sp = GetCurrentQuickFrame();
+ AbstractMethod** sp = GetCurrentQuickFrame();
CHECK(sp != NULL);
byte* pc_addr = reinterpret_cast<byte*>(sp) + GetMethod()->GetReturnPcOffsetInBytes();
*reinterpret_cast<uintptr_t*>(pc_addr) = new_ret_pc;
@@ -178,9 +178,9 @@
void StackVisitor::SanityCheckFrame() const {
#ifndef NDEBUG
- Method* method = GetMethod();
- CHECK(method->GetClass() == Method::GetMethodClass() ||
- method->GetClass() == Method::GetConstructorClass());
+ AbstractMethod* method = GetMethod();
+ CHECK(method->GetClass() == AbstractMethod::GetMethodClass() ||
+ method->GetClass() == AbstractMethod::GetConstructorClass());
if (cur_quick_frame_ != NULL) {
method->AssertPcIsWithinCode(cur_quick_frame_pc_);
// Frame sanity.
@@ -204,7 +204,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);
- Method* method = *cur_quick_frame_;
+ AbstractMethod* method = *cur_quick_frame_;
do {
SanityCheckFrame();
bool should_continue = VisitFrame();
@@ -234,7 +234,7 @@
}
cur_quick_frame_pc_ = return_pc;
byte* next_frame = reinterpret_cast<byte*>(cur_quick_frame_) + frame_size;
- cur_quick_frame_ = reinterpret_cast<Method**>(next_frame);
+ cur_quick_frame_ = reinterpret_cast<AbstractMethod**>(next_frame);
cur_depth_++;
method = *cur_quick_frame_;
} while (method != NULL);
diff --git a/src/stack.h b/src/stack.h
index 21b05c4..4686c6b 100644
--- a/src/stack.h
+++ b/src/stack.h
@@ -28,7 +28,7 @@
namespace art {
-class Method;
+class AbstractMethod;
class Object;
class ShadowFrame;
class StackIndirectReferenceTable;
@@ -75,12 +75,12 @@
references_[i] = object;
}
- Method* GetMethod() const {
+ AbstractMethod* GetMethod() const {
DCHECK_NE(method_, static_cast<void*>(NULL));
return method_;
}
- void SetMethod(Method* method) {
+ void SetMethod(AbstractMethod* method) {
DCHECK_NE(method, static_cast<void*>(NULL));
method_ = method;
}
@@ -132,7 +132,7 @@
uint32_t number_of_references_;
ShadowFrame* link_;
- Method* method_;
+ AbstractMethod* method_;
uint32_t dex_pc_;
Object* references_[];
@@ -154,11 +154,11 @@
return link_;
}
- Method** GetTopQuickFrame() const {
+ AbstractMethod** GetTopQuickFrame() const {
return top_quick_frame_;
}
- void SetTopQuickFrame(Method** top) {
+ void SetTopQuickFrame(AbstractMethod** top) {
top_quick_frame_ = top;
}
@@ -207,7 +207,7 @@
private:
ManagedStack* link_;
ShadowFrame* top_shadow_frame_;
- Method** top_quick_frame_;
+ AbstractMethod** top_quick_frame_;
uintptr_t top_quick_frame_pc_;
};
@@ -229,7 +229,7 @@
void WalkStack(bool include_transitions = false)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- Method* GetMethod() const {
+ AbstractMethod* GetMethod() const {
if (cur_shadow_frame_ != NULL) {
return cur_shadow_frame_->GetMethod();
} else if (cur_quick_frame_ != NULL) {
@@ -249,7 +249,7 @@
uintptr_t LoadCalleeSave(int num, size_t frame_size) const {
// Callee saves are held at the top of the frame
- Method* method = GetMethod();
+ AbstractMethod* method = GetMethod();
DCHECK(method != NULL);
byte* save_addr =
reinterpret_cast<byte*>(cur_quick_frame_) + frame_size - ((num + 1) * kPointerSize);
@@ -276,14 +276,14 @@
return num_frames_;
}
- uint32_t GetVReg(Method* m, int vreg) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+ uint32_t GetVReg(AbstractMethod* m, int vreg) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- void SetVReg(Method* m, int vreg, uint32_t new_value)
+ void SetVReg(AbstractMethod* m, int vreg, uint32_t new_value)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
uintptr_t GetGPR(uint32_t reg) const;
- uint32_t GetVReg(Method** cur_quick_frame, const DexFile::CodeItem* code_item,
+ uint32_t GetVReg(AbstractMethod** cur_quick_frame, const DexFile::CodeItem* code_item,
uint32_t core_spills, uint32_t fp_spills, size_t frame_size, int vreg) const {
int offset = GetVRegOffset(code_item, core_spills, fp_spills, frame_size, vreg);
DCHECK_EQ(cur_quick_frame, GetCurrentQuickFrame());
@@ -356,7 +356,7 @@
return cur_quick_frame_pc_;
}
- Method** GetCurrentQuickFrame() const {
+ AbstractMethod** GetCurrentQuickFrame() const {
return cur_quick_frame_;
}
@@ -365,7 +365,7 @@
}
StackIndirectReferenceTable* GetCurrentSirt() const {
- Method** sp = GetCurrentQuickFrame();
+ AbstractMethod** sp = GetCurrentQuickFrame();
++sp; // Skip Method*; SIRT comes next;
return reinterpret_cast<StackIndirectReferenceTable*>(sp);
}
@@ -382,7 +382,7 @@
const ManagedStack* const stack_start_;
const std::vector<TraceStackFrame>* const trace_stack_;
ShadowFrame* cur_shadow_frame_;
- Method** cur_quick_frame_;
+ 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/thread.cc b/src/thread.cc
index eaa6683..9db25f4 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -115,7 +115,7 @@
CHECK(self->peer_ != NULL);
Object* receiver = self->peer_;
jmethodID mid = WellKnownClasses::java_lang_Thread_run;
- Method* m = receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(soa.DecodeMethod(mid));
+ AbstractMethod* m = receiver->GetClass()->FindVirtualMethodForVirtualOrInterface(soa.DecodeMethod(mid));
m->Invoke(self, receiver, NULL, NULL);
}
@@ -708,7 +708,7 @@
}
bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* m = GetMethod();
+ AbstractMethod* m = GetMethod();
if (m->IsRuntimeMethod()) {
return true;
}
@@ -757,7 +757,7 @@
const Thread* thread;
bool can_allocate;
MethodHelper mh;
- Method* last_method;
+ AbstractMethod* last_method;
int last_line_number;
int repetition_count;
int frame_count;
@@ -962,7 +962,7 @@
// Call the handler.
jmethodID mid = WellKnownClasses::java_lang_Thread$UncaughtExceptionHandler_uncaughtException;
- Method* m = handler->GetClass()->FindVirtualMethodForVirtualOrInterface(soa.DecodeMethod(mid));
+ AbstractMethod* m = handler->GetClass()->FindVirtualMethodForVirtualOrInterface(soa.DecodeMethod(mid));
JValue args[2];
args[0].SetL(peer_);
args[1].SetL(exception);
@@ -982,7 +982,7 @@
Object* group = GetThreadGroup(soa);
if (group != NULL) {
jmethodID mid = WellKnownClasses::java_lang_ThreadGroup_removeThread;
- Method* m = group->GetClass()->FindVirtualMethodForVirtualOrInterface(soa.DecodeMethod(mid));
+ AbstractMethod* m = group->GetClass()->FindVirtualMethodForVirtualOrInterface(soa.DecodeMethod(mid));
JValue args[1];
args[0].SetL(peer_);
m->Invoke(this, group, args, NULL);
@@ -1091,7 +1091,7 @@
// 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)
- Method* m = GetMethod();
+ AbstractMethod* m = GetMethod();
if (skipping_ && !m->IsRuntimeMethod() &&
!Throwable::GetJavaLangThrowable()->IsAssignableFrom(m->GetDeclaringClass())) {
skipping_ = false;
@@ -1166,7 +1166,7 @@
skip_depth_--;
return true;
}
- Method* m = GetMethod();
+ AbstractMethod* m = GetMethod();
if (m->IsRuntimeMethod()) {
return true; // Ignore runtime frames (in particular callee save).
}
@@ -1255,7 +1255,7 @@
MethodHelper mh;
for (int32_t i = 0; i < depth; ++i) {
// Prepare parameters for StackTraceElement(String cls, String method, String file, int line)
- Method* method = down_cast<Method*>(method_trace->Get(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);
@@ -1535,7 +1535,7 @@
bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* method = GetMethod();
+ 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();
@@ -1577,7 +1577,7 @@
}
void DoLongJump() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* catch_method = *handler_quick_frame_;
+ AbstractMethod* catch_method = *handler_quick_frame_;
Dbg::PostException(self_, throw_frame_id_, throw_method_, throw_dex_pc_,
catch_method, handler_dex_pc_, exception_);
if (kDebugExceptionDelivery) {
@@ -1607,11 +1607,11 @@
Throwable* exception_;
// The type of the exception catch block to find.
Class* to_find_;
- Method* throw_method_;
+ 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.
- Method** handler_quick_frame_;
+ AbstractMethod** handler_quick_frame_;
// PC to branch to for the handler.
uintptr_t handler_quick_frame_pc_;
// Associated dex PC.
@@ -1652,7 +1652,7 @@
return result;
}
-Method* Thread::GetCurrentMethod(uint32_t* dex_pc, size_t* frame_id) const {
+AbstractMethod* Thread::GetCurrentMethod(uint32_t* dex_pc, size_t* frame_id) const {
struct CurrentMethodVisitor : public StackVisitor {
CurrentMethodVisitor(const ManagedStack* stack,
const std::vector<TraceStackFrame>* trace_stack)
@@ -1660,7 +1660,7 @@
: StackVisitor(stack, trace_stack, NULL), method_(NULL), dex_pc_(0), frame_id_(0) {}
virtual bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
- Method* m = GetMethod();
+ AbstractMethod* m = GetMethod();
if (m->IsRuntimeMethod()) {
// Continue if this is a runtime method.
return true;
@@ -1670,7 +1670,7 @@
frame_id_ = GetFrameId();
return false;
}
- Method* method_;
+ AbstractMethod* method_;
uint32_t dex_pc_;
size_t frame_id_;
};
@@ -1709,7 +1709,7 @@
if (shadow_frame != NULL) {
shadow_frame->VisitRoots(root_visitor_, arg_);
} else {
- Method* m = GetMethod();
+ 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();
@@ -1728,7 +1728,7 @@
uint32_t fp_spills = m->GetFpSpillMask();
size_t frame_size = m->GetFrameSizeInBytes();
// For all dex registers in the bitmap
- Method** cur_quick_frame = GetCurrentQuickFrame();
+ 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?
diff --git a/src/thread.h b/src/thread.h
index 6fbf1d2..ad861e0 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -50,7 +50,7 @@
class ClassLoader;
class Context;
struct DebugInvokeReq;
-class Method;
+class AbstractMethod;
class Monitor;
class Object;
class Runtime;
@@ -347,11 +347,11 @@
long_jump_context_ = context;
}
- Method* GetCurrentMethod(uint32_t* dex_pc = NULL, size_t* frame_id = NULL) const
+ 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) {
- Method** top_method = reinterpret_cast<Method**>(stack);
+ AbstractMethod** top_method = reinterpret_cast<AbstractMethod**>(stack);
managed_stack_.SetTopQuickFrame(top_method);
managed_stack_.SetTopQuickFramePc(pc);
}
@@ -383,7 +383,7 @@
//QuickFrameIterator FindExceptionHandler(void* throw_pc, void** handler_pc);
- void* FindExceptionHandlerInMethod(const Method* method,
+ void* FindExceptionHandlerInMethod(const AbstractMethod* method,
void* throw_pc,
const DexFile& dex_file,
ClassLinker* class_linker);
diff --git a/src/trace.cc b/src/trace.cc
index e4bc836..d1f3f50 100644
--- a/src/trace.cc
+++ b/src/trace.cc
@@ -162,14 +162,14 @@
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Trace* tracer = Runtime::Current()->GetTracer();
for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
- Method* method = klass->GetDirectMethod(i);
+ AbstractMethod* method = klass->GetDirectMethod(i);
if (tracer->GetSavedCodeFromMap(method) == NULL) {
tracer->SaveAndUpdateCode(method);
}
}
for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
- Method* method = klass->GetVirtualMethod(i);
+ AbstractMethod* method = klass->GetVirtualMethod(i);
if (tracer->GetSavedCodeFromMap(method) == NULL) {
tracer->SaveAndUpdateCode(method);
}
@@ -181,14 +181,14 @@
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Trace* tracer = Runtime::Current()->GetTracer();
for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
- Method* method = klass->GetDirectMethod(i);
+ AbstractMethod* method = klass->GetDirectMethod(i);
if (tracer->GetSavedCodeFromMap(method) != NULL) {
tracer->ResetSavedCode(method);
}
}
for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
- Method* method = klass->GetVirtualMethod(i);
+ AbstractMethod* method = klass->GetVirtualMethod(i);
if (tracer->GetSavedCodeFromMap(method) != NULL) {
tracer->ResetSavedCode(method);
}
@@ -221,16 +221,16 @@
visitor.WalkStack();
}
-void Trace::AddSavedCodeToMap(const Method* method, const void* code) {
+void Trace::AddSavedCodeToMap(const AbstractMethod* method, const void* code) {
saved_code_map_.Put(method, code);
}
-void Trace::RemoveSavedCodeFromMap(const Method* method) {
+void Trace::RemoveSavedCodeFromMap(const AbstractMethod* method) {
saved_code_map_.erase(method);
}
-const void* Trace::GetSavedCodeFromMap(const Method* method) {
- typedef SafeMap<const Method*, const void*>::const_iterator It; // TODO: C++0x auto
+const void* Trace::GetSavedCodeFromMap(const AbstractMethod* method) {
+ typedef SafeMap<const 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;
@@ -239,7 +239,7 @@
}
}
-void Trace::SaveAndUpdateCode(Method* method) {
+void Trace::SaveAndUpdateCode(AbstractMethod* method) {
#if defined(ART_USE_LLVM_COMPILER)
UNIMPLEMENTED(FATAL);
#else
@@ -250,7 +250,7 @@
#endif
}
-void Trace::ResetSavedCode(Method* method) {
+void Trace::ResetSavedCode(AbstractMethod* method) {
CHECK(GetSavedCodeFromMap(method) != NULL);
method->SetCode(GetSavedCodeFromMap(method));
RemoveSavedCodeFromMap(method);
@@ -419,7 +419,7 @@
}
}
-void Trace::LogMethodTraceEvent(Thread* self, const Method* method, Trace::TraceEvent event) {
+void Trace::LogMethodTraceEvent(Thread* self, const 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);
@@ -464,16 +464,16 @@
while (ptr < end) {
uint32_t method_value = ptr[2] | (ptr[3] << 8) | (ptr[4] << 16) | (ptr[5] << 24);
- Method* method = reinterpret_cast<Method*>(TraceMethodId(method_value));
+ AbstractMethod* method = reinterpret_cast<AbstractMethod*>(TraceMethodId(method_value));
visited_methods_.insert(method);
ptr += record_size_;
}
}
void Trace::DumpMethodList(std::ostream& os) {
- typedef std::set<const Method*>::const_iterator It; // TODO: C++0x auto
+ typedef std::set<const AbstractMethod*>::const_iterator It; // TODO: C++0x auto
for (It it = visited_methods_.begin(); it != visited_methods_.end(); ++it) {
- const Method* method = *it;
+ const 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(),
@@ -508,7 +508,7 @@
uint32_t TraceMethodUnwindFromCode(Thread* self) {
Trace* tracer = Runtime::Current()->GetTracer();
TraceStackFrame trace_frame = self->PopTraceStackFrame();
- Method* method = trace_frame.method_;
+ AbstractMethod* method = trace_frame.method_;
uint32_t lr = trace_frame.return_pc_;
tracer->LogMethodTraceEvent(self, method, Trace::kMethodTraceUnwind);
diff --git a/src/trace.h b/src/trace.h
index 9c64347..43b0ff7 100644
--- a/src/trace.h
+++ b/src/trace.h
@@ -29,17 +29,17 @@
namespace art {
-class Method;
+class AbstractMethod;
class Thread;
uint32_t TraceMethodUnwindFromCode(Thread* self);
struct TraceStackFrame {
- TraceStackFrame(Method* method, uintptr_t return_pc)
+ TraceStackFrame(AbstractMethod* method, uintptr_t return_pc)
: method_(method), return_pc_(return_pc) {
}
- Method* method_;
+ AbstractMethod* method_;
uintptr_t return_pc_;
};
@@ -70,14 +70,14 @@
bool UseWallClock();
bool UseThreadCpuClock();
- void LogMethodTraceEvent(Thread* self, const Method* method, TraceEvent event);
+ void LogMethodTraceEvent(Thread* self, const AbstractMethod* method, TraceEvent event);
- void AddSavedCodeToMap(const Method* method, const void* code);
- void RemoveSavedCodeFromMap(const Method* method);
- const void* GetSavedCodeFromMap(const Method* method);
+ void AddSavedCodeToMap(const AbstractMethod* method, const void* code);
+ void RemoveSavedCodeFromMap(const AbstractMethod* method);
+ const void* GetSavedCodeFromMap(const AbstractMethod* method);
- void SaveAndUpdateCode(Method* method);
- void ResetSavedCode(Method* method);
+ void SaveAndUpdateCode(AbstractMethod* method);
+ void ResetSavedCode(AbstractMethod* method);
private:
explicit Trace(File* trace_file, int buffer_size, int flags);
@@ -97,10 +97,10 @@
void DumpThreadList(std::ostream& os) LOCKS_EXCLUDED(Locks::thread_list_lock_);
// Maps a method to its original code pointer.
- SafeMap<const Method*, const void*> saved_code_map_;
+ SafeMap<const AbstractMethod*, const void*> saved_code_map_;
// Set of methods visited by the profiler.
- std::set<const Method*> visited_methods_;
+ std::set<const AbstractMethod*> visited_methods_;
// Maps a thread to its clock base.
SafeMap<Thread*, uint64_t> thread_clock_base_map_;
diff --git a/src/utils.cc b/src/utils.cc
index bff1f0c..534b28e 100644
--- a/src/utils.cc
+++ b/src/utils.cc
@@ -317,7 +317,7 @@
return PrettyDescriptor(return_type);
}
-std::string PrettyMethod(const Method* m, bool with_signature) {
+std::string PrettyMethod(const AbstractMethod* m, bool with_signature) {
if (m == NULL) {
return "null";
}
@@ -573,7 +573,7 @@
return descriptor;
}
-std::string JniShortName(const Method* m) {
+std::string JniShortName(const AbstractMethod* m) {
MethodHelper mh(m);
std::string class_name(mh.GetDeclaringClassDescriptor());
// Remove the leading 'L' and trailing ';'...
@@ -592,7 +592,7 @@
return short_name;
}
-std::string JniLongName(const Method* m) {
+std::string JniLongName(const AbstractMethod* m) {
std::string long_name;
long_name += JniShortName(m);
long_name += "__";
diff --git a/src/utils.h b/src/utils.h
index b59f114..7daf61c 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -32,7 +32,7 @@
class Class;
class DexFile;
class Field;
-class Method;
+class AbstractMethod;
class Object;
class String;
@@ -185,7 +185,7 @@
// 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 Method* m, bool with_signature = true)
+std::string PrettyMethod(const 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);
@@ -249,10 +249,10 @@
bool IsValidMemberName(const char* s);
// Returns the JNI native function name for the non-overloaded method 'm'.
-std::string JniShortName(const Method* m)
+std::string JniShortName(const AbstractMethod* m)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Returns the JNI native function name for the overloaded method 'm'.
-std::string JniLongName(const Method* m)
+std::string JniLongName(const 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 e6ff118..0b27fc5 100644
--- a/src/utils_test.cc
+++ b/src/utils_test.cc
@@ -194,7 +194,7 @@
ScopedObjectAccess soa(Thread::Current());
Class* c = class_linker_->FindSystemClass("Ljava/lang/String;");
ASSERT_TRUE(c != NULL);
- Method* m;
+ 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 ac9a0c9..f4884ad 100644
--- a/src/verifier/method_verifier.cc
+++ b/src/verifier/method_verifier.cc
@@ -215,7 +215,7 @@
while (it.HasNextDirectMethod()) {
uint32_t method_idx = it.GetMemberIndex();
InvokeType type = it.GetMethodInvokeType(class_def);
- Method* method = linker->ResolveMethod(*dex_file, method_idx, dex_cache, class_loader, NULL, type);
+ 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.
@@ -241,7 +241,7 @@
while (it.HasNextVirtualMethod()) {
uint32_t method_idx = it.GetMemberIndex();
InvokeType type = it.GetMethodInvokeType(class_def);
- Method* method = linker->ResolveMethod(*dex_file, method_idx, dex_cache, class_loader, NULL, type);
+ 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.
@@ -273,7 +273,7 @@
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, Method* method, uint32_t method_access_flags) {
+ const DexFile::CodeItem* code_item, AbstractMethod* method, uint32_t method_access_flags) {
MethodVerifier::FailureKind result = kNoFailure;
uint64_t start_ns = NanoTime();
@@ -308,7 +308,7 @@
return result;
}
-void MethodVerifier::VerifyMethodAndDump(Method* method) {
+void MethodVerifier::VerifyMethodAndDump(AbstractMethod* method) {
CHECK(method != NULL);
MethodHelper mh(method);
MethodVerifier verifier(&mh.GetDexFile(), mh.GetDexCache(), mh.GetClassLoader(),
@@ -321,7 +321,7 @@
MethodVerifier::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, Method* method, uint32_t method_access_flags)
+ uint32_t method_idx, AbstractMethod* method, uint32_t method_access_flags)
: work_insn_idx_(-1),
method_idx_(method_idx),
foo_method_(method),
@@ -339,7 +339,7 @@
monitor_enter_count_(0) {
}
-void MethodVerifier::FindLocksAtDexPc(Method* m, uint32_t dex_pc, std::vector<uint32_t>& monitor_enter_dex_pcs) {
+void MethodVerifier::FindLocksAtDexPc(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(),
mh.GetClassDefIndex(), mh.GetCodeItem(), m->GetDexMethodIndex(),
@@ -1890,7 +1890,7 @@
dec_insn.opcode == Instruction::INVOKE_SUPER_RANGE);
bool is_super = (dec_insn.opcode == Instruction::INVOKE_SUPER ||
dec_insn.opcode == Instruction::INVOKE_SUPER_RANGE);
- Method* called_method = VerifyInvocationArgs(dec_insn, METHOD_VIRTUAL, is_range, is_super);
+ 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;
@@ -1908,7 +1908,7 @@
case Instruction::INVOKE_DIRECT:
case Instruction::INVOKE_DIRECT_RANGE: {
bool is_range = (dec_insn.opcode == Instruction::INVOKE_DIRECT_RANGE);
- Method* called_method = VerifyInvocationArgs(dec_insn, METHOD_DIRECT, is_range, false);
+ AbstractMethod* called_method = VerifyInvocationArgs(dec_insn, METHOD_DIRECT, is_range, false);
const char* return_type_descriptor;
bool is_constructor;
if (called_method == NULL) {
@@ -1969,7 +1969,7 @@
case Instruction::INVOKE_STATIC:
case Instruction::INVOKE_STATIC_RANGE: {
bool is_range = (dec_insn.opcode == Instruction::INVOKE_STATIC_RANGE);
- Method* called_method = VerifyInvocationArgs(dec_insn, METHOD_STATIC, is_range, false);
+ 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;
@@ -1987,7 +1987,7 @@
case Instruction::INVOKE_INTERFACE:
case Instruction::INVOKE_INTERFACE_RANGE: {
bool is_range = (dec_insn.opcode == Instruction::INVOKE_INTERFACE_RANGE);
- Method* abs_method = VerifyInvocationArgs(dec_insn, METHOD_INTERFACE, is_range, false);
+ AbstractMethod* abs_method = VerifyInvocationArgs(dec_insn, METHOD_INTERFACE, is_range, false);
if (abs_method != NULL) {
Class* called_interface = abs_method->GetDeclaringClass();
if (!called_interface->IsInterface() && !called_interface->IsObjectClass()) {
@@ -2511,7 +2511,7 @@
return *common_super;
}
-Method* MethodVerifier::ResolveMethodAndCheckAccess(uint32_t dex_method_idx, MethodType method_type) {
+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()) {
@@ -2525,7 +2525,7 @@
}
Class* klass = klass_type.GetClass();
const RegType& referrer = GetDeclaringClass();
- Method* res_method = dex_cache_->GetResolvedMethod(dex_method_idx);
+ 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));
@@ -2602,11 +2602,11 @@
return res_method;
}
-Method* MethodVerifier::VerifyInvocationArgs(const DecodedInstruction& dec_insn,
+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.
- Method* res_method = ResolveMethodAndCheckAccess(dec_insn.vB, method_type);
+ AbstractMethod* res_method = ResolveMethodAndCheckAccess(dec_insn.vB, method_type);
if (res_method == NULL) { // error or class is unresolved
return NULL;
}
diff --git a/src/verifier/method_verifier.h b/src/verifier/method_verifier.h
index c1c2562..8951b13 100644
--- a/src/verifier/method_verifier.h
+++ b/src/verifier/method_verifier.h
@@ -193,7 +193,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(Method* m, uint32_t dex_pc,
+ static void FindLocksAtDexPc(AbstractMethod* m, uint32_t dex_pc,
std::vector<uint32_t>& monitor_enter_dex_pcs)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -211,7 +211,7 @@
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, Method* method, uint32_t access_flags)
+ uint32_t method_idx, AbstractMethod* method, uint32_t access_flags)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Adds the given string to the beginning of the last failure message.
@@ -233,9 +233,9 @@
*/
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,
- Method* method, uint32_t method_access_flags)
+ AbstractMethod* method, uint32_t method_access_flags)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
- static void VerifyMethodAndDump(Method* method)
+ static void VerifyMethodAndDump(AbstractMethod* method)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
// Run verification on the method. Returns true if verification completes and false if the input
@@ -493,7 +493,7 @@
* the referrer can access the resolved method.
* Does not throw exceptions.
*/
- Method* ResolveMethodAndCheckAccess(uint32_t method_idx, MethodType method_type)
+ AbstractMethod* ResolveMethodAndCheckAccess(uint32_t method_idx, MethodType method_type)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
/*
@@ -518,7 +518,7 @@
* Returns the resolved method on success, NULL on failure (with *failure
* set appropriately).
*/
- Method* VerifyInvocationArgs(const DecodedInstruction& dec_insn,
+ AbstractMethod* VerifyInvocationArgs(const DecodedInstruction& dec_insn,
MethodType method_type, bool is_range, bool is_super)
SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
@@ -618,7 +618,7 @@
uint32_t method_idx_; // The method we're working on.
// Its object representation if known.
- Method* foo_method_ GUARDED_BY(Locks::mutator_lock_);
+ 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.
diff --git a/src/well_known_classes.cc b/src/well_known_classes.cc
index cae7369..1413f0b 100644
--- a/src/well_known_classes.cc
+++ b/src/well_known_classes.cc
@@ -31,7 +31,7 @@
jclass WellKnownClasses::java_lang_Daemons;
jclass WellKnownClasses::java_lang_Error;
jclass WellKnownClasses::java_lang_reflect_InvocationHandler;
-jclass WellKnownClasses::java_lang_reflect_Method;
+jclass WellKnownClasses::java_lang_reflect_AbstractMethod;
jclass WellKnownClasses::java_lang_reflect_Proxy;
jclass WellKnownClasses::java_lang_RuntimeException;
jclass WellKnownClasses::java_lang_Thread;
@@ -125,7 +125,7 @@
java_lang_Daemons = CacheClass(env, "java/lang/Daemons");
java_lang_Error = CacheClass(env, "java/lang/Error");
java_lang_reflect_InvocationHandler = CacheClass(env, "java/lang/reflect/InvocationHandler");
- java_lang_reflect_Method = CacheClass(env, "java/lang/reflect/Method");
+ java_lang_reflect_AbstractMethod = CacheClass(env, "java/lang/reflect/AbstractMethod");
java_lang_reflect_Proxy = CacheClass(env, "java/lang/reflect/Proxy");
java_lang_RuntimeException = CacheClass(env, "java/lang/RuntimeException");
java_lang_Thread = CacheClass(env, "java/lang/Thread");
diff --git a/src/well_known_classes.h b/src/well_known_classes.h
index 65ee6b4..15a204f 100644
--- a/src/well_known_classes.h
+++ b/src/well_known_classes.h
@@ -42,7 +42,7 @@
static jclass java_lang_Daemons;
static jclass java_lang_Error;
static jclass java_lang_reflect_InvocationHandler;
- static jclass java_lang_reflect_Method;
+ static jclass java_lang_reflect_AbstractMethod;
static jclass java_lang_reflect_Proxy;
static jclass java_lang_RuntimeException;
static jclass java_lang_Thread;