Working ClassLoader
Change-Id: Ia1122165e47f846a1d4506111849f830d9f14c1b
diff --git a/Android.mk b/Android.mk
index 97bf41a..9a53fd0 100644
--- a/Android.mk
+++ b/Android.mk
@@ -166,7 +166,7 @@
# oatdump targets
.PHONY: dump-oat
-dump-oat: dump-oat-core dump-oat-boot dump-oat-Calculator
+dump-oat: dump-oat-core dump-oat-boot # dump-oat-Calculator # TODO: restore when oatdump can dump an oat without an image
.PHONY: dump-oat-core
dump-oat-core: $(TARGET_CORE_OAT) $(OATDUMP)
diff --git a/build/Android.common.mk b/build/Android.common.mk
index 605c48b..a45c644 100644
--- a/build/Android.common.mk
+++ b/build/Android.common.mk
@@ -27,6 +27,7 @@
art_cflags := \
-O2 \
+ -O0 \
-ggdb3 \
-Wall \
-Werror \
@@ -178,6 +179,7 @@
TEST_COMMON_SRC_FILES := \
src/class_linker_test.cc \
+ src/compiler_test.cc \
src/dex_cache_test.cc \
src/dex_file_test.cc \
src/dex_instruction_visitor_test.cc \
@@ -198,8 +200,7 @@
src/runtime_test.cc \
src/space_test.cc \
src/utils_test.cc \
- src/zip_archive_test.cc \
- src/compiler_test.cc
+ src/zip_archive_test.cc
TEST_TARGET_SRC_FILES := \
$(TEST_COMMON_SRC_FILES)
diff --git a/build/Android.oattest.mk b/build/Android.oattest.mk
index b3dee96..6dfbf99 100644
--- a/build/Android.oattest.mk
+++ b/build/Android.oattest.mk
@@ -40,7 +40,7 @@
# TODO: change DEX2OATD (and perhaps $(2) boot oat) to order-only prerequisite when output is stable
$(patsubst %.apk,%.oat,$(patsubst %.jar,%.oat,$(1))): $(1) $(2) $(DEX2OAT)
@echo "target dex2oat: $$@ ($$<)"
- $(hide) $(DEX2OAT) -Xms16m -Xmx16m --boot-image=$(patsubst %.oat,%.art,$(2)) $(addprefix --dex-file=,$$<) --oat=$$@ --image=$$(patsubst %.oat,%.art,$$@) --host-prefix=$(PRODUCT_OUT)
+ $(hide) $(DEX2OAT) -Xms16m -Xmx16m --boot-image=$(patsubst %.oat,%.art,$(2)) $(addprefix --dex-file=,$$<) --oat=$$@ --host-prefix=$(PRODUCT_OUT)
endef
########################################################################
@@ -64,7 +64,7 @@
test-art-target-oat-$(1): test-art-target-sync
adb shell touch /sdcard/test-art-target-oat-$(1)
adb shell rm /sdcard/test-art-target-oat-$(1)
- adb shell sh -c "oatexecd -Ximage:/system/framework/core.art -classpath /system/framework/art-test-dex-$(1).jar -Ximage:/system/framework/art-test-dex-$(1).art $(1) $(2) && touch /sdcard/test-art-target-oat-$(1)"
+ adb shell sh -c "oatexecd -Ximage:/system/framework/core.art -classpath /system/framework/art-test-dex-$(1).jar $(1) $(2) && touch /sdcard/test-art-target-oat-$(1)"
$(hide) (adb pull /sdcard/test-art-target-oat-$(1) /tmp/ && echo test-art-target-oat-$(1) PASSED) || (echo test-art-target-oat-$(1) FAILED && exit 1)
$(hide) rm /tmp/test-art-target-oat-$(1)
diff --git a/oat_process/app_main.cpp b/oat_process/app_main.cpp
index e769907..53321f1 100644
--- a/oat_process/app_main.cpp
+++ b/oat_process/app_main.cpp
@@ -82,52 +82,6 @@
free(slashClassName);
mClass = reinterpret_cast<jclass>(env->NewGlobalRef(mClass));
-
- // TODO: remove this ClassLoader code
- jclass ApplicationLoaders = env->FindClass("android/app/ApplicationLoaders");
- jmethodID getDefault = env->GetStaticMethodID(ApplicationLoaders,
- "getDefault",
- "()Landroid/app/ApplicationLoaders;");
- jfieldID mLoaders = env->GetFieldID(ApplicationLoaders, "mLoaders", "Ljava/util/Map;");
- jclass BootClassLoader = env->FindClass("java/lang/BootClassLoader");
- jmethodID getInstance = env->GetStaticMethodID(BootClassLoader,
- "getInstance",
- "()Ljava/lang/BootClassLoader;");
- jclass ClassLoader = env->FindClass("java/lang/ClassLoader");
- jfieldID parent = env->GetFieldID(ClassLoader, "parent", "Ljava/lang/ClassLoader;");
- jclass Map = env->FindClass("java/util/Map");
- jmethodID put = env->GetMethodID(Map,
- "put",
- "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
- jclass BaseDexClassLoader = env->FindClass("dalvik/system/BaseDexClassLoader");
- jfieldID originalPath = env->GetFieldID(BaseDexClassLoader, "originalPath", "Ljava/lang/String;");
- jfieldID pathList = env->GetFieldID(BaseDexClassLoader, "pathList", "Ldalvik/system/DexPathList;");
- jclass DexPathList = env->FindClass("dalvik/system/DexPathList");
- jmethodID init = env->GetMethodID(DexPathList,
- "<init>",
- "(Ljava/lang/ClassLoader;Ljava/lang/String;Ljava/lang/String;Ljava/io/File;)V");
-
- // Set the parent of our pre-existing ClassLoader to the non-null BootClassLoader.getInstance()
- const art::ClassLoader* class_loader_object = art::Thread::Current()->GetClassLoaderOverride();
- jobject class_loader = art::AddLocalReference<jobject>(env, class_loader_object);
- jobject boot_class_loader = env->CallStaticObjectMethod(BootClassLoader, getInstance);
- env->SetObjectField(class_loader, parent, boot_class_loader);
-
- // Create a DexPathList
- jstring dex_path = env->NewStringUTF("/system/app/Calculator.apk");
- jstring library_path = env->NewStringUTF("/data/data/com.android.calculator2/lib");
- jobject dex_path_list = env->NewObject(DexPathList, init,
- boot_class_loader, dex_path, library_path, NULL);
-
- // Set DexPathList into our pre-existing ClassLoader
- env->SetObjectField(class_loader, pathList, dex_path_list);
- env->SetObjectField(class_loader, originalPath, dex_path);
-
- // Stash our pre-existing ClassLoader into ApplicationLoaders.getDefault().mLoaders
- // under the expected name.
- jobject application_loaders = env->CallStaticObjectMethod(ApplicationLoaders, getDefault);
- jobject loaders = env->GetObjectField(application_loaders, mLoaders);
- env->CallObjectMethod(loaders, put, dex_path, class_loader);
}
virtual void onStarted()
@@ -209,14 +163,12 @@
}
}
- // TODO: remove Calculator special case
- int oatArgc = argc + 2;
+ // TODO: remove when we default the boot image
+ int oatArgc = argc + 1;
const char* oatArgv[oatArgc];
if (strcmp(argv[0], "-Ximage:/system/framework/boot.art") != 0) {
- LOG(INFO) << "Adding oat arguments";
+ LOG(INFO) << "Adding image arguments";
oatArgv[0] = "-Ximage:/system/framework/boot.art";
- oatArgv[1] = "-Ximage:/system/app/Calculator.art";
- setenv("CLASSPATH", "/system/app/Calculator.apk", 1);
memcpy(oatArgv + (oatArgc - argc), argv, argc * sizeof(*argv));
argv = oatArgv;
argc = oatArgc;
diff --git a/src/class_linker.cc b/src/class_linker.cc
index 8ca633b..3f30b9e 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -436,10 +436,9 @@
java_lang_ref_WeakReference->GetAccessFlags() |
kAccClassIsReference | kAccClassIsWeakReference);
- // Setup the ClassLoaders, adjusting the object_size_ as necessary
+ // Setup the ClassLoaders, verifying the object_size_
Class* java_lang_ClassLoader = FindSystemClass("Ljava/lang/ClassLoader;");
- CHECK_LT(java_lang_ClassLoader->GetObjectSize(), sizeof(ClassLoader));
- java_lang_ClassLoader->SetObjectSize(sizeof(ClassLoader));
+ CHECK_EQ(java_lang_ClassLoader->GetObjectSize(), sizeof(ClassLoader));
SetClassRoot(kJavaLangClassLoader, java_lang_ClassLoader);
Class* dalvik_system_BaseDexClassLoader = FindSystemClass("Ldalvik/system/BaseDexClassLoader;");
@@ -539,6 +538,7 @@
}
OatFile* ClassLinker::OpenOat(const Space* space) {
+ MutexLock mu(lock_);
const Runtime* runtime = Runtime::Current();
if (runtime->IsVerboseStartup()) {
LOG(INFO) << "ClassLinker::OpenOat entering";
@@ -568,6 +568,37 @@
return oat_file;
}
+const OatFile* ClassLinker::FindOatFile(const DexFile& dex_file) {
+ MutexLock mu(lock_);
+ std::string dex_file_location = dex_file.GetLocation();
+ std::string location(dex_file_location);
+ CHECK(StringPiece(location).ends_with(".dex")
+ || StringPiece(location).ends_with(".zip")
+ || StringPiece(location).ends_with(".jar")
+ || StringPiece(location).ends_with(".apk"));
+ location.erase(location.size()-3);
+ location += "oat";
+ // TODO: check if dex_file matches an OatDexFile location and checksum
+ return FindOatFile(location);
+}
+
+const OatFile* ClassLinker::FindOatFile(const std::string& location) {
+ for (size_t i = 0; i < oat_files_.size(); i++) {
+ const OatFile* oat_file = oat_files_[i];
+ DCHECK(oat_file != NULL);
+ if (oat_file->GetLocation() == location) {
+ return oat_file;
+ }
+ }
+
+ const OatFile* oat_file = OatFile::Open(location, "", NULL);
+ if (oat_file == NULL) {
+ LOG(ERROR) << "Failed to open oat file " << location;
+ return NULL;
+ }
+ return oat_file;
+}
+
void ClassLinker::InitFromImage() {
const Runtime* runtime = Runtime::Current();
if (runtime->IsVerboseStartup()) {
@@ -599,8 +630,8 @@
<< " referenced from oat file as " << dex_file_location;
}
- const OatFile::OatDexFile& oat_dex_file = oat_file->GetOatDexFile(dex_file_location);
- CHECK_EQ(dex_file->GetHeader().checksum_, oat_dex_file.GetDexFileChecksum());
+ const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file_location);
+ CHECK_EQ(dex_file->GetHeader().checksum_, oat_dex_file->GetDexFileChecksum());
RegisterDexFile(*dex_file, dex_cache);
}
@@ -653,21 +684,13 @@
class_linker->intern_table_->RegisterStrong(obj->AsString());
return;
}
- if (!obj->IsClass()) {
+ if (obj->IsClass()) {
+ // restore class to ClassLinker::classes_ table
+ Class* klass = obj->AsClass();
+ std::string descriptor = klass->GetDescriptor()->ToModifiedUtf8();
+ class_linker->InsertClass(descriptor, klass);
return;
}
- Class* klass = obj->AsClass();
- // TODO: restore ClassLoader's list of DexFiles after image load
- // CHECK(klass->GetClassLoader() == NULL);
- const ClassLoader* class_loader = klass->GetClassLoader();
- if (class_loader != NULL) {
- // TODO: replace this hack with something based on command line arguments
- Thread::Current()->SetClassLoaderOverride(class_loader);
- }
-
- std::string descriptor = klass->GetDescriptor()->ToModifiedUtf8();
- // restore class to ClassLinker::classes_ table
- class_linker->InsertClass(descriptor, klass);
}
// Keep in sync with InitCallback. Anything we visit, we need to
@@ -759,100 +782,10 @@
length);
}
-Class* ClassLinker::FindClass(const StringPiece& descriptor,
- const ClassLoader* class_loader) {
- // TODO: remove this contrived parent class loader check when we have a real ClassLoader.
- if (class_loader != NULL) {
- Class* klass = FindClass(descriptor, NULL);
- if (klass != NULL) {
- return klass;
- }
- Thread::Current()->ClearException();
- }
-
+Class* EnsureResolved(Class* klass) {
+ DCHECK(klass != NULL);
+ // Wait for the class if it has not already been linked.
Thread* self = Thread::Current();
- DCHECK(self != NULL);
- CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
- // Find the class in the loaded classes table.
- Class* klass = LookupClass(descriptor, class_loader);
- if (klass == NULL) {
- // Class is not yet loaded.
- if (descriptor[0] == '[' && descriptor[1] != '\0') {
- return CreateArrayClass(descriptor, class_loader);
- }
- const DexFile::ClassPath& class_path = ((class_loader != NULL)
- ? ClassLoader::GetClassPath(class_loader)
- : boot_class_path_);
- DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, class_path);
- if (pair.second == NULL) {
- std::string name(PrintableString(descriptor));
- ThrowNoClassDefFoundError("Class %s not found in class loader %p", name.c_str(), class_loader);
- return NULL;
- }
- const DexFile& dex_file = *pair.first;
- const DexFile::ClassDef& dex_class_def = *pair.second;
- DexCache* dex_cache = FindDexCache(dex_file);
- // Load the class from the dex file.
- if (!init_done_) {
- // finish up init of hand crafted class_roots_
- if (descriptor == "Ljava/lang/Object;") {
- klass = GetClassRoot(kJavaLangObject);
- } else if (descriptor == "Ljava/lang/Class;") {
- klass = GetClassRoot(kJavaLangClass);
- } else if (descriptor == "Ljava/lang/String;") {
- klass = GetClassRoot(kJavaLangString);
- } else if (descriptor == "Ljava/lang/reflect/Constructor;") {
- klass = GetClassRoot(kJavaLangReflectConstructor);
- } else if (descriptor == "Ljava/lang/reflect/Field;") {
- klass = GetClassRoot(kJavaLangReflectField);
- } else if (descriptor == "Ljava/lang/reflect/Method;") {
- klass = GetClassRoot(kJavaLangReflectMethod);
- } else {
- klass = AllocClass(SizeOfClass(dex_file, dex_class_def));
- }
- } else {
- klass = AllocClass(SizeOfClass(dex_file, dex_class_def));
- }
- if (!klass->IsResolved()) {
- klass->SetDexCache(dex_cache);
- LoadClass(dex_file, dex_class_def, klass, class_loader);
- // Check for a pending exception during load
- if (self->IsExceptionPending()) {
- return NULL;
- }
- ObjectLock lock(klass);
- klass->SetClinitThreadId(self->GetTid());
- // Add the newly loaded class to the loaded classes table.
- bool success = InsertClass(descriptor, klass); // TODO: just return collision
- if (!success) {
- // We may fail to insert if we raced with another thread.
- klass->SetClinitThreadId(0);
- klass = LookupClass(descriptor, class_loader);
- CHECK(klass != NULL);
- return klass;
- } else {
- // Finish loading (if necessary) by finding parents
- CHECK(!klass->IsLoaded());
- if (!LoadSuperAndInterfaces(klass, dex_file)) {
- // Loading failed.
- CHECK(self->IsExceptionPending());
- lock.NotifyAll();
- return NULL;
- }
- CHECK(klass->IsLoaded());
- // Link the class (if necessary)
- CHECK(!klass->IsResolved());
- if (!LinkClass(klass)) {
- // Linking failed.
- CHECK(self->IsExceptionPending());
- lock.NotifyAll();
- return NULL;
- }
- CHECK(klass->IsResolved());
- }
- }
- }
- // Link the class if it has not already been linked.
if (!klass->IsResolved() && !klass->IsErroneous()) {
ObjectLock lock(klass);
// Check for circular dependencies between classes.
@@ -871,8 +804,134 @@
return NULL;
}
// Return the loaded class. No exceptions should be pending.
- CHECK(klass->IsResolved()) << descriptor;
- CHECK(!self->IsExceptionPending()) << descriptor << " " << PrettyTypeOf(self->GetException());
+ CHECK(klass->IsResolved()) << PrettyClass(klass);
+ CHECK(!self->IsExceptionPending())
+ << PrettyClass(klass) << " " << PrettyTypeOf(self->GetException());
+ return klass;
+}
+
+Class* ClassLinker::FindClass(const std::string& descriptor,
+ const ClassLoader* class_loader) {
+ CHECK_NE(descriptor.size(), 0U);
+ Thread* self = Thread::Current();
+ DCHECK(self != NULL);
+ CHECK(!self->IsExceptionPending()) << PrettyTypeOf(self->GetException());
+ // Find the class in the loaded classes table.
+ Class* klass = LookupClass(descriptor, class_loader);
+ if (klass != NULL) {
+ return EnsureResolved(klass);
+ }
+ if (descriptor.size() == 1) {
+ // only the descriptors of primitive types should be 1 character long
+ return FindPrimitiveClass(descriptor[0]);
+ }
+ // Class is not yet loaded.
+ if (descriptor[0] == '[') {
+ return CreateArrayClass(descriptor, class_loader);
+ }
+ if (class_loader == NULL) {
+ DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, boot_class_path_);
+ if (pair.second == NULL) {
+ std::string name(PrintableString(descriptor));
+ ThrowNoClassDefFoundError("Class %s not found in boot class loader", name.c_str());
+ return NULL;
+ }
+ return DefineClass(descriptor, NULL, *pair.first, *pair.second);
+ }
+
+ if (ClassLoader::UseCompileTimeClassPath()) {
+ const std::vector<const DexFile*>& class_path
+ = ClassLoader::GetCompileTimeClassPath(class_loader);
+ DexFile::ClassPathEntry pair = DexFile::FindInClassPath(descriptor, class_path);
+ if (pair.second == NULL) {
+ return FindSystemClass(descriptor);
+ }
+ return DefineClass(descriptor, class_loader, *pair.first, *pair.second);
+ }
+
+ std::string class_name_string = DescriptorToDot(descriptor);
+ ScopedThreadStateChange(self, Thread::kNative);
+ JNIEnv* env = self->GetJniEnv();
+ jclass c = AddLocalReference<jclass>(env, GetClassRoot(kJavaLangClassLoader));
+ CHECK(c != NULL);
+ // TODO: cache method?
+ jmethodID mid = env->GetMethodID(c, "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
+ CHECK(mid != NULL);
+ jobject class_name_object = env->NewStringUTF(class_name_string.c_str());
+ if (class_name_string == NULL) {
+ return NULL;
+ }
+ jobject class_loader_object = AddLocalReference<jobject>(env, class_loader);
+ jobject result = env->CallObjectMethod(class_loader_object, mid, class_name_object);
+ Class* klass_result = Decode<Class*>(env, result);
+ env->DeleteLocalRef(result);
+ env->DeleteLocalRef(class_name_object);
+ env->DeleteLocalRef(c);
+ return klass_result;
+}
+
+Class* ClassLinker::DefineClass(const std::string& descriptor,
+ const ClassLoader* class_loader,
+ const DexFile& dex_file,
+ const DexFile::ClassDef& dex_class_def) {
+ Class* klass;
+ // Load the class from the dex file.
+ if (!init_done_) {
+ // finish up init of hand crafted class_roots_
+ if (descriptor == "Ljava/lang/Object;") {
+ klass = GetClassRoot(kJavaLangObject);
+ } else if (descriptor == "Ljava/lang/Class;") {
+ klass = GetClassRoot(kJavaLangClass);
+ } else if (descriptor == "Ljava/lang/String;") {
+ klass = GetClassRoot(kJavaLangString);
+ } else if (descriptor == "Ljava/lang/reflect/Constructor;") {
+ klass = GetClassRoot(kJavaLangReflectConstructor);
+ } else if (descriptor == "Ljava/lang/reflect/Field;") {
+ klass = GetClassRoot(kJavaLangReflectField);
+ } else if (descriptor == "Ljava/lang/reflect/Method;") {
+ klass = GetClassRoot(kJavaLangReflectMethod);
+ } else {
+ klass = AllocClass(SizeOfClass(dex_file, dex_class_def));
+ }
+ } else {
+ klass = AllocClass(SizeOfClass(dex_file, dex_class_def));
+ }
+ klass->SetDexCache(FindDexCache(dex_file));
+ LoadClass(dex_file, dex_class_def, klass, class_loader);
+ // Check for a pending exception during load
+ Thread* self = Thread::Current();
+ if (self->IsExceptionPending()) {
+ return NULL;
+ }
+ ObjectLock lock(klass);
+ klass->SetClinitThreadId(self->GetTid());
+ // Add the newly loaded class to the loaded classes table.
+ bool success = InsertClass(descriptor, klass); // TODO: just return collision
+ if (!success) {
+ // We may fail to insert if we raced with another thread.
+ klass->SetClinitThreadId(0);
+ klass = LookupClass(descriptor, class_loader);
+ CHECK(klass != NULL);
+ return klass;
+ }
+ // Finish loading (if necessary) by finding parents
+ CHECK(!klass->IsLoaded());
+ if (!LoadSuperAndInterfaces(klass, dex_file)) {
+ // Loading failed.
+ CHECK(self->IsExceptionPending());
+ lock.NotifyAll();
+ return NULL;
+ }
+ CHECK(klass->IsLoaded());
+ // Link the class (if necessary)
+ CHECK(!klass->IsResolved());
+ if (!LinkClass(klass)) {
+ // Linking failed.
+ CHECK(self->IsExceptionPending());
+ lock.NotifyAll();
+ return NULL;
+ }
+ CHECK(klass->IsResolved());
return klass;
}
@@ -991,18 +1050,36 @@
}
}
+ UniquePtr<const OatFile::OatClass> oat_class;
+ if (Runtime::Current()->IsStarted() && !ClassLoader::UseCompileTimeClassPath()) {
+ const OatFile* oat_file = FindOatFile(dex_file);
+ if (oat_file != NULL) {
+ const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
+ if (oat_dex_file != NULL) {
+ uint32_t class_def_index;
+ bool found = dex_file.FindClassDefIndex(descriptor, class_def_index);
+ CHECK(found) << descriptor;
+ oat_class.reset(oat_dex_file->GetOatClass(class_def_index));
+ }
+ }
+ }
+ size_t method_index = 0;
+
// Load direct methods.
if (num_direct_methods != 0) {
// TODO: append direct methods to class object
klass->SetDirectMethods(AllocObjectArray<Method>(num_direct_methods));
uint32_t last_idx = 0;
- for (size_t i = 0; i < num_direct_methods; ++i) {
+ for (size_t i = 0; i < num_direct_methods; ++i, ++method_index) {
DexFile::Method dex_method;
dex_file.dexReadClassDataMethod(&class_data, &dex_method, &last_idx);
Method* meth = AllocMethod();
klass->SetDirectMethod(i, meth);
LoadMethod(dex_file, dex_method, klass, meth);
- // TODO: register maps
+ if (oat_class.get() != NULL) {
+ const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
+ oat_method.LinkMethod(meth);
+ }
}
}
@@ -1011,13 +1088,16 @@
// TODO: append virtual methods to class object
klass->SetVirtualMethods(AllocObjectArray<Method>(num_virtual_methods));
uint32_t last_idx = 0;
- for (size_t i = 0; i < num_virtual_methods; ++i) {
+ for (size_t i = 0; i < num_virtual_methods; ++i, ++method_index) {
DexFile::Method dex_method;
dex_file.dexReadClassDataMethod(&class_data, &dex_method, &last_idx);
Method* meth = AllocMethod();
klass->SetVirtualMethod(i, meth);
LoadMethod(dex_file, dex_method, klass, meth);
- // TODO: register maps
+ if (oat_class.get() != NULL) {
+ const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
+ oat_method.LinkMethod(meth);
+ }
}
}
}
@@ -1130,18 +1210,42 @@
RegisterDexFile(dex_file, dex_cache);
}
-void ClassLinker::RegisterDexFile(const DexFile& dex_file) {
- RegisterDexFile(dex_file, AllocDexCache(dex_file));
+bool ClassLinker::IsDexFileRegisteredLocked(const DexFile& dex_file) const {
+ lock_.AssertHeld();
+ for (size_t i = 0; i != dex_files_.size(); ++i) {
+ if (dex_files_[i] == &dex_file) {
+ return true;
+ }
+ }
+ return false;
}
-void ClassLinker::RegisterDexFile(const DexFile& dex_file, DexCache* dex_cache) {
+bool ClassLinker::IsDexFileRegistered(const DexFile& dex_file) const {
MutexLock mu(lock_);
+ return IsDexFileRegistered(dex_file);
+}
+
+void ClassLinker::RegisterDexFileLocked(const DexFile& dex_file, DexCache* dex_cache) {
+ lock_.AssertHeld();
CHECK(dex_cache != NULL) << dex_file.GetLocation();
CHECK(dex_cache->GetLocation()->Equals(dex_file.GetLocation()));
dex_files_.push_back(&dex_file);
dex_caches_.push_back(dex_cache);
}
+void ClassLinker::RegisterDexFile(const DexFile& dex_file) {
+ MutexLock mu(lock_);
+ if (IsDexFileRegisteredLocked(dex_file)) {
+ return;
+ }
+ RegisterDexFileLocked(dex_file, AllocDexCache(dex_file));
+}
+
+void ClassLinker::RegisterDexFile(const DexFile& dex_file, DexCache* dex_cache) {
+ MutexLock mu(lock_);
+ RegisterDexFileLocked(dex_file, dex_cache);
+}
+
const DexFile& ClassLinker::FindDexFile(const DexCache* dex_cache) const {
MutexLock mu(lock_);
for (size_t i = 0; i != dex_caches_.size(); ++i) {
@@ -1191,7 +1295,7 @@
// array class; that always comes from the base element class.
//
// Returns NULL with an exception raised on failure.
-Class* ClassLinker::CreateArrayClass(const StringPiece& descriptor,
+Class* ClassLinker::CreateArrayClass(const std::string& descriptor,
const ClassLoader* class_loader) {
CHECK_EQ('[', descriptor[0]);
@@ -1259,7 +1363,7 @@
if (new_class->GetDescriptor() != NULL) {
DCHECK(new_class->GetDescriptor()->Equals(descriptor));
} else {
- new_class->SetDescriptor(intern_table_->InternStrong(descriptor.ToString().c_str()));
+ new_class->SetDescriptor(intern_table_->InternStrong(descriptor.c_str()));
}
Class* java_lang_Object = GetClassRoot(kJavaLangObject);
new_class->SetSuperClass(java_lang_Object);
@@ -1339,14 +1443,14 @@
return NULL;
}
-bool ClassLinker::InsertClass(const StringPiece& descriptor, Class* klass) {
+bool ClassLinker::InsertClass(const std::string& descriptor, Class* klass) {
size_t hash = StringPieceHash()(descriptor);
MutexLock mu(lock_);
Table::iterator it = classes_.insert(std::make_pair(hash, klass));
return ((*it).second == klass);
}
-Class* ClassLinker::LookupClass(const StringPiece& descriptor, const ClassLoader* class_loader) {
+Class* ClassLinker::LookupClass(const std::string& descriptor, const ClassLoader* class_loader) {
size_t hash = StringPieceHash()(descriptor);
MutexLock mu(lock_);
typedef Table::const_iterator It; // TODO: C++0x auto
@@ -2290,12 +2394,7 @@
Class* resolved = dex_cache->GetResolvedType(type_idx);
if (resolved == NULL) {
const char* descriptor = dex_file.dexStringByTypeIdx(type_idx);
- if (descriptor[1] == '\0') {
- // only the descriptors of primitive types should be 1 character long
- resolved = FindPrimitiveClass(descriptor[0]);
- } else {
- resolved = FindClass(descriptor, class_loader);
- }
+ resolved = FindClass(descriptor, class_loader);
if (resolved != NULL) {
Class* check = resolved;
while (check->IsArrayClass()) {
diff --git a/src/class_linker.h b/src/class_linker.h
index 6d17a10..67bb35c 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -50,23 +50,38 @@
// Finds a class by its descriptor, loading it if necessary.
// If class_loader is null, searches boot_class_path_.
- Class* FindClass(const StringPiece& descriptor, const ClassLoader* class_loader);
+ Class* FindClass(const std::string& descriptor, const ClassLoader* class_loader);
+
+ Class* FindSystemClass(const std::string& descriptor) {
+ return FindClass(descriptor, NULL);
+ }
+
+ // Define a new a class based on a ClassDef from a DexFile
+ Class* DefineClass(const std::string& descriptor, const ClassLoader* class_loader,
+ const DexFile& dex_file, const DexFile::ClassDef& dex_class_def);
// Finds a class by its descriptor, returning NULL if it isn't wasn't loaded
// by the given 'class_loader'.
- Class* LookupClass(const StringPiece& descriptor, const ClassLoader* class_loader);
+ Class* LookupClass(const std::string& descriptor, const ClassLoader* class_loader);
Class* FindPrimitiveClass(char type);
- Class* FindSystemClass(const StringPiece& descriptor) {
- return FindClass(descriptor, NULL);
- }
-
void DumpAllClasses(int flags) const;
size_t NumLoadedClasses() const;
// 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) {
+ Class* declaring_class = referrer->GetDeclaringClass();
+ DexCache* dex_cache = declaring_class->GetDexCache();
+ // TODO: we could check for a dex cache hit here
+ const DexFile& dex_file = FindDexFile(dex_cache);
+ return ResolveString(dex_file, string_idx, dex_cache);
+ }
+
+ // Resolve a String with the given index from the DexFile, storing the
// result in the DexCache.
String* ResolveString(const DexFile& dex_file, uint32_t string_idx, DexCache* dex_cache);
@@ -175,6 +190,8 @@
const DexFile& FindDexFile(const DexCache* dex_cache) const;
DexCache* FindDexCache(const DexFile& dex_file) const;
+ bool IsDexFileRegistered(const DexFile& dex_file) const;
+ const OatFile* FindOatFile(const std::string& location);
// TODO: replace this with multiple methods that allocate the correct managed type.
template <class T>
@@ -228,7 +245,7 @@
Class::PrimitiveType type);
- Class* CreateArrayClass(const StringPiece& descriptor,
+ Class* CreateArrayClass(const std::string& descriptor,
const ClassLoader* class_loader);
void AppendToBootClassPath(const DexFile& dex_file);
@@ -261,7 +278,13 @@
// Inserts a class into the class table. Returns true if the class
// was inserted.
- bool InsertClass(const StringPiece& descriptor, Class* klass);
+ bool InsertClass(const std::string& descriptor, Class* klass);
+
+ void RegisterDexFileLocked(const DexFile& dex_file, DexCache* dex_cache);
+ bool IsDexFileRegisteredLocked(const DexFile& dex_file) const;
+
+ // Find, possibily opening, an OatFile corresponding to a DexFile
+ const OatFile* FindOatFile(const DexFile& dex_file);
bool InitializeClass(Class* klass, bool can_run_clinit);
bool WaitForInitializeClass(Class* klass, Thread* self, ObjectLock& lock);
@@ -314,7 +337,7 @@
std::vector<const DexFile*> dex_files_;
std::vector<DexCache*> dex_caches_;
- // multimap from a StringPiece hash code of a class descriptor to
+ // multimap from a string hash code of a class descriptor to
// Class* instances. Results should be compared for a matching
// Class::descriptor_ and Class::class_loader_.
typedef std::tr1::unordered_multimap<size_t, Class*> Table;
diff --git a/src/class_linker_test.cc b/src/class_linker_test.cc
index 264b669..8ad2a20 100644
--- a/src/class_linker_test.cc
+++ b/src/class_linker_test.cc
@@ -15,7 +15,7 @@
class ClassLinkerTest : public CommonTest {
protected:
- void AssertNonExistentClass(const StringPiece& descriptor) {
+ void AssertNonExistentClass(const std::string& descriptor) {
EXPECT_TRUE(class_linker_->FindSystemClass(descriptor) == NULL);
Thread* self = Thread::Current();
EXPECT_TRUE(self->IsExceptionPending());
@@ -25,11 +25,11 @@
EXPECT_TRUE(exception->InstanceOf(exception_class));
}
- void AssertPrimitiveClass(const StringPiece& descriptor) {
+ void AssertPrimitiveClass(const std::string& descriptor) {
AssertPrimitiveClass(descriptor, class_linker_->FindSystemClass(descriptor));
}
- void AssertPrimitiveClass(const StringPiece& descriptor, const Class* primitive) {
+ void AssertPrimitiveClass(const std::string& descriptor, const Class* primitive) {
ASSERT_TRUE(primitive != NULL);
ASSERT_TRUE(primitive->GetClass() != NULL);
ASSERT_EQ(primitive->GetClass(), primitive->GetClass()->GetClass());
@@ -62,8 +62,8 @@
EXPECT_TRUE(primitive->GetIfTable() == NULL);
}
- void AssertArrayClass(const StringPiece& array_descriptor,
- const StringPiece& component_type,
+ void AssertArrayClass(const std::string& array_descriptor,
+ const std::string& component_type,
const ClassLoader* class_loader) {
Class* array = class_linker_->FindClass(array_descriptor, class_loader);
EXPECT_TRUE(array->GetComponentType()->GetDescriptor()->Equals(component_type));
@@ -71,7 +71,7 @@
AssertArrayClass(array_descriptor, array);
}
- void AssertArrayClass(const StringPiece& array_descriptor, Class* array) {
+ void AssertArrayClass(const std::string& array_descriptor, Class* array) {
ASSERT_TRUE(array != NULL);
ASSERT_TRUE(array->GetClass() != NULL);
ASSERT_EQ(array->GetClass(), array->GetClass()->GetClass());
@@ -142,7 +142,7 @@
EXPECT_TRUE(field->GetType() != NULL);
}
- void AssertClass(const StringPiece& descriptor, Class* klass) {
+ void AssertClass(const std::string& descriptor, Class* klass) {
EXPECT_TRUE(klass->GetDescriptor()->Equals(descriptor));
if (klass->GetDescriptor()->Equals(String::AllocFromModifiedUtf8("Ljava/lang/Object;"))) {
EXPECT_FALSE(klass->HasSuperClass());
@@ -259,7 +259,7 @@
total_num_reference_instance_fields == 0);
}
- void AssertDexFileClass(ClassLoader* class_loader, const StringPiece& descriptor) {
+ void AssertDexFileClass(ClassLoader* class_loader, const std::string& descriptor) {
ASSERT_TRUE(descriptor != NULL);
Class* klass = class_linker_->FindSystemClass(descriptor);
ASSERT_TRUE(klass != NULL);
@@ -668,11 +668,11 @@
}
TEST_F(ClassLinkerTest, FindClass_Primitives) {
- StringPiece expected = "BCDFIJSZV";
+ const std::string expected("BCDFIJSZV");
for (int ch = 0; ch < 255; ch++) {
char* s = reinterpret_cast<char*>(&ch);
- StringPiece descriptor(s, 1);
- if (expected.find(ch) == StringPiece::npos) {
+ const std::string descriptor(s, 1);
+ if (expected.find(ch) == std::string::npos) {
AssertNonExistentClass(descriptor);
} else {
AssertPrimitiveClass(descriptor);
@@ -932,7 +932,7 @@
// case 2, get the initialized storage from StaticsFromCode.getS0
const ClassLoader* class_loader = LoadDex("StaticsFromCode");
- const DexFile* dex_file = ClassLoader::GetClassPath(class_loader)[0];
+ const DexFile* dex_file = ClassLoader::GetCompileTimeClassPath(class_loader)[0];
CHECK(dex_file != NULL);
Class* klass = class_linker_->FindClass("LStaticsFromCode;", class_loader);
diff --git a/src/class_loader.cc b/src/class_loader.cc
index 8f8e829..94a212f 100644
--- a/src/class_loader.cc
+++ b/src/class_loader.cc
@@ -7,20 +7,35 @@
namespace art {
-const std::vector<const DexFile*>& ClassLoader::GetClassPath(const ClassLoader* class_loader) {
+bool ClassLoader::use_compile_time_class_path = false;
+ClassLoader::Table ClassLoader::compile_time_class_paths_;
+
+const std::vector<const DexFile*>& ClassLoader::GetCompileTimeClassPath(const ClassLoader* class_loader) {
+ Runtime* runtime = Runtime::Current();
if (class_loader == NULL) {
- return Runtime::Current()->GetClassLinker()->GetBootClassPath();
+ return runtime->GetClassLinker()->GetBootClassPath();
}
- return class_loader->class_path_;
+ CHECK(ClassLoader::UseCompileTimeClassPath());
+ Table::const_iterator it = compile_time_class_paths_.find(class_loader);
+ CHECK(it != compile_time_class_paths_.end());
+ return it->second;
+}
+
+void ClassLoader::SetCompileTimeClassPath(const ClassLoader* class_loader,
+ std::vector<const DexFile*>& class_path) {
+ CHECK(!Runtime::Current()->IsStarted());
+ use_compile_time_class_path = true;
+ compile_time_class_paths_[class_loader] = class_path;
}
// TODO: get global references for these
Class* PathClassLoader::dalvik_system_PathClassLoader_ = NULL;
-const PathClassLoader* PathClassLoader::Alloc(std::vector<const DexFile*> dex_files) {
+const PathClassLoader* PathClassLoader::AllocCompileTime(std::vector<const DexFile*>& dex_files) {
+ CHECK(!Runtime::Current()->IsStarted());
DCHECK(dalvik_system_PathClassLoader_ != NULL);
PathClassLoader* p = down_cast<PathClassLoader*>(dalvik_system_PathClassLoader_->AllocObject());
- p->SetClassPath(dex_files);
+ SetCompileTimeClassPath(p, dex_files);
return p;
}
diff --git a/src/class_loader.h b/src/class_loader.h
index 80444f5..8fe6a09 100644
--- a/src/class_loader.h
+++ b/src/class_loader.h
@@ -7,19 +7,17 @@
#include "dex_file.h"
#include "object.h"
+#include "unordered_map.h"
namespace art {
// C++ mirror of java.lang.ClassLoader
-// TODO: add MANAGED when class_path_ removed
-class ClassLoader : public Object {
+class MANAGED ClassLoader : public Object {
public:
- static const std::vector<const DexFile*>& GetClassPath(const ClassLoader* class_loader);
-
- void SetClassPath(std::vector<const DexFile*>& class_path) {
- DCHECK_EQ(class_path_.size(), 0U);
- // TODO: use setter
- class_path_ = class_path;
+ static const std::vector<const DexFile*>& GetCompileTimeClassPath(const ClassLoader* class_loader);
+ static void SetCompileTimeClassPath(const ClassLoader* class_loader, std::vector<const DexFile*>& class_path);
+ static bool UseCompileTimeClassPath() {
+ return use_compile_time_class_path;
}
private:
@@ -27,8 +25,10 @@
Object* packages_;
ClassLoader* parent_;
- // TODO: remove once we can create a real PathClassLoader
- std::vector<const DexFile*> class_path_;
+ typedef std::tr1::unordered_map<const ClassLoader*, std::vector<const DexFile*>, ObjectIdentityHash> Table;
+ static Table compile_time_class_paths_;
+
+ static bool use_compile_time_class_path;
friend struct ClassLoaderOffsets; // for verifying offset information
DISALLOW_IMPLICIT_CONSTRUCTORS(ClassLoader);
@@ -50,7 +50,7 @@
// TODO: add MANAGED when class_path_ removed
class PathClassLoader : public BaseDexClassLoader {
public:
- static const PathClassLoader* Alloc(std::vector<const DexFile*> dex_files);
+ static const PathClassLoader* AllocCompileTime(std::vector<const DexFile*>& dex_files);
static void SetClass(Class* dalvik_system_PathClassLoader);
static void ResetClass();
private:
diff --git a/src/common_test.h b/src/common_test.h
index 950020d..024cde9 100644
--- a/src/common_test.h
+++ b/src/common_test.h
@@ -210,7 +210,7 @@
runtime_->CreateCalleeSaveMethod(instruction_set, type), type);
}
}
- compiler_.reset(new Compiler(instruction_set));
+ compiler_.reset(new Compiler(instruction_set, false));
Heap::VerifyHeap(); // Check for heap corruption before the test
}
@@ -301,7 +301,7 @@
class_linker_->RegisterDexFile(*dex_file);
std::vector<const DexFile*> dex_files;
dex_files.push_back(dex_file);
- return PathClassLoader::Alloc(dex_files);
+ return PathClassLoader::AllocCompileTime(dex_files);
}
const DexFile* OpenTestDexFile(const char* name) {
@@ -326,12 +326,24 @@
class_linker_->RegisterDexFile(*dex_file);
std::vector<const DexFile*> class_path;
class_path.push_back(dex_file);
- const ClassLoader* class_loader = PathClassLoader::Alloc(class_path);
+ const ClassLoader* class_loader = PathClassLoader::AllocCompileTime(class_path);
CHECK(class_loader != NULL);
Thread::Current()->SetClassLoaderOverride(class_loader);
return class_loader;
}
+ void CompileClass(const ClassLoader* class_loader, const char* class_name) {
+ std::string class_descriptor = DotToDescriptor(class_name);
+ Class* klass = class_linker_->FindClass(class_descriptor, class_loader);
+ CHECK(klass != NULL) << "Class not found " << class_name;
+ for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
+ CompileMethod(klass->GetDirectMethod(i));
+ }
+ for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
+ CompileMethod(klass->GetVirtualMethod(i));
+ }
+ }
+
void CompileMethod(Method* method) {
CHECK(method != NULL);
compiler_->CompileOne(method);
diff --git a/src/compiler.cc b/src/compiler.cc
index 3b98ea0..b62c40b 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -31,8 +31,11 @@
ByteArray* X86CreateResolutionTrampoline(Runtime::TrampolineType type);
}
-Compiler::Compiler(InstructionSet instruction_set)
- : instruction_set_(instruction_set), jni_compiler_(instruction_set), verbose_(false) {
+Compiler::Compiler(InstructionSet instruction_set, bool image)
+ : instruction_set_(instruction_set),
+ jni_compiler_(instruction_set),
+ image_(image),
+ verbose_(false) {
CHECK(!Runtime::Current()->IsStarted());
}
@@ -82,7 +85,8 @@
}
void Compiler::Resolve(const ClassLoader* class_loader) {
- const std::vector<const DexFile*>& class_path = ClassLoader::GetClassPath(class_loader);
+ const std::vector<const DexFile*>& class_path
+ = ClassLoader::GetCompileTimeClassPath(class_loader);
for (size_t i = 0; i != class_path.size(); ++i) {
const DexFile* dex_file = class_path[i];
CHECK(dex_file != NULL);
@@ -92,11 +96,13 @@
void Compiler::ResolveDexFile(const ClassLoader* class_loader, const DexFile& dex_file) {
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+ DexCache* dex_cache = class_linker->FindDexCache(dex_file);
// Strings are easy, they always are simply resolved to literals in the same file
- DexCache* dex_cache = class_linker->FindDexCache(dex_file);
- for (size_t string_idx = 0; string_idx < dex_cache->NumStrings(); string_idx++) {
- class_linker->ResolveString(dex_file, string_idx, dex_cache);
+ if (IsImage()) { // Only resolve when we'll have an image, so compiler won't choose fast path
+ for (size_t string_idx = 0; string_idx < dex_cache->NumStrings(); string_idx++) {
+ class_linker->ResolveString(dex_file, string_idx, dex_cache);
+ }
}
// Class derived values are more complicated, they require the linker and loader.
@@ -188,7 +194,8 @@
}
void Compiler::Verify(const ClassLoader* class_loader) {
- const std::vector<const DexFile*>& class_path = ClassLoader::GetClassPath(class_loader);
+ const std::vector<const DexFile*>& class_path
+ = ClassLoader::GetCompileTimeClassPath(class_loader);
for (size_t i = 0; i != class_path.size(); ++i) {
const DexFile* dex_file = class_path[i];
CHECK(dex_file != NULL);
@@ -227,7 +234,8 @@
}
void Compiler::InitializeClassesWithoutClinit(const ClassLoader* class_loader) {
- const std::vector<const DexFile*>& class_path = ClassLoader::GetClassPath(class_loader);
+ const std::vector<const DexFile*>& class_path
+ = ClassLoader::GetCompileTimeClassPath(class_loader);
for (size_t i = 0; i != class_path.size(); ++i) {
const DexFile* dex_file = class_path[i];
CHECK(dex_file != NULL);
@@ -260,7 +268,8 @@
}
void Compiler::Compile(const ClassLoader* class_loader) {
- const std::vector<const DexFile*>& class_path = ClassLoader::GetClassPath(class_loader);
+ const std::vector<const DexFile*>& class_path
+ = ClassLoader::GetCompileTimeClassPath(class_loader);
for (size_t i = 0; i != class_path.size(); ++i) {
const DexFile* dex_file = class_path[i];
CHECK(dex_file != NULL);
@@ -323,7 +332,7 @@
}
const CompiledMethod* Compiler::GetCompiledMethod(const Method* method) const {
- MethodTable::const_iterator it = compiled_methods_.find(method);
+ MethodTable::const_iterator it = compiled_methods_.find(method);
if (it == compiled_methods_.end()) {
return NULL;
}
@@ -341,7 +350,8 @@
}
void Compiler::SetCodeAndDirectMethods(const ClassLoader* class_loader) {
- const std::vector<const DexFile*>& class_path = ClassLoader::GetClassPath(class_loader);
+ const std::vector<const DexFile*>& class_path
+ = ClassLoader::GetCompileTimeClassPath(class_loader);
for (size_t i = 0; i != class_path.size(); ++i) {
const DexFile* dex_file = class_path[i];
CHECK(dex_file != NULL);
diff --git a/src/compiler.h b/src/compiler.h
index 6059a2a..0fc68df 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -16,7 +16,9 @@
class Compiler {
public:
- explicit Compiler(InstructionSet instruction_set);
+ // Create a compiler targeting the requested "instruction_set".
+ // "image" should be true if image specific optimizations should be enabled.
+ explicit Compiler(InstructionSet instruction_set, bool image);
~Compiler();
@@ -26,14 +28,18 @@
// Compile a single Method
void CompileOne(const Method* method);
- void SetVerbose(bool verbose) {
- verbose_ = verbose;
- }
-
InstructionSet GetInstructionSet() const {
return instruction_set_;
}
+ bool IsImage() const {
+ return image_;
+ }
+
+ void SetVerbose(bool verbose) {
+ verbose_ = verbose;
+ }
+
bool IsVerbose() const {
return verbose_;
}
@@ -81,6 +87,8 @@
typedef std::tr1::unordered_map<const Method*, CompiledInvokeStub*, ObjectIdentityHash> InvokeStubTable;
InvokeStubTable compiled_invoke_stubs_;
+ bool image_;
+
bool verbose_;
DISALLOW_COPY_AND_ASSIGN(Compiler);
diff --git a/src/compiler_test.cc b/src/compiler_test.cc
index f261406..1066783 100644
--- a/src/compiler_test.cc
+++ b/src/compiler_test.cc
@@ -39,7 +39,8 @@
}
void MakeAllExecutable(const ClassLoader* class_loader) {
- const std::vector<const DexFile*>& class_path = ClassLoader::GetClassPath(class_loader);
+ const std::vector<const DexFile*>& class_path
+ = ClassLoader::GetCompileTimeClassPath(class_loader);
for (size_t i = 0; i != class_path.size(); ++i) {
const DexFile* dex_file = class_path[i];
CHECK(dex_file != NULL);
diff --git a/src/dalvik_system_DexFile.cc b/src/dalvik_system_DexFile.cc
index 3c373d5..977abc8 100644
--- a/src/dalvik_system_DexFile.cc
+++ b/src/dalvik_system_DexFile.cc
@@ -14,7 +14,11 @@
* limitations under the License.
*/
+#include "class_loader.h"
+#include "class_linker.h"
+#include "dex_file.h"
#include "logging.h"
+#include "runtime.h"
#include "ScopedUtfChars.h"
#include "JniConstants.h" // Last to avoid problems with LOG redefinition.
@@ -80,20 +84,61 @@
if (env->ExceptionOccurred()) {
return 0;
}
- UNIMPLEMENTED(WARNING) << sourceName.c_str();
- return 0;
+ const DexFile* dex_file = DexFile::Open(sourceName.c_str(), "");
+ if (dex_file == NULL) {
+ jniThrowExceptionFmt(env, "java/io/IOException", "unable to open DEX file: %s",
+ sourceName.c_str());
+ return NULL;
+ }
+ return static_cast<jint>(reinterpret_cast<uintptr_t>(dex_file));
+}
+
+static const DexFile* toDexFile(JNIEnv* env, int dex_file_address) {
+ const DexFile* dex_file = reinterpret_cast<const DexFile*>(static_cast<uintptr_t>(dex_file_address));
+ if ((dex_file == NULL)) {
+ jniThrowNullPointerException(env, "dex_file == null");
+ }
+ return dex_file;
}
void DexFile_closeDexFile(JNIEnv* env, jclass, jint cookie) {
- UNIMPLEMENTED(WARNING);
+ const DexFile* dex_file = toDexFile(env, cookie);
+ if (dex_file == NULL) {
+ return;
+ }
+ if (Runtime::Current()->GetClassLinker()->IsDexFileRegistered(*dex_file)) {
+ return;
+ }
+ delete dex_file;
}
jclass DexFile_defineClass(JNIEnv* env, jclass, jstring javaName, jobject javaLoader, jint cookie) {
- UNIMPLEMENTED(ERROR);
- return NULL;
+ const DexFile* dex_file = toDexFile(env, cookie);
+ if (dex_file == NULL) {
+ return NULL;
+ }
+ String* name = Decode<String*>(env, javaName);
+ const char* class_name = name->ToModifiedUtf8().c_str();
+ const std::string descriptor = DotToDescriptor(class_name);
+ const DexFile::ClassDef* dex_class_def = dex_file->FindClassDef(descriptor);
+ if (dex_class_def == NULL) {
+ jniThrowExceptionFmt(env, "Ljava/lang/NoClassDefFoundError;", "Class %s not found", class_name);
+ return NULL;
+ }
+
+ Object* class_loader_object = Decode<Object*>(env, javaLoader);
+ ClassLoader* class_loader = down_cast<ClassLoader*>(class_loader_object);
+ ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+ class_linker->RegisterDexFile(*dex_file);
+ Class* result = class_linker->DefineClass(descriptor, class_loader, *dex_file, *dex_class_def);
+ return AddLocalReference<jclass>(env, result);
}
jobjectArray DexFile_getClassNameList(JNIEnv* env, jclass, jint cookie) {
+ const DexFile* dex_file = toDexFile(env, cookie);
+ if (dex_file == NULL) {
+ return NULL;
+ }
UNIMPLEMENTED(ERROR);
return NULL;
}
diff --git a/src/dex2oat.cc b/src/dex2oat.cc
index d5db436..b6a12835 100644
--- a/src/dex2oat.cc
+++ b/src/dex2oat.cc
@@ -124,8 +124,8 @@
return EXIT_FAILURE;
}
- if (image_filename == NULL) {
- fprintf(stderr, "--image file name not specified\n");
+ if (image_filename == NULL && boot_image_option.empty()) {
+ fprintf(stderr, "Either --image or --boot-image must be specified\n");
return EXIT_FAILURE;
}
@@ -190,7 +190,7 @@
for (size_t i = 0; i < dex_files.size(); i++) {
class_linker->RegisterDexFile(*dex_files[i]);
}
- class_loader = PathClassLoader::Alloc(dex_files);
+ class_loader = PathClassLoader::AllocCompileTime(dex_files);
}
// if we loaded an existing image, we will reuse values from the image roots.
@@ -212,7 +212,7 @@
runtime->SetCalleeSaveMethod(runtime->CreateCalleeSaveMethod(kThumb2, type), type);
}
}
- Compiler compiler(kThumb2);
+ Compiler compiler(kThumb2, image_filename != NULL);
if (method_names.empty()) {
compiler.CompileAll(class_loader);
} else {
@@ -263,6 +263,11 @@
return EXIT_FAILURE;
}
+ if (image_filename == NULL) {
+ return EXIT_SUCCESS;
+ }
+ CHECK(compiler.IsImage());
+
ImageWriter image_writer;
if (!image_writer.Write(image_filename, image_base, oat_filename, host_prefix)) {
fprintf(stderr, "Failed to create image file %s\n", image_filename);
diff --git a/src/dex_cache.cc b/src/dex_cache.cc
index d24c436..4eb18a5 100644
--- a/src/dex_cache.cc
+++ b/src/dex_cache.cc
@@ -30,6 +30,15 @@
Set(kResolvedFields, resolved_fields);
Set(kCodeAndDirectMethods, code_and_direct_methods);
Set(kInitializedStaticStorage, initialized_static_storage);
+
+ Runtime* runtime = Runtime::Current();
+ if (runtime->IsStarted()) {
+ Runtime::TrampolineType unknown_method_resolution_type = Runtime::GetTrampolineType(NULL);
+ ByteArray* res_trampoline = runtime->GetResolutionStubArray(unknown_method_resolution_type);
+ for (size_t i = 0; i < NumResolvedMethods(); i++) {
+ code_and_direct_methods->SetResolvedDirectMethodTrampoline(i, res_trampoline);
+ }
+ }
}
} // namespace art
diff --git a/src/dex_file.h b/src/dex_file.h
index 45cd33e..468ce4d 100644
--- a/src/dex_file.h
+++ b/src/dex_file.h
@@ -437,8 +437,13 @@
}
// Returns the prototype of a method id.
- const char* GetMethodPrototype(const MethodId& method_id) const {
- return dexStringById(method_id.proto_idx_);
+ const ProtoId& GetMethodPrototype(const MethodId& method_id) const {
+ return GetProtoId(method_id.proto_idx_);
+ }
+
+ // Returns the signature of a method id.
+ const std::string GetMethodSignature(const MethodId& method_id) const {
+ return CreateMethodDescriptor(method_id.proto_idx_, NULL);
}
// Returns the name of a method id.
diff --git a/src/dex_verifier.cc b/src/dex_verifier.cc
index 2908d58..d84e4cb 100644
--- a/src/dex_verifier.cc
+++ b/src/dex_verifier.cc
@@ -4934,11 +4934,11 @@
if (res_method == NULL) {
const DexFile::MethodId& method_id = dex_file->GetMethodId(dec_insn->vB_);
const char* method_name = dex_file->GetMethodName(method_id);
- const char* method_proto = dex_file->GetMethodPrototype(method_id);
+ std::string method_signature = dex_file->GetMethodSignature(method_id);
const char* class_descriptor = dex_file->GetMethodClassDescriptor(method_id);
LOG(ERROR) << "VFY: unable to resolve method " << dec_insn->vB_ << ": "
- << class_descriptor << "." << method_name << " " << method_proto;
+ << class_descriptor << "." << method_name << " " << method_signature;
return NULL;
}
diff --git a/src/dex_verifier_test.cc b/src/dex_verifier_test.cc
index 39e14c4..89482bd 100644
--- a/src/dex_verifier_test.cc
+++ b/src/dex_verifier_test.cc
@@ -13,7 +13,7 @@
class DexVerifierTest : public CommonTest {
protected:
- void VerifyClass(ClassLoader* class_loader, const StringPiece& descriptor) {
+ void VerifyClass(ClassLoader* class_loader, const std::string& descriptor) {
ASSERT_TRUE(descriptor != NULL);
Class* klass = class_linker_->FindSystemClass(descriptor);
diff --git a/src/image.h b/src/image.h
index 86b71e1..76db7e5 100644
--- a/src/image.h
+++ b/src/image.h
@@ -81,10 +81,14 @@
};
Object* GetImageRoot(ImageRoot image_root) const {
- return reinterpret_cast<ObjectArray<Object>*>(image_roots_)->Get(image_root);
+ return GetImageRoots()->Get(image_root);
}
private:
+ ObjectArray<Object>* GetImageRoots() const {
+ return reinterpret_cast<ObjectArray<Object>*>(image_roots_);
+ }
+
static const byte kImageMagic[4];
static const byte kImageVersion[4];
@@ -107,6 +111,7 @@
uint32_t image_roots_;
friend class ImageWriter;
+ friend class ImageDump; // For GetImageRoots()
};
} // namespace art
diff --git a/src/image_writer.cc b/src/image_writer.cc
index 39f3e64..f3ecda0 100644
--- a/src/image_writer.cc
+++ b/src/image_writer.cc
@@ -25,6 +25,8 @@
bool ImageWriter::Write(const char* image_filename, uintptr_t image_base,
const std::string& oat_filename, const std::string& strip_location_prefix) {
+ CHECK(image_filename != NULL);
+
CHECK_NE(image_base, 0U);
image_base_ = reinterpret_cast<byte*>(image_base);
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 9ca4034..277284a 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -2771,7 +2771,7 @@
version = (*jni_on_load)(this, NULL);
}
- self->SetClassLoaderOverride(old_class_loader);;
+ self->SetClassLoaderOverride(old_class_loader);
if (version != JNI_VERSION_1_2 &&
version != JNI_VERSION_1_4 &&
diff --git a/src/oat_file.cc b/src/oat_file.cc
index 95ef64c..8a4aa9a 100644
--- a/src/oat_file.cc
+++ b/src/oat_file.cc
@@ -123,12 +123,21 @@
return mem_map_->GetLimit();
}
-const OatFile::OatDexFile& OatFile::GetOatDexFile(const std::string& dex_file_location) {
+const OatFile::OatDexFile* OatFile::GetOatDexFile(const std::string& dex_file_location) const {
Table::const_iterator it = oat_dex_files_.find(dex_file_location);
if (it == oat_dex_files_.end()) {
- LOG(FATAL) << "Failed to find OatDexFile for DexFile " << dex_file_location;
+ LOG(WARNING) << "Failed to find OatDexFile for DexFile " << dex_file_location;
+ return NULL;
}
- return *it->second;
+ return it->second;
+}
+
+std::vector<const OatFile::OatDexFile*> OatFile::GetOatDexFiles() const {
+ std::vector<const OatFile::OatDexFile*> result;
+ for (Table::const_iterator it = oat_dex_files_.begin(); it != oat_dex_files_.end(); ++it ) {
+ result.push_back(it->second);
+ }
+ return result;
}
OatFile::OatDexFile::OatDexFile(const OatFile* oat_file,
@@ -142,11 +151,11 @@
OatFile::OatDexFile::~OatDexFile() {}
-const OatFile::OatClass OatFile::OatDexFile::GetOatClass(uint32_t class_def_index) const {
+const OatFile::OatClass* OatFile::OatDexFile::GetOatClass(uint32_t class_def_index) const {
uint32_t methods_offset = classes_pointer_[class_def_index];
const byte* methods_pointer = oat_file_->GetBase() + methods_offset;
CHECK_LT(methods_pointer, oat_file_->GetLimit());
- return OatClass(oat_file_, reinterpret_cast<const OatMethodOffsets*>(methods_pointer));
+ return new OatClass(oat_file_, reinterpret_cast<const OatMethodOffsets*>(methods_pointer));
}
OatFile::OatClass::OatClass(const OatFile* oat_file, const OatMethodOffsets* methods_pointer)
@@ -186,7 +195,7 @@
OatFile::OatMethod::~OatMethod() {}
-void OatFile::OatMethod::LinkMethod(Method* method) {
+void OatFile::OatMethod::LinkMethod(Method* method) const {
CHECK(method != NULL);
method->SetCode(code_);
method->SetFrameSizeInBytes(frame_size_in_bytes_);
diff --git a/src/oat_file.h b/src/oat_file.h
index 0472c16..9f95b3b 100644
--- a/src/oat_file.h
+++ b/src/oat_file.h
@@ -47,7 +47,7 @@
~OatMethod();
// Link Method using the contents of this OatMethod
- void LinkMethod(Method* method);
+ void LinkMethod(Method* method) const;
const void* code_;
size_t frame_size_in_bytes_;
@@ -65,7 +65,7 @@
// defintion. direct methods come first, followed by virtual
// methods. note that runtime created methods such as miranda
// methods are not included.
- const OatMethod GetOatMethod(uint32_t method_idx) const;
+ const OatMethod GetOatMethod(uint32_t method_index) const;
~OatClass();
private:
@@ -89,7 +89,11 @@
class OatDexFile {
public:
- const OatClass GetOatClass(uint32_t class_def_index) const;
+ const OatClass* GetOatClass(uint32_t class_def_index) const;
+
+ const std::string& GetDexFileLocation() const {
+ return dex_file_location_;
+ }
uint32_t GetDexFileChecksum() const {
return dex_file_checksum_;
@@ -111,7 +115,8 @@
DISALLOW_COPY_AND_ASSIGN(OatDexFile);
};
- const OatDexFile& GetOatDexFile(const std::string& dex_file_location);
+ const OatDexFile* GetOatDexFile(const std::string& dex_file_location) const;
+ std::vector<const OatDexFile*> GetOatDexFiles() const;
size_t GetSize() const {
return GetLimit() - GetBase();
@@ -137,6 +142,7 @@
friend class OatClass;
friend class OatDexFile;
+ friend class OatDump; // For GetBase and GetLimit
DISALLOW_COPY_AND_ASSIGN(OatFile);
};
diff --git a/src/oat_test.cc b/src/oat_test.cc
index 3137728..392a822 100644
--- a/src/oat_test.cc
+++ b/src/oat_test.cc
@@ -14,7 +14,7 @@
const ClassLoader* class_loader = NULL;
if (compile) {
- compiler_.reset(new Compiler(kThumb2));
+ compiler_.reset(new Compiler(kThumb2, false));
compiler_->CompileAll(class_loader);
}
@@ -33,7 +33,7 @@
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
const DexFile& dex_file = *java_lang_dex_file_.get();
- const OatFile::OatDexFile& oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
+ const OatFile::OatDexFile* oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
for (size_t i = 0; i < dex_file.NumClassDefs(); i++) {
const DexFile::ClassDef& class_def = dex_file.GetClassDef(i);
const byte* class_data = dex_file.GetClassData(class_def);
@@ -41,14 +41,14 @@
size_t num_virtual_methods = header.virtual_methods_size_;
const char* descriptor = dex_file.GetClassDescriptor(class_def);
- const OatFile::OatClass oat_class = oat_dex_file.GetOatClass(i);
+ UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file->GetOatClass(i));
Class* klass = class_linker->FindClass(descriptor, class_loader);
size_t method_index = 0;
for (size_t i = 0; i < klass->NumDirectMethods(); i++, method_index++) {
Method* method = klass->GetDirectMethod(i);
- const OatFile::OatMethod oat_method = oat_class.GetOatMethod(method_index);
+ const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
const CompiledMethod* compiled_method = compiler_->GetCompiledMethod(method);
if (compiled_method == NULL) {
@@ -75,7 +75,7 @@
}
for (size_t i = 0; i < num_virtual_methods; i++, method_index++) {
Method* method = klass->GetVirtualMethod(i);
- const OatFile::OatMethod oat_method = oat_class.GetOatMethod(method_index);
+ const OatFile::OatMethod oat_method = oat_class->GetOatMethod(method_index);
const CompiledMethod* compiled_method = compiler_->GetCompiledMethod(method);
if (compiled_method == NULL) {
diff --git a/src/oat_writer.cc b/src/oat_writer.cc
index 0722520..99c9361 100644
--- a/src/oat_writer.cc
+++ b/src/oat_writer.cc
@@ -13,7 +13,7 @@
bool OatWriter::Create(const std::string& filename,
const ClassLoader* class_loader,
const Compiler& compiler) {
- const std::vector<const DexFile*>& dex_files = ClassLoader::GetClassPath(class_loader);
+ const std::vector<const DexFile*>& dex_files = ClassLoader::GetCompileTimeClassPath(class_loader);
OatWriter oat_writer(dex_files, class_loader, compiler);
return oat_writer.Write(filename);
}
diff --git a/src/oatdump.cc b/src/oatdump.cc
index 8113c2b..4d99647 100644
--- a/src/oatdump.cc
+++ b/src/oatdump.cc
@@ -26,7 +26,11 @@
" Example: adb shell oatdump --image=/system/framework/boot.art\n"
"\n");
fprintf(stderr,
- " --image=<file.art>: specifies the required input image filename.\n"
+ " --oat=<file.oat>: specifies an input oat filename.\n"
+ " Example: --image=/system/framework/boot.oat\n"
+ "\n");
+ fprintf(stderr,
+ " --image=<file.art>: specifies an input image filename.\n"
" Example: --image=/system/framework/boot.art\n"
"\n");
fprintf(stderr,
@@ -52,15 +56,168 @@
"kStaticResolutionStubArray",
"kUnknownMethodResolutionStubArray",
"kCalleeSaveMethod",
+ "kRefsOnlySaveMethod",
+ "kRefsAndArgsSaveMethod",
"kOatLocation",
"kDexCaches",
"kClassRoots",
};
class OatDump {
+ public:
+ static void Dump(const std::string& oat_filename,
+ const std::string& host_prefix,
+ std::ostream& os,
+ const OatFile& oat_file) {
+ const OatHeader& oat_header = oat_file.GetOatHeader();
+
+ os << "MAGIC:\n";
+ os << oat_header.GetMagic() << "\n\n";
+
+ os << "CHECKSUM:\n";
+ os << StringPrintf("%08x\n\n", oat_header.GetChecksum());
+
+ os << "DEX FILE COUNT:\n";
+ os << oat_header.GetDexFileCount() << "\n\n";
+
+ os << "EXECUTABLE OFFSET:\n";
+ os << StringPrintf("%08x\n\n", oat_header.GetExecutableOffset());
+
+ os << "BASE:\n";
+ os << oat_file.GetBase() << "\n\n";
+
+ os << "LIMIT:\n";
+ os << oat_file.GetLimit() << "\n\n";
+
+ os << std::flush;
+
+ std::vector<const OatFile::OatDexFile*> oat_dex_files = oat_file.GetOatDexFiles() ;
+ for (size_t i = 0; i < oat_dex_files.size(); i++) {
+ const OatFile::OatDexFile* oat_dex_file = oat_dex_files[i];
+ CHECK(oat_dex_file != NULL);
+ DumpOatDexFile(host_prefix, os, oat_file, *oat_dex_file);
+ }
+ }
+
+ private:
+ static void DumpOatDexFile(const std::string& host_prefix,
+ std::ostream& os,
+ const OatFile& oat_file,
+ const OatFile::OatDexFile& oat_dex_file) {
+ os << "OAT DEX FILE:\n";
+ std::string dex_file_location = oat_dex_file.GetDexFileLocation();
+ os << "location: " << dex_file_location;
+ if (!host_prefix.empty()) {
+ dex_file_location = host_prefix + dex_file_location;
+ os << " (" << dex_file_location << ")\n";
+ }
+ os << StringPrintf("checksum: %08x\n", oat_dex_file.GetDexFileChecksum());
+ const DexFile* dex_file = DexFile::Open(dex_file_location, "");
+ if (dex_file == NULL) {
+ os << "NOT FOUND\n\n";
+ return;
+ }
+ for (size_t class_def_index = 0; class_def_index < dex_file->NumClassDefs(); class_def_index++) {
+ const DexFile::ClassDef& class_def = dex_file->GetClassDef(class_def_index);
+ const char* descriptor = dex_file->GetClassDescriptor(class_def);
+ os << StringPrintf("%d: %s (type_ide=%d)\n", class_def_index, descriptor, class_def.class_idx_);
+ UniquePtr<const OatFile::OatClass> oat_class(oat_dex_file.GetOatClass(class_def_index));
+ CHECK(oat_class.get() != NULL);
+ DumpOatClass(os, oat_file, *oat_class.get(), *dex_file, class_def);
+ }
+
+ os << std::flush;
+ }
+
+ static void DumpOatClass(std::ostream& os,
+ const OatFile& oat_file,
+ const OatFile::OatClass& oat_class,
+ const DexFile& dex_file,
+ const DexFile::ClassDef& class_def) {
+ const byte* class_data = dex_file.GetClassData(class_def);
+ DexFile::ClassDataHeader header = dex_file.ReadClassDataHeader(&class_data);
+ size_t num_static_fields = header.static_fields_size_;
+ size_t num_instance_fields = header.instance_fields_size_;
+ size_t num_direct_methods = header.direct_methods_size_;
+ size_t num_virtual_methods = header.virtual_methods_size_;
+ uint32_t method_index = 0;
+
+ // just skipping through the fields to advance class_data
+ if (num_static_fields != 0) {
+ uint32_t last_idx = 0;
+ for (size_t i = 0; i < num_static_fields; ++i) {
+ DexFile::Field dex_field;
+ dex_file.dexReadClassDataField(&class_data, &dex_field, &last_idx);
+ }
+ }
+ if (num_instance_fields != 0) {
+ uint32_t last_idx = 0;
+ for (size_t i = 0; i < num_instance_fields; ++i) {
+ DexFile::Field dex_field;
+ dex_file.dexReadClassDataField(&class_data, &dex_field, &last_idx);
+ }
+ }
+
+ if (num_direct_methods != 0) {
+ uint32_t last_idx = 0;
+ for (size_t i = 0; i < num_direct_methods; ++i, method_index++) {
+ DexFile::Method dex_method;
+ dex_file.dexReadClassDataMethod(&class_data, &dex_method, &last_idx);
+ const OatFile::OatMethod oat_method = oat_class.GetOatMethod(method_index);
+ DumpOatMethod(os, method_index, oat_file, oat_method, dex_file, dex_method);
+ }
+ }
+ if (num_virtual_methods != 0) {
+ uint32_t last_idx = 0;
+ for (size_t i = 0; i < num_virtual_methods; ++i, method_index++) {
+ DexFile::Method dex_method;
+ dex_file.dexReadClassDataMethod(&class_data, &dex_method, &last_idx);
+ const OatFile::OatMethod oat_method = oat_class.GetOatMethod(method_index);
+ DumpOatMethod(os, method_index, oat_file, oat_method, dex_file, dex_method);
+ }
+ }
+ os << std::flush;
+ }
+ static void DumpOatMethod(std::ostream& os,
+ uint32_t method_index,
+ const OatFile& oat_file,
+ const OatFile::OatMethod& oat_method,
+ const DexFile& dex_file,
+ const DexFile::Method& dex_method) {
+ const DexFile::MethodId& method_id = dex_file.GetMethodId(dex_method.method_idx_);
+ const char* name = dex_file.GetMethodName(method_id);
+ std::string signature = dex_file.GetMethodSignature(method_id);
+ os << StringPrintf("\t%d: %s %s (method_idx=%d)\n",
+ method_index, name, signature.c_str(), dex_method.method_idx_);
+ os << StringPrintf("\t\tcode: %p (offset=%08x)\n",
+ oat_method.code_,
+ reinterpret_cast<const byte*>(oat_method.code_) - oat_file.GetBase());
+ os << StringPrintf("\t\tframe_size_in_bytes: %d\n",
+ oat_method.frame_size_in_bytes_);
+ os << StringPrintf("\t\treturn_pc_offset_in_bytes: %d\n",
+ oat_method.return_pc_offset_in_bytes_);
+ os << StringPrintf("\t\tcore_spill_mask: %08x\n",
+ oat_method.core_spill_mask_);
+ os << StringPrintf("\t\tfp_spill_mask: %08x\n",
+ oat_method.fp_spill_mask_);
+ os << StringPrintf("\t\tmapping_table: %p (offset=%08x)\n",
+ oat_method.mapping_table_,
+ reinterpret_cast<const byte*>(oat_method.mapping_table_) - oat_file.GetBase());
+ os << StringPrintf("\t\tvmap_table: %p (offset=%08x)\n",
+ oat_method.vmap_table_,
+ reinterpret_cast<const byte*>(oat_method.vmap_table_) - oat_file.GetBase());
+ os << StringPrintf("\t\tinvoke_stub: %p (offset=%08x)\n",
+ oat_method.invoke_stub_,
+ reinterpret_cast<const byte*>(oat_method.invoke_stub_) - oat_file.GetBase());
+ }
+
+};
+
+class ImageDump {
public:
static void Dump(const std::string& image_filename,
+ const std::string& host_prefix,
std::ostream& os,
Space& image_space,
const ImageHeader& image_header) {
@@ -70,10 +227,17 @@
os << "IMAGE BASE:\n";
os << reinterpret_cast<void*>(image_header.GetImageBaseAddr()) << "\n\n";
+ os << "OAT CHECKSUM:\n";
+ os << StringPrintf("%08x\n\n", image_header.GetOatChecksum());
+
os << "OAT BASE:\n";
os << reinterpret_cast<void*>(image_header.GetOatBaseAddr()) << "\n\n";
+ os << "OAT LIMIT:\n";
+ os << reinterpret_cast<void*>(image_header.GetOatLimitAddr()) << "\n\n";
+
os << "ROOTS:\n";
+ os << reinterpret_cast<void*>(image_header.GetImageRoots()) << "\n";
CHECK_EQ(arraysize(image_roots_descriptions_), size_t(ImageHeader::kImageRootsMax));
for (int i = 0; i < ImageHeader::kImageRootsMax; i++) {
ImageHeader::ImageRoot image_root = static_cast<ImageHeader::ImageRoot>(i);
@@ -93,10 +257,10 @@
os << "\n";
os << "OBJECTS:\n" << std::flush;
- OatDump state(image_space, os);
+ ImageDump state(image_space, os);
HeapBitmap* heap_bitmap = Heap::GetLiveBits();
DCHECK(heap_bitmap != NULL);
- heap_bitmap->Walk(OatDump::Callback, &state);
+ heap_bitmap->Walk(ImageDump::Callback, &state);
os << "\n";
os << "STATS:\n" << std::flush;
@@ -107,22 +271,41 @@
size_t alignment_bytes = RoundUp(header_bytes, kObjectAlignment) - header_bytes;
state.stats_.alignment_bytes += alignment_bytes;
state.stats_.Dump(os);
+ os << "\n";
os << std::flush;
+
+ os << "OAT LOCATION:\n" << std::flush;
+ Object* oat_location_object = image_header.GetImageRoot(ImageHeader::kOatLocation);
+ std::string oat_location = oat_location_object->AsString()->ToModifiedUtf8();
+ ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+ os << oat_location;
+ if (!host_prefix.empty()) {
+ oat_location = host_prefix + oat_location;
+ os << " (" << oat_location << ")\n";
+ }
+ const OatFile* oat_file = class_linker->FindOatFile(oat_location);
+ if (oat_file == NULL) {
+ os << "NOT FOUND\n";
+ os << std::flush;
+ return;
+ }
+ os << "\n";
+ os << std::flush;
+
+ OatDump::Dump(oat_location, host_prefix, os, *oat_file);
}
private:
- OatDump(const Space& dump_space, std::ostream& os) : dump_space_(dump_space), os_(os) {
- }
+ ImageDump(const Space& dump_space, std::ostream& os) : dump_space_(dump_space), os_(os) {}
- ~OatDump() {
- }
+ ~ImageDump() {}
static void Callback(Object* obj, void* arg) {
DCHECK(obj != NULL);
DCHECK(arg != NULL);
- OatDump* state = reinterpret_cast<OatDump*>(arg);
+ ImageDump* state = reinterpret_cast<ImageDump*>(arg);
if (!state->InDumpSpace(obj)) {
return;
}
@@ -319,7 +502,6 @@
/ static_cast<double>(dex_instruction_bytes));
os << "\n";
os << std::flush;
-
}
} stats_;
@@ -327,7 +509,7 @@
const Space& dump_space_;
std::ostream& os_;
- DISALLOW_COPY_AND_ASSIGN(OatDump);
+ DISALLOW_COPY_AND_ASSIGN(ImageDump);
};
int oatdump(int argc, char** argv) {
@@ -336,10 +518,11 @@
argc--;
if (argc == 0) {
- fprintf(stderr, "no arguments specified\n");
+ fprintf(stderr, "No arguments specified\n");
usage();
}
+ const char* oat_filename = NULL;
const char* image_filename = NULL;
const char* boot_image_filename = NULL;
std::string host_prefix;
@@ -348,7 +531,9 @@
for (int i = 0; i < argc; i++) {
const StringPiece option(argv[i]);
- if (option.starts_with("--image=")) {
+ if (option.starts_with("--oat=")) {
+ oat_filename = option.substr(strlen("--oat=")).data();
+ } else if (option.starts_with("--image=")) {
image_filename = option.substr(strlen("--image=")).data();
} else if (option.starts_with("--boot-image=")) {
boot_image_filename = option.substr(strlen("--boot-image=")).data();
@@ -358,21 +543,36 @@
const char* filename = option.substr(strlen("--output=")).data();
out.reset(new std::ofstream(filename));
if (!out->good()) {
- fprintf(stderr, "failed to open output filename %s\n", filename);
+ fprintf(stderr, "Failed to open output filename %s\n", filename);
usage();
}
os = out.get();
} else {
- fprintf(stderr, "unknown argument %s\n", option.data());
+ fprintf(stderr, "Unknown argument %s\n", option.data());
usage();
}
}
- if (image_filename == NULL) {
- fprintf(stderr, "--image file name not specified\n");
+ if (image_filename == NULL && oat_filename == NULL) {
+ fprintf(stderr, "Either --image or --oat must be specified\n");
return EXIT_FAILURE;
}
+ if (image_filename != NULL && oat_filename != NULL) {
+ fprintf(stderr, "Either --image or --oat must be specified but not both\n");
+ return EXIT_FAILURE;
+ }
+
+ if (oat_filename != NULL) {
+ const OatFile* oat_file = OatFile::Open(oat_filename, "", NULL);
+ if (oat_file == NULL) {
+ fprintf(stderr, "Failed to open oat file from %s\n", oat_filename);
+ return EXIT_FAILURE;
+ }
+ OatDump::Dump(oat_filename, host_prefix, *os, *oat_file);
+ return EXIT_SUCCESS;
+ }
+
Runtime::Options options;
std::string image_option;
std::string oat_option;
@@ -383,9 +583,11 @@
boot_image_option += boot_image_filename;
options.push_back(std::make_pair(boot_image_option.c_str(), reinterpret_cast<void*>(NULL)));
}
- image_option += "-Ximage:";
- image_option += image_filename;
- options.push_back(std::make_pair(image_option.c_str(), reinterpret_cast<void*>(NULL)));
+ if (image_filename != NULL) {
+ image_option += "-Ximage:";
+ image_option += image_filename;
+ options.push_back(std::make_pair(image_option.c_str(), reinterpret_cast<void*>(NULL)));
+ }
if (!host_prefix.empty()) {
options.push_back(std::make_pair("host-prefix", host_prefix.c_str()));
@@ -393,7 +595,7 @@
UniquePtr<Runtime> runtime(Runtime::Create(options, false));
if (runtime.get() == NULL) {
- fprintf(stderr, "could not create runtime\n");
+ fprintf(stderr, "Failed to create runtime\n");
return EXIT_FAILURE;
}
@@ -401,10 +603,10 @@
CHECK(image_space != NULL);
const ImageHeader& image_header = image_space->GetImageHeader();
if (!image_header.IsValid()) {
- fprintf(stderr, "invalid image header %s\n", image_filename);
+ fprintf(stderr, "Invalid image header %s\n", image_filename);
return EXIT_FAILURE;
}
- OatDump::Dump(image_filename, *os, *image_space, image_header);
+ ImageDump::Dump(image_filename, host_prefix, *os, *image_space, image_header);
return EXIT_SUCCESS;
}
diff --git a/src/object.cc b/src/object.cc
index 58ffa6b..33cd802 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -309,7 +309,7 @@
}
++p; // Either the ';' or the primitive type.
- StringPiece descriptor(start, (p - start));
+ std::string descriptor(start, (p - start));
return class_linker->FindClass(descriptor, cl);
} else if (*p == 'L') {
const char* start = p;
@@ -318,7 +318,7 @@
}
++p;
StringPiece descriptor(start, (p - start));
- return class_linker->FindClass(descriptor, cl);
+ return class_linker->FindClass(descriptor.ToString(), cl);
} else {
return class_linker->FindPrimitiveClass(*p++);
}
diff --git a/src/object_test.cc b/src/object_test.cc
index 6b1f818..1c317e6 100644
--- a/src/object_test.cc
+++ b/src/object_test.cc
@@ -178,7 +178,7 @@
TEST_F(ObjectTest, StaticFieldFromCode) {
// pretend we are trying to access 'Static.s0' from StaticsFromCode.<clinit>
const ClassLoader* class_loader = LoadDex("StaticsFromCode");
- const DexFile* dex_file = ClassLoader::GetClassPath(class_loader)[0];
+ const DexFile* dex_file = ClassLoader::GetCompileTimeClassPath(class_loader)[0];
CHECK(dex_file != NULL);
Class* klass = class_linker_->FindClass("LStaticsFromCode;", class_loader);
diff --git a/src/runtime.cc b/src/runtime.cc
index 64df1d3..c733bfe 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -7,8 +7,10 @@
#include <limits>
#include <vector>
+#include "ScopedLocalRef.h"
#include "UniquePtr.h"
#include "class_linker.h"
+#include "class_loader.h"
#include "heap.h"
#include "image.h"
#include "intern_table.h"
@@ -307,6 +309,29 @@
return instance_;
}
+void CreateSystemClassLoader() {
+ if (ClassLoader::UseCompileTimeClassPath()) {
+ return;
+ }
+
+ Thread* self = Thread::Current();
+
+ // Must be in the kNative state for calling native methods.
+ CHECK_EQ(self->GetState(), Thread::kNative);
+
+ JNIEnv* env = self->GetJniEnv();
+ ScopedLocalRef<jclass> c(env, env->FindClass("java/lang/ClassLoader"));
+ CHECK(c.get() != NULL);
+ jmethodID mid = env->GetStaticMethodID(c.get(),
+ "getSystemClassLoader", "()Ljava/lang/ClassLoader;");
+ CHECK(mid != NULL);
+ ScopedLocalRef<jobject> result(env, env->CallStaticObjectMethod(c.get(), mid));
+ CHECK(result.get() != NULL);
+
+ ClassLoader* class_loader = Decode<ClassLoader*>(env, result.get());
+ Thread::Current()->SetClassLoaderOverride(class_loader);
+}
+
void Runtime::Start() {
if (IsVerboseStartup()) {
LOG(INFO) << "Runtime::Start entering";
@@ -327,6 +352,8 @@
StartDaemonThreads();
+ CreateSystemClassLoader();
+
Thread::Current()->GetJniEnv()->locals.AssertEmpty();
if (IsVerboseStartup()) {
@@ -338,6 +365,10 @@
signal_catcher_ = new SignalCatcher;
Thread* self = Thread::Current();
+
+ // Must be in the kNative state for calling native methods.
+ CHECK_EQ(self->GetState(), Thread::kNative);
+
JNIEnv* env = self->GetJniEnv();
ScopedLocalRef<jclass> c(env, env->FindClass("java/lang/Daemons"));
CHECK(c.get() != NULL);
@@ -408,7 +439,7 @@
JNIEnv* env = self->GetJniEnv();
// Must be in the kNative state for calling native methods (JNI_OnLoad code).
- ScopedThreadStateChange tsc(self, Thread::kNative);
+ CHECK_EQ(self->GetState(), Thread::kNative);
// First set up JniConstants, which is used by both the runtime's built-in native
// methods and libcore.
@@ -581,8 +612,9 @@
}
void Runtime::SetJniStubArray(ByteArray* jni_stub_array) {
- CHECK(jni_stub_array != NULL);
- CHECK(jni_stub_array_ == NULL || jni_stub_array_ == jni_stub_array);
+ CHECK(jni_stub_array != NULL) << " jni_stub_array=" << jni_stub_array;
+ CHECK(jni_stub_array_ == NULL || jni_stub_array_ == jni_stub_array)
+ << "jni_stub_array_=" << jni_stub_array_ << " jni_stub_array=" << jni_stub_array;
jni_stub_array_ = jni_stub_array;
}
diff --git a/src/runtime.h b/src/runtime.h
index bb6bfda..65a54e9 100644
--- a/src/runtime.h
+++ b/src/runtime.h
@@ -25,6 +25,7 @@
template<class T> class PrimitiveArray;
typedef PrimitiveArray<int8_t> ByteArray;
class ClassLinker;
+class ClassLoader;
class DexFile;
class Heap;
class InternTable;
@@ -245,6 +246,9 @@
Method* callee_save_method_[kLastCalleeSaveType];
+ // As returned by ClassLoader.getSystemClassLoader()
+ ClassLoader* system_class_loader_;
+
bool started_;
// Hooks supported by JNI_CreateJavaVM
diff --git a/src/runtime_support.cc b/src/runtime_support.cc
index c7a04ec..23bb2f514 100644
--- a/src/runtime_support.cc
+++ b/src/runtime_support.cc
@@ -669,6 +669,17 @@
return InitializeStaticStorage(type_idx, referrer, self);
}
+String* ResolveStringFromCode(const Method* referrer, uint32_t string_idx) {
+ ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
+ return class_linker->ResolveString(string_idx, referrer);
+}
+
+extern "C" String* artResolveStringFromCode(Method* referrer, int32_t string_idx,
+ Thread* self, Method** sp) {
+ FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
+ return ResolveStringFromCode(referrer, string_idx);
+}
+
extern "C" int artUnlockObjectFromCode(Object* obj, Thread* self, Method** sp) {
FinishCalleeSaveFrameSetup(self, sp, Runtime::kRefsOnly);
DCHECK(obj != NULL); // Assumed to have been checked before entry
diff --git a/src/runtime_support.h b/src/runtime_support.h
index 2d34f9b..9c7fc3e 100644
--- a/src/runtime_support.h
+++ b/src/runtime_support.h
@@ -44,6 +44,7 @@
extern "C" void* art_get_obj_static_from_code(uint32_t, void*);
extern "C" void art_handle_fill_data_from_code(void*, void*);
extern "C" void* art_initialize_static_storage_from_code(uint32_t, void*);
+ extern "C" void* art_resolve_string_from_code(void*, uint32_t);
extern "C" void art_invoke_interface_trampoline(uint32_t, void*);
extern "C" int art_set32_static_from_code(uint32_t, void*, int32_t);
extern "C" int art_set64_static_from_code(uint32_t, void*, int64_t);
diff --git a/src/runtime_support_asm.S b/src/runtime_support_asm.S
index 38eaf82..f1a6d63 100644
--- a/src/runtime_support_asm.S
+++ b/src/runtime_support_asm.S
@@ -256,7 +256,7 @@
SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC
mov r2, r9 @ pass Thread::Current
mov r3, sp @ pass SP
- @ ClassLinker::InitializeStaticStorageFromCode(uint32_t type_idx, Method* referrer, Thread*, SP)
+ @ artInitializeStaticStorageFromCode(uint32_t type_idx, Method* referrer, Thread*, SP)
bl artInitializeStaticStorageFromCode
RESTORE_REF_ONLY_CALLEE_SAVE_FRAME
cmp r0, #0 @ success if result is non-null
@@ -373,6 +373,24 @@
bxeq lr @ return on success
DELIVER_PENDING_EXCEPTION
+ .global art_resolve_string_from_code
+ .extern artResolveStringFromCode
+ /*
+ * Entry from managed code to resolve a string, this stub will
+ * allocate a String and deliver an exception on error. On
+ * success the String is returned.
+ */
+ art_resolve_string_from_code:
+ SETUP_REF_ONLY_CALLEE_SAVE_FRAME @ save callee saves in case of GC
+ mov r2, r9 @ pass Thread::Current
+ mov r3, sp @ pass SP
+ @ artResolveStringFromCode(Method* referrer, uint32_t type_idx, Thread*, SP)
+ bl artResolveStringFromCode
+ RESTORE_REF_ONLY_CALLEE_SAVE_FRAME
+ cmp r0, #0 @ success if result is non-null
+ bxne lr @ return on success
+ DELIVER_PENDING_EXCEPTION
+
.global art_alloc_object_from_code
.extern artAllocObjectFromCode
/*
diff --git a/src/thread.cc b/src/thread.cc
index 400da0c..4dcef55 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -61,12 +61,6 @@
static Method* gThreadGroup_removeThread = NULL;
static Method* gUncaughtExceptionHandler_uncaughtException = NULL;
-// TODO: flesh out and move to appropriate location
-String* ResolveStringFromCode(Method* method, int32_t string_idx) {
- UNIMPLEMENTED(FATAL) << "Resolve string; handle OOM";
- return NULL; // Must return valid string or if exception, doesn't return
-}
-
// TODO: move to appropriate location
static void ObjectInitFromCode(Object* o) {
Class* c = o->GetClass();
@@ -118,6 +112,7 @@
pGetObjStatic = art_get_obj_static_from_code;
pHandleFillArrayDataFromCode = art_handle_fill_data_from_code;
pInitializeStaticStorage = art_initialize_static_storage_from_code;
+ pResolveStringFromCode = art_resolve_string_from_code;
pInvokeInterfaceTrampoline = art_invoke_interface_trampoline;
pSet32Static = art_set32_static_from_code;
pSet64Static = art_set64_static_from_code;
@@ -144,7 +139,6 @@
pInstanceofNonTrivialFromCode = Class::IsAssignableFromCode;
pObjectInit = ObjectInitFromCode;
pResolveMethodFromCode = ResolveMethodFromCode;
- pResolveStringFromCode = ResolveStringFromCode;
pThrowAbstractMethodErrorFromCode = ThrowAbstractMethodErrorFromCode;
pUnresolvedDirectMethodTrampolineFromCode = UnresolvedDirectMethodTrampolineFromCode;
}
diff --git a/src/thread.h b/src/thread.h
index 52e01f2..884aa64 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -82,7 +82,7 @@
};
// Space to throw a StackOverflowError in.
- static const size_t kStackOverflowReservedBytes = 3 * KB;
+ static const size_t kStackOverflowReservedBytes = 4 * KB;
static const size_t kDefaultStackSize = 64 * KB;
@@ -139,7 +139,7 @@
void (*pLockObjectFromCode)(void*);
void (*pObjectInit)(Object*);
void (*pResolveMethodFromCode)(Method*, uint32_t);
- String* (*pResolveStringFromCode)(Method*, int32_t);
+ void* (*pResolveStringFromCode)(void*, uint32_t);
int (*pSet32Static)(uint32_t, void*, int32_t);
int (*pSet64Static)(uint32_t, void*, int64_t);
int (*pSetObjStatic)(uint32_t, void*, void*);
diff --git a/src/utils.cc b/src/utils.cc
index 48ae2ae..86fa312 100644
--- a/src/utils.cc
+++ b/src/utils.cc
@@ -198,6 +198,14 @@
return descriptor;
}
+std::string DescriptorToDot(const std::string& descriptor) {
+ DCHECK_EQ(descriptor[0], 'L');
+ DCHECK_EQ(descriptor[descriptor.size()-1], ';');
+ std::string dot = descriptor.substr(1, descriptor.size()-2);
+ std::replace(dot.begin(), dot.end(), '/', '.');
+ return dot;
+}
+
std::string JniShortName(const Method* m) {
Class* declaring_class = m->GetDeclaringClass();
diff --git a/src/utils.h b/src/utils.h
index 5470f7f..4f58c52 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -176,6 +176,9 @@
// Turn "java.lang.String" into "Ljava/lang/String;".
std::string DotToDescriptor(const char* class_name);
+// Turn "Ljava/lang/String;" into "java.lang.String".
+std::string DescriptorToDot(const std::string& descriptor);
+
// Tests whether 's' is a valid class name.
// name_or_descriptor
// true => "java/lang/String"
diff --git a/test/003-omnibus-opcodes/build b/test/003-omnibus-opcodes/build
index 2a09167..6ee341b 100644
--- a/test/003-omnibus-opcodes/build
+++ b/test/003-omnibus-opcodes/build
@@ -29,5 +29,4 @@
--boot-image=${ANDROID_PRODUCT_OUT}/system/framework/core.art \
--dex-file=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME.jar \
--oat=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME.oat \
- --image=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME.art \
--host-prefix=${ANDROID_PRODUCT_OUT}
diff --git a/test/023-many-interfaces/build b/test/023-many-interfaces/build
index 10c1c06..88201a2 100644
--- a/test/023-many-interfaces/build
+++ b/test/023-many-interfaces/build
@@ -31,5 +31,4 @@
--boot-image=${ANDROID_PRODUCT_OUT}/system/framework/core.art \
--dex-file=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME.jar \
--oat=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME.oat \
- --image=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME.art \
--host-prefix=${ANDROID_PRODUCT_OUT}
diff --git a/test/056-const-string-jumbo/build b/test/056-const-string-jumbo/build
index 22c9646..fbd4116 100644
--- a/test/056-const-string-jumbo/build
+++ b/test/056-const-string-jumbo/build
@@ -50,5 +50,4 @@
--boot-image=${ANDROID_PRODUCT_OUT}/system/framework/core.art \
--dex-file=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME.jar \
--oat=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME.oat \
- --image=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME.art \
--host-prefix=${ANDROID_PRODUCT_OUT}
diff --git a/test/085-old-style-inner-class/build b/test/085-old-style-inner-class/build
index db6a5dd..a08c98b 100644
--- a/test/085-old-style-inner-class/build
+++ b/test/085-old-style-inner-class/build
@@ -32,5 +32,4 @@
--boot-image=${ANDROID_PRODUCT_OUT}/system/framework/core.art \
--dex-file=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME.jar \
--oat=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME.oat \
- --image=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME.art \
--host-prefix=${ANDROID_PRODUCT_OUT}
diff --git a/test/etc/default-build b/test/etc/default-build
index a2e9066..c3cdd79 100755
--- a/test/etc/default-build
+++ b/test/etc/default-build
@@ -32,7 +32,6 @@
--boot-image=${ANDROID_PRODUCT_OUT}/system/framework/core.art \
--dex-file=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME.jar \
--oat=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME.oat \
- --image=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME.art \
--host-prefix=${ANDROID_PRODUCT_OUT}
if [ -r src-ex ]; then
@@ -52,6 +51,5 @@
--boot-image=${ANDROID_PRODUCT_OUT}/system/framework/core.art \
--dex-file=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME-ex.jar \
--oat=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME-ex.oat \
- --image=${ANDROID_PRODUCT_OUT}/system/framework/$TEST_NAME-ex.art \
--host-prefix=${ANDROID_PRODUCT_OUT}
fi
diff --git a/test/etc/push-and-run-test-jar b/test/etc/push-and-run-test-jar
index 8bbf8d8..79b0605 100755
--- a/test/etc/push-and-run-test-jar
+++ b/test/etc/push-and-run-test-jar
@@ -136,7 +136,7 @@
else
cmdline="cd /data; oatexecd \
-Ximage:/system/framework/core.art \
- -Ximage:/system/framework/$TEST_NAME.art \
+ -cp /system/framework/$TEST_NAME.jar \
Main"
#cmdline="cd /data; dalvikvm $DEX_VERIFY $DEX_OPTIMIZE $DEX_DEBUG \
# $GC_OPTS -cp test.jar -Xint:${INTERP} -ea Main"
