summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--build/Android.test.mk2
-rw-r--r--src/class_linker.cc4
-rw-r--r--src/class_linker.h4
-rw-r--r--src/class_linker_test.cc14
-rw-r--r--src/common_test.h2
-rw-r--r--src/compiler.cc22
-rw-r--r--src/compiler.h11
-rw-r--r--src/compiler_test.cc168
-rw-r--r--src/dex_cache.h2
-rw-r--r--src/dex_verifier_test.cc2
-rw-r--r--src/exception_test.cc2
-rw-r--r--src/jni_compiler_test.cc2
-rw-r--r--src/jni_internal_test.cc30
-rw-r--r--src/object.cc9
-rw-r--r--src/object.h7
-rw-r--r--src/object_test.cc10
-rw-r--r--test/IntMath/java/lang/Object.java5
17 files changed, 173 insertions, 123 deletions
diff --git a/build/Android.test.mk b/build/Android.test.mk
index d940a1d..3429041 100644
--- a/build/Android.test.mk
+++ b/build/Android.test.mk
@@ -63,8 +63,6 @@ define build-art-test-dex
LOCAL_MODULE := art-test-dex-$(1)
LOCAL_MODULE_TAGS := optional
LOCAL_SRC_FILES := $(call all-java-files-under, test/$(1))
- # TODO: remove --core-library when separate compilation works
- LOCAL_DX_FLAGS := --core-library
include $(BUILD_JAVA_LIBRARY)
ART_TEST_DEX_FILES += $(TARGET_OUT_JAVA_LIBRARIES)/$$(LOCAL_MODULE).jar
endef
diff --git a/src/class_linker.cc b/src/class_linker.cc
index a42ab72..e03eca6 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -489,7 +489,9 @@ Class* ClassLinker::FindClass(const StringPiece& descriptor,
if (descriptor[0] == '[') {
return CreateArrayClass(descriptor, class_loader);
}
- const DexFile::ClassPath& class_path = ((class_loader != NULL) ? class_loader->GetClassPath() : boot_class_path_);
+ 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));
diff --git a/src/class_linker.h b/src/class_linker.h
index b62433c..6e13aa7 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -117,6 +117,10 @@ class ClassLinker {
void RegisterDexFile(const DexFile& dex_file);
void RegisterDexFile(const DexFile& dex_file, DexCache* dex_cache);
+ const std::vector<const DexFile*>& GetBootClassPath() {
+ return boot_class_path_;
+ }
+
const InternTable& GetInternTable() {
return intern_table_;
}
diff --git a/src/class_linker_test.cc b/src/class_linker_test.cc
index 201db45..48408c8 100644
--- a/src/class_linker_test.cc
+++ b/src/class_linker_test.cc
@@ -58,7 +58,7 @@ class ClassLinkerTest : public CommonTest {
void AssertArrayClass(const StringPiece& array_descriptor,
int32_t array_rank,
const StringPiece& component_type,
- ClassLoader* class_loader) {
+ const ClassLoader* class_loader) {
Class* array = class_linker_->FindClass(array_descriptor, class_loader);
EXPECT_EQ(array_rank, array->array_rank_);
EXPECT_TRUE(array->GetComponentType()->GetDescriptor()->Equals(component_type));
@@ -274,7 +274,7 @@ TEST_F(ClassLinkerTest, FindClassNonexistent) {
TEST_F(ClassLinkerTest, FindClassNested) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("Nested"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
Class* outer = class_linker_->FindClass("LNested;", class_loader);
ASSERT_TRUE(outer != NULL);
@@ -329,7 +329,7 @@ TEST_F(ClassLinkerTest, FindClass) {
EXPECT_EQ(0U, JavaLangObject->NumInterfaces());
scoped_ptr<const DexFile> dex(OpenTestDexFile("MyClass"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
AssertNonExistentClass("LMyClass;");
Class* MyClass = class_linker_->FindClass("LMyClass;", class_loader);
ASSERT_TRUE(MyClass != NULL);
@@ -453,8 +453,8 @@ TEST_F(ClassLinkerTest, ValidatePrimitiveArrayElementsOffset) {
TEST_F(ClassLinkerTest, TwoClassLoadersOneClass) {
scoped_ptr<const DexFile> dex_1(OpenTestDexFile("MyClass"));
scoped_ptr<const DexFile> dex_2(OpenTestDexFile("MyClass"));
- PathClassLoader* class_loader_1 = AllocPathClassLoader(dex_1.get());
- PathClassLoader* class_loader_2 = AllocPathClassLoader(dex_2.get());
+ const PathClassLoader* class_loader_1 = AllocPathClassLoader(dex_1.get());
+ const PathClassLoader* class_loader_2 = AllocPathClassLoader(dex_2.get());
Class* MyClass_1 = class_linker_->FindClass("LMyClass;", class_loader_1);
Class* MyClass_2 = class_linker_->FindClass("LMyClass;", class_loader_2);
EXPECT_TRUE(MyClass_1 != NULL);
@@ -465,7 +465,7 @@ TEST_F(ClassLinkerTest, TwoClassLoadersOneClass) {
TEST_F(ClassLinkerTest, StaticFields) {
// TODO: uncomment expectations of initial values when InitializeClass works
scoped_ptr<const DexFile> dex(OpenTestDexFile("Statics"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
Class* statics = class_linker_->FindClass("LStatics;", class_loader);
class_linker_->EnsureInitialized(statics);
@@ -535,7 +535,7 @@ TEST_F(ClassLinkerTest, StaticFields) {
TEST_F(ClassLinkerTest, Interfaces) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("Interfaces"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
Class* I = class_linker_->FindClass("LInterfaces$I;", class_loader);
Class* J = class_linker_->FindClass("LInterfaces$J;", class_loader);
Class* A = class_linker_->FindClass("LInterfaces$A;", class_loader);
diff --git a/src/common_test.h b/src/common_test.h
index aa9229e..afe0c0f 100644
--- a/src/common_test.h
+++ b/src/common_test.h
@@ -148,7 +148,7 @@ class CommonTest : public testing::Test {
return DexFile::OpenZip(libcore_dex_file_name);
}
- PathClassLoader* AllocPathClassLoader(const DexFile* dex_file) {
+ const PathClassLoader* AllocPathClassLoader(const DexFile* dex_file) {
CHECK(dex_file != NULL);
class_linker_->RegisterDexFile(*dex_file);
std::vector<const DexFile*> dex_files;
diff --git a/src/compiler.cc b/src/compiler.cc
index 7644444..37f8298 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -12,17 +12,23 @@ extern bool oatCompileMethod(art::Method*, art::InstructionSet);
namespace art {
// TODO need to specify target
-const ClassLoader* Compiler::Compile(std::vector<const DexFile*> class_path) {
- const ClassLoader* class_loader = PathClassLoader::Alloc(class_path);
+void Compiler::CompileAll(const ClassLoader* class_loader) {
Resolve(class_loader);
// TODO add verification step
Compile(class_loader);
SetCodeAndDirectMethods(class_loader);
- return class_loader;
+}
+
+void Compiler::CompileOne(Method* method) {
+ const ClassLoader* class_loader = method->GetDeclaringClass()->GetClassLoader();
+ Resolve(class_loader);
+ // TODO add verification step
+ CompileMethod(method);
+ SetCodeAndDirectMethods(class_loader);
}
void Compiler::Resolve(const ClassLoader* class_loader) {
- const std::vector<const DexFile*>& class_path = class_loader->GetClassPath();
+ const std::vector<const DexFile*>& class_path = ClassLoader::GetClassPath(class_loader);
for (size_t i = 0; i != class_path.size(); ++i) {
const DexFile* dex_file = class_path[i];
CHECK(dex_file != NULL);
@@ -60,7 +66,7 @@ void Compiler::ResolveDexFile(const ClassLoader* class_loader, const DexFile& de
}
void Compiler::Compile(const ClassLoader* class_loader) {
- const std::vector<const DexFile*>& class_path = class_loader->GetClassPath();
+ const std::vector<const DexFile*>& class_path = ClassLoader::GetClassPath(class_loader);
for (size_t i = 0; i != class_path.size(); ++i) {
const DexFile* dex_file = class_path[i];
CHECK(dex_file != NULL);
@@ -105,15 +111,15 @@ void Compiler::CompileMethod(Method* method) {
}
void Compiler::SetCodeAndDirectMethods(const ClassLoader* class_loader) {
- const std::vector<const DexFile*>& class_path = class_loader->GetClassPath();
+ const std::vector<const DexFile*>& class_path = ClassLoader::GetClassPath(class_loader);
for (size_t i = 0; i != class_path.size(); ++i) {
const DexFile* dex_file = class_path[i];
CHECK(dex_file != NULL);
- SetCodeAndDirectMethodsDexFile(class_loader, *dex_file);
+ SetCodeAndDirectMethodsDexFile(*dex_file);
}
}
-void Compiler::SetCodeAndDirectMethodsDexFile(const ClassLoader* class_loader, const DexFile& dex_file) {
+void Compiler::SetCodeAndDirectMethodsDexFile(const DexFile& dex_file) {
ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
DexCache* dex_cache = class_linker->FindDexCache(dex_file);
CodeAndDirectMethods* code_and_direct_methods = dex_cache->GetCodeAndDirectMethods();
diff --git a/src/compiler.h b/src/compiler.h
index fde7a37..1214d3c 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -10,10 +10,11 @@ namespace art {
class Compiler {
public:
- // Compile the DexFiles on a classpath. Returns a ClassLoader for
- // the path used by the classes that were compiled. This ClassLoader
- // can be used with FindClass to lookup a compiled class by name.
- const ClassLoader* Compile(std::vector<const DexFile*> class_path);
+ // Compile all Methods of all the Classes of all the DexFiles that are part of a ClassLoader.
+ void CompileAll(const ClassLoader* class_loader);
+
+ // Compile a single Method
+ void CompileOne(Method* method);
private:
// Attempt to resolve all type, methods, fields, and strings
@@ -30,7 +31,7 @@ class Compiler {
// After compiling, walk all the DexCaches and set the code and
// method pointers of CodeAndDirectMethods entries in the DexCaches.
void SetCodeAndDirectMethods(const ClassLoader* class_loader);
- void SetCodeAndDirectMethodsDexFile(const ClassLoader* class_loader, const DexFile& dex_file);
+ void SetCodeAndDirectMethodsDexFile(const DexFile& dex_file);
};
} // namespace art
diff --git a/src/compiler_test.cc b/src/compiler_test.cc
index 124668e..229235a 100644
--- a/src/compiler_test.cc
+++ b/src/compiler_test.cc
@@ -16,23 +16,76 @@ namespace art {
class CompilerTest : public CommonTest {
protected:
- void CompileDex(const char* name) {
- dex_file_.reset(OpenTestDexFile(name));
+
+ const ClassLoader* LoadDex(const char* dex_name) {
+ dex_file_.reset(OpenTestDexFile(dex_name));
class_linker_->RegisterDexFile(*dex_file_.get());
std::vector<const DexFile*> class_path;
class_path.push_back(dex_file_.get());
- Compiler compiler;
- const ClassLoader* class_loader = compiler.Compile(class_path);
+ const ClassLoader* class_loader = PathClassLoader::Alloc(class_path);
Thread::Current()->SetClassLoaderOverride(class_loader);
+ return class_loader;
+ }
+
+
+ void CompileDex(const char* dex_name) {
+ Compile(LoadDex(dex_name));
+ }
+
+ void CompileSystem() {
+ Compile(NULL);
+ }
+
+ void Compile(const ClassLoader* class_loader) {
+ Compiler compiler;
+ compiler.CompileAll(NULL);
}
- void AssertStaticIntMethod(const char* klass, const char* method, const char* signature,
+ std::string ConvertClassNameToClassDescriptor(const char* class_name) {
+ std::string desc;
+ desc += "L";
+ desc += class_name;
+ desc += ";";
+ std::replace(desc.begin(), desc.end(), '.', '/');
+ return desc;
+ }
+
+
+ void CompileDirectMethod(const ClassLoader* class_loader,
+ const char* class_name,
+ const char* method_name,
+ const char* signature) {
+ std::string class_descriptor = ConvertClassNameToClassDescriptor(class_name);
+ Class* klass = class_linker_->FindClass(class_descriptor, class_loader);
+ CHECK(klass != NULL) << "Class not found " << class_name;
+ Method* method = klass->FindDirectMethod(method_name, signature);
+ CHECK(method != NULL) << "Method not found " << method_name;
+ Compiler compiler;
+ compiler.CompileOne(method);
+ }
+
+ void CompileVirtualMethod(const ClassLoader* class_loader,
+ const char* class_name,
+ const char* method_name,
+ const char* signature) {
+ std::string class_descriptor = ConvertClassNameToClassDescriptor(class_name);
+ Class* klass = class_linker_->FindClass(class_descriptor, class_loader);
+ CHECK(klass != NULL) << "Class not found " << class_name;
+ Method* method = klass->FindVirtualMethod(method_name, signature);
+ CHECK(method != NULL) << "Method not found " << method_name;
+ Compiler compiler;
+ compiler.CompileOne(method);
+ }
+
+ void AssertStaticIntMethod(const ClassLoader* class_loader,
+ const char* klass, const char* method, const char* signature,
jint expected, ...) {
+ CompileDirectMethod(class_loader, klass, method, signature);
JNIEnv* env = Thread::Current()->GetJniEnv();
jclass c = env->FindClass(klass);
- CHECK(c != NULL);
+ CHECK(c != NULL) << "Class not found " << klass;
jmethodID m = env->GetStaticMethodID(c, method, signature);
- CHECK(m != NULL);
+ CHECK(m != NULL) << "Method not found " << method;
#if defined(__arm__)
va_list args;
va_start(args, expected);
@@ -42,13 +95,15 @@ class CompilerTest : public CommonTest {
EXPECT_EQ(expected, result);
#endif // __arm__
}
- void AssertStaticLongMethod(const char* klass, const char* method,
- const char* signature, jlong expected, ...) {
+ void AssertStaticLongMethod(const ClassLoader* class_loader,
+ const char* klass, const char* method, const char* signature,
+ jlong expected, ...) {
+ CompileDirectMethod(class_loader, klass, method, signature);
JNIEnv* env = Thread::Current()->GetJniEnv();
jclass c = env->FindClass(klass);
- CHECK(c != NULL);
+ CHECK(c != NULL) << "Class not found " << klass;
jmethodID m = env->GetStaticMethodID(c, method, signature);
- CHECK(m != NULL);
+ CHECK(m != NULL) << "Method not found " << method;
#if defined(__arm__)
va_list args;
va_start(args, expected);
@@ -62,13 +117,10 @@ class CompilerTest : public CommonTest {
scoped_ptr<const DexFile> dex_file_;
};
-TEST_F(CompilerTest, CompileDexLibCore) {
- // TODO renenable when compiler can handle libcore
- if (true) {
- return;
- }
+// TODO renenable when compiler can handle libcore
+TEST_F(CompilerTest, DISABLED_CompileDexLibCore) {
Compiler compiler;
- compiler.Compile(boot_class_path_);
+ compiler.CompileAll(NULL);
// All libcore references should resolve
const DexFile* dex = java_lang_dex_file_.get();
@@ -108,132 +160,110 @@ TEST_F(CompilerTest, CompileDexLibCore) {
}
TEST_F(CompilerTest, BasicCodegen) {
- CompileDex("Fibonacci");
- AssertStaticIntMethod("Fibonacci", "fibonacci", "(I)I", 55,
+ AssertStaticIntMethod(LoadDex("Fibonacci"), "Fibonacci", "fibonacci", "(I)I", 55,
10);
}
TEST_F(CompilerTest, StaticFieldTest) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "staticFieldTest", "(I)I", 1404,
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "staticFieldTest", "(I)I", 1404,
404);
}
TEST_F(CompilerTest, UnopTest) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "unopTest", "(I)I", 37,
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "unopTest", "(I)I", 37,
38);
}
TEST_F(CompilerTest, ShiftTest1) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "shiftTest1", "()I", 0);
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "shiftTest1", "()I", 0);
}
TEST_F(CompilerTest, ShiftTest2) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "shiftTest2", "()I", 0);
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "shiftTest2", "()I", 0);
}
TEST_F(CompilerTest, UnsignedShiftTest) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "unsignedShiftTest", "()I", 0);
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "unsignedShiftTest", "()I", 0);
}
TEST_F(CompilerTest, ConvTest) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "convTest", "()I", 0);
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "convTest", "()I", 0);
}
TEST_F(CompilerTest, CharSubTest) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "charSubTest", "()I", 0);
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "charSubTest", "()I", 0);
}
TEST_F(CompilerTest, IntOperTest) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "intOperTest", "(II)I", 0,
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "intOperTest", "(II)I", 0,
70000, -3);
}
TEST_F(CompilerTest, Lit16Test) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "lit16Test", "(I)I", 0,
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "lit16Test", "(I)I", 0,
77777);
}
TEST_F(CompilerTest, Lit8Test) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "lit8Test", "(I)I", 0,
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "lit8Test", "(I)I", 0,
-55555);
}
TEST_F(CompilerTest, IntShiftTest) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "intShiftTest", "(II)I", 0,
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "intShiftTest", "(II)I", 0,
0xff00aa01, 8);
}
TEST_F(CompilerTest, LongOperTest) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "longOperTest", "(JJ)I", 0,
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "longOperTest", "(JJ)I", 0,
70000000000LL, -3LL);
}
TEST_F(CompilerTest, LongShiftTest) {
- CompileDex("IntMath");
- AssertStaticLongMethod("IntMath", "longShiftTest", "(JI)J",
+ AssertStaticLongMethod(LoadDex("IntMath"), "IntMath", "longShiftTest", "(JI)J",
0x96deff00aa010000LL, 0xd5aa96deff00aa01LL, 16);
}
TEST_F(CompilerTest, SwitchTest1) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "switchTest", "(I)I", 1234,
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "switchTest", "(I)I", 1234,
1);
}
TEST_F(CompilerTest, IntCompare) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "testIntCompare", "(IIII)I", 1111,
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "testIntCompare", "(IIII)I", 1111,
-5, 4, 4, 0);
}
TEST_F(CompilerTest, LongCompare) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "testLongCompare", "(JJJJ)I", 2222,
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "testLongCompare", "(JJJJ)I", 2222,
-5LL, -4294967287LL, 4LL, 8LL);
}
TEST_F(CompilerTest, FloatCompare) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "testFloatCompare", "(FFFF)I", 3333,
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "testFloatCompare", "(FFFF)I", 3333,
-5.0f, 4.0f, 4.0f,
(1.0f/0.0f) / (1.0f/0.0f));
}
TEST_F(CompilerTest, DoubleCompare) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "testDoubleCompare", "(DDDD)I", 4444,
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "testDoubleCompare", "(DDDD)I", 4444,
-5.0, 4.0, 4.0,
(1.0/0.0) / (1.0/0.0));
}
TEST_F(CompilerTest, RecursiveFibonacci) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "fibonacci", "(I)I", 55,
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "fibonacci", "(I)I", 55,
10);
}
#if 0 // Need to complete try/catch block handling
TEST_F(CompilerTest, ThrowAndCatch) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "throwAndCatch", "()I", 4);
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "throwAndCatch", "()I", 4);
}
#endif
TEST_F(CompilerTest, ManyArgs) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "manyArgs",
+ AssertStaticIntMethod(LoadDex("IntMath"), "IntMath", "manyArgs",
"(IJIJIJIIDFDSICIIBZIIJJIIIII)I", -1,
0, 1LL, 2, 3LL, 4, 5LL, 6, 7, 8.0, 9.0f, 10.0,
(short)11, 12, (char)13, 14, 15, (int8_t)-16, true, 18,
@@ -241,14 +271,22 @@ TEST_F(CompilerTest, ManyArgs) {
}
TEST_F(CompilerTest, VirtualCall) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "staticCall", "(I)I", 6,
+ CompileDirectMethod(NULL, "java.lang.Object", "<init>", "()V");
+ const ClassLoader* class_loader = LoadDex("IntMath");
+ CompileDirectMethod(class_loader, "IntMath", "<init>", "()V");
+ CompileVirtualMethod(class_loader, "IntMath", "virtualCall", "(I)I");
+ AssertStaticIntMethod(class_loader, "IntMath", "staticCall", "(I)I", 6,
3);
}
TEST_F(CompilerTest, TestIGetPut) {
- CompileDex("IntMath");
- AssertStaticIntMethod("IntMath", "testIGetPut", "(I)I", 333,
+ CompileDirectMethod(NULL, "java.lang.Object", "<init>", "()V");
+ const ClassLoader* class_loader = LoadDex("IntMath");
+ CompileDirectMethod(class_loader, "IntMath", "<init>", "(I)V");
+ CompileDirectMethod(class_loader, "IntMath", "<init>", "()V");
+ CompileVirtualMethod(class_loader, "IntMath", "getFoo", "()I");
+ CompileVirtualMethod(class_loader, "IntMath", "setFoo", "(I)V");
+ AssertStaticIntMethod(class_loader, "IntMath", "testIGetPut", "(I)I", 333,
111);
}
diff --git a/src/dex_cache.h b/src/dex_cache.h
index 0d217bc..137f267 100644
--- a/src/dex_cache.h
+++ b/src/dex_cache.h
@@ -26,7 +26,7 @@ class CodeAndDirectMethods : public IntArray {
}
void SetResolvedDirectMethodTrampoline(uint32_t method_idx) {
- UNIMPLEMENTED(FATAL) << "need to install a trampoline to resolve the method_idx at runtime";
+ UNIMPLEMENTED(WARNING) << "need to install a trampoline to resolve the method_idx at runtime";
Set(method_idx * kMax + kCode, 0xffffffff);
Set(method_idx * kMax + kMethod, method_idx);
}
diff --git a/src/dex_verifier_test.cc b/src/dex_verifier_test.cc
index a9da38f..20a3157 100644
--- a/src/dex_verifier_test.cc
+++ b/src/dex_verifier_test.cc
@@ -39,7 +39,7 @@ TEST_F(DexVerifierTest, LibCore) {
TEST_F(DexVerifierTest, IntMath) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("IntMath"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
Class* klass = class_linker_->FindClass("LIntMath;", class_loader);
ASSERT_TRUE(DexVerify::VerifyClass(klass));
}
diff --git a/src/exception_test.cc b/src/exception_test.cc
index cc5e3e0..c384bc1 100644
--- a/src/exception_test.cc
+++ b/src/exception_test.cc
@@ -67,7 +67,7 @@ class ExceptionTest : public CommonTest {
dex_.reset(OpenDexFileBase64(kMyClassExceptionHandleDex, "kMyClassExceptionHandleDex"));
ASSERT_TRUE(dex_ != NULL);
- PathClassLoader* class_loader = AllocPathClassLoader(dex_.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex_.get());
ASSERT_TRUE(class_loader != NULL);
my_klass_ = class_linker_->FindClass("Ljava/lang/MyClass;", class_loader);
ASSERT_TRUE(my_klass_ != NULL);
diff --git a/src/jni_compiler_test.cc b/src/jni_compiler_test.cc
index 4cd32e8..016a606 100644
--- a/src/jni_compiler_test.cc
+++ b/src/jni_compiler_test.cc
@@ -66,7 +66,7 @@ class JniCompilerTest : public CommonTest {
static jobject jobj_;
protected:
scoped_ptr<const DexFile> dex_;
- PathClassLoader* class_loader_;
+ const PathClassLoader* class_loader_;
Assembler jni_asm;
JniCompiler jni_compiler;
JNIEnv* env_;
diff --git a/src/jni_internal_test.cc b/src/jni_internal_test.cc
index a71975b..fa98dd8 100644
--- a/src/jni_internal_test.cc
+++ b/src/jni_internal_test.cc
@@ -638,7 +638,7 @@ TEST_F(JniInternalTest, GetObjectArrayElement_SetObjectArrayElement) {
TEST_F(JniInternalTest, GetPrimitiveField_SetPrimitiveField) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("AllFields"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
Thread::Current()->SetClassLoaderOverride(class_loader);
jclass c = env_->FindClass("AllFields");
@@ -667,7 +667,7 @@ TEST_F(JniInternalTest, GetPrimitiveField_SetPrimitiveField) {
TEST_F(JniInternalTest, GetObjectField_SetObjectField) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("AllFields"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
Thread::Current()->SetClassLoaderOverride(class_loader);
jclass c = env_->FindClass("AllFields");
@@ -830,7 +830,7 @@ Method::InvokeStub* AllocateStub(Method* method,
TEST_F(JniInternalTest, StaticMainMethod) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("Main"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
ASSERT_TRUE(class_loader != NULL);
Class* klass = class_linker_->FindClass("LMain;", class_loader);
@@ -856,7 +856,7 @@ TEST_F(JniInternalTest, StaticMainMethod) {
TEST_F(JniInternalTest, StaticNopMethod) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("StaticLeafMethods"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
ASSERT_TRUE(class_loader != NULL);
Class* klass = class_linker_->FindClass("LStaticLeafMethods;", class_loader);
@@ -881,7 +881,7 @@ TEST_F(JniInternalTest, StaticNopMethod) {
TEST_F(JniInternalTest, StaticIdentityByteMethod) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("StaticLeafMethods"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
ASSERT_TRUE(class_loader != NULL);
Class* klass = class_linker_->FindClass("LStaticLeafMethods;", class_loader);
@@ -927,7 +927,7 @@ TEST_F(JniInternalTest, StaticIdentityByteMethod) {
TEST_F(JniInternalTest, StaticIdentityIntMethod) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("StaticLeafMethods"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
ASSERT_TRUE(class_loader != NULL);
Class* klass = class_linker_->FindClass("LStaticLeafMethods;", class_loader);
@@ -973,7 +973,7 @@ TEST_F(JniInternalTest, StaticIdentityIntMethod) {
TEST_F(JniInternalTest, StaticIdentityDoubleMethod) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("StaticLeafMethods"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
ASSERT_TRUE(class_loader != NULL);
Class* klass = class_linker_->FindClass("LStaticLeafMethods;", class_loader);
@@ -1020,7 +1020,7 @@ TEST_F(JniInternalTest, StaticIdentityDoubleMethod) {
TEST_F(JniInternalTest, StaticSumIntIntMethod) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("StaticLeafMethods"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
ASSERT_TRUE(class_loader != NULL);
Class* klass = class_linker_->FindClass("LStaticLeafMethods;", class_loader);
@@ -1078,7 +1078,7 @@ TEST_F(JniInternalTest, StaticSumIntIntMethod) {
TEST_F(JniInternalTest, StaticSumIntIntIntMethod) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("StaticLeafMethods"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
ASSERT_TRUE(class_loader != NULL);
Class* klass = class_linker_->FindClass("LStaticLeafMethods;", class_loader);
@@ -1143,7 +1143,7 @@ TEST_F(JniInternalTest, StaticSumIntIntIntMethod) {
TEST_F(JniInternalTest, StaticSumIntIntIntIntMethod) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("StaticLeafMethods"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
ASSERT_TRUE(class_loader != NULL);
Class* klass = class_linker_->FindClass("LStaticLeafMethods;", class_loader);
@@ -1214,7 +1214,7 @@ TEST_F(JniInternalTest, StaticSumIntIntIntIntMethod) {
TEST_F(JniInternalTest, StaticSumIntIntIntIntIntMethod) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("StaticLeafMethods"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
ASSERT_TRUE(class_loader != NULL);
Class* klass = class_linker_->FindClass("LStaticLeafMethods;", class_loader);
@@ -1292,7 +1292,7 @@ TEST_F(JniInternalTest, StaticSumIntIntIntIntIntMethod) {
TEST_F(JniInternalTest, StaticSumDoubleDoubleMethod) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("StaticLeafMethods"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
ASSERT_TRUE(class_loader != NULL);
Class* klass = class_linker_->FindClass("LStaticLeafMethods;", class_loader);
@@ -1351,7 +1351,7 @@ TEST_F(JniInternalTest, StaticSumDoubleDoubleMethod) {
TEST_F(JniInternalTest, StaticSumDoubleDoubleDoubleMethod) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("StaticLeafMethods"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
ASSERT_TRUE(class_loader != NULL);
Class* klass = class_linker_->FindClass("LStaticLeafMethods;", class_loader);
@@ -1403,7 +1403,7 @@ TEST_F(JniInternalTest, StaticSumDoubleDoubleDoubleMethod) {
TEST_F(JniInternalTest, StaticSumDoubleDoubleDoubleDoubleMethod) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("StaticLeafMethods"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
ASSERT_TRUE(class_loader != NULL);
Class* klass = class_linker_->FindClass("LStaticLeafMethods;", class_loader);
@@ -1460,7 +1460,7 @@ TEST_F(JniInternalTest, StaticSumDoubleDoubleDoubleDoubleMethod) {
TEST_F(JniInternalTest, StaticSumDoubleDoubleDoubleDoubleDoubleMethod) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("StaticLeafMethods"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
ASSERT_TRUE(class_loader != NULL);
Class* klass = class_linker_->FindClass("LStaticLeafMethods;", class_loader);
diff --git a/src/object.cc b/src/object.cc
index 9bb1cb7..66ea03f 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -14,6 +14,13 @@
namespace art {
+const std::vector<const DexFile*>& ClassLoader::GetClassPath(const ClassLoader* class_loader) {
+ if (class_loader == NULL) {
+ return Runtime::Current()->GetClassLinker()->GetBootClassPath();
+ }
+ return class_loader->class_path_;
+}
+
Array* Array::Alloc(Class* array_class, int32_t component_count, size_t component_size) {
DCHECK_GE(component_count, 0);
DCHECK(array_class->IsArrayClass());
@@ -671,7 +678,7 @@ void String::ResetClass() {
// TODO: get global references for these
Class* PathClassLoader::dalvik_system_PathClassLoader_ = NULL;
-PathClassLoader* PathClassLoader::Alloc(std::vector<const DexFile*> dex_files) {
+const PathClassLoader* PathClassLoader::Alloc(std::vector<const DexFile*> dex_files) {
PathClassLoader* p = down_cast<PathClassLoader*>(dalvik_system_PathClassLoader_->NewInstance());
p->SetClassPath(dex_files);
return p;
diff --git a/src/object.h b/src/object.h
index 1df10ad..2d07bd5 100644
--- a/src/object.h
+++ b/src/object.h
@@ -872,9 +872,8 @@ class ObjectArray : public Array {
// ClassLoader objects.
class ClassLoader : public Object {
public:
- const std::vector<const DexFile*>& GetClassPath() const {
- return class_path_;
- }
+ static const std::vector<const DexFile*>& GetClassPath(const ClassLoader* class_loader);
+
void SetClassPath(std::vector<const DexFile*>& class_path) {
DCHECK_EQ(0U, class_path_.size());
class_path_ = class_path;
@@ -901,7 +900,7 @@ class BaseDexClassLoader : public ClassLoader {
class PathClassLoader : public BaseDexClassLoader {
public:
- static PathClassLoader* Alloc(std::vector<const DexFile*> dex_files);
+ static const PathClassLoader* Alloc(std::vector<const DexFile*> dex_files);
static void SetClass(Class* dalvik_system_PathClassLoader);
static void ResetClass();
private:
diff --git a/src/object_test.cc b/src/object_test.cc
index a862f71..1967ea7 100644
--- a/src/object_test.cc
+++ b/src/object_test.cc
@@ -275,9 +275,9 @@ TEST_F(ObjectTest, DescriptorCompare) {
ClassLinker* linker = class_linker_;
scoped_ptr<const DexFile> proto1_dex_file(OpenTestDexFile("ProtoCompare"));
- PathClassLoader* class_loader_1 = AllocPathClassLoader(proto1_dex_file.get());
+ const PathClassLoader* class_loader_1 = AllocPathClassLoader(proto1_dex_file.get());
scoped_ptr<const DexFile> proto2_dex_file(OpenTestDexFile("ProtoCompare2"));
- PathClassLoader* class_loader_2 = AllocPathClassLoader(proto2_dex_file.get());
+ const PathClassLoader* class_loader_2 = AllocPathClassLoader(proto2_dex_file.get());
Class* klass1 = linker->FindClass("LProtoCompare;", class_loader_1);
ASSERT_TRUE(klass1 != NULL);
@@ -324,7 +324,7 @@ TEST_F(ObjectTest, StringHashCode) {
TEST_F(ObjectTest, InstanceOf) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("XandY"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
Class* X = class_linker_->FindClass("LX;", class_loader);
Class* Y = class_linker_->FindClass("LY;", class_loader);
ASSERT_TRUE(X != NULL);
@@ -351,7 +351,7 @@ TEST_F(ObjectTest, InstanceOf) {
TEST_F(ObjectTest, IsAssignableFrom) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("XandY"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
Class* X = class_linker_->FindClass("LX;", class_loader);
Class* Y = class_linker_->FindClass("LY;", class_loader);
@@ -363,7 +363,7 @@ TEST_F(ObjectTest, IsAssignableFrom) {
TEST_F(ObjectTest, IsAssignableFromArray) {
scoped_ptr<const DexFile> dex(OpenTestDexFile("XandY"));
- PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
+ const PathClassLoader* class_loader = AllocPathClassLoader(dex.get());
Class* X = class_linker_->FindClass("LX;", class_loader);
Class* Y = class_linker_->FindClass("LY;", class_loader);
ASSERT_TRUE(X != NULL);
diff --git a/test/IntMath/java/lang/Object.java b/test/IntMath/java/lang/Object.java
deleted file mode 100644
index 67e54e3..0000000
--- a/test/IntMath/java/lang/Object.java
+++ /dev/null
@@ -1,5 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-
-// TODO: remove this when separate compilation works
-package java.lang;
-public class Object {}
generated by cgit v1.1 at 2025-01-29 02:41:18 +0000