Finish moving state to managed heap
Change-Id: I8a3b0e353b30268a05d6ed8ea0a6a4bead100660
diff --git a/Android.mk b/Android.mk
index d6c8eb3..462aa29 100644
--- a/Android.mk
+++ b/Android.mk
@@ -17,6 +17,13 @@
LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
+# These can be overridden via the environment or by editing to
+# enable/disable certain build configuration.
+ART_BUILD_TARGET_NDEBUG ?= true
+ART_BUILD_TARGET_DEBUG ?= true
+ART_BUILD_HOST_NDEBUG ?= true
+ART_BUILD_HOST_DEBUG ?= true
+
build_path := $(LOCAL_PATH)/build
include $(build_path)/Android.common.mk
diff --git a/build/Android.common.mk b/build/Android.common.mk
index 8b22b83..3c203d4 100644
--- a/build/Android.common.mk
+++ b/build/Android.common.mk
@@ -173,3 +173,18 @@
SystemMethods \
Invoke \
XandY
+
+ART_BUILD_TARGET := false
+ART_BUILD_HOST := false
+ifeq ($(ART_BUILD_TARGET_NDEBUG),true)
+ ART_BUILD_TARGET := true
+endif
+ifeq ($(ART_BUILD_TARGET_DEBUG),true)
+ ART_BUILD_TARGET := true
+endif
+ifeq ($(ART_BUILD_HOST_NDEBUG),true)
+ ART_BUILD_HOST := true
+endif
+ifeq ($(ART_BUILD_HOST_DEBUG),true)
+ ART_BUILD_HOST := true
+endif
diff --git a/build/Android.executable.mk b/build/Android.executable.mk
index 328f60a..2abb42a 100644
--- a/build/Android.executable.mk
+++ b/build/Android.executable.mk
@@ -60,17 +60,20 @@
endif
endef
-$(eval $(call build-art-executable,dex2oat,$(DEX2OAT_SRC_FILES),target,ndebug))
-$(eval $(call build-art-executable,dex2oat,$(DEX2OAT_SRC_FILES),target,debug))
-ifeq ($(WITH_HOST_DALVIK),true)
- $(eval $(call build-art-executable,dex2oat,$(DEX2OAT_SRC_FILES),host,ndebug))
- $(eval $(call build-art-executable,dex2oat,$(DEX2OAT_SRC_FILES),host,debug))
+ifeq ($(ART_BUILD_TARGET_NDEBUG),true)
+ $(eval $(call build-art-executable,dex2oat,$(DEX2OAT_SRC_FILES),target,ndebug))
+ $(eval $(call build-art-executable,oatexec,$(OATEXEC_SRC_FILES),target,ndebug))
endif
-
-$(eval $(call build-art-executable,oatexec,$(OATEXEC_SRC_FILES),target,ndebug))
-$(eval $(call build-art-executable,oatexec,$(OATEXEC_SRC_FILES),target,debug))
-ifeq ($(WITH_HOST_DALVIK),true)
+ifeq ($(ART_BUILD_TARGET_DEBUG),true)
+ $(eval $(call build-art-executable,dex2oat,$(DEX2OAT_SRC_FILES),target,debug))
+ $(eval $(call build-art-executable,oatexec,$(OATEXEC_SRC_FILES),target,debug))
+endif
+ifeq ($(ART_BUILD_HOST_NDEBUG),true)
+ $(eval $(call build-art-executable,dex2oat,$(DEX2OAT_SRC_FILES),host,ndebug))
$(eval $(call build-art-executable,oatexec,$(OATEXEC_SRC_FILES),host,ndebug))
+endif
+ifeq ($(ART_BUILD_HOST_DEBUG),true)
+ $(eval $(call build-art-executable,dex2oat,$(DEX2OAT_SRC_FILES),host,debug))
$(eval $(call build-art-executable,oatexec,$(OATEXEC_SRC_FILES),host,debug))
endif
diff --git a/build/Android.libart.mk b/build/Android.libart.mk
index 3218a42..974907e 100644
--- a/build/Android.libart.mk
+++ b/build/Android.libart.mk
@@ -53,9 +53,15 @@
endif
endef
-$(eval $(call build-libart,target,ndebug))
-$(eval $(call build-libart,target,debug))
-ifeq ($(WITH_HOST_DALVIK),true)
+ifeq ($(ART_BUILD_TARGET_NDEBUG),true)
+ $(eval $(call build-libart,target,ndebug))
+endif
+ifeq ($(ART_BUILD_TARGET_DEBUG),true)
+ $(eval $(call build-libart,target,debug))
+endif
+ifeq ($(ART_BUILD_HOST_NDEBUG),true)
$(eval $(call build-libart,host,ndebug))
+endif
+ifeq ($(ART_BUILD_HOST_DEBUG),true)
$(eval $(call build-libart,host,debug))
endif
diff --git a/build/Android.libarttest.mk b/build/Android.libarttest.mk
index 107eddc..9cde3e5 100644
--- a/build/Android.libarttest.mk
+++ b/build/Android.libarttest.mk
@@ -37,7 +37,9 @@
endif
endef
-$(eval $(call build-libarttest,target))
-ifeq ($(WITH_HOST_DALVIK),true)
+ifeq ($(ART_BUILD_TARGET),true)
+ $(eval $(call build-libarttest,target))
+endif
+ifeq ($(ART_BUILD_HOST),true)
$(eval $(call build-libarttest,host))
endif
diff --git a/build/Android.test.mk b/build/Android.test.mk
index 9dabd4f..90fc44a 100644
--- a/build/Android.test.mk
+++ b/build/Android.test.mk
@@ -50,8 +50,10 @@
endif
endef
-$(foreach file,$(TEST_TARGET_SRC_FILES), $(eval $(call build-art-test,target,$(file))))
-ifeq ($(WITH_HOST_DALVIK),true)
+ifeq ($(ART_BUILD_TARGET),true)
+ $(foreach file,$(TEST_TARGET_SRC_FILES), $(eval $(call build-art-test,target,$(file))))
+endif
+ifeq ($(ART_BUILD_HOST),true)
$(foreach file,$(TEST_HOST_SRC_FILES), $(eval $(call build-art-test,host,$(file))))
endif
diff --git a/src/class_linker.cc b/src/class_linker.cc
index c81df8d..8595bfc 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -151,7 +151,7 @@
// Create array interface entries to populate once we can load system classes
array_interfaces_ = AllocObjectArray<Class>(2);
- array_iftable_ = new InterfaceEntry[2];
+ array_iftable_ = AllocObjectArray<InterfaceEntry>(2);
// Create int array type for AllocDexCache (done in AppendToBootClassPath)
Class* int_array_class = AllocClass(java_lang_Class, sizeof(Class));
@@ -195,8 +195,7 @@
// now we can use FindSystemClass
- // Object and String just need more minimal setup, since they do not have
- // extra C++ fields.
+ // Object and String need to be rerun through FindSystemClass to finish init
java_lang_Object->SetStatus(Class::kStatusNotReady);
Class* Object_class = FindSystemClass("Ljava/lang/Object;");
CHECK_EQ(java_lang_Object, Object_class);
@@ -206,8 +205,7 @@
CHECK_EQ(java_lang_String, String_class);
CHECK_EQ(java_lang_String->GetObjectSize(), sizeof(String));
- // Setup the primitive array type classes - can't be done until Object has
- // a vtable
+ // Setup the primitive array type classes - can't be done until Object has a vtable
SetClassRoot(kBooleanArrayClass, FindSystemClass("[Z"));
BooleanArray::SetArrayClass(GetClassRoot(kBooleanArrayClass));
@@ -245,10 +243,9 @@
array_interfaces_->Set(1, java_io_Serializable);
// We assume that Cloneable/Serializable don't have superinterfaces --
// normally we'd have to crawl up and explicitly list all of the
- // supers as well. These interfaces don't have any methods, so we
- // don't have to worry about the ifviPool either.
- array_iftable_[0].SetInterface(array_interfaces_->Get(0));
- array_iftable_[1].SetInterface(array_interfaces_->Get(1));
+ // supers as well.
+ array_iftable_->Set(0, AllocInterfaceEntry(array_interfaces_->Get(0)));
+ array_iftable_->Set(1, AllocInterfaceEntry(array_interfaces_->Get(1)));
// Sanity check Object[]'s interfaces
CHECK_EQ(java_lang_Cloneable, object_array_class->GetInterface(0));
@@ -549,6 +546,14 @@
return down_cast<CodeAndDirectMethods*>(IntArray::Alloc(CodeAndDirectMethods::LengthAsArray(length)));
}
+InterfaceEntry* ClassLinker::AllocInterfaceEntry(Class* interface) {
+ DCHECK(interface->IsInterface());
+ ObjectArray<Object>* array = AllocObjectArray<Object>(InterfaceEntry::LengthAsArray());
+ InterfaceEntry* interface_entry = down_cast<InterfaceEntry*>(array);
+ interface_entry->SetInterface(interface);
+ return interface_entry;
+}
+
Class* ClassLinker::AllocClass(Class* java_lang_Class, size_t class_size) {
DCHECK_GE(class_size, sizeof(Class));
Class* klass = Heap::AllocObject(java_lang_Class, class_size)->AsClass();
@@ -774,7 +779,7 @@
size_t num_direct_methods = header.direct_methods_size_;
size_t num_virtual_methods = header.virtual_methods_size_;
- klass->SetSourceFile(dex_file.dexGetSourceFile(dex_class_def));
+ klass->SetSourceFile(String::AllocFromModifiedUtf8(dex_file.dexGetSourceFile(dex_class_def)));
// Load class interfaces.
LoadInterfaces(dex_file, dex_class_def, klass);
@@ -1099,8 +1104,7 @@
// Use the single, global copies of "interfaces" and "iftable"
// (remember not to free them for arrays).
new_class->SetInterfaces(array_interfaces_);
- new_class->SetIFTableCount(2);
- new_class->SetIFTable(array_iftable_);
+ new_class->SetIfTable(array_iftable_);
// Inherit access flags from the component type. Arrays can't be
// used as a superclass or interface, so we want to add "final"
@@ -1303,13 +1307,12 @@
}
}
}
- for (size_t i = 0; i < klass->GetIFTableCount(); ++i) {
- const InterfaceEntry* iftable = &klass->GetIFTable()[i];
- Class* interface = iftable->GetInterface();
+ for (int32_t i = 0; i < klass->GetIfTableCount(); ++i) {
+ InterfaceEntry* interface_entry = klass->GetIfTable()->Get(i);
+ Class* interface = interface_entry->GetInterface();
if (klass->GetClassLoader() != interface->GetClassLoader()) {
for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
- uint32_t vtable_index = iftable->GetMethodIndexArray()[j];
- const Method* method = klass->GetVirtualMethod(vtable_index);
+ const Method* method = interface_entry->GetMethodArray()->Get(j);
if (!HasSameMethodDescriptorClasses(method, interface,
method->GetClass())) {
LG << "Classes resolve differently in interface"; // TODO: LinkageError
@@ -1684,71 +1687,61 @@
}
bool ClassLinker::LinkInterfaceMethods(Class* klass) {
- int pool_offset = 0;
- int pool_size = 0;
int miranda_count = 0;
int miranda_alloc = 0;
size_t super_ifcount;
if (klass->HasSuperClass()) {
- super_ifcount = klass->GetSuperClass()->GetIFTableCount();
+ super_ifcount = klass->GetSuperClass()->GetIfTableCount();
} else {
super_ifcount = 0;
}
size_t ifcount = super_ifcount;
ifcount += klass->NumInterfaces();
for (size_t i = 0; i < klass->NumInterfaces(); i++) {
- ifcount += klass->GetInterface(i)->GetIFTableCount();
+ ifcount += klass->GetInterface(i)->GetIfTableCount();
}
if (ifcount == 0) {
// TODO: enable these asserts with klass status validation
- // DCHECK(klass->GetIFTableCount() == 0);
- // DCHECK(klass->GetIFTable() == NULL);
+ // DCHECK(klass->GetIfTableCount() == 0);
+ // DCHECK(klass->GetIfTable() == NULL);
return true;
}
- InterfaceEntry* iftable = new InterfaceEntry[ifcount];
- memset(iftable, 0x00, sizeof(InterfaceEntry) * ifcount);
+ ObjectArray<InterfaceEntry>* iftable = AllocObjectArray<InterfaceEntry>(ifcount);
if (super_ifcount != 0) {
- memcpy(iftable, klass->GetSuperClass()->GetIFTable(),
- sizeof(InterfaceEntry) * super_ifcount);
+ ObjectArray<InterfaceEntry>* super_iftable = klass->GetSuperClass()->GetIfTable();
+ for (size_t i = 0; i < super_ifcount; i++) {
+ iftable->Set(i, AllocInterfaceEntry(super_iftable->Get(i)->GetInterface()));
+ }
}
// Flatten the interface inheritance hierarchy.
size_t idx = super_ifcount;
for (size_t i = 0; i < klass->NumInterfaces(); i++) {
- Class* interf = klass->GetInterface(i);
- DCHECK(interf != NULL);
- if (!interf->IsInterface()) {
+ Class* interface = klass->GetInterface(i);
+ DCHECK(interface != NULL);
+ if (!interface->IsInterface()) {
LG << "Class implements non-interface class"; // TODO: IncompatibleClassChangeError
return false;
}
- iftable[idx++].SetInterface(interf);
- for (size_t j = 0; j < interf->GetIFTableCount(); j++) {
- iftable[idx++].SetInterface(interf->GetIFTable()[j].GetInterface());
+ iftable->Set(idx++, AllocInterfaceEntry(interface));
+ for (int32_t j = 0; j < interface->GetIfTableCount(); j++) {
+ iftable->Set(idx++, AllocInterfaceEntry(interface->GetIfTable()->Get(j)->GetInterface()));
}
}
- klass->SetIFTable(iftable);
+ klass->SetIfTable(iftable);
CHECK_EQ(idx, ifcount);
- klass->SetIFTableCount(ifcount);
if (klass->IsInterface() || super_ifcount == ifcount) {
return true;
}
- for (size_t i = super_ifcount; i < ifcount; i++) {
- pool_size += iftable[i].GetInterface()->NumVirtualMethods();
- }
- if (pool_size == 0) {
- return true;
- }
- klass->SetIfviPoolCount(pool_size);
- uint32_t* ifvi_pool = new uint32_t[pool_size];
- klass->SetIfviPool(ifvi_pool);
std::vector<Method*> miranda_list;
- for (size_t i = super_ifcount; i < ifcount; ++i) {
- iftable[i].SetMethodIndexArray(ifvi_pool + pool_offset);
- Class* interface = iftable[i].GetInterface();
- pool_offset += interface->NumVirtualMethods(); // end here
+ for (size_t i = 0; i < ifcount; ++i) {
+ InterfaceEntry* interface_entry = iftable->Get(i);
+ Class* interface = interface_entry->GetInterface();
+ ObjectArray<Method>* method_array = AllocObjectArray<Method>(interface->NumVirtualMethods());
+ interface_entry->SetMethodArray(method_array);
ObjectArray<Method>* vtable = klass->GetVTableDuringLinking();
for (size_t j = 0; j < interface->NumVirtualMethods(); ++j) {
Method* interface_method = interface->GetVirtualMethod(j);
- int k; // must be signed
+ int32_t k;
for (k = vtable->GetLength() - 1; k >= 0; --k) {
Method* vtable_method = vtable->Get(k);
if (interface_method->HasSameNameAndDescriptor(vtable_method)) {
@@ -1756,7 +1749,7 @@
LG << "Implementation not public";
return false;
}
- iftable[i].GetMethodIndexArray()[j] = k;
+ method_array->Set(j, vtable_method);
break;
}
}
@@ -1769,16 +1762,16 @@
miranda_list.resize(miranda_alloc);
}
}
+ Method* miranda_method = NULL;
int mir;
for (mir = 0; mir < miranda_count; mir++) {
- Method* miranda_method = miranda_list[mir];
+ miranda_method = miranda_list[mir];
if (miranda_method->HasSameNameAndDescriptor(interface_method)) {
break;
}
}
- // point the interface table at a phantom slot index
- iftable[i].GetMethodIndexArray()[j] =
- vtable->GetLength() + mir;
+ // point the interface table at a phantom slot
+ method_array->Set(j, miranda_method);
if (mir == miranda_count) {
miranda_list[miranda_count++] = interface_method;
}
diff --git a/src/class_linker.h b/src/class_linker.h
index fe375c2..e9606a7 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -175,6 +175,7 @@
Field* AllocField();
Method* AllocMethod();
CodeAndDirectMethods* AllocCodeAndDirectMethods(size_t length);
+ InterfaceEntry* AllocInterfaceEntry(Class* interface);
Class* CreatePrimitiveClass(const char* descriptor,
Class::PrimitiveType type);
@@ -331,7 +332,7 @@
}
ObjectArray<Class>* array_interfaces_;
- InterfaceEntry* array_iftable_;
+ ObjectArray<InterfaceEntry>* array_iftable_;
bool init_done_;
diff --git a/src/class_linker_test.cc b/src/class_linker_test.cc
index c3bb4c3..eab184e 100644
--- a/src/class_linker_test.cc
+++ b/src/class_linker_test.cc
@@ -390,16 +390,26 @@
bool error = false;
- if (!klass->IsClassClass() && instance)
- if (size != (instance ? klass->GetObjectSize() : klass->GetClassSize())) {
+ if (!klass->IsClassClass() && instance) {
+ size_t expected_size = instance ? klass->GetObjectSize() : klass->GetClassSize();
+ if (size != expected_size) {
LG << "Class size mismatch:"
<< " class=" << class_descriptor
<< " Java=" << klass->GetObjectSize()
- << " C++=" << (instance ? klass->GetObjectSize() : klass->GetClassSize());
+ << " C++=" << expected_size;
+ error = true;
+ }
+ }
+
+ size_t num_fields = instance ? klass->NumInstanceFields() : klass->NumStaticFields();
+ if (offsets.size() != num_fields) {
+ LG << "Field count mismatch:"
+ << " class=" << class_descriptor
+ << " Java=" << num_fields
+ << " C++=" << offsets.size();
error = true;
}
- CHECK_EQ(offsets.size(), instance ? klass->NumInstanceFields() : klass->NumStaticFields());
for (size_t i = 0; i < offsets.size(); i++) {
Field* field = instance ? klass->GetInstanceField(i) : klass->GetStaticField(i);
if (!field->GetName()->Equals(offsets[i].java_name)) {
@@ -550,9 +560,11 @@
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, dex_cache_), "shadow$_dex_cache_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, direct_methods_), "shadow$_direct_methods_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, ifields_), "shadow$_ifields_"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, iftable_), "shadow$_iftable_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, interfaces_), "shadow$_interfaces_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, interfaces_type_idx_), "shadow$_interfaces_type_idx_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, sfields_), "shadow$_sfields_"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, source_file_), "shadow$_source_file_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, super_class_), "shadow$_super_class_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, verify_error_class_), "shadow$_verify_error_class_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, virtual_methods_), "shadow$_virtual_methods_"));
@@ -563,17 +575,12 @@
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, array_rank_), "shadow$_array_rank_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, class_size_), "shadow$_class_size_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, clinit_thread_id_), "shadow$_clinit_thread_id_"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, iftable_), "shadow$_iftable_"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, iftable_count_), "shadow$_iftable_count_"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, ifvi_pool_), "shadow$_ifvi_pool_"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, ifvi_pool_count_), "shadow$_ifvi_pool_count_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, num_reference_instance_fields_), "shadow$_num_reference_instance_fields_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, num_reference_static_fields_), "shadow$_num_reference_static_fields_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, object_size_), "shadow$_object_size_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, primitive_type_), "shadow$_primitive_type_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, reference_instance_offsets_), "shadow$_reference_instance_offsets_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, reference_static_offsets_), "shadow$_reference_static_offsets_"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, source_file_), "shadow$_source_file_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, status_), "shadow$_status_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, super_class_type_idx_), "shadow$_super_class_type_idx_"));
};
@@ -662,9 +669,6 @@
size = sizeof(ClassClass);
class_descriptor = "Ljava/lang/Class;";
- // padding 32-bit
- // this space intentionally left blank
-
// alphabetical 64-bit
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(ClassClass, serialVersionUID_), "serialVersionUID"));
};
@@ -680,11 +684,11 @@
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(StringClass, ASCII_), "ASCII"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(StringClass, CASE_INSENSITIVE_ORDER_), "CASE_INSENSITIVE_ORDER"));
- // padding 32-bit
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(StringClass, REPLACEMENT_CHAR_), "REPLACEMENT_CHAR"));
-
// alphabetical 64-bit
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(StringClass, serialVersionUID_), "serialVersionUID"));
+
+ // alphabetical 32-bit
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(StringClass, REPLACEMENT_CHAR_), "REPLACEMENT_CHAR"));
};
};
diff --git a/src/dex_cache.h b/src/dex_cache.h
index 22dae24..0ac2ee1 100644
--- a/src/dex_cache.h
+++ b/src/dex_cache.h
@@ -182,9 +182,9 @@
return static_cast<ObjectArray<StaticStorageBase>*>(GetNonNull(kInitializedStaticStorage));
}
- static size_t LengthAsArray() {
- return kMax;
- }
+ static size_t LengthAsArray() {
+ return kMax;
+ }
private:
diff --git a/src/object.cc b/src/object.cc
index 2c66690..3696374 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -497,9 +497,8 @@
bool have_executable_code = (GetCode() != NULL);
#if !defined(__arm__)
- // Currently we can only compile for ARM, so we can't execute
- // code on other architectures even if we do have it.
- have_executable_code = false;
+ // Currently we can only compile non-native methods for ARM.
+ have_executable_code = IsNative();
#endif
if (have_executable_code && stub != NULL) {
@@ -620,8 +619,10 @@
// All interfaces implemented directly and by our superclass, and
// recursively all super-interfaces of those interfaces, are listed
// in iftable_, so we can just do a linear scan through that.
- for (size_t i = 0; i < iftable_count_; i++) {
- if (iftable_[i].GetInterface() == klass) {
+ int32_t iftable_count = GetIfTableCount();
+ ObjectArray<InterfaceEntry>* iftable = GetIfTable();
+ for (int32_t i = 0; i < iftable_count; i++) {
+ if (iftable->Get(i)->GetInterface() == klass) {
return true;
}
}
@@ -783,11 +784,12 @@
Class* declaring_class = method->GetDeclaringClass();
DCHECK(declaring_class->IsInterface());
// TODO cache to improve lookup speed
- for (size_t i = 0; i < iftable_count_; i++) {
- InterfaceEntry& interface_entry = iftable_[i];
- if (interface_entry.GetInterface() == declaring_class) {
- return GetVTable()->Get(
- interface_entry.GetMethodIndexArray()[method->GetMethodIndex()]);
+ int32_t iftable_count = GetIfTableCount();
+ ObjectArray<InterfaceEntry>* iftable = GetIfTable();
+ for (int32_t i = 0; i < iftable_count; i++) {
+ InterfaceEntry* interface_entry = iftable->Get(i);
+ if (interface_entry->GetInterface() == declaring_class) {
+ return interface_entry->GetMethodArray()->Get(method->GetMethodIndex());
}
}
UNIMPLEMENTED(FATAL) << "Need to throw an error of some kind";
@@ -802,9 +804,10 @@
return method;
}
- InterfaceEntry* iftable = GetIFTable();
- for (size_t i = 0; i < GetIFTableCount(); i++) {
- method = iftable[i].GetInterface()->FindVirtualMethod(name, signature);
+ int32_t iftable_count = GetIfTableCount();
+ ObjectArray<InterfaceEntry>* iftable = GetIfTable();
+ for (int32_t i = 0; i < iftable_count; i++) {
+ method = iftable->Get(i)->GetInterface()->FindVirtualMethod(name, signature);
if (method != NULL) {
return method;
}
diff --git a/src/object.h b/src/object.h
index 8f51244..b7cbee5 100644
--- a/src/object.h
+++ b/src/object.h
@@ -1072,7 +1072,7 @@
// in Class::vtable_.
//
// For abstract methods in an interface class, this is the offset
- // of the method in "iftable_[n]->method_index_array_".
+ // of the method in "iftable_->Get(n)->GetMethodArray()".
uint32_t method_index_; // (could be uint16_t)
// The target native method registered with this method
@@ -1761,49 +1761,23 @@
return GetInterfaces()->Get(i);
}
- size_t GetIFTableCount() const {
- DCHECK(IsResolved());
- DCHECK(sizeof(size_t) == sizeof(int32_t));
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, iftable_count_), false);
+ int32_t GetIfTableCount() const {
+ ObjectArray<InterfaceEntry>* iftable = GetIfTable();
+ if (iftable == NULL) {
+ return 0;
+ }
+ return iftable->GetLength();
}
- void SetIFTableCount(size_t new_iftable_count) {
- DCHECK(sizeof(size_t) == sizeof(int32_t));
- SetField32(OFFSET_OF_OBJECT_MEMBER(Class, iftable_count_),
- new_iftable_count, false);
- }
-
- InterfaceEntry* GetIFTable() const {
+ ObjectArray<InterfaceEntry>* GetIfTable() const {
DCHECK(IsResolved());
- return GetFieldPtr<InterfaceEntry*>(
+ return GetFieldObject<ObjectArray<InterfaceEntry>*>(
OFFSET_OF_OBJECT_MEMBER(Class, iftable_), false);
}
- void SetIFTable(InterfaceEntry* new_iftable) {
- SetFieldPtr<InterfaceEntry*>(OFFSET_OF_OBJECT_MEMBER(Class, iftable_),
- new_iftable, false);
- }
-
- size_t GetIfviPoolCount() const {
- DCHECK(IsResolved());
- CHECK(sizeof(size_t) == sizeof(int32_t));
- return GetField32(OFFSET_OF_OBJECT_MEMBER(Class, ifvi_pool_count_), false);
- }
-
- void SetIfviPoolCount(size_t new_count) {
- CHECK(sizeof(size_t) == sizeof(int32_t));
- SetField32(OFFSET_OF_OBJECT_MEMBER(Class, ifvi_pool_count_), new_count,
- false);
- }
-
- uint32_t* GetIfviPool() const {
- DCHECK(IsResolved());
- return GetFieldPtr<uint32_t*>(
- OFFSET_OF_OBJECT_MEMBER(Class, ifvi_pool_), false);
- }
-
- void SetIfviPool(uint32_t* new_pool) {
- SetFieldPtr(OFFSET_OF_OBJECT_MEMBER(Class, ifvi_pool_), new_pool, false);
+ void SetIfTable(ObjectArray<InterfaceEntry>* new_iftable) {
+ SetFieldObject(OFFSET_OF_OBJECT_MEMBER(Class, iftable_),
+ new_iftable, false);
}
// Get instance fields
@@ -1955,14 +1929,14 @@
klass, false);
}
- const char* GetSourceFile() const {
+ String* GetSourceFile() const {
DCHECK(IsLoaded());
- return GetFieldPtr<const char*>(
+ return GetFieldPtr<String*>(
OFFSET_OF_OBJECT_MEMBER(Class, source_file_), false);
}
- void SetSourceFile(const char* new_source_file) {
- SetFieldPtr<const char*>(OFFSET_OF_OBJECT_MEMBER(Class, source_file_),
+ void SetSourceFile(String* new_source_file) {
+ SetFieldPtr<String*>(OFFSET_OF_OBJECT_MEMBER(Class, source_file_),
new_source_file, false);
}
@@ -1981,7 +1955,7 @@
// For array classes, the class object for base element, for
// instanceof/checkcast (for String[][][], this will be String).
// Otherwise, NULL.
- Class* component_type_; // TODO: make an instance field
+ Class* component_type_;
// descriptor for the class such as "Ljava/lang/Class;" or "[C"
String* descriptor_;
@@ -2005,6 +1979,21 @@
// specifies the number of reference fields.
ObjectArray<Field>* ifields_;
+ // Interface table (iftable_), one entry per interface supported by
+ // this class. That means one entry for each interface we support
+ // directly, indirectly via superclass, or indirectly via
+ // superinterface. This will be null if neither we nor our
+ // superclass implement any interfaces.
+ //
+ // Why we need this: given "class Foo implements Face", declare
+ // "Face faceObj = new Foo()". Invoke faceObj.blah(), where "blah"
+ // is part of the Face interface. We can't easily use a single
+ // vtable.
+ //
+ // For every interface a concrete class implements, we create an array
+ // of the concrete vtable_ methods for the methods in the interface.
+ ObjectArray<InterfaceEntry>* iftable_;
+
// array of interfaces this class implements directly
// see also interfaces_type_idx_
ObjectArray<Class>* interfaces_;
@@ -2016,6 +2005,9 @@
// Static fields
ObjectArray<Field>* sfields_;
+ // source file name, if known. Otherwise, NULL.
+ String* source_file_;
+
// The superclass, or NULL if this is java.lang.Object or a
// primitive type.
// see also super_class_type_idx_;
@@ -2046,40 +2038,6 @@
// threadId, used to check for recursive <clinit> invocation
pid_t clinit_thread_id_;
- // Interface table (iftable_), one entry per interface supported by
- // this class. That means one entry for each interface we support
- // directly, indirectly via superclass, or indirectly via
- // superinterface. This will be null if neither we nor our
- // superclass implement any interfaces.
- //
- // Why we need this: given "class Foo implements Face", declare
- // "Face faceObj = new Foo()". Invoke faceObj.blah(), where "blah"
- // is part of the Face interface. We can't easily use a single
- // vtable.
- //
- // For every interface a concrete class implements, we create a list
- // of virtualMethod indices for the methods in the interface.
- //
- // see also iftable_count_;
- // TODO convert to ObjectArray<?>
- //
- InterfaceEntry* iftable_;
-
- // size of iftable_
- size_t iftable_count_;
-
- // The interface vtable indices for iftable get stored here. By
- // placing them all in a single pool for each class that implements
- // interfaces, we decrease the number of allocations.
- //
- // see also ifvi_pool_count_
- //
- // TODO convert to IntArray
- uint32_t* ifvi_pool_;
-
- // size of ifvi_pool_
- size_t ifvi_pool_count_;
-
// number of instance fields that are object refs
size_t num_reference_instance_fields_;
@@ -2099,9 +2057,6 @@
// Bitmap of offsets of sfields.
uint32_t reference_static_offsets_;
- // source file name, if known. Otherwise, NULL.
- const char* source_file_;
-
// state of class initialization
Status status_;
@@ -2328,8 +2283,6 @@
class ClassClass : public Class {
private:
- // Padding to ensure the 64-bit serialVersionUID_ begins on a 8-byte boundary
- int32_t padding_;
int64_t serialVersionUID_;
friend struct ClassClassOffsets; // for verifying offset information
DISALLOW_IMPLICIT_CONSTRUCTORS(ClassClass);
@@ -2339,8 +2292,8 @@
private:
CharArray* ASCII_;
Object* CASE_INSENSITIVE_ORDER_;
- uint32_t REPLACEMENT_CHAR_;
int64_t serialVersionUID_;
+ uint32_t REPLACEMENT_CHAR_;
friend struct StringClassOffsets; // for verifying offset information
DISALLOW_IMPLICIT_CONSTRUCTORS(StringClass);
};
@@ -2725,39 +2678,49 @@
DISALLOW_IMPLICIT_CONSTRUCTORS(StackTraceElement);
};
-class InterfaceEntry {
+ class InterfaceEntry : public ObjectArray<Object> {
public:
- InterfaceEntry() : interface_(NULL), method_index_array_(NULL) {
- }
-
Class* GetInterface() const {
- DCHECK(interface_ != NULL);
- return interface_;
+ Class* interface = Get(kInterface)->AsClass();
+ DCHECK(interface != NULL);
+ return interface;
}
void SetInterface(Class* interface) {
+ DCHECK(interface != NULL);
DCHECK(interface->IsInterface());
- interface_ = interface;
+ DCHECK(Get(kInterface) == NULL);
+ Set(kInterface, interface);
}
- uint32_t* GetMethodIndexArray() const {
- return method_index_array_;
+ ObjectArray<Method>* GetMethodArray() const {
+ ObjectArray<Method>* method_array = down_cast<ObjectArray<Method>*>(Get(kMethodArray));
+ DCHECK(method_array != NULL);
+ return method_array;
}
- void SetMethodIndexArray(uint32_t* new_mia) {
- method_index_array_ = new_mia;
+ void SetMethodArray(ObjectArray<Method>* new_ma) {
+ DCHECK(new_ma != NULL);
+ DCHECK(Get(kMethodArray) == NULL);
+ Set(kMethodArray, new_ma);
+ }
+
+ static size_t LengthAsArray() {
+ return kMax;
}
private:
- // Points to the interface class.
- Class* interface_;
- // Index into array of vtable offsets. This points into the
- // ifvi_pool_, which holds the vtables for all interfaces declared by
- // this class.
- uint32_t* method_index_array_;
+ enum ArrayIndex {
+ // Points to the interface class.
+ kInterface = 0,
+ // Method pointers into the vtable, allow fast map from interface
+ // method index to concrete instance method.
+ kMethodArray = 1,
+ kMax = 2,
+ };
- DISALLOW_COPY_AND_ASSIGN(InterfaceEntry);
+ DISALLOW_IMPLICIT_CONSTRUCTORS(InterfaceEntry);
};
} // namespace art
diff --git a/src/thread.cc b/src/thread.cc
index 9361d00..78cb1c6 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -325,7 +325,11 @@
if (errno != 0) {
PLOG(FATAL) << "pthread_mutexattr_init failed";
}
+#if VERIFY_OBJECT_ENABLED
+ errno = pthread_mutexattr_settype(&debug_attributes, PTHREAD_MUTEX_RECURSIVE);
+#else
errno = pthread_mutexattr_settype(&debug_attributes, PTHREAD_MUTEX_ERRORCHECK);
+#endif
if (errno != 0) {
PLOG(FATAL) << "pthread_mutexattr_settype failed";
}
@@ -928,7 +932,7 @@
StackTraceElement* obj =
StackTraceElement::Alloc(readable_descriptor,
method->GetName(),
- String::AllocFromModifiedUtf8(klass->GetSourceFile()),
+ klass->GetSourceFile(),
dex_file.GetLineNumFromPC(method,
method->ToDexPC(build_trace_visitor.GetPC(i))));
java_traces->Set(i, obj);
