Move DexFiles to be allocated on the heap
Removed pointer from DexFile to RawDexfile to allow heap allocation of
DexFile. DexFile is now an ObjectArray of ObjectArrays. Removing the
pointer from DexFile to RawDexfile meant adding arguments to pass the
RawDexfile along to ClassLinker::LoadClass, LoadInterfaces, LoadField,
LoadMethod, LinkClass, LinkInterfaces, ResolveClass to avoid the need
to look a RawDexfile up from a DexFile. ClassLinker::CreateArrayClass
now takes the raw_dex_file to assist in looking up the component class
from the proper source. Moved Method::HasSame* methods to ClassLinker
since for access to the RawDexfile (and tests of HasSame from
ObjectTest to ClassLinkerTest.
src/dex_file.cc
src/dex_file.h
src/class_linker.cc
src/class_linker.h
src/object.h
RunTime::Create/RunTime::Init/ClassLinker::Create/ClassLinker::Init
now take the boot class path. A boot class path with
Ljava/lang/Object; must be provided to initalize [Ljava/lang/Object;
during startup in order to heap allocate DexFiles.
src/class_linker.cc
src/class_linker.h
src/runtime.cc
src/runtime.h
Restored FindClass to load from a specific dex file. This is for use
by class loaders, otherwise it is assumed the caller wants to use the
boot classpath. We now distinguish and track the boot classpath as
separate from other dex files known to the class linker. Renamed
AppendToClassPath to AppendToBootClassPath and FindInClassPath to
FindInBootClassPath to clarify.
src/class_linker.cc
src/class_linker.h
Cleaned up AllocCharArray to generic AllocArray and added
AllocObjectArray. Added a functional ObjectArray implementation and a
ObjectTest to cover it.
src/heap.h
src/object.h
src/object_test.cc
Switched more Object* downcasting to down_cast
src/class_linker.cc
Switched order of arguments for DexFile::SetResolved to follow more
conventional collection ordering ( "(index, value)" vs "(value, index)" )
src/dex_file.h
src/class_linker.cc
src/class_linker.h
Added class_linker_ and java_lang_raw_dex_file_ to RuntimeTest as
convenience to test subclasses. ClassLinkerTest now can use these to
simplify its ::Assert* methods. JniCompilerTest now uses it for
setting up its boot class path. Removed now unneeded
OpenDexFileBase64.
src/common_test.h
src/class_linker_test.cc
src/jni_compiler_test.cc
Add external/gtest/include to non-test include path so FRIEND_TEST can be used.
Add src to include path to remove the need of using in in art/src files.
build/Android.libart.host.mk
build/Android.libart.mk
src/assembler.cc
src/assembler.h
src/assembler_arm.cc
src/assembler_arm.h
src/assembler_x86.cc
src/assembler_x86.h
src/assembler_x86_test.cc
src/base64.cc
src/base64.h
src/calling_convention.cc
src/calling_convention.h
src/calling_convention_arm.cc
src/calling_convention_x86.cc
src/casts.h
src/class_linker.h
src/class_linker_test.cc
src/common_test.h
src/constants.h
src/constants_arm.h
src/constants_x86.h
src/dex_file.cc
src/dex_file.h
src/dex_file_test.cc
src/dex_instruction.cc
src/dex_instruction.h
src/dex_instruction_visitor.h
src/dex_instruction_visitor_test.cc
src/dex_verifier.cc
src/dex_verifier.h
src/heap.cc
src/heap.h
src/jni_compiler.cc
src/jni_compiler_test.cc
src/jni_internal.cc
src/jni_internal.h
src/leb128.h
src/managed_register.h
src/managed_register_arm.cc
src/managed_register_arm.h
src/managed_register_arm_test.cc
src/managed_register_x86.cc
src/managed_register_x86.h
src/managed_register_x86_test.cc
src/mark_stack.cc
src/mark_stack.h
src/mark_sweep.cc
src/mark_sweep.h
src/memory_region.cc
src/memory_region.h
src/monitor.h
src/object.cc
src/object.h
src/object_bitmap.cc
src/object_bitmap.h
src/object_test.cc
src/offsets.cc
src/offsets.h
src/raw_dex_file.cc
src/raw_dex_file.h
src/raw_dex_file_test.cc
src/runtime.cc
src/runtime.h
src/scoped_ptr.h
src/space.cc
src/space.h
src/space_test.cc
src/stringpiece.cc
src/thread.cc
src/thread.h
src/thread_arm.cc
src/thread_x86.cc
src/utils.h
Change-Id: Ib633cea878c36921e9037b0464cb903aec318c3e
diff --git a/build/Android.libart.host.mk b/build/Android.libart.host.mk
index 92cc4da..9772d63 100644
--- a/build/Android.libart.host.mk
+++ b/build/Android.libart.host.mk
@@ -20,6 +20,7 @@
LOCAL_MODULE_TAGS := optional
LOCAL_SRC_FILES := $(LIBART_HOST_SRC_FILES)
LOCAL_CFLAGS := $(ART_CFLAGS)
+LOCAL_C_INCLUDES += src external/gtest/include
LOCAL_SHARED_LIBRARIES := liblog libz-host
LOCAL_LDLIBS := -ldl -lpthread -lrt
include $(BUILD_HOST_SHARED_LIBRARY)
diff --git a/build/Android.libart.mk b/build/Android.libart.mk
index 94442a1..fae5c7e 100644
--- a/build/Android.libart.mk
+++ b/build/Android.libart.mk
@@ -21,5 +21,6 @@
LOCAL_MODULE_TAGS := optional
LOCAL_SRC_FILES := $(LIBART_TARGET_SRC_FILES)
LOCAL_CFLAGS := $(ART_CFLAGS)
+LOCAL_C_INCLUDES += src external/gtest/include
LOCAL_SHARED_LIBRARIES := libcutils liblog libstlport libz
include $(BUILD_SHARED_LIBRARY)
diff --git a/src/assembler.cc b/src/assembler.cc
index 8bd7625..55c6d07 100644
--- a/src/assembler.cc
+++ b/src/assembler.cc
@@ -2,9 +2,9 @@
#include <algorithm>
#include <vector>
-#include "src/assembler.h"
-#include "src/globals.h"
-#include "src/memory_region.h"
+#include "assembler.h"
+#include "globals.h"
+#include "memory_region.h"
namespace art {
diff --git a/src/assembler.h b/src/assembler.h
index c98a6b7..96d5ff0 100644
--- a/src/assembler.h
+++ b/src/assembler.h
@@ -3,11 +3,11 @@
#ifndef ART_SRC_ASSEMBLER_H_
#define ART_SRC_ASSEMBLER_H_
-#include "src/logging.h"
-#include "src/macros.h"
-#include "src/managed_register.h"
-#include "src/memory_region.h"
-#include "src/offsets.h"
+#include "logging.h"
+#include "macros.h"
+#include "managed_register.h"
+#include "memory_region.h"
+#include "offsets.h"
namespace art {
@@ -300,9 +300,9 @@
} // namespace art
#if defined(__i386__)
-#include "src/assembler_x86.h"
+#include "assembler_x86.h"
#elif defined(__arm__)
-#include "src/assembler_arm.h"
+#include "assembler_arm.h"
#endif
#endif // ART_SRC_ASSEMBLER_H_
diff --git a/src/assembler_arm.cc b/src/assembler_arm.cc
index d470b90..900d8d4 100644
--- a/src/assembler_arm.cc
+++ b/src/assembler_arm.cc
@@ -1,9 +1,9 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/assembler.h"
-#include "src/logging.h"
-#include "src/offsets.h"
-#include "src/utils.h"
+#include "assembler.h"
+#include "logging.h"
+#include "offsets.h"
+#include "utils.h"
namespace art {
diff --git a/src/assembler_arm.h b/src/assembler_arm.h
index acaf870..728fadf 100644
--- a/src/assembler_arm.h
+++ b/src/assembler_arm.h
@@ -3,11 +3,11 @@
#ifndef ART_SRC_ASSEMBLER_ARM_H_
#define ART_SRC_ASSEMBLER_ARM_H_
-#include "src/constants.h"
-#include "src/managed_register.h"
-#include "src/logging.h"
-#include "src/offsets.h"
-#include "src/utils.h"
+#include "constants.h"
+#include "managed_register.h"
+#include "logging.h"
+#include "offsets.h"
+#include "utils.h"
namespace art {
diff --git a/src/assembler_x86.cc b/src/assembler_x86.cc
index a3d47e3..e7d048b 100644
--- a/src/assembler_x86.cc
+++ b/src/assembler_x86.cc
@@ -1,11 +1,11 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/assembler.h"
-#include "src/casts.h"
-#include "src/globals.h"
-#include "src/memory_region.h"
-#include "src/offsets.h"
-#include "src/thread.h"
+#include "assembler.h"
+#include "casts.h"
+#include "globals.h"
+#include "memory_region.h"
+#include "offsets.h"
+#include "thread.h"
namespace art {
diff --git a/src/assembler_x86.h b/src/assembler_x86.h
index e446c51..5e691d1 100644
--- a/src/assembler_x86.h
+++ b/src/assembler_x86.h
@@ -3,13 +3,13 @@
#ifndef ART_SRC_ASSEMBLER_X86_H_
#define ART_SRC_ASSEMBLER_X86_H_
-#include "src/assembler.h"
-#include "src/constants.h"
-#include "src/globals.h"
-#include "src/managed_register.h"
-#include "src/macros.h"
-#include "src/offsets.h"
-#include "src/utils.h"
+#include "assembler.h"
+#include "constants.h"
+#include "globals.h"
+#include "managed_register.h"
+#include "macros.h"
+#include "offsets.h"
+#include "utils.h"
namespace art {
diff --git a/src/assembler_x86_test.cc b/src/assembler_x86_test.cc
index c0d1495..ffe3d0b 100644
--- a/src/assembler_x86_test.cc
+++ b/src/assembler_x86_test.cc
@@ -1,7 +1,7 @@
// Copyright 2011 Google Inc. All Rights Reserved.
// Author: cshapiro@google.com (Carl Shapiro)
-#include "src/assembler_x86.h"
+#include "assembler_x86.h"
#include "gtest/gtest.h"
diff --git a/src/base64.cc b/src/base64.cc
index 7c09688..a1bb61c 100644
--- a/src/base64.cc
+++ b/src/base64.cc
@@ -1,7 +1,7 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/globals.h"
-#include "src/scoped_ptr.h"
+#include "globals.h"
+#include "scoped_ptr.h"
#include <vector>
diff --git a/src/base64.h b/src/base64.h
index 160046d..a4344ea 100644
--- a/src/base64.h
+++ b/src/base64.h
@@ -3,7 +3,7 @@
#ifndef ART_SRC_BASE64_H_
#define ART_SRC_BASE64_H_
-#include "src/globals.h"
+#include "globals.h"
namespace art {
diff --git a/src/calling_convention.cc b/src/calling_convention.cc
index ae6ac25..5ab5b45 100644
--- a/src/calling_convention.cc
+++ b/src/calling_convention.cc
@@ -1,9 +1,9 @@
// Copyright 2011 Google Inc. All Rights Reserved.
// Author: irogers@google.com (Ian Rogers)
-#include "src/calling_convention.h"
-#include "src/logging.h"
-#include "src/utils.h"
+#include "calling_convention.h"
+#include "logging.h"
+#include "utils.h"
namespace art {
diff --git a/src/calling_convention.h b/src/calling_convention.h
index 4e2eab7..6dec292 100644
--- a/src/calling_convention.h
+++ b/src/calling_convention.h
@@ -4,9 +4,9 @@
#ifndef ART_SRC_CALLING_CONVENTION_H_
#define ART_SRC_CALLING_CONVENTION_H_
-#include "src/managed_register.h"
-#include "src/object.h"
-#include "src/thread.h"
+#include "managed_register.h"
+#include "object.h"
+#include "thread.h"
namespace art {
diff --git a/src/calling_convention_arm.cc b/src/calling_convention_arm.cc
index bac943b..7535389 100644
--- a/src/calling_convention_arm.cc
+++ b/src/calling_convention_arm.cc
@@ -1,8 +1,8 @@
// Copyright 2011 Google Inc. All Rights Reserved.
// Author: irogers@google.com (Ian Rogers)
-#include "src/calling_convention.h"
-#include "src/logging.h"
+#include "calling_convention.h"
+#include "logging.h"
namespace art {
diff --git a/src/calling_convention_x86.cc b/src/calling_convention_x86.cc
index f1b96a6..c212013 100644
--- a/src/calling_convention_x86.cc
+++ b/src/calling_convention_x86.cc
@@ -1,9 +1,9 @@
// Copyright 2011 Google Inc. All Rights Reserved.
// Author: irogers@google.com (Ian Rogers)
-#include "src/calling_convention.h"
-#include "src/logging.h"
-#include "src/utils.h"
+#include "calling_convention.h"
+#include "logging.h"
+#include "utils.h"
namespace art {
diff --git a/src/casts.h b/src/casts.h
index cdb57ee..0534eca 100644
--- a/src/casts.h
+++ b/src/casts.h
@@ -5,7 +5,7 @@
#include <assert.h>
#include <string.h>
-#include "src/macros.h"
+#include "macros.h"
namespace art {
diff --git a/src/class_linker.cc b/src/class_linker.cc
index 6fac610..20960d2 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -1,32 +1,39 @@
// Copyright 2011 Google Inc. All Rights Reserved.
// Author: cshapiro@google.com (Carl Shapiro)
-#include "src/class_linker.h"
+#include "class_linker.h"
#include <vector>
#include <utility>
-#include "src/casts.h"
-#include "src/dex_verifier.h"
-#include "src/heap.h"
-#include "src/logging.h"
-#include "src/monitor.h"
-#include "src/object.h"
-#include "src/raw_dex_file.h"
-#include "src/scoped_ptr.h"
-#include "src/thread.h"
-#include "src/utils.h"
+#include "casts.h"
+#include "dex_file.h"
+#include "dex_verifier.h"
+#include "heap.h"
+#include "logging.h"
+#include "monitor.h"
+#include "object.h"
+#include "raw_dex_file.h"
+#include "scoped_ptr.h"
+#include "thread.h"
+#include "utils.h"
namespace art {
-ClassLinker* ClassLinker::Create() {
+ClassLinker* ClassLinker::Create(std::vector<RawDexFile*> boot_class_path) {
scoped_ptr<ClassLinker> class_linker(new ClassLinker);
- class_linker->Init();
+ class_linker->Init(boot_class_path);
// TODO: check for failure during initialization
return class_linker.release();
}
-void ClassLinker::Init() {
+void ClassLinker::Init(std::vector<RawDexFile*> boot_class_path) {
+
+ // setup boot_class_path_ so that object_array_class_ can be properly initialized
+ for (size_t i = 0; i != boot_class_path.size(); ++i) {
+ AppendToBootClassPath(boot_class_path[i]);
+ }
+
// Allocate and partially initialize the Class, Object, Field, Method classes.
// Initialization will be completed when the definitions are loaded.
java_lang_Class_ = down_cast<Class*>(Heap::AllocObject(NULL, sizeof(Class)));
@@ -74,10 +81,17 @@
char_array_class_ = FindSystemClass("[C");
CHECK(char_array_class_ != NULL);
+
+ object_array_class_ = FindSystemClass("[Ljava/lang/Object;");
+ CHECK(object_array_class_ != NULL);
+}
+
+DexFile* ClassLinker::AllocDexFile() {
+ return down_cast<DexFile*>(Heap::AllocObjectArray(object_array_class_, DexFile::kMax));
}
Class* ClassLinker::AllocClass(DexFile* dex_file) {
- Class* klass = reinterpret_cast<Class*>(Heap::AllocObject(java_lang_Class_));
+ Class* klass = down_cast<Class*>(Heap::AllocObject(java_lang_Class_));
klass->dex_file_ = dex_file;
return klass;
}
@@ -97,8 +111,13 @@
sizeof(Method)));
}
+ObjectArray* ClassLinker::AllocObjectArray(size_t length) {
+ return Heap::AllocObjectArray(object_array_class_, length);
+}
+
Class* ClassLinker::FindClass(const StringPiece& descriptor,
- Object* class_loader) {
+ Object* class_loader,
+ const RawDexFile* raw_dex_file) {
Thread* self = Thread::Current();
DCHECK(self != NULL);
CHECK(!self->IsExceptionPending());
@@ -107,15 +126,22 @@
if (klass == NULL) {
// Class is not yet loaded.
if (descriptor[0] == '[') {
- return CreateArrayClass(descriptor, class_loader);
+ return CreateArrayClass(descriptor, class_loader, raw_dex_file);
}
- ClassPathEntry pair = FindInClassPath(descriptor);
- if (pair.first == NULL) {
+ ClassPathEntry pair;
+ if (raw_dex_file == NULL) {
+ pair = FindInBootClassPath(descriptor);
+ } else {
+ pair.first = raw_dex_file;
+ pair.second = raw_dex_file->FindClassDef(descriptor);
+ }
+ if (pair.second == NULL) {
LG << "Class " << descriptor << " not found"; // TODO: NoClassDefFoundError
return NULL;
}
- DexFile* dex_file = pair.first;
+ const RawDexFile* raw_dex_file = pair.first;
const RawDexFile::ClassDef* class_def = pair.second;
+ DexFile* dex_file = FindDexFile(raw_dex_file);
// Load the class from the dex file.
if (descriptor == "Ljava/lang/Object;") {
klass = java_lang_Object_;
@@ -147,7 +173,7 @@
} else {
klass = AllocClass(dex_file);
}
- LoadClass(*class_def, klass);
+ LoadClass(*raw_dex_file, *class_def, klass);
// Check for a pending exception during load
if (self->IsExceptionPending()) {
// TODO: free native allocations in klass
@@ -166,7 +192,7 @@
CHECK(klass != NULL);
} else {
// Link the class.
- if (!LinkClass(klass)) {
+ if (!LinkClass(klass, raw_dex_file)) {
// Linking failed.
// TODO: CHECK(self->IsExceptionPending());
lock.NotifyAll();
@@ -197,14 +223,15 @@
return klass;
}
-void ClassLinker::LoadClass(const RawDexFile::ClassDef& class_def, Class* klass) {
+void ClassLinker::LoadClass(const RawDexFile& raw_dex_file,
+ const RawDexFile::ClassDef& class_def,
+ Class* klass) {
CHECK(klass != NULL);
CHECK(klass->dex_file_ != NULL);
- const RawDexFile* raw = klass->GetDexFile()->GetRaw();
- const byte* class_data = raw->GetClassData(class_def);
- RawDexFile::ClassDataHeader header = raw->ReadClassDataHeader(&class_data);
+ const byte* class_data = raw_dex_file.GetClassData(class_def);
+ RawDexFile::ClassDataHeader header = raw_dex_file.ReadClassDataHeader(&class_data);
- const char* descriptor = raw->GetClassDescriptor(class_def);
+ const char* descriptor = raw_dex_file.GetClassDescriptor(class_def);
CHECK(descriptor != NULL);
klass->klass_ = java_lang_Class_;
@@ -223,10 +250,10 @@
klass->num_direct_methods_ = header.direct_methods_size_;
klass->num_virtual_methods_ = header.virtual_methods_size_;
- klass->source_file_ = raw->dexGetSourceFile(class_def);
+ klass->source_file_ = raw_dex_file.dexGetSourceFile(class_def);
// Load class interfaces.
- LoadInterfaces(class_def, klass);
+ LoadInterfaces(raw_dex_file, class_def, klass);
// Load static fields.
if (klass->NumStaticFields() != 0) {
@@ -235,10 +262,10 @@
uint32_t last_idx = 0;
for (size_t i = 0; i < klass->NumStaticFields(); ++i) {
RawDexFile::Field raw_field;
- raw->dexReadClassDataField(&class_data, &raw_field, &last_idx);
+ raw_dex_file.dexReadClassDataField(&class_data, &raw_field, &last_idx);
StaticField* sfield = AllocStaticField();
klass->sfields_[i] = sfield;
- LoadField(klass, raw_field, sfield);
+ LoadField(raw_dex_file, raw_field, klass, sfield);
}
}
@@ -249,10 +276,10 @@
uint32_t last_idx = 0;
for (size_t i = 0; i < klass->NumInstanceFields(); ++i) {
RawDexFile::Field raw_field;
- raw->dexReadClassDataField(&class_data, &raw_field, &last_idx);
+ raw_dex_file.dexReadClassDataField(&class_data, &raw_field, &last_idx);
InstanceField* ifield = AllocInstanceField();
klass->ifields_[i] = ifield;
- LoadField(klass, raw_field, ifield);
+ LoadField(raw_dex_file, raw_field, klass, ifield);
}
}
@@ -263,10 +290,10 @@
uint32_t last_idx = 0;
for (size_t i = 0; i < klass->NumDirectMethods(); ++i) {
RawDexFile::Method raw_method;
- raw->dexReadClassDataMethod(&class_data, &raw_method, &last_idx);
+ raw_dex_file.dexReadClassDataMethod(&class_data, &raw_method, &last_idx);
Method* meth = AllocMethod();
klass->direct_methods_[i] = meth;
- LoadMethod(klass, raw_method, meth);
+ LoadMethod(raw_dex_file, raw_method, klass, meth);
// TODO: register maps
}
}
@@ -278,19 +305,19 @@
uint32_t last_idx = 0;
for (size_t i = 0; i < klass->NumVirtualMethods(); ++i) {
RawDexFile::Method raw_method;
- raw->dexReadClassDataMethod(&class_data, &raw_method, &last_idx);
+ raw_dex_file.dexReadClassDataMethod(&class_data, &raw_method, &last_idx);
Method* meth = AllocMethod();
klass->virtual_methods_[i] = meth;
- LoadMethod(klass, raw_method, meth);
+ LoadMethod(raw_dex_file, raw_method, klass, meth);
// TODO: register maps
}
}
}
-void ClassLinker::LoadInterfaces(const RawDexFile::ClassDef& class_def,
+void ClassLinker::LoadInterfaces(const RawDexFile& raw_dex_file,
+ const RawDexFile::ClassDef& class_def,
Class* klass) {
- const RawDexFile* raw = klass->GetDexFile()->GetRaw();
- const RawDexFile::TypeList* list = raw->GetInterfacesList(class_def);
+ const RawDexFile::TypeList* list = raw_dex_file.GetInterfacesList(class_def);
if (list != NULL) {
klass->interface_count_ = list->Size();
// TODO: allocate the interfaces array on the object heap.
@@ -302,29 +329,31 @@
}
}
-void ClassLinker::LoadField(Class* klass, const RawDexFile::Field& src,
+void ClassLinker::LoadField(const RawDexFile& raw_dex_file,
+ const RawDexFile::Field& src,
+ Class* klass,
Field* dst) {
- const RawDexFile* raw = klass->GetDexFile()->GetRaw();
- const RawDexFile::FieldId& field_id = raw->GetFieldId(src.field_idx_);
+ const RawDexFile::FieldId& field_id = raw_dex_file.GetFieldId(src.field_idx_);
dst->klass_ = klass;
- dst->name_ = raw->dexStringById(field_id.name_idx_);
- dst->signature_ = raw->dexStringByTypeIdx(field_id.type_idx_);
+ dst->name_ = raw_dex_file.dexStringById(field_id.name_idx_);
+ dst->signature_ = raw_dex_file.dexStringByTypeIdx(field_id.type_idx_);
dst->access_flags_ = src.access_flags_;
}
-void ClassLinker::LoadMethod(Class* klass, const RawDexFile::Method& src,
+void ClassLinker::LoadMethod(const RawDexFile& raw_dex_file,
+ const RawDexFile::Method& src,
+ Class* klass,
Method* dst) {
- const RawDexFile* raw = klass->GetDexFile()->GetRaw();
- const RawDexFile::MethodId& method_id = raw->GetMethodId(src.method_idx_);
+ const RawDexFile::MethodId& method_id = raw_dex_file.GetMethodId(src.method_idx_);
dst->klass_ = klass;
- dst->name_.set(raw->dexStringById(method_id.name_idx_));
+ dst->name_.set(raw_dex_file.dexStringById(method_id.name_idx_));
dst->proto_idx_ = method_id.proto_idx_;
- dst->shorty_.set(raw->GetShorty(method_id.proto_idx_));
+ dst->shorty_.set(raw_dex_file.GetShorty(method_id.proto_idx_));
dst->access_flags_ = src.access_flags_;
// TODO: check for finalize method
- const RawDexFile::CodeItem* code_item = raw->GetCodeItem(src);
+ const RawDexFile::CodeItem* code_item = raw_dex_file.GetCodeItem(src);
if (code_item != NULL) {
dst->num_registers_ = code_item->registers_size_;
dst->num_ins_ = code_item->ins_size_;
@@ -340,19 +369,53 @@
}
}
-ClassLinker::ClassPathEntry ClassLinker::FindInClassPath(const StringPiece& descriptor) {
- for (size_t i = 0; i != class_path_.size(); ++i) {
- DexFile* dex_file = class_path_[i];
- const RawDexFile::ClassDef* class_def = dex_file->GetRaw()->FindClassDef(descriptor);
+ClassLinker::ClassPathEntry ClassLinker::FindInBootClassPath(const StringPiece& descriptor) {
+ for (size_t i = 0; i != boot_class_path_.size(); ++i) {
+ RawDexFile* raw_dex_file = boot_class_path_[i];
+ const RawDexFile::ClassDef* class_def = raw_dex_file->FindClassDef(descriptor);
if (class_def != NULL) {
- return ClassPathEntry(dex_file, class_def);
+ return ClassPathEntry(raw_dex_file, class_def);
}
}
return ClassPathEntry(NULL, NULL);
}
-void ClassLinker::AppendToClassPath(DexFile* dex_file) {
- class_path_.push_back(dex_file);
+void ClassLinker::AppendToBootClassPath(RawDexFile* raw_dex_file) {
+ boot_class_path_.push_back(raw_dex_file);
+ RegisterDexFile(raw_dex_file);
+}
+
+void ClassLinker::RegisterDexFile(RawDexFile* raw_dex_file) {
+ raw_dex_files_.push_back(raw_dex_file);
+ DexFile* dex_file = AllocDexFile();
+ CHECK(dex_file != NULL);
+ dex_file->Init(AllocObjectArray(raw_dex_file->NumStringIds()),
+ AllocObjectArray(raw_dex_file->NumTypeIds()),
+ AllocObjectArray(raw_dex_file->NumMethodIds()),
+ AllocObjectArray(raw_dex_file->NumFieldIds()));
+ dex_files_.push_back(dex_file);
+}
+
+const RawDexFile* ClassLinker::FindRawDexFile(const DexFile* dex_file) const {
+ CHECK(dex_file != NULL);
+ for (size_t i = 0; i != dex_files_.size(); ++i) {
+ if (dex_files_[i] == dex_file) {
+ return raw_dex_files_[i];
+ }
+ }
+ CHECK(false) << "Could not find RawDexFile";
+ return NULL;
+}
+
+DexFile* ClassLinker::FindDexFile(const RawDexFile* raw_dex_file) const {
+ CHECK(raw_dex_file != NULL);
+ for (size_t i = 0; i != raw_dex_files_.size(); ++i) {
+ if (raw_dex_files_[i] == raw_dex_file) {
+ return dex_files_[i];
+ }
+ }
+ CHECK(false) << "Could not find DexFile";
+ return NULL;
}
Class* ClassLinker::CreatePrimitiveClass(const StringPiece& descriptor) {
@@ -381,7 +444,9 @@
// always comes from the base element class.
//
// Returns NULL with an exception raised on failure.
-Class* ClassLinker::CreateArrayClass(const StringPiece& descriptor, Object* class_loader)
+Class* ClassLinker::CreateArrayClass(const StringPiece& descriptor,
+ Object* class_loader,
+ const RawDexFile* raw_dex_file)
{
CHECK(descriptor[0] == '[');
DCHECK(java_lang_Class_ != NULL);
@@ -392,7 +457,7 @@
int array_rank;
if (descriptor[1] == '[') {
// array of arrays; keep descriptor and grab stuff from parent
- Class* outer = FindClass(descriptor.substr(1), class_loader);
+ Class* outer = FindClass(descriptor.substr(1), class_loader, raw_dex_file);
if (outer != NULL) {
// want the base class, not "outer", in our component_type_
component_type_ = outer->component_type_;
@@ -405,8 +470,7 @@
if (descriptor[1] == 'L') {
// array of objects; strip off "[" and look up descriptor.
const StringPiece subDescriptor = descriptor.substr(1);
- LG << "searching for element class '" << subDescriptor << "'";
- component_type_ = FindClass(subDescriptor, class_loader); // TODO FindClassNoInit
+ component_type_ = FindClass(subDescriptor, class_loader, raw_dex_file);
} else {
// array of a primitive type
component_type_ = FindPrimitiveClass(descriptor[1]);
@@ -474,7 +538,7 @@
// interfaces. We need to set that up here, so that stuff like
// "instanceof" works right.
//
- // Note: The GC could run during the call to FindSystemClassNoInit(),
+ // Note: The GC could run during the call to FindSystemClass,
// so we need to make sure the class object is GC-valid while we're in
// there. Do this by clearing the interface list so the GC will just
// think that the entries are null.
@@ -735,7 +799,7 @@
bool ClassLinker::HasSameMethodDescriptorClasses(const Method* method,
const Class* klass1,
const Class* klass2) {
- const RawDexFile* raw = method->GetClass()->GetDexFile()->GetRaw();
+ const RawDexFile* raw = FindRawDexFile(method->GetClass()->GetDexFile());
const RawDexFile::ProtoId& proto_id = raw->GetProtoId(method->proto_idx_);
RawDexFile::ParameterIterator *it;
for (it = raw->GetParameterIterator(proto_id); it->HasNext(); it->Next()) {
@@ -769,9 +833,9 @@
CHECK(klass1 != NULL);
CHECK(klass2 != NULL);
#if 0
- Class* found1 = FindClassNoInit(descriptor, klass1->GetClassLoader());
+ Class* found1 = FindClass(descriptor, klass1->GetClassLoader());
// TODO: found1 == NULL
- Class* found2 = FindClassNoInit(descriptor, klass2->GetClassLoader());
+ Class* found2 = FindClass(descriptor, klass2->GetClassLoader());
// TODO: found2 == NULL
// TODO: lookup found1 in initiating loader list
if (found1 == NULL || found2 == NULL) {
@@ -786,6 +850,44 @@
return true;
}
+bool ClassLinker::HasSameArgumentTypes(const Method* m1, const Method* m2) const {
+ const RawDexFile* raw1 = FindRawDexFile(m1->GetClass()->GetDexFile());
+ const RawDexFile* raw2 = FindRawDexFile(m2->GetClass()->GetDexFile());
+ const RawDexFile::ProtoId& proto1 = raw1->GetProtoId(m1->proto_idx_);
+ const RawDexFile::ProtoId& proto2 = raw2->GetProtoId(m2->proto_idx_);
+
+ // TODO: compare ProtoId objects for equality and exit early
+ const RawDexFile::TypeList* type_list1 = raw1->GetProtoParameters(proto1);
+ const RawDexFile::TypeList* type_list2 = raw2->GetProtoParameters(proto2);
+ size_t arity1 = (type_list1 == NULL) ? 0 : type_list1->Size();
+ size_t arity2 = (type_list2 == NULL) ? 0 : type_list2->Size();
+ if (arity1 != arity2) {
+ return false;
+ }
+
+ for (size_t i = 0; i < arity1; ++i) {
+ uint32_t type_idx1 = type_list1->GetTypeItem(i).type_idx_;
+ uint32_t type_idx2 = type_list2->GetTypeItem(i).type_idx_;
+ const char* type1 = raw1->dexStringByTypeIdx(type_idx1);
+ const char* type2 = raw2->dexStringByTypeIdx(type_idx2);
+ if (strcmp(type1, type2) != 0) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool ClassLinker::HasSameReturnType(const Method* m1, const Method* m2) const {
+ const RawDexFile* raw1 = FindRawDexFile(m1->GetClass()->GetDexFile());
+ const RawDexFile* raw2 = FindRawDexFile(m2->GetClass()->GetDexFile());
+ const RawDexFile::ProtoId& proto1 = raw1->GetProtoId(m1->proto_idx_);
+ const RawDexFile::ProtoId& proto2 = raw2->GetProtoId(m2->proto_idx_);
+ const char* type1 = raw1->dexStringByTypeIdx(proto1.return_type_idx_);
+ const char* type2 = raw2->dexStringByTypeIdx(proto2.return_type_idx_);
+ return (strcmp(type1, type2) == 0);
+}
+
bool ClassLinker::InitializeSuperClass(Class* klass) {
CHECK(klass != NULL);
// TODO: assert klass lock is acquired
@@ -817,7 +919,7 @@
return;
}
const StringPiece& descriptor = klass->GetDescriptor();
- const RawDexFile* raw = dex_file->GetRaw();
+ const RawDexFile* raw = FindRawDexFile(dex_file);
const RawDexFile::ClassDef* class_def = raw->FindClassDef(descriptor);
CHECK(class_def != NULL);
const byte* addr = raw->GetEncodedArray(*class_def);
@@ -866,11 +968,11 @@
}
}
-bool ClassLinker::LinkClass(Class* klass) {
+bool ClassLinker::LinkClass(Class* klass, const RawDexFile* raw_dex_file) {
CHECK(klass->status_ == Class::kStatusIdx ||
klass->status_ == Class::kStatusLoaded);
if (klass->status_ == Class::kStatusIdx) {
- if (!LinkInterfaces(klass)) {
+ if (!LinkInterfaces(klass, raw_dex_file)) {
return false;
}
}
@@ -889,7 +991,7 @@
return true;
}
-bool ClassLinker::LinkInterfaces(Class* klass) {
+bool ClassLinker::LinkInterfaces(Class* klass, const RawDexFile* raw_dex_file) {
scoped_array<uint32_t> interfaces_idx;
// TODO: store interfaces_idx in the Class object
// TODO: move this outside of link interfaces
@@ -902,7 +1004,7 @@
// Mark the class as loaded.
klass->status_ = Class::kStatusLoaded;
if (klass->super_class_idx_ != RawDexFile::kDexNoIndex) {
- Class* super_class = ResolveClass(klass, klass->super_class_idx_);
+ Class* super_class = ResolveClass(klass, klass->super_class_idx_, raw_dex_file);
if (super_class == NULL) {
LG << "Failed to resolve superclass";
return false;
@@ -912,7 +1014,7 @@
if (klass->interface_count_ > 0) {
for (size_t i = 0; i < klass->interface_count_; ++i) {
uint32_t idx = interfaces_idx[i];
- klass->interfaces_[i] = ResolveClass(klass, idx);
+ klass->interfaces_[i] = ResolveClass(klass, idx, raw_dex_file);
if (klass->interfaces_[i] == NULL) {
LG << "Failed to resolve interface";
return false;
@@ -1004,7 +1106,7 @@
size_t j = 0;
for (; j < klass->GetSuperClass()->vtable_count_; ++j) {
const Method* super_method = klass->vtable_[j];
- if (local_method->HasSameNameAndPrototype(super_method)) {
+ if (HasSameNameAndPrototype(local_method, super_method)) {
// Verify
if (super_method->IsFinal()) {
LG << "Method overrides final method"; // TODO: VirtualMachineError
@@ -1115,7 +1217,7 @@
Method* interface_method = interface->GetVirtualMethod(j);
int k; // must be signed
for (k = klass->vtable_count_ - 1; k >= 0; --k) {
- if (interface_method->HasSameNameAndPrototype(klass->vtable_[k])) {
+ if (HasSameNameAndPrototype(interface_method, klass->vtable_[k])) {
if (!klass->vtable_[k]->IsPublic()) {
LG << "Implementation not public";
return false;
@@ -1135,7 +1237,7 @@
}
int mir;
for (mir = 0; mir < miranda_count; mir++) {
- if (miranda_list[mir]->HasSameNameAndPrototype(interface_method)) {
+ if (HasSameNameAndPrototype(miranda_list[mir], interface_method)) {
break;
}
}
@@ -1349,17 +1451,19 @@
}
}
-Class* ClassLinker::ResolveClass(const Class* referrer, uint32_t class_idx) {
+Class* ClassLinker::ResolveClass(const Class* referrer,
+ uint32_t class_idx,
+ const RawDexFile* raw_dex_file) {
DexFile* dex_file = referrer->GetDexFile();
Class* resolved = dex_file->GetResolvedClass(class_idx);
if (resolved != NULL) {
return resolved;
}
- const char* descriptor = dex_file->GetRaw()->dexStringByTypeIdx(class_idx);
+ const char* descriptor = raw_dex_file->dexStringByTypeIdx(class_idx);
if (descriptor[0] != '\0' && descriptor[1] == '\0') {
resolved = FindPrimitiveClass(descriptor[0]);
} else {
- resolved = FindClass(descriptor, referrer->GetClassLoader());
+ resolved = FindClass(descriptor, referrer->GetClassLoader(), raw_dex_file);
}
if (resolved != NULL) {
Class* check = resolved->IsArray() ? resolved->component_type_ : resolved;
@@ -1369,7 +1473,7 @@
return NULL;
}
}
- dex_file->SetResolvedClass(resolved, class_idx);
+ dex_file->SetResolvedClass(class_idx, resolved);
} else {
DCHECK(Thread::Current()->IsExceptionPending());
}
@@ -1384,14 +1488,14 @@
String* ClassLinker::ResolveString(const Class* referring,
uint32_t string_idx) {
- const RawDexFile* raw = referring->GetDexFile()->GetRaw();
+ const RawDexFile* raw = FindRawDexFile(referring->GetDexFile());
const RawDexFile::StringId& string_id = raw->GetStringId(string_idx);
const char* string_data = raw->GetStringData(string_id);
String* new_string = Heap::AllocStringFromModifiedUtf8(java_lang_String_,
char_array_class_,
string_data);
// TODO: intern the new string
- referring->GetDexFile()->SetResolvedString(new_string, string_idx);
+ referring->GetDexFile()->SetResolvedString(string_idx, new_string);
return new_string;
}
diff --git a/src/class_linker.h b/src/class_linker.h
index 47f8c24..d7bb191 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -7,64 +7,90 @@
#include <utility>
#include <vector>
-#include "src/macros.h"
-#include "src/thread.h"
-#include "src/object.h"
+#include "macros.h"
+#include "raw_dex_file.h"
+#include "thread.h"
+#include "object.h"
+#include "gtest/gtest.h"
namespace art {
class ClassLinker {
public:
// Initializes the class linker.
- static ClassLinker* Create();
+ static ClassLinker* Create(std::vector<RawDexFile*> boot_class_path);
~ClassLinker() {}
+ DexFile* AllocDexFile();
Class* AllocClass(DexFile* dex_file);
StaticField* AllocStaticField();
InstanceField* AllocInstanceField();
Method* AllocMethod();
+ ObjectArray* AllocObjectArray(size_t length);
// Finds a class by its descriptor name.
+ // If raw_dex_file is null, searches boot_class_path_.
Class* FindClass(const StringPiece& descriptor,
- Object* class_loader);
+ Object* class_loader,
+ const RawDexFile* raw_dex_file);
Class* FindSystemClass(const StringPiece& descriptor) {
- return FindClass(descriptor, NULL);
+ return FindClass(descriptor, NULL, NULL);
}
- Class* FindPrimitiveClass(char type);
-
bool InitializeClass(Class* klass);
Class* LookupClass(const StringPiece& descriptor, Object* class_loader);
- Class* ResolveClass(const Class* referring, uint32_t class_idx);
+ Class* ResolveClass(const Class* referring,
+ uint32_t class_idx,
+ const RawDexFile* raw_dex_file);
String* ResolveString(const Class* referring, uint32_t string_idx);
- typedef std::pair<DexFile*, const RawDexFile::ClassDef*> ClassPathEntry;
-
- ClassPathEntry FindInClassPath(const StringPiece& descriptor);
-
- void AppendToClassPath(DexFile* dex_file);
+ void RegisterDexFile(RawDexFile* raw_dex_file);
private:
ClassLinker() {}
- void Init();
+ void Init(std::vector<RawDexFile*> boot_class_path_);
Class* CreatePrimitiveClass(const StringPiece& descriptor);
- Class* CreateArrayClass(const StringPiece& descriptor, Object* class_loader);
+ Class* CreateArrayClass(const StringPiece& descriptor,
+ Object* class_loader,
+ const RawDexFile* raw_dex_file);
- void LoadClass(const RawDexFile::ClassDef& class_def, Class* klass);
+ Class* FindPrimitiveClass(char type);
- void LoadInterfaces(const RawDexFile::ClassDef& class_def, Class *klass);
+ const RawDexFile* FindRawDexFile(const DexFile* dex_file) const;
- void LoadField(Class* klass, const RawDexFile::Field& src, Field* dst);
+ DexFile* FindDexFile(const RawDexFile* raw_dex_file) const;
- void LoadMethod(Class* klass, const RawDexFile::Method& src, Method* dst);
+ typedef std::pair<const RawDexFile*, const RawDexFile::ClassDef*> ClassPathEntry;
+
+ void AppendToBootClassPath(RawDexFile* raw_dex_file);
+
+ ClassPathEntry FindInBootClassPath(const StringPiece& descriptor);
+
+ void LoadClass(const RawDexFile& raw_dex_file,
+ const RawDexFile::ClassDef& class_def,
+ Class* klass);
+
+ void LoadInterfaces(const RawDexFile& raw_dex_file,
+ const RawDexFile::ClassDef& class_def,
+ Class *klass);
+
+ void LoadField(const RawDexFile& raw_dex_file,
+ const RawDexFile::Field& src,
+ Class* klass,
+ Field* dst);
+
+ void LoadMethod(const RawDexFile& raw_dex_file,
+ const RawDexFile::Method& src,
+ Class* klass,
+ Method* dst);
// Inserts a class into the class table. Returns true if the class
// was inserted.
@@ -84,11 +110,27 @@
const Class* klass1,
const Class* klass2);
- bool LinkClass(Class* klass);
+ bool HasSameNameAndPrototype(const Method* m1, const Method* m2) const {
+ return HasSameName(m1, m2) && HasSamePrototype(m1, m2);
+ }
+
+ bool HasSameName(const Method* m1, const Method* m2) const {
+ return m1->GetName() == m2->GetName();
+ }
+
+ bool HasSamePrototype(const Method* m1, const Method* m2) const {
+ return HasSameReturnType(m1, m2) && HasSameArgumentTypes(m1, m2);
+ }
+
+ bool HasSameReturnType(const Method* m1, const Method* m2) const;
+
+ bool HasSameArgumentTypes(const Method* m1, const Method* m2) const;
+
+ bool LinkClass(Class* klass, const RawDexFile* raw_dex_file);
bool LinkSuperClass(Class* klass);
- bool LinkInterfaces(Class* klass);
+ bool LinkInterfaces(Class* klass, const RawDexFile* raw_dex_file);
bool LinkMethods(Class* klass);
@@ -102,7 +144,11 @@
void CreateReferenceOffsets(Class* klass);
- std::vector<DexFile*> class_path_;
+ std::vector<RawDexFile*> boot_class_path_;
+
+ std::vector<RawDexFile*> raw_dex_files_;
+
+ std::vector<DexFile*> dex_files_;
// TODO: multimap
typedef std::map<const StringPiece, Class*> Table;
@@ -131,8 +177,11 @@
Class* primitive_long_;
Class* primitive_void_;
+ Class* object_array_class_;
Class* char_array_class_;
+ FRIEND_TEST(ClassLinkerTest, ProtoCompare);
+ FRIEND_TEST(ClassLinkerTest, ProtoCompare2);
DISALLOW_COPY_AND_ASSIGN(ClassLinker);
};
diff --git a/src/class_linker_test.cc b/src/class_linker_test.cc
index 888ef12..a128445 100644
--- a/src/class_linker_test.cc
+++ b/src/class_linker_test.cc
@@ -1,132 +1,116 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/common_test.h"
-#include "src/class_linker.h"
-#include "src/dex_file.h"
-#include "src/heap.h"
+#include "common_test.h"
+#include "class_linker.h"
+#include "dex_file.h"
+#include "heap.h"
#include "gtest/gtest.h"
namespace art {
-class ClassLinkerTest : public RuntimeTest {};
+class ClassLinkerTest : public RuntimeTest {
+ protected:
+ void AssertNonExistantClass(const StringPiece& descriptor) {
+ EXPECT_TRUE(class_linker_.get()->FindSystemClass(descriptor) == NULL);
+ }
+
+ void AssertPrimitiveClass(const StringPiece& descriptor) {
+ Class* primitive = class_linker_.get()->FindSystemClass(descriptor);
+ ASSERT_TRUE(primitive != NULL);
+ ASSERT_TRUE(primitive->GetClass() != NULL);
+ ASSERT_EQ(primitive->GetClass(), primitive->GetClass()->GetClass());
+ EXPECT_TRUE(primitive->GetClass()->GetSuperClass() != NULL);
+ ASSERT_EQ(descriptor, primitive->GetDescriptor());
+ EXPECT_TRUE(primitive->GetSuperClass() == NULL);
+ EXPECT_FALSE(primitive->HasSuperClass());
+ EXPECT_TRUE(primitive->GetComponentType() == NULL);
+ EXPECT_TRUE(primitive->GetStatus() == Class::kStatusInitialized);
+ EXPECT_FALSE(primitive->IsErroneous());
+ EXPECT_TRUE(primitive->IsVerified());
+ EXPECT_TRUE(primitive->IsLinked());
+ EXPECT_FALSE(primitive->IsArray());
+ EXPECT_EQ(0, primitive->array_rank_);
+ EXPECT_FALSE(primitive->IsInterface());
+ EXPECT_TRUE(primitive->IsPublic());
+ EXPECT_TRUE(primitive->IsFinal());
+ EXPECT_TRUE(primitive->IsPrimitive());
+ EXPECT_EQ(0U, primitive->NumDirectMethods());
+ EXPECT_EQ(0U, primitive->NumVirtualMethods());
+ EXPECT_EQ(0U, primitive->NumInstanceFields());
+ EXPECT_EQ(0U, primitive->NumStaticFields());
+ EXPECT_EQ(0U, primitive->interface_count_);
+ }
+
+ void AssertArrayClass(const StringPiece& array_descriptor,
+ int32_t array_rank,
+ const StringPiece& component_type) {
+ Class* array = class_linker_.get()->FindSystemClass(array_descriptor);
+ ASSERT_TRUE(array != NULL);
+ ASSERT_TRUE(array->GetClass() != NULL);
+ ASSERT_EQ(array->GetClass(), array->GetClass()->GetClass());
+ EXPECT_TRUE(array->GetClass()->GetSuperClass() != NULL);
+ ASSERT_EQ(array_descriptor, array->GetDescriptor());
+ EXPECT_TRUE(array->GetSuperClass() != NULL);
+ EXPECT_EQ(class_linker_.get()->FindSystemClass("Ljava/lang/Object;"), array->GetSuperClass());
+ EXPECT_TRUE(array->HasSuperClass());
+ ASSERT_TRUE(array->GetComponentType() != NULL);
+ ASSERT_TRUE(array->GetComponentType()->GetDescriptor() != NULL);
+ EXPECT_EQ(component_type, array->GetComponentType()->GetDescriptor());
+ EXPECT_TRUE(array->GetStatus() == Class::kStatusInitialized);
+ EXPECT_FALSE(array->IsErroneous());
+ EXPECT_TRUE(array->IsVerified());
+ EXPECT_TRUE(array->IsLinked());
+ EXPECT_TRUE(array->IsArray());
+ EXPECT_EQ(array_rank, array->array_rank_);
+ EXPECT_FALSE(array->IsInterface());
+ EXPECT_EQ(array->GetComponentType()->IsPublic(), array->IsPublic());
+ EXPECT_TRUE(array->IsFinal());
+ EXPECT_FALSE(array->IsPrimitive());
+ EXPECT_EQ(0U, array->NumDirectMethods());
+ EXPECT_EQ(0U, array->NumVirtualMethods());
+ EXPECT_EQ(0U, array->NumInstanceFields());
+ EXPECT_EQ(0U, array->NumStaticFields());
+ EXPECT_EQ(2U, array->interface_count_);
+ }
+};
TEST_F(ClassLinkerTest, FindClassNonexistent) {
- scoped_ptr<DexFile> dex(OpenDexFileBase64(kMyClassDex));
- ASSERT_TRUE(dex != NULL);
-
- scoped_ptr<ClassLinker> linker(ClassLinker::Create());
- linker->AppendToClassPath(dex.get());
-
- Class* result1 = linker.get()->FindClass("NoSuchClass;", NULL);
+ Class* result1 = class_linker_.get()->FindSystemClass("NoSuchClass;");
EXPECT_TRUE(result1 == NULL);
- Class* result2 = linker.get()->FindClass("LNoSuchClass;", NULL);
+ Class* result2 = class_linker_.get()->FindSystemClass("LNoSuchClass;");
EXPECT_TRUE(result2 == NULL);
}
TEST_F(ClassLinkerTest, FindClassNested) {
- scoped_ptr<DexFile> objectDex(OpenDexFileBase64(kJavaLangDex));
- ASSERT_TRUE(objectDex != NULL);
- scoped_ptr<DexFile> nestedDex(OpenDexFileBase64(kNestedDex));
- ASSERT_TRUE(nestedDex != NULL);
+ scoped_ptr<RawDexFile> nestedDex(OpenRawDexFileBase64(kNestedDex));
+ class_linker_.get()->RegisterDexFile(nestedDex.get());
- scoped_ptr<ClassLinker> linker(ClassLinker::Create());
- linker->AppendToClassPath(objectDex.get());
- linker->AppendToClassPath(nestedDex.get());
-
- Class* outer = linker.get()->FindClass("LNested;", NULL);
+ Class* outer = class_linker_.get()->FindClass("LNested;", NULL, nestedDex.get());
ASSERT_TRUE(outer != NULL);
EXPECT_EQ(0U, outer->NumVirtualMethods());
EXPECT_EQ(1U, outer->NumDirectMethods());
- Class* inner = linker.get()->FindClass("LNested$Inner;", NULL);
+ Class* inner = class_linker_.get()->FindClass("LNested$Inner;", NULL, nestedDex.get());
ASSERT_TRUE(inner != NULL);
EXPECT_EQ(0U, inner->NumVirtualMethods());
EXPECT_EQ(1U, inner->NumDirectMethods());
}
-static void AssertNonExistantClass(ClassLinker* linker, const StringPiece& descriptor) {
- EXPECT_TRUE(linker->FindClass(descriptor, NULL) == NULL);
-}
-
-static void AssertPrimitiveClass(ClassLinker* linker, const StringPiece& descriptor) {
- Class* primitive = linker->FindClass(descriptor, NULL);
- ASSERT_TRUE(primitive != NULL);
- ASSERT_TRUE(primitive->GetClass() != NULL);
- ASSERT_EQ(primitive->GetClass(), primitive->GetClass()->GetClass());
- EXPECT_TRUE(primitive->GetClass()->GetSuperClass() != NULL);
- ASSERT_EQ(descriptor, primitive->GetDescriptor());
- EXPECT_TRUE(primitive->GetSuperClass() == NULL);
- EXPECT_FALSE(primitive->HasSuperClass());
- EXPECT_TRUE(primitive->GetComponentType() == NULL);
- EXPECT_TRUE(primitive->GetStatus() == Class::kStatusInitialized);
- EXPECT_FALSE(primitive->IsErroneous());
- EXPECT_TRUE(primitive->IsVerified());
- EXPECT_TRUE(primitive->IsLinked());
- EXPECT_FALSE(primitive->IsArray());
- EXPECT_EQ(0, primitive->array_rank_);
- EXPECT_FALSE(primitive->IsInterface());
- EXPECT_TRUE(primitive->IsPublic());
- EXPECT_TRUE(primitive->IsFinal());
- EXPECT_TRUE(primitive->IsPrimitive());
- EXPECT_EQ(0U, primitive->NumDirectMethods());
- EXPECT_EQ(0U, primitive->NumVirtualMethods());
- EXPECT_EQ(0U, primitive->NumInstanceFields());
- EXPECT_EQ(0U, primitive->NumStaticFields());
- EXPECT_EQ(0U, primitive->interface_count_);
-}
-
-static void AssertArrayClass(ClassLinker* linker,
- const StringPiece& array_descriptor,
- int32_t array_rank,
- const StringPiece& component_type) {
- Class* array = linker->FindClass(array_descriptor, NULL);
- ASSERT_TRUE(array != NULL);
- ASSERT_TRUE(array->GetClass() != NULL);
- ASSERT_EQ(array->GetClass(), array->GetClass()->GetClass());
- EXPECT_TRUE(array->GetClass()->GetSuperClass() != NULL);
- ASSERT_EQ(array_descriptor, array->GetDescriptor());
- EXPECT_TRUE(array->GetSuperClass() != NULL);
- EXPECT_EQ(linker->FindSystemClass("Ljava/lang/Object;"), array->GetSuperClass());
- EXPECT_TRUE(array->HasSuperClass());
- ASSERT_TRUE(array->GetComponentType() != NULL);
- ASSERT_TRUE(array->GetComponentType()->GetDescriptor() != NULL);
- EXPECT_EQ(component_type, array->GetComponentType()->GetDescriptor());
- EXPECT_TRUE(array->GetStatus() == Class::kStatusInitialized);
- EXPECT_FALSE(array->IsErroneous());
- EXPECT_TRUE(array->IsVerified());
- EXPECT_TRUE(array->IsLinked());
- EXPECT_TRUE(array->IsArray());
- EXPECT_EQ(array_rank, array->array_rank_);
- EXPECT_FALSE(array->IsInterface());
- EXPECT_EQ(array->GetComponentType()->IsPublic(), array->IsPublic());
- EXPECT_TRUE(array->IsFinal());
- EXPECT_FALSE(array->IsPrimitive());
- EXPECT_EQ(0U, array->NumDirectMethods());
- EXPECT_EQ(0U, array->NumVirtualMethods());
- EXPECT_EQ(0U, array->NumInstanceFields());
- EXPECT_EQ(0U, array->NumStaticFields());
- EXPECT_EQ(2U, array->interface_count_);
-}
-
TEST_F(ClassLinkerTest, FindClass) {
- scoped_ptr<ClassLinker> linker(ClassLinker::Create());
+ ClassLinker* linker = class_linker_.get();
StringPiece 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) {
- AssertNonExistantClass(linker.get(), descriptor);
+ AssertNonExistantClass(descriptor);
} else {
- AssertPrimitiveClass(linker.get(), descriptor);
+ AssertPrimitiveClass(descriptor);
}
}
- scoped_ptr<DexFile> dex(OpenDexFileBase64(kMyClassDex));
- ASSERT_TRUE(dex != NULL);
- linker->AppendToClassPath(dex.get());
-
- Class* JavaLangObject = linker->FindClass("Ljava/lang/Object;", NULL);
+ Class* JavaLangObject = linker->FindSystemClass("Ljava/lang/Object;");
ASSERT_TRUE(JavaLangObject != NULL);
ASSERT_TRUE(JavaLangObject->GetClass() != NULL);
ASSERT_EQ(JavaLangObject->GetClass(), JavaLangObject->GetClass()->GetClass());
@@ -151,7 +135,10 @@
EXPECT_EQ(0U, JavaLangObject->interface_count_);
- Class* MyClass = linker->FindClass("LMyClass;", NULL);
+ scoped_ptr<RawDexFile> dex(OpenRawDexFileBase64(kMyClassDex));
+ linker->RegisterDexFile(dex.get());
+ EXPECT_TRUE(linker->FindSystemClass("LMyClass;") == NULL);
+ Class* MyClass = linker->FindClass("LMyClass;", NULL, dex.get());
ASSERT_TRUE(MyClass != NULL);
ASSERT_TRUE(MyClass->GetClass() != NULL);
ASSERT_EQ(MyClass->GetClass(), MyClass->GetClass()->GetClass());
@@ -179,12 +166,111 @@
EXPECT_EQ(JavaLangObject->GetClass()->GetClass(), MyClass->GetClass()->GetClass());
// created by class_linker
- AssertArrayClass(linker.get(), "[C", 1, "C");
+ AssertArrayClass("[C", 1, "C");
+ AssertArrayClass("[Ljava/lang/Object;", 1, "Ljava/lang/Object;");
// synthesized on the fly
- AssertArrayClass(linker.get(), "[[C", 2, "C");
- AssertArrayClass(linker.get(), "[[[LMyClass;", 3, "LMyClass;");
+ AssertArrayClass("[[C", 2, "C");
+ AssertArrayClass("[[[LMyClass;", 3, "LMyClass;");
// or not available at all
- AssertNonExistantClass(linker.get(), "[[[[LNonExistantClass;");
+ AssertNonExistantClass("[[[[LNonExistantClass;");
+}
+
+TEST_F(ClassLinkerTest, ProtoCompare) {
+ ClassLinker* linker = class_linker_.get();
+
+ scoped_ptr<RawDexFile> proto_dex_file(OpenRawDexFileBase64(kProtoCompareDex));
+ linker->RegisterDexFile(proto_dex_file.get());
+
+ Class* klass = linker->FindClass("LProtoCompare;", NULL, proto_dex_file.get());
+ ASSERT_TRUE(klass != NULL);
+
+ ASSERT_EQ(4U, klass->NumVirtualMethods());
+
+ Method* m1 = klass->GetVirtualMethod(0);
+ ASSERT_EQ("m1", m1->GetName());
+
+ Method* m2 = klass->GetVirtualMethod(1);
+ ASSERT_EQ("m2", m2->GetName());
+
+ Method* m3 = klass->GetVirtualMethod(2);
+ ASSERT_EQ("m3", m3->GetName());
+
+ Method* m4 = klass->GetVirtualMethod(3);
+ ASSERT_EQ("m4", m4->GetName());
+
+ EXPECT_TRUE(linker->HasSameReturnType(m1, m2));
+ EXPECT_TRUE(linker->HasSameReturnType(m2, m1));
+
+ EXPECT_TRUE(linker->HasSameReturnType(m1, m2));
+ EXPECT_TRUE(linker->HasSameReturnType(m2, m1));
+
+ EXPECT_FALSE(linker->HasSameReturnType(m1, m4));
+ EXPECT_FALSE(linker->HasSameReturnType(m4, m1));
+
+ EXPECT_TRUE(linker->HasSameArgumentTypes(m1, m2));
+ EXPECT_TRUE(linker->HasSameArgumentTypes(m2, m1));
+
+ EXPECT_FALSE(linker->HasSameArgumentTypes(m1, m3));
+ EXPECT_FALSE(linker->HasSameArgumentTypes(m3, m1));
+
+ EXPECT_FALSE(linker->HasSameArgumentTypes(m1, m4));
+ EXPECT_FALSE(linker->HasSameArgumentTypes(m4, m1));
+
+ EXPECT_TRUE(linker->HasSamePrototype(m1, m2));
+ EXPECT_TRUE(linker->HasSamePrototype(m2, m1));
+
+ EXPECT_FALSE(linker->HasSamePrototype(m1, m3));
+ EXPECT_FALSE(linker->HasSamePrototype(m3, m1));
+
+ EXPECT_FALSE(linker->HasSamePrototype(m3, m4));
+ EXPECT_FALSE(linker->HasSamePrototype(m4, m3));
+
+ EXPECT_FALSE(linker->HasSameName(m1, m2));
+ EXPECT_FALSE(linker->HasSameNameAndPrototype(m1, m2));
+}
+
+TEST_F(ClassLinkerTest, ProtoCompare2) {
+ ClassLinker* linker = class_linker_.get();
+
+ scoped_ptr<RawDexFile> proto1_dex_file(OpenRawDexFileBase64(kProtoCompareDex));
+ linker->RegisterDexFile(proto1_dex_file.get());
+ scoped_ptr<RawDexFile> proto2_dex_file(OpenRawDexFileBase64(kProtoCompare2Dex));
+ linker->RegisterDexFile(proto2_dex_file.get());
+
+ Class* klass1 = linker->FindClass("LProtoCompare;", NULL, proto1_dex_file.get());
+ ASSERT_TRUE(klass1 != NULL);
+ Class* klass2 = linker->FindClass("LProtoCompare2;", NULL, proto2_dex_file.get());
+ ASSERT_TRUE(klass2 != NULL);
+
+ Method* m1_1 = klass1->GetVirtualMethod(0);
+ ASSERT_EQ("m1", m1_1->GetName());
+ Method* m2_1 = klass1->GetVirtualMethod(1);
+ ASSERT_EQ("m2", m2_1->GetName());
+ Method* m3_1 = klass1->GetVirtualMethod(2);
+ ASSERT_EQ("m3", m3_1->GetName());
+ Method* m4_1 = klass1->GetVirtualMethod(3);
+ ASSERT_EQ("m4", m4_1->GetName());
+
+ Method* m1_2 = klass2->GetVirtualMethod(0);
+ ASSERT_EQ("m1", m1_2->GetName());
+ Method* m2_2 = klass2->GetVirtualMethod(1);
+ ASSERT_EQ("m2", m2_2->GetName());
+ Method* m3_2 = klass2->GetVirtualMethod(2);
+ ASSERT_EQ("m3", m3_2->GetName());
+ Method* m4_2 = klass2->GetVirtualMethod(3);
+ ASSERT_EQ("m4", m4_2->GetName());
+
+ EXPECT_TRUE(linker->HasSameNameAndPrototype(m1_1, m1_2));
+ EXPECT_TRUE(linker->HasSameNameAndPrototype(m1_2, m1_1));
+
+ EXPECT_TRUE(linker->HasSameNameAndPrototype(m2_1, m2_2));
+ EXPECT_TRUE(linker->HasSameNameAndPrototype(m2_2, m2_1));
+
+ EXPECT_TRUE(linker->HasSameNameAndPrototype(m3_1, m3_2));
+ EXPECT_TRUE(linker->HasSameNameAndPrototype(m3_2, m3_1));
+
+ EXPECT_TRUE(linker->HasSameNameAndPrototype(m4_1, m4_2));
+ EXPECT_TRUE(linker->HasSameNameAndPrototype(m4_2, m4_1));
}
} // namespace art
diff --git a/src/common_test.h b/src/common_test.h
index bb82d19..26a4348 100644
--- a/src/common_test.h
+++ b/src/common_test.h
@@ -1,41 +1,15 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/base64.h"
-#include "src/heap.h"
-#include "src/thread.h"
-#include "src/dex_file.h"
+#include "base64.h"
+#include "heap.h"
+#include "thread.h"
+#include "class_linker.h"
+#include "dex_file.h"
#include "gtest/gtest.h"
namespace art {
-static inline RawDexFile* OpenRawDexFileBase64(const char* base64) {
- CHECK(base64 != NULL);
- size_t length;
- byte* dex_file = DecodeBase64(base64, &length);
- if (dex_file == NULL) {
- return NULL;
- }
- return RawDexFile::OpenPtr(dex_file, length);
-}
-
-static inline DexFile* OpenDexFileBase64(const char* base64) {
- return DexFile::Open(OpenRawDexFileBase64(base64));
-}
-
-class RuntimeTest : public testing::Test {
- protected:
- virtual void SetUp() {
- ASSERT_TRUE(Thread::Init());
- ASSERT_TRUE(Thread::Attach() != NULL);
- ASSERT_TRUE(Heap::Init());
- }
-
- virtual void TearDown() {
- Heap::Destroy();
- }
-};
-
// package java.lang;
// public class Object {}
//
@@ -171,4 +145,38 @@
"AAAACQAAAAwBAAAGAAAAAgAAAFQBAAABIAAAAgAAAJQBAAABEAAABAAAAMABAAACIAAAEwAAAOIB"
"AAADIAAAAgAAAHUCAAAAIAAAAgAAAH8CAAAAEAAAAQAAALACAAA=";
+static inline RawDexFile* OpenRawDexFileBase64(const char* base64) {
+ CHECK(base64 != NULL);
+ size_t length;
+ byte* dex_file = DecodeBase64(base64, &length);
+ CHECK(dex_file != NULL);
+ RawDexFile* raw_dex_file = RawDexFile::OpenPtr(dex_file, length);
+ CHECK(raw_dex_file != NULL);
+ return raw_dex_file;
+}
+
+class RuntimeTest : public testing::Test {
+ protected:
+ virtual void SetUp() {
+ ASSERT_TRUE(Thread::Init());
+ ASSERT_TRUE(Thread::Attach() != NULL);
+ ASSERT_TRUE(Heap::Init());
+
+ java_lang_raw_dex_file_.reset(OpenRawDexFileBase64(kJavaLangDex));
+
+ std::vector<RawDexFile*> boot_class_path;
+ boot_class_path.push_back(java_lang_raw_dex_file_.get());
+
+ class_linker_.reset(ClassLinker::Create(boot_class_path));
+ CHECK(class_linker_ != NULL);
+ }
+
+ virtual void TearDown() {
+ Heap::Destroy();
+ }
+
+ scoped_ptr<RawDexFile> java_lang_raw_dex_file_;
+ scoped_ptr<ClassLinker> class_linker_;
+};
+
} // namespace art
diff --git a/src/constants.h b/src/constants.h
index 22a4043..2dd13b7 100644
--- a/src/constants.h
+++ b/src/constants.h
@@ -4,9 +4,9 @@
#define ART_SRC_CONSTANTS_H_
#if defined(__i386__)
-#include "src/constants_x86.h"
+#include "constants_x86.h"
#elif defined(__arm__)
-#include "src/constants_arm.h"
+#include "constants_arm.h"
#endif
#endif // ART_SRC_CONSTANTS_H_
diff --git a/src/constants_arm.h b/src/constants_arm.h
index c2aed30..2d2acb7 100644
--- a/src/constants_arm.h
+++ b/src/constants_arm.h
@@ -5,9 +5,9 @@
#include <stdint.h>
#include <iosfwd>
-#include "src/casts.h"
-#include "src/globals.h"
-#include "src/logging.h"
+#include "casts.h"
+#include "globals.h"
+#include "logging.h"
namespace art {
diff --git a/src/constants_x86.h b/src/constants_x86.h
index c7457c9..391d078 100644
--- a/src/constants_x86.h
+++ b/src/constants_x86.h
@@ -4,9 +4,9 @@
#define ART_SRC_CONSTANTS_X86_H_
#include <iosfwd>
-#include "src/globals.h"
-#include "src/logging.h"
-#include "src/macros.h"
+#include "globals.h"
+#include "logging.h"
+#include "macros.h"
namespace art {
diff --git a/src/dex_file.cc b/src/dex_file.cc
index 6cb8258..e3c8fa0 100644
--- a/src/dex_file.cc
+++ b/src/dex_file.cc
@@ -1,47 +1,19 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/dex_file.h"
-#include "src/heap.h"
-#include "src/globals.h"
-#include "src/logging.h"
-#include "src/object.h"
-#include "src/raw_dex_file.h"
+#include "dex_file.h"
+#include "heap.h"
+#include "globals.h"
+#include "logging.h"
+#include "object.h"
+#include "raw_dex_file.h"
namespace art {
-DexFile* DexFile::OpenFile(const char* filename) {
- RawDexFile* raw = RawDexFile::OpenFile(filename);
- return Open(raw);
-}
-
-DexFile* DexFile::Open(RawDexFile* raw) {
- if (raw == NULL) {
- return NULL;
- }
- DexFile* dex_file = new DexFile(raw);
- dex_file->Init();
- return dex_file;
-}
-
-DexFile::~DexFile() {
- delete[] strings_;
- delete[] classes_;
- delete[] methods_;
- delete[] fields_;
-}
-
-void DexFile::Init() {
- num_strings_ = raw_->NumStringIds();
- strings_ = new String*[num_strings_]();
-
- num_classes_ = raw_->NumTypeIds();
- classes_ = new Class*[num_classes_]();
-
- num_methods_ = raw_->NumMethodIds();
- methods_ = new Method*[num_methods_]();
-
- num_fields_ = raw_->NumFieldIds();
- fields_ = new Field*[num_fields_]();
+void DexFile::Init(ObjectArray* strings, ObjectArray* classes, ObjectArray* methods, ObjectArray* fields) {
+ Set(kStrings, strings);
+ Set(kClasses, classes);
+ Set(kMethods, methods);
+ Set(kFields, fields);
}
} // namespace art
diff --git a/src/dex_file.h b/src/dex_file.h
index 1f4afa3..6339317 100644
--- a/src/dex_file.h
+++ b/src/dex_file.h
@@ -3,9 +3,9 @@
#ifndef ART_SRC_DEX_FILE_H_
#define ART_SRC_DEX_FILE_H_
-#include "src/globals.h"
-#include "src/macros.h"
-#include "src/raw_dex_file.h"
+#include "globals.h"
+#include "macros.h"
+#include "object.h"
namespace art {
@@ -15,82 +15,81 @@
class String;
union JValue;
-class DexFile {
+class DexFile : public ObjectArray {
public:
- // Opens a .dex file from the file system. Returns NULL on failure.
- static DexFile* OpenFile(const char* filename);
- // Opens a .dex file from a RawDexFile. Takes ownership of the
- // RawDexFile.
- static DexFile* Open(RawDexFile* raw);
+ enum ArrayIndexes {
+ kStrings = 0,
+ kClasses = 1,
+ kMethods = 2,
+ kFields = 3,
+ kMax = 4,
+ };
- // Close and deallocate.
- ~DexFile();
+ void Init(ObjectArray* strings, ObjectArray* classes, ObjectArray* methods, ObjectArray* fields);
- size_t NumTypes() const {
- return num_classes_;
+ size_t NumStrings() const {
+ return GetStrings()->GetLength();
+ }
+
+ size_t NumClasses() const {
+ return GetClasses()->GetLength();
}
size_t NumMethods() const {
- return num_methods_;
+ return GetMethods()->GetLength();
}
- bool HasClass(const StringPiece& descriptor) {
- return raw_->FindClassDef(descriptor) != NULL;
- }
-
- RawDexFile* GetRaw() const {
- return raw_.get();
+ size_t NumFields() const {
+ return GetFields()->GetLength();
}
String* GetResolvedString(uint32_t string_idx) const {
- CHECK_LT(string_idx, num_strings_);
- return strings_[string_idx];
+ return down_cast<String*>(GetStrings()->Get(string_idx));
}
- void SetResolvedString(String* resolved, uint32_t string_idx) {
- CHECK_LT(string_idx, num_strings_);
- strings_[string_idx] = resolved;
+ void SetResolvedString(uint32_t string_idx, String* resolved) {
+ GetStrings()->Set(string_idx, resolved);
}
Class* GetResolvedClass(uint32_t class_idx) const {
- CHECK_LT(class_idx, num_classes_);
- return classes_[class_idx];
+ return down_cast<Class*>(GetClasses()->Get(class_idx));
}
- void SetResolvedClass(Class* resolved, uint32_t class_idx) {
- CHECK_LT(class_idx, num_classes_);
- classes_[class_idx] = resolved;
+ void SetResolvedClass(uint32_t class_idx, Class* resolved) {
+ GetClasses()->Set(class_idx, resolved);
+ }
+
+ Method* GetResolvedMethod(uint32_t method_idx) const {
+ return down_cast<Method*>(GetMethods()->Get(method_idx));
+ }
+
+ void SetResolvedMethod(uint32_t method_idx, Method* resolved) {
+ GetMethods()->Set(method_idx, resolved);
+ }
+
+ Field* GetResolvedField(uint32_t field_idx) const {
+ return down_cast<Field*>(GetFields()->Get(field_idx));
+ }
+
+ void SetResolvedfield(uint32_t field_idx, Field* resolved) {
+ GetFields()->Set(field_idx, resolved);
}
private:
- DexFile(RawDexFile* raw) : raw_(raw) {};
-
- void Init();
-
- // Table of contents for interned String objects.
- String** strings_;
- size_t num_strings_;
-
- // Table of contents for Class objects.
- Class** classes_;
- size_t num_classes_;
-
- // Table of contents for methods.
- Method** methods_;
- size_t num_methods_;
-
- // Table of contents for fields.
- Field** fields_;
- size_t num_fields_;
-
- // The size of the DEX file, in bytes.
- size_t length_;
-
- // The underlying dex file.
- scoped_ptr<RawDexFile> raw_;
-
- DISALLOW_COPY_AND_ASSIGN(DexFile);
+ ObjectArray* GetStrings() const {
+ return down_cast<ObjectArray*>(Get(kStrings));
+ }
+ ObjectArray* GetClasses() const {
+ return down_cast<ObjectArray*>(Get(kClasses));
+ }
+ ObjectArray* GetMethods() const {
+ return down_cast<ObjectArray*>(Get(kMethods));
+ }
+ ObjectArray* GetFields() const {
+ return down_cast<ObjectArray*>(Get(kFields));
+ }
+ DexFile();
};
} // namespace art
diff --git a/src/dex_file_test.cc b/src/dex_file_test.cc
index 561c740..0ad0b3b 100644
--- a/src/dex_file_test.cc
+++ b/src/dex_file_test.cc
@@ -1,18 +1,31 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/common_test.h"
-#include "src/dex_file.h"
-#include "src/object.h"
-#include "src/scoped_ptr.h"
+#include "class_linker.h"
+#include "common_test.h"
+#include "dex_file.h"
+#include "heap.h"
+#include "object.h"
+#include "scoped_ptr.h"
#include <stdio.h>
#include "gtest/gtest.h"
namespace art {
-TEST(DexFileTest, Open) {
- scoped_ptr<DexFile> dex(OpenDexFileBase64(kNestedDex));
- ASSERT_TRUE(dex != NULL);
+class DexFileTest : public RuntimeTest {};
+
+TEST_F(DexFileTest, Open) {
+
+ DexFile* dex_file = down_cast<DexFile*>(class_linker_->AllocObjectArray(DexFile::kMax));
+ ASSERT_TRUE(dex_file != NULL);
+ dex_file->Init(class_linker_->AllocObjectArray(1),
+ class_linker_->AllocObjectArray(2),
+ class_linker_->AllocObjectArray(3),
+ class_linker_->AllocObjectArray(4));
+ EXPECT_EQ(1U, dex_file->NumStrings());
+ EXPECT_EQ(2U, dex_file->NumClasses());
+ EXPECT_EQ(3U, dex_file->NumMethods());
+ EXPECT_EQ(4U, dex_file->NumFields());
}
} // namespace art
diff --git a/src/dex_instruction.cc b/src/dex_instruction.cc
index 37585a6..d753204 100644
--- a/src/dex_instruction.cc
+++ b/src/dex_instruction.cc
@@ -1,12 +1,12 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/dex_instruction.h"
+#include "dex_instruction.h"
namespace art {
const char* const Instruction::kInstructionNames[] = {
#define INSTRUCTION_NAME(o, c, pname, f, r, i, a) pname,
-#include "src/dex_instruction_list.h"
+#include "dex_instruction_list.h"
DEX_INSTRUCTION_LIST(INSTRUCTION_NAME)
#undef DEX_INSTRUCTION_LIST
#undef INSTRUCTION_NAME
@@ -14,7 +14,7 @@
Instruction::InstructionFormat const Instruction::kInstructionFormats[] = {
#define INSTRUCTION_FORMAT(o, c, p, format, r, i, a) format,
-#include "src/dex_instruction_list.h"
+#include "dex_instruction_list.h"
DEX_INSTRUCTION_LIST(INSTRUCTION_FORMAT)
#undef DEX_INSTRUCTION_LIST
#undef INSTRUCTION_FORMAT
@@ -22,7 +22,7 @@
int const Instruction::kInstructionFlags[] = {
#define INSTRUCTION_FLAGS(o, c, p, f, r, i, flags) flags,
-#include "src/dex_instruction_list.h"
+#include "dex_instruction_list.h"
DEX_INSTRUCTION_LIST(INSTRUCTION_FLAGS)
#undef DEX_INSTRUCTION_LIST
#undef INSTRUCTION_FLAGS
diff --git a/src/dex_instruction.h b/src/dex_instruction.h
index f1bb7bf..617f818 100644
--- a/src/dex_instruction.h
+++ b/src/dex_instruction.h
@@ -3,9 +3,9 @@
#ifndef ART_SRC_DEX_INSTRUCTION_H_
#define ART_SRC_DEX_INSTRUCTION_H_
-#include "src/globals.h"
-#include "src/logging.h"
-#include "src/macros.h"
+#include "globals.h"
+#include "logging.h"
+#include "macros.h"
namespace art {
@@ -20,7 +20,7 @@
enum Code {
#define INSTRUCTION_ENUM(opcode, cname, p, f, r, i, a) cname = opcode,
-#include "src/dex_instruction_list.h"
+#include "dex_instruction_list.h"
DEX_INSTRUCTION_LIST(INSTRUCTION_ENUM)
#undef DEX_INSTRUCTION_LIST
#undef INSTRUCTION_ENUM
diff --git a/src/dex_instruction_visitor.h b/src/dex_instruction_visitor.h
index 2af26e3..f7fdf77 100644
--- a/src/dex_instruction_visitor.h
+++ b/src/dex_instruction_visitor.h
@@ -3,8 +3,8 @@
#ifndef ART_SRC_DEX_INSTRUCTION_VISITOR_H_
#define ART_SRC_DEX_INSTRUCTION_VISITOR_H_
-#include "src/dex_instruction.h"
-#include "src/macros.h"
+#include "dex_instruction.h"
+#include "macros.h"
namespace art {
@@ -23,7 +23,7 @@
derived->Do_ ## cname(inst); \
break; \
}
-#include "src/dex_instruction_list.h"
+#include "dex_instruction_list.h"
DEX_INSTRUCTION_LIST(INSTRUCTION_CASE)
#undef DEX_INSTRUCTION_LIST
#undef INSTRUCTION_CASE
@@ -42,7 +42,7 @@
T* derived = static_cast<T*>(this); \
derived->Do_Default(inst); \
};
-#include "src/dex_instruction_list.h"
+#include "dex_instruction_list.h"
DEX_INSTRUCTION_LIST(INSTRUCTION_VISITOR)
#undef DEX_INSTRUCTION_LIST
#undef INSTRUCTION_VISITOR
diff --git a/src/dex_instruction_visitor_test.cc b/src/dex_instruction_visitor_test.cc
index 3889d73..ff24e52 100644
--- a/src/dex_instruction_visitor_test.cc
+++ b/src/dex_instruction_visitor_test.cc
@@ -1,7 +1,7 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/dex_instruction_visitor.h"
-#include "src/scoped_ptr.h"
+#include "dex_instruction_visitor.h"
+#include "scoped_ptr.h"
#include <iostream>
#include "gtest/gtest.h"
diff --git a/src/dex_verifier.cc b/src/dex_verifier.cc
index 53bc305..63f6e8c 100644
--- a/src/dex_verifier.cc
+++ b/src/dex_verifier.cc
@@ -1,6 +1,6 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/dex_verifier.h"
+#include "dex_verifier.h"
#include <iostream>
diff --git a/src/dex_verifier.h b/src/dex_verifier.h
index eb4c6e3..03b2c96 100644
--- a/src/dex_verifier.h
+++ b/src/dex_verifier.h
@@ -3,8 +3,8 @@
#ifndef ART_SRC_DEX_VERIFY_H_
#define ART_SRC_DEX_VERIFY_H_
-#include "src/macros.h"
-#include "src/object.h"
+#include "macros.h"
+#include "object.h"
namespace art {
diff --git a/src/heap.cc b/src/heap.cc
index bbdf80a..3955a31 100644
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -1,9 +1,9 @@
// Copyright 2011 Google Inc. All Rights Reserved.
// Author: cshapiro@google.com (Carl Shapiro)
-#include "src/heap.h"
-#include "src/object.h"
-#include "src/space.h"
+#include "heap.h"
+#include "object.h"
+#include "space.h"
namespace art {
diff --git a/src/heap.h b/src/heap.h
index f35e3f8..3721604 100644
--- a/src/heap.h
+++ b/src/heap.h
@@ -4,10 +4,10 @@
#ifndef ART_SRC_HEAP_H_
#define ART_SRC_HEAP_H_
-#include "src/globals.h"
-#include "src/object.h"
-#include "src/object_bitmap.h"
-#include "src/thread.h"
+#include "globals.h"
+#include "object.h"
+#include "object_bitmap.h"
+#include "thread.h"
namespace art {
@@ -40,13 +40,21 @@
return obj;
}
- static CharArray* AllocCharArray(Class* char_array, size_t length) {
- size_t size = sizeof(Array) + length * sizeof(uint16_t);
- Object* new_array = AllocObject(char_array, size);
- if (new_array != NULL) {
- char_array->klass_ = char_array;
+ static Array* AllocArray(Class* array_class, size_t component_count, size_t component_size) {
+ size_t size = sizeof(Array) + component_count * component_size;
+ Array* array = down_cast<Array*>(AllocObject(array_class, size));
+ if (array != NULL) {
+ array->SetLength(component_count);
}
- return down_cast<CharArray*>(new_array);
+ return array;
+ }
+
+ static ObjectArray* AllocObjectArray(Class* object_array_class, size_t length) {
+ return down_cast<ObjectArray*>(AllocArray(object_array_class, length, sizeof(uint32_t)));
+ }
+
+ static CharArray* AllocCharArray(Class* char_array_class, size_t length) {
+ return down_cast<CharArray*>(AllocArray(char_array_class, length, sizeof(uint16_t)));
}
static String* AllocString(Class* java_lang_String) {
diff --git a/src/jni_compiler.cc b/src/jni_compiler.cc
index a6f5faf..f80e7ad 100644
--- a/src/jni_compiler.cc
+++ b/src/jni_compiler.cc
@@ -1,14 +1,17 @@
// Copyright 2011 Google Inc. All Rights Reserved.
// Author: irogers@google.com (Ian Rogers)
-#include "src/jni_compiler.h"
+
+#include "jni_compiler.h"
+
#include <sys/mman.h>
-#include "src/assembler.h"
-#include "src/calling_convention.h"
-#include "src/jni_internal.h"
-#include "src/macros.h"
-#include "src/managed_register.h"
-#include "src/logging.h"
-#include "src/thread.h"
+
+#include "assembler.h"
+#include "calling_convention.h"
+#include "jni_internal.h"
+#include "macros.h"
+#include "managed_register.h"
+#include "logging.h"
+#include "thread.h"
namespace art {
diff --git a/src/jni_compiler_test.cc b/src/jni_compiler_test.cc
index db8a9e7..c7af269 100644
--- a/src/jni_compiler_test.cc
+++ b/src/jni_compiler_test.cc
@@ -2,22 +2,26 @@
// Author: irogers@google.com (Ian Rogers)
#include <sys/mman.h>
-#include "src/assembler.h"
-#include "src/class_linker.h"
-#include "src/common_test.h"
-#include "src/dex_file.h"
-#include "src/jni_compiler.h"
-#include "src/runtime.h"
-#include "src/thread.h"
+
+#include "assembler.h"
+#include "class_linker.h"
+#include "common_test.h"
+#include "dex_file.h"
+#include "jni_compiler.h"
+#include "runtime.h"
+#include "thread.h"
#include "gtest/gtest.h"
namespace art {
-class JniCompilerTest : public testing::Test {
+class JniCompilerTest : public RuntimeTest {
protected:
virtual void SetUp() {
+ RuntimeTest::SetUp();
// Create runtime and attach thread
- runtime_ = Runtime::Create();
+ std::vector<RawDexFile*> boot_class_path;
+ boot_class_path.push_back(java_lang_raw_dex_file_.get());
+ runtime_ = Runtime::Create(boot_class_path);
CHECK(runtime_->AttachCurrentThread());
// Create thunk code that performs the native to managed transition
thunk_code_size_ = 4096;
@@ -180,10 +184,9 @@
}
TEST_F(JniCompilerTest, CompileAndRunNoArgMethod) {
- scoped_ptr<DexFile> dex(OpenDexFileBase64(kMyClassNativesDex));
- scoped_ptr<ClassLinker> linker(ClassLinker::Create());
- linker->AppendToClassPath(dex.get());
- Class* klass = linker->FindClass("LMyClass;", NULL);
+ scoped_ptr<RawDexFile> dex(OpenRawDexFileBase64(kMyClassNativesDex));
+ class_linker_.get()->RegisterDexFile(dex.get());
+ Class* klass = class_linker_.get()->FindClass("LMyClass;", NULL, dex.get());
Method* method = klass->FindVirtualMethod("foo");
Assembler jni_asm;
@@ -206,10 +209,9 @@
}
TEST_F(JniCompilerTest, CompileAndRunIntMethod) {
- scoped_ptr<DexFile> dex(OpenDexFileBase64(kMyClassNativesDex));
- scoped_ptr<ClassLinker> linker(ClassLinker::Create());
- linker->AppendToClassPath(dex.get());
- Class* klass = linker->FindClass("LMyClass;", NULL);
+ scoped_ptr<RawDexFile> dex(OpenRawDexFileBase64(kMyClassNativesDex));
+ class_linker_.get()->RegisterDexFile(dex.get());
+ Class* klass = class_linker_.get()->FindClass("LMyClass;", NULL, dex.get());
Method* method = klass->FindVirtualMethod("fooI");
Assembler jni_asm;
@@ -234,10 +236,9 @@
}
TEST_F(JniCompilerTest, CompileAndRunIntIntMethod) {
- scoped_ptr<DexFile> dex(OpenDexFileBase64(kMyClassNativesDex));
- scoped_ptr<ClassLinker> linker(ClassLinker::Create());
- linker->AppendToClassPath(dex.get());
- Class* klass = linker->FindClass("LMyClass;", NULL);
+ scoped_ptr<RawDexFile> dex(OpenRawDexFileBase64(kMyClassNativesDex));
+ class_linker_.get()->RegisterDexFile(dex.get());
+ Class* klass = class_linker_.get()->FindClass("LMyClass;", NULL, dex.get());
Method* method = klass->FindVirtualMethod("fooII");
Assembler jni_asm;
@@ -265,10 +266,9 @@
TEST_F(JniCompilerTest, CompileAndRunDoubleDoubleMethod) {
- scoped_ptr<DexFile> dex(OpenDexFileBase64(kMyClassNativesDex));
- scoped_ptr<ClassLinker> linker(ClassLinker::Create());
- linker->AppendToClassPath(dex.get());
- Class* klass = linker->FindClass("LMyClass;", NULL);
+ scoped_ptr<RawDexFile> dex(OpenRawDexFileBase64(kMyClassNativesDex));
+ class_linker_.get()->RegisterDexFile(dex.get());
+ Class* klass = class_linker_.get()->FindClass("LMyClass;", NULL, dex.get());
Method* method = klass->FindVirtualMethod("fooDD");
Assembler jni_asm;
@@ -295,10 +295,9 @@
}
TEST_F(JniCompilerTest, CompileAndRunIntObjectObjectMethod) {
- scoped_ptr<DexFile> dex(OpenDexFileBase64(kMyClassNativesDex));
- scoped_ptr<ClassLinker> linker(ClassLinker::Create());
- linker->AppendToClassPath(dex.get());
- Class* klass = linker->FindClass("LMyClass;", NULL);
+ scoped_ptr<RawDexFile> dex(OpenRawDexFileBase64(kMyClassNativesDex));
+ class_linker_.get()->RegisterDexFile(dex.get());
+ Class* klass = class_linker_.get()->FindClass("LMyClass;", NULL, dex.get());
Method* method = klass->FindVirtualMethod("fooIOO");
Assembler jni_asm;
@@ -351,10 +350,9 @@
}
TEST_F(JniCompilerTest, CompileAndRunStaticIntObjectObjectMethod) {
- scoped_ptr<DexFile> dex(OpenDexFileBase64(kMyClassNativesDex));
- scoped_ptr<ClassLinker> linker(ClassLinker::Create());
- linker->AppendToClassPath(dex.get());
- Class* klass = linker->FindClass("LMyClass;", NULL);
+ scoped_ptr<RawDexFile> dex(OpenRawDexFileBase64(kMyClassNativesDex));
+ class_linker_.get()->RegisterDexFile(dex.get());
+ Class* klass = class_linker_.get()->FindClass("LMyClass;", NULL, dex.get());
Method* method = klass->FindDirectMethod("fooSIOO");
Assembler jni_asm;
@@ -404,10 +402,9 @@
}
TEST_F(JniCompilerTest, CompileAndRunStaticSynchronizedIntObjectObjectMethod) {
- scoped_ptr<DexFile> dex(OpenDexFileBase64(kMyClassNativesDex));
- scoped_ptr<ClassLinker> linker(ClassLinker::Create());
- linker->AppendToClassPath(dex.get());
- Class* klass = linker->FindClass("LMyClass;", NULL);
+ scoped_ptr<RawDexFile> dex(OpenRawDexFileBase64(kMyClassNativesDex));
+ class_linker_.get()->RegisterDexFile(dex.get());
+ Class* klass = class_linker_.get()->FindClass("LMyClass;", NULL, dex.get());
Method* method = klass->FindDirectMethod("fooSSIOO");
Assembler jni_asm;
@@ -463,10 +460,9 @@
Thread::Current()->DecrementSuspendCount();
}
TEST_F(JniCompilerTest, SuspendCountAcknolewdgement) {
- scoped_ptr<DexFile> dex(OpenDexFileBase64(kMyClassNativesDex));
- scoped_ptr<ClassLinker> linker(ClassLinker::Create());
- linker->AppendToClassPath(dex.get());
- Class* klass = linker->FindClass("LMyClass;", NULL);
+ scoped_ptr<RawDexFile> dex(OpenRawDexFileBase64(kMyClassNativesDex));
+ class_linker_.get()->RegisterDexFile(dex.get());
+ Class* klass = class_linker_.get()->FindClass("LMyClass;", NULL, dex.get());
Method* method = klass->FindVirtualMethod("fooI");
Assembler jni_asm;
@@ -505,10 +501,9 @@
Thread::Current()->ClearException();
}
TEST_F(JniCompilerTest, ExceptionHandling) {
- scoped_ptr<DexFile> dex(OpenDexFileBase64(kMyClassNativesDex));
- scoped_ptr<ClassLinker> linker(ClassLinker::Create());
- linker->AppendToClassPath(dex.get());
- Class* klass = linker->FindClass("LMyClass;", NULL);
+ scoped_ptr<RawDexFile> dex(OpenRawDexFileBase64(kMyClassNativesDex));
+ class_linker_.get()->RegisterDexFile(dex.get());
+ Class* klass = class_linker_.get()->FindClass("LMyClass;", NULL, dex.get());
Method* method = klass->FindVirtualMethod("foo");
Assembler jni_asm;
diff --git a/src/jni_internal.cc b/src/jni_internal.cc
index 7a5025a..74f8961 100644
--- a/src/jni_internal.cc
+++ b/src/jni_internal.cc
@@ -1,7 +1,7 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/jni_internal.h"
-#include "src/logging.h"
+#include "jni_internal.h"
+#include "logging.h"
namespace art {
diff --git a/src/jni_internal.h b/src/jni_internal.h
index 64941cc..e1474ab 100644
--- a/src/jni_internal.h
+++ b/src/jni_internal.h
@@ -4,8 +4,9 @@
#define ART_SRC_JNI_INTERNAL_H_
#include "jni.h"
-#include "src/assembler.h"
-#include "src/macros.h"
+
+#include "assembler.h"
+#include "macros.h"
namespace art {
diff --git a/src/leb128.h b/src/leb128.h
index aa8b895..51df6c9 100644
--- a/src/leb128.h
+++ b/src/leb128.h
@@ -3,7 +3,7 @@
#ifndef ART_SRC_LEB128_H_
#define ART_SRC_LEB128_H_
-#include "src/globals.h"
+#include "globals.h"
namespace art {
diff --git a/src/managed_register.h b/src/managed_register.h
index 7e077a0..2540895 100644
--- a/src/managed_register.h
+++ b/src/managed_register.h
@@ -4,9 +4,9 @@
#define ART_SRC_MANAGED_REGISTER_H_
#if defined(__i386__)
-#include "src/managed_register_x86.h"
+#include "managed_register_x86.h"
#elif defined(__arm__)
-#include "src/managed_register_arm.h"
+#include "managed_register_arm.h"
#else
#error Unknown architecture.
#endif
diff --git a/src/managed_register_arm.cc b/src/managed_register_arm.cc
index d203689..227467e 100644
--- a/src/managed_register_arm.cc
+++ b/src/managed_register_arm.cc
@@ -1,8 +1,8 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/globals.h"
-#include "src/calling_convention.h"
-#include "src/managed_register.h"
+#include "globals.h"
+#include "calling_convention.h"
+#include "managed_register.h"
namespace art {
diff --git a/src/managed_register_arm.h b/src/managed_register_arm.h
index 843095c..a132fa9 100644
--- a/src/managed_register_arm.h
+++ b/src/managed_register_arm.h
@@ -3,8 +3,8 @@
#ifndef ART_SRC_MANAGED_REGISTER_ARM_H_
#define ART_SRC_MANAGED_REGISTER_ARM_H_
-#include "src/constants.h"
-#include "src/logging.h"
+#include "constants.h"
+#include "logging.h"
namespace art {
diff --git a/src/managed_register_arm_test.cc b/src/managed_register_arm_test.cc
index 7ffe894..238291f 100644
--- a/src/managed_register_arm_test.cc
+++ b/src/managed_register_arm_test.cc
@@ -1,7 +1,7 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/globals.h"
-#include "src/managed_register_arm.h"
+#include "globals.h"
+#include "managed_register_arm.h"
#include "gtest/gtest.h"
namespace art {
diff --git a/src/managed_register_x86.cc b/src/managed_register_x86.cc
index 414c51b..d2271fb 100644
--- a/src/managed_register_x86.cc
+++ b/src/managed_register_x86.cc
@@ -1,8 +1,8 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/globals.h"
-#include "src/calling_convention.h"
-#include "src/managed_register.h"
+#include "globals.h"
+#include "calling_convention.h"
+#include "managed_register.h"
namespace art {
diff --git a/src/managed_register_x86.h b/src/managed_register_x86.h
index 5d906c3..1d38d7f 100644
--- a/src/managed_register_x86.h
+++ b/src/managed_register_x86.h
@@ -3,7 +3,7 @@
#ifndef ART_SRC_MANAGED_REGISTER_X86_H_
#define ART_SRC_MANAGED_REGISTER_X86_H_
-#include "src/constants_x86.h"
+#include "constants_x86.h"
namespace art {
diff --git a/src/managed_register_x86_test.cc b/src/managed_register_x86_test.cc
index 3192bb3..2059f65 100644
--- a/src/managed_register_x86_test.cc
+++ b/src/managed_register_x86_test.cc
@@ -1,7 +1,7 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/globals.h"
-#include "src/managed_register.h"
+#include "globals.h"
+#include "managed_register.h"
#include "gtest/gtest.h"
namespace art {
diff --git a/src/mark_stack.cc b/src/mark_stack.cc
index 1d66346..c6d7712 100644
--- a/src/mark_stack.cc
+++ b/src/mark_stack.cc
@@ -1,13 +1,13 @@
// Copyright 2011 Google Inc. All Rights Reserved.
// Author: cshapiro@google.com (Carl Shapiro)
-#include "src/mark_stack.h"
+#include "mark_stack.h"
#include <sys/mman.h>
-#include "src/globals.h"
-#include "src/logging.h"
-#include "src/scoped_ptr.h"
+#include "globals.h"
+#include "logging.h"
+#include "scoped_ptr.h"
namespace art {
diff --git a/src/mark_stack.h b/src/mark_stack.h
index 3f9d5e9..a3e19e9 100644
--- a/src/mark_stack.h
+++ b/src/mark_stack.h
@@ -4,8 +4,8 @@
#ifndef ART_SRC_MARK_STACK_H_
#define ART_SRC_MARK_STACK_H_
-#include "src/logging.h"
-#include "src/macros.h"
+#include "logging.h"
+#include "macros.h"
namespace art {
diff --git a/src/mark_sweep.cc b/src/mark_sweep.cc
index 5ab9e3e..d2e7b66 100644
--- a/src/mark_sweep.cc
+++ b/src/mark_sweep.cc
@@ -1,13 +1,13 @@
// Copyright 2011 Google Inc. All Rights Reserved.
// Author: cshapiro@google.com (Carl Shapiro)
-#include "src/mark_sweep.h"
+#include "mark_sweep.h"
-#include "src/logging.h"
-#include "src/macros.h"
-#include "src/mark_stack.h"
-#include "src/object.h"
-#include "src/thread.h"
+#include "logging.h"
+#include "macros.h"
+#include "mark_stack.h"
+#include "object.h"
+#include "thread.h"
#define CLZ(x) __builtin_clz(x)
diff --git a/src/mark_sweep.h b/src/mark_sweep.h
index 98fbf1b..d0c0a44 100644
--- a/src/mark_sweep.h
+++ b/src/mark_sweep.h
@@ -4,9 +4,9 @@
#ifndef ART_SRC_MARK_SWEEP_H_
#define ART_SRC_MARK_SWEEP_H_
-#include "src/macros.h"
-#include "src/mark_stack.h"
-#include "src/object_bitmap.h"
+#include "macros.h"
+#include "mark_stack.h"
+#include "object_bitmap.h"
namespace art {
diff --git a/src/memory_region.cc b/src/memory_region.cc
index 30d61ed..987db51 100644
--- a/src/memory_region.cc
+++ b/src/memory_region.cc
@@ -2,9 +2,9 @@
#include <stdint.h>
#include <string.h>
-#include "src/globals.h"
-#include "src/logging.h"
-#include "src/memory_region.h"
+#include "globals.h"
+#include "logging.h"
+#include "memory_region.h"
namespace art {
diff --git a/src/memory_region.h b/src/memory_region.h
index f5382cd..3d04d91 100644
--- a/src/memory_region.h
+++ b/src/memory_region.h
@@ -4,10 +4,10 @@
#define ART_SRC_MEMORY_REGION_H_
#include <stdint.h>
-#include "src/globals.h"
-#include "src/logging.h"
-#include "src/macros.h"
-#include "src/memory_region.h"
+#include "globals.h"
+#include "logging.h"
+#include "macros.h"
+#include "memory_region.h"
namespace art {
diff --git a/src/monitor.h b/src/monitor.h
index f624056..2f5b5ff 100644
--- a/src/monitor.h
+++ b/src/monitor.h
@@ -4,8 +4,8 @@
#ifndef ART_SRC_MONITOR_H_
#define ART_SRC_MONITOR_H_
-#include "src/logging.h"
-#include "src/macros.h"
+#include "logging.h"
+#include "macros.h"
namespace art {
diff --git a/src/object.cc b/src/object.cc
index c79271d..fb80fb9 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -1,12 +1,14 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/object.h"
+#include "object.h"
+
#include <string.h>
#include <algorithm>
-#include "src/globals.h"
-#include "src/logging.h"
-#include "src/dex_file.h"
-#include "src/raw_dex_file.h"
+
+#include "globals.h"
+#include "logging.h"
+#include "dex_file.h"
+#include "raw_dex_file.h"
namespace art {
@@ -152,50 +154,6 @@
return ShortyCharToSize(shorty_[0]);
}
-bool Method::HasSameArgumentTypes(const Method* that) const {
- const RawDexFile* raw1 = this->GetClass()->GetDexFile()->GetRaw();
- const RawDexFile::ProtoId& proto1 = raw1->GetProtoId(this->proto_idx_);
- const RawDexFile* raw2 = that->GetClass()->GetDexFile()->GetRaw();
- const RawDexFile::ProtoId& proto2 = raw2->GetProtoId(that->proto_idx_);
-
- // TODO: compare ProtoId objects for equality and exit early
-
- const RawDexFile::TypeList* type_list1 = raw1->GetProtoParameters(proto1);
- size_t arity1 = (type_list1 == NULL) ? 0 : type_list1->Size();
- const RawDexFile::TypeList* type_list2 = raw2->GetProtoParameters(proto2);
- size_t arity2 = (type_list2 == NULL) ? 0 : type_list2->Size();
-
- if (arity1 != arity2) {
- return false;
- }
-
- for (size_t i = 0; i < arity1; ++i) {
- uint32_t type_idx1 = type_list1->GetTypeItem(i).type_idx_;
- const char* type1 = raw1->dexStringByTypeIdx(type_idx1);
-
- uint32_t type_idx2 = type_list2->GetTypeItem(i).type_idx_;
- const char* type2 = raw2->dexStringByTypeIdx(type_idx2);
-
- if (strcmp(type1, type2) != 0) {
- return false;
- }
- }
-
- return true;
-}
-
-bool Method::HasSameReturnType(const Method* that) const {
- const RawDexFile* raw1 = this->GetClass()->GetDexFile()->GetRaw();
- const RawDexFile::ProtoId& proto1 = raw1->GetProtoId(this->proto_idx_);
- const char* type1 = raw1->dexStringByTypeIdx(proto1.return_type_idx_);
-
- const RawDexFile* raw2 = that->GetClass()->GetDexFile()->GetRaw();
- const RawDexFile::ProtoId& proto2 = raw2->GetProtoId(that->proto_idx_);
- const char* type2 = raw2->dexStringByTypeIdx(proto2.return_type_idx_);
-
- return (strcmp(type1, type2) == 0);
-}
-
Method* Class::FindDirectMethod(const StringPiece& name) const {
Method* result = NULL;
for (size_t i = 0; i < NumDirectMethods(); i++) {
diff --git a/src/object.h b/src/object.h
index 218aed9..abbf6ca 100644
--- a/src/object.h
+++ b/src/object.h
@@ -3,15 +3,14 @@
#ifndef ART_SRC_OBJECT_H_
#define ART_SRC_OBJECT_H_
-#include "src/constants.h"
-#include "src/casts.h"
-#include "src/dex_file.h"
-#include "src/globals.h"
-#include "src/logging.h"
-#include "src/macros.h"
-#include "src/offsets.h"
-#include "src/stringpiece.h"
-#include "src/monitor.h"
+#include "constants.h"
+#include "casts.h"
+#include "globals.h"
+#include "logging.h"
+#include "macros.h"
+#include "offsets.h"
+#include "stringpiece.h"
+#include "monitor.h"
namespace art {
@@ -433,22 +432,6 @@
// Number of argument registers required by the prototype.
uint32_t NumArgRegisters();
- bool HasSameNameAndPrototype(const Method* that) const {
- return HasSameName(that) && HasSamePrototype(that);
- }
-
- bool HasSameName(const Method* that) const {
- return this->GetName() == that->GetName();
- }
-
- bool HasSamePrototype(const Method* that) const {
- return HasSameReturnType(that) && HasSameArgumentTypes(that);
- }
-
- bool HasSameReturnType(const Method* that) const;
-
- bool HasSameArgumentTypes(const Method* that) const;
-
public: // TODO: private
#define METHOD_FIELD_SLOTS 1+11
// AccessibleObject #0 flag
@@ -911,26 +894,32 @@
class DataObject : public Object {
public:
- uint32_t fields_[1];
+ uint32_t fields_[0];
private:
DataObject();
};
class Array : public Object {
public:
- uint32_t GetLength() const{
+ uint32_t GetLength() const {
return length_;
}
-
void SetLength(uint32_t length) {
length_ = length;
}
+ const void* GetData() const {
+ return &elements_;
+ }
+ void* GetData() {
+ return &elements_;
+ }
private:
// The number of array elements.
uint32_t length_;
-
- DISALLOW_IMPLICIT_CONSTRUCTORS(Array);
+ // Location of first element.
+ uint32_t elements_[0];
+ Array();
};
class CharArray : public Array {
@@ -940,19 +929,20 @@
class ObjectArray : public Array {
public:
- Object* Get(int32_t i) {
- return NULL;
+ Object* Get(uint32_t i) const {
+ DCHECK_LT(i, GetLength());
+ Object* const * data = reinterpret_cast<Object* const *>(GetData());
+ return data[i];
}
-
- const Object* Get(int32_t i) const {
- return NULL;
+ void Set(uint32_t i, Object* object) {
+ DCHECK_LT(i, GetLength());
+ Object** data = reinterpret_cast<Object**>(GetData());
+ data[i] = object;
}
-
private:
- DISALLOW_IMPLICIT_CONSTRUCTORS(ObjectArray);
+ ObjectArray();
};
-
class String : public Object {
public:
CharArray* array_;
diff --git a/src/object_bitmap.cc b/src/object_bitmap.cc
index 7234143..85fee73 100644
--- a/src/object_bitmap.cc
+++ b/src/object_bitmap.cc
@@ -12,12 +12,12 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-#include "src/object_bitmap.h"
+#include "object_bitmap.h"
#include <sys/mman.h>
-#include "src/logging.h"
-#include "src/scoped_ptr.h"
+#include "logging.h"
+#include "scoped_ptr.h"
namespace art {
diff --git a/src/object_bitmap.h b/src/object_bitmap.h
index 3e779b2..d766a83 100644
--- a/src/object_bitmap.h
+++ b/src/object_bitmap.h
@@ -18,8 +18,8 @@
#include <limits.h>
#include <stdint.h>
-#include "src/globals.h"
-#include "src/logging.h"
+#include "globals.h"
+#include "logging.h"
namespace art {
diff --git a/src/object_test.cc b/src/object_test.cc
index 334461a..6598167 100644
--- a/src/object_test.cc
+++ b/src/object_test.cc
@@ -1,12 +1,12 @@
// Copyright 2011 Google Inc. All Rights Reserved.
// Author: cshapiro@google.com (Carl Shapiro)
-#include "src/class_linker.h"
-#include "src/common_test.h"
-#include "src/dex_file.h"
-#include "src/heap.h"
-#include "src/object.h"
-#include "src/scoped_ptr.h"
+#include "class_linker.h"
+#include "common_test.h"
+#include "dex_file.h"
+#include "heap.h"
+#include "object.h"
+#include "scoped_ptr.h"
#include <stdio.h>
#include "gtest/gtest.h"
@@ -29,116 +29,17 @@
"Ljava/lang/reflect/Method;"));
}
-class MethodTest : public RuntimeTest {};
-
-// TODO: test 0 argument methods
-// TODO: make this test simpler and shorter
-TEST_F(MethodTest, ProtoCompare) {
- scoped_ptr<DexFile> object_dex_file(OpenDexFileBase64(kJavaLangDex));
- ASSERT_TRUE(object_dex_file != NULL);
- scoped_ptr<DexFile> proto_dex_file(OpenDexFileBase64(kProtoCompareDex));
- ASSERT_TRUE(proto_dex_file != NULL);
-
- scoped_ptr<ClassLinker> linker(ClassLinker::Create());
- linker->AppendToClassPath(object_dex_file.get());
- linker->AppendToClassPath(proto_dex_file.get());
-
- Class* klass = linker->FindClass("LProtoCompare;", NULL);
- ASSERT_TRUE(klass != NULL);
-
- ASSERT_EQ(4U, klass->NumVirtualMethods());
-
- Method* m1 = klass->GetVirtualMethod(0u);
- ASSERT_EQ("m1", m1->GetName());
-
- Method* m2 = klass->GetVirtualMethod(1);
- ASSERT_EQ("m2", m2->GetName());
-
- Method* m3 = klass->GetVirtualMethod(2);
- ASSERT_EQ("m3", m3->GetName());
-
- Method* m4 = klass->GetVirtualMethod(3);
- ASSERT_EQ("m4", m4->GetName());
-
- EXPECT_TRUE(m1->HasSameReturnType(m2));
- EXPECT_TRUE(m2->HasSameReturnType(m1));
-
- EXPECT_TRUE(m1->HasSameReturnType(m2));
- EXPECT_TRUE(m2->HasSameReturnType(m1));
-
- EXPECT_FALSE(m1->HasSameReturnType(m4));
- EXPECT_FALSE(m4->HasSameReturnType(m1));
-
- EXPECT_TRUE(m1->HasSameArgumentTypes(m2));
- EXPECT_TRUE(m2->HasSameArgumentTypes(m1));
-
- EXPECT_FALSE(m1->HasSameArgumentTypes(m3));
- EXPECT_FALSE(m3->HasSameArgumentTypes(m1));
-
- EXPECT_FALSE(m1->HasSameArgumentTypes(m4));
- EXPECT_FALSE(m4->HasSameArgumentTypes(m1));
-
- EXPECT_TRUE(m1->HasSamePrototype(m2));
- EXPECT_TRUE(m2->HasSamePrototype(m1));
-
- EXPECT_FALSE(m1->HasSamePrototype(m3));
- EXPECT_FALSE(m3->HasSamePrototype(m1));
-
- EXPECT_FALSE(m3->HasSamePrototype(m4));
- EXPECT_FALSE(m4->HasSamePrototype(m3));
-
- EXPECT_FALSE(m1->HasSameName(m2));
- EXPECT_FALSE(m1->HasSameNameAndPrototype(m2));
-}
-
-TEST_F(MethodTest, ProtoCompare2) {
- scoped_ptr<DexFile> object_dex_file(OpenDexFileBase64(kJavaLangDex));
- ASSERT_TRUE(object_dex_file != NULL);
- scoped_ptr<DexFile> proto1_dex_file(OpenDexFileBase64(kProtoCompareDex));
- ASSERT_TRUE(proto1_dex_file != NULL);
- scoped_ptr<DexFile> proto2_dex_file(OpenDexFileBase64(kProtoCompare2Dex));
- ASSERT_TRUE(proto2_dex_file != NULL);
- scoped_ptr<ClassLinker> linker1(ClassLinker::Create());
- linker1->AppendToClassPath(object_dex_file.get());
- linker1->AppendToClassPath(proto1_dex_file.get());
- scoped_ptr<ClassLinker> linker2(ClassLinker::Create());
- linker2->AppendToClassPath(object_dex_file.get());
- linker2->AppendToClassPath(proto2_dex_file.get());
-
- Class* klass1 = linker1->FindClass("LProtoCompare;", NULL);
- ASSERT_TRUE(klass1 != NULL);
- Class* klass2 = linker2->FindClass("LProtoCompare2;", NULL);
- ASSERT_TRUE(klass2 != NULL);
-
- Method* m1_1 = klass1->GetVirtualMethod(0u);
- ASSERT_EQ("m1", m1_1->GetName());
- Method* m2_1 = klass1->GetVirtualMethod(1);
- ASSERT_EQ("m2", m2_1->GetName());
- Method* m3_1 = klass1->GetVirtualMethod(2);
- ASSERT_EQ("m3", m3_1->GetName());
- Method* m4_1 = klass1->GetVirtualMethod(3);
- ASSERT_EQ("m4", m4_1->GetName());
-
- Method* m1_2 = klass2->GetVirtualMethod(0u);
- ASSERT_EQ("m1", m1_2->GetName());
- Method* m2_2 = klass2->GetVirtualMethod(1);
- ASSERT_EQ("m2", m2_2->GetName());
- Method* m3_2 = klass2->GetVirtualMethod(2);
- ASSERT_EQ("m3", m3_2->GetName());
- Method* m4_2 = klass2->GetVirtualMethod(3);
- ASSERT_EQ("m4", m4_2->GetName());
-
- EXPECT_TRUE(m1_1->HasSameNameAndPrototype(m1_2));
- EXPECT_TRUE(m1_2->HasSameNameAndPrototype(m1_1));
-
- EXPECT_TRUE(m2_1->HasSameNameAndPrototype(m2_2));
- EXPECT_TRUE(m2_2->HasSameNameAndPrototype(m2_1));
-
- EXPECT_TRUE(m3_1->HasSameNameAndPrototype(m3_2));
- EXPECT_TRUE(m3_2->HasSameNameAndPrototype(m3_1));
-
- EXPECT_TRUE(m4_1->HasSameNameAndPrototype(m4_2));
- EXPECT_TRUE(m4_2->HasSameNameAndPrototype(m4_1));
+TEST_F(ObjectTest, AllocObjectArray) {
+ ObjectArray* oa = class_linker_->AllocObjectArray(2);
+ EXPECT_EQ(2U, oa->GetLength());
+ EXPECT_TRUE(oa->Get(0) == NULL);
+ EXPECT_TRUE(oa->Get(1) == NULL);
+ oa->Set(0, oa);
+ EXPECT_TRUE(oa->Get(0) == oa);
+ EXPECT_TRUE(oa->Get(1) == NULL);
+ oa->Set(1, oa);
+ EXPECT_TRUE(oa->Get(0) == oa);
+ EXPECT_TRUE(oa->Get(1) == oa);
}
} // namespace art
diff --git a/src/offsets.cc b/src/offsets.cc
index 1dce268..6fdc4d1 100644
--- a/src/offsets.cc
+++ b/src/offsets.cc
@@ -1,7 +1,7 @@
// Copyright 2011 Google Inc. All Rights Reserved.
// Author: cshapiro@google.com (Carl Shapiro)
-#include "src/offsets.h"
+#include "offsets.h"
#include <iostream> // NOLINT
diff --git a/src/offsets.h b/src/offsets.h
index 33f395f..2fe873c 100644
--- a/src/offsets.h
+++ b/src/offsets.h
@@ -5,7 +5,7 @@
#define ART_SRC_OFFSETS_H_
#include <iostream> // NOLINT
-#include "src/globals.h"
+#include "globals.h"
namespace art {
diff --git a/src/raw_dex_file.cc b/src/raw_dex_file.cc
index d03723d..21badb4 100644
--- a/src/raw_dex_file.cc
+++ b/src/raw_dex_file.cc
@@ -1,6 +1,6 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/raw_dex_file.h"
+#include "raw_dex_file.h"
#include <fcntl.h>
#include <string.h>
@@ -9,11 +9,11 @@
#include <sys/types.h>
#include <map>
-#include "src/globals.h"
-#include "src/logging.h"
-#include "src/object.h"
-#include "src/scoped_ptr.h"
-#include "src/utils.h"
+#include "globals.h"
+#include "logging.h"
+#include "object.h"
+#include "scoped_ptr.h"
+#include "utils.h"
namespace art {
diff --git a/src/raw_dex_file.h b/src/raw_dex_file.h
index 0bfab12..da7cd86 100644
--- a/src/raw_dex_file.h
+++ b/src/raw_dex_file.h
@@ -3,12 +3,12 @@
#ifndef ART_SRC_RAW_DEX_FILE_H_
#define ART_SRC_RAW_DEX_FILE_H_
-#include "src/globals.h"
-#include "src/leb128.h"
-#include "src/logging.h"
-#include "src/scoped_ptr.h"
-#include "src/stringpiece.h"
-#include "src/strutil.h"
+#include "globals.h"
+#include "leb128.h"
+#include "logging.h"
+#include "scoped_ptr.h"
+#include "stringpiece.h"
+#include "strutil.h"
#include <map>
diff --git a/src/raw_dex_file_test.cc b/src/raw_dex_file_test.cc
index 0395bbd..4be9991 100644
--- a/src/raw_dex_file_test.cc
+++ b/src/raw_dex_file_test.cc
@@ -1,9 +1,9 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/common_test.h"
-#include "src/dex_file.h"
-#include "src/raw_dex_file.h"
-#include "src/scoped_ptr.h"
+#include "common_test.h"
+#include "dex_file.h"
+#include "raw_dex_file.h"
+#include "scoped_ptr.h"
#include <stdio.h>
#include "gtest/gtest.h"
diff --git a/src/runtime.cc b/src/runtime.cc
index 3adaea7..be926c3 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -1,13 +1,13 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/runtime.h"
+#include "runtime.h"
#include <cstdio>
#include <cstdlib>
-#include "src/class_linker.h"
-#include "src/heap.h"
-#include "src/thread.h"
+#include "class_linker.h"
+#include "heap.h"
+#include "thread.h"
namespace art {
@@ -44,9 +44,9 @@
// notreached
}
-Runtime* Runtime::Create() {
+Runtime* Runtime::Create(std::vector<RawDexFile*> boot_class_path) {
scoped_ptr<Runtime> runtime(new Runtime());
- bool success = runtime->Init();
+ bool success = runtime->Init(boot_class_path);
if (!success) {
return NULL;
} else {
@@ -54,13 +54,13 @@
}
}
-bool Runtime::Init() {
+bool Runtime::Init(std::vector<RawDexFile*> boot_class_path) {
thread_list_ = ThreadList::Create();
Heap::Init(Heap::kStartupSize, Heap::kMaximumSize);
Thread::Init();
Thread* current_thread = Thread::Attach();
thread_list_->Register(current_thread);
- class_linker_ = ClassLinker::Create();
+ class_linker_ = ClassLinker::Create(boot_class_path);
return true;
}
diff --git a/src/runtime.h b/src/runtime.h
index cbccccb..69f6228 100644
--- a/src/runtime.h
+++ b/src/runtime.h
@@ -3,9 +3,12 @@
#ifndef ART_SRC_RUNTIME_H_
#define ART_SRC_RUNTIME_H_
-#include "src/globals.h"
-#include "src/macros.h"
-#include "src/stringpiece.h"
+#include <vector>
+
+#include "globals.h"
+#include "macros.h"
+#include "raw_dex_file.h"
+#include "stringpiece.h"
namespace art {
@@ -16,7 +19,7 @@
class Runtime {
public:
// Creates and initializes a new runtime.
- static Runtime* Create();
+ static Runtime* Create(std::vector<RawDexFile*> boot_class_path);
// Compiles a dex file.
static void Compile(const StringPiece& filename);
@@ -42,7 +45,7 @@
Runtime() : class_linker_(NULL), thread_list_(NULL) {}
// Initializes a new uninitialized runtime.
- bool Init();
+ bool Init(std::vector<RawDexFile*> boot_class_path);
ClassLinker* class_linker_;
diff --git a/src/runtime_linux.cc b/src/runtime_linux.cc
index e59111f..e150d8e 100644
--- a/src/runtime_linux.cc
+++ b/src/runtime_linux.cc
@@ -23,7 +23,7 @@
// TODO: in practice, we may find that we should use backtrace_symbols_fd
// to avoid allocation, rather than use our own custom formatting.
art::scoped_ptr_malloc<char*> symbols(backtrace_symbols(frames, frame_count));
- if (symbols.get() == NULL) {
+ if (symbols == NULL) {
PLOG(ERROR) << "backtrace_symbols failed";
return;
}
diff --git a/src/scoped_ptr.h b/src/scoped_ptr.h
index ce21cc5..a3b30d5 100644
--- a/src/scoped_ptr.h
+++ b/src/scoped_ptr.h
@@ -18,7 +18,7 @@
// implementation of the scoped_ptr class, and its closely-related brethren,
// scoped_array, scoped_ptr_malloc, and make_scoped_ptr.
-#include "src/macros.h"
+#include "macros.h"
#include <assert.h>
#include <stdlib.h>
diff --git a/src/space.cc b/src/space.cc
index dc9950c..9e091f2 100644
--- a/src/space.cc
+++ b/src/space.cc
@@ -1,14 +1,14 @@
// Copyright 2011 Google Inc. All Rights Reserved.
// Author: cshapiro@google.com (Carl Shapiro)
-#include "src/space.h"
+#include "space.h"
#include <sys/mman.h>
-#include "src/logging.h"
-#include "src/mspace.h"
-#include "src/scoped_ptr.h"
-#include "src/utils.h"
+#include "logging.h"
+#include "mspace.h"
+#include "scoped_ptr.h"
+#include "utils.h"
namespace art {
diff --git a/src/space.h b/src/space.h
index ac69ba6..c61d91f 100644
--- a/src/space.h
+++ b/src/space.h
@@ -4,8 +4,8 @@
#ifndef ART_SRC_SPACE_H_
#define ART_SRC_SPACE_H_
-#include "src/globals.h"
-#include "src/macros.h"
+#include "globals.h"
+#include "macros.h"
namespace art {
diff --git a/src/space_test.cc b/src/space_test.cc
index db623eb..9a61fa5 100644
--- a/src/space_test.cc
+++ b/src/space_test.cc
@@ -1,12 +1,12 @@
// Copyright 2011 Google Inc. All Rights Reserved.
// Author: cshapiro@google.com (Carl Shapiro)
-#include "src/space.h"
+#include "space.h"
#include "gtest/gtest.h"
-#include "src/globals.h"
-#include "src/scoped_ptr.h"
+#include "globals.h"
+#include "scoped_ptr.h"
namespace art {
diff --git a/src/stringpiece.cc b/src/stringpiece.cc
index 9927309..3779550 100644
--- a/src/stringpiece.cc
+++ b/src/stringpiece.cc
@@ -11,7 +11,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-#include "src/stringpiece.h"
+#include "stringpiece.h"
#include <iostream>
#include <utility>
diff --git a/src/thread.cc b/src/thread.cc
index 5b4b073..56eeb7f 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -1,6 +1,6 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/thread.h"
+#include "thread.h"
#include <pthread.h>
#include <sys/mman.h>
@@ -8,8 +8,8 @@
#include <cerrno>
#include <list>
-#include "src/runtime.h"
-#include "src/utils.h"
+#include "runtime.h"
+#include "utils.h"
namespace art {
diff --git a/src/thread.h b/src/thread.h
index fd03464..ed2ba12 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -7,13 +7,13 @@
#include <pthread.h>
#include <list>
-#include "src/globals.h"
-#include "src/jni_internal.h"
-#include "src/logging.h"
-#include "src/macros.h"
-#include "src/object.h"
-#include "src/offsets.h"
-#include "src/runtime.h"
+#include "globals.h"
+#include "jni_internal.h"
+#include "logging.h"
+#include "macros.h"
+#include "object.h"
+#include "offsets.h"
+#include "runtime.h"
#include "jni.h"
diff --git a/src/thread_arm.cc b/src/thread_arm.cc
index 4b5eab7..8b0d9a4 100644
--- a/src/thread_arm.cc
+++ b/src/thread_arm.cc
@@ -1,7 +1,7 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/macros.h"
-#include "src/thread.h"
+#include "macros.h"
+#include "thread.h"
namespace art {
diff --git a/src/thread_x86.cc b/src/thread_x86.cc
index 718e9b8..d0a4469 100644
--- a/src/thread_x86.cc
+++ b/src/thread_x86.cc
@@ -1,10 +1,12 @@
// Copyright 2011 Google Inc. All Rights Reserved.
-#include "src/thread.h"
+#include "thread.h"
+
#include <asm/ldt.h>
#include <sys/syscall.h>
#include <sys/types.h>
-#include "src/macros.h"
+
+#include "macros.h"
namespace art {
diff --git a/src/utils.h b/src/utils.h
index 217bd69..1da7c88 100644
--- a/src/utils.h
+++ b/src/utils.h
@@ -3,7 +3,7 @@
#ifndef ART_SRC_UTILS_H_
#define ART_SRC_UTILS_H_
-#include "src/globals.h"
+#include "globals.h"
namespace art {