Move rest of code related blobs from Method to oat
Change-Id: I55041b564ab65317c8b1f863005f20ba650a0322
diff --git a/build/Android.common.mk b/build/Android.common.mk
index ae713d0..605c48b 100644
--- a/build/Android.common.mk
+++ b/build/Android.common.mk
@@ -73,6 +73,7 @@
src/check_jni.cc \
src/class_linker.cc \
src/class_loader.cc \
+ src/compiled_method.cc \
src/compiler.cc \
src/compiler/Dataflow.cc \
src/compiler/Frontend.cc \
diff --git a/src/calling_convention.cc b/src/calling_convention.cc
index 17bfcff..5256ee1 100644
--- a/src/calling_convention.cc
+++ b/src/calling_convention.cc
@@ -17,7 +17,7 @@
// Managed runtime calling convention
ManagedRuntimeCallingConvention* ManagedRuntimeCallingConvention::Create(
- Method* native_method, InstructionSet instruction_set) {
+ const Method* native_method, InstructionSet instruction_set) {
if (instruction_set == kX86) {
return new x86::X86ManagedRuntimeCallingConvention(native_method);
} else {
@@ -67,7 +67,7 @@
// JNI calling convention
-JniCallingConvention* JniCallingConvention::Create(Method* native_method,
+JniCallingConvention* JniCallingConvention::Create(const Method* native_method,
InstructionSet instruction_set) {
if (instruction_set == kX86) {
return new x86::X86JniCallingConvention(native_method);
@@ -152,7 +152,7 @@
}
}
-size_t JniCallingConvention::NumberOfExtraArgumentsForJni(Method* method) {
+size_t JniCallingConvention::NumberOfExtraArgumentsForJni(const Method* method) {
// The first argument is the JNIEnv*.
// Static methods have an extra argument which is the jclass.
return method->IsStatic() ? 2 : 1;
diff --git a/src/calling_convention.h b/src/calling_convention.h
index b57fd4d..3a7cf1e 100644
--- a/src/calling_convention.h
+++ b/src/calling_convention.h
@@ -42,10 +42,10 @@
virtual ~CallingConvention() {}
protected:
- explicit CallingConvention(Method* method) : displacement_(0),
- method_(method) {}
+ explicit CallingConvention(const Method* method)
+ : displacement_(0), method_(const_cast<Method*>(method)) {}
- Method* GetMethod() const { return method_; }
+ const Method* GetMethod() const { return method_; }
// The slot number for current calling_convention argument.
// Note that each slot is 32-bit. When the current argument is bigger
@@ -74,8 +74,8 @@
// | { Method* } | <-- SP
class ManagedRuntimeCallingConvention : public CallingConvention {
public:
- static ManagedRuntimeCallingConvention* Create(Method* native_method,
- InstructionSet instruction_set);
+ static ManagedRuntimeCallingConvention* Create(const Method* native_method,
+ InstructionSet instruction_set);
size_t FrameSize();
@@ -97,7 +97,7 @@
virtual ~ManagedRuntimeCallingConvention() {}
protected:
- explicit ManagedRuntimeCallingConvention(Method* method) :
+ explicit ManagedRuntimeCallingConvention(const Method* method) :
CallingConvention(method) {}
};
@@ -117,7 +117,7 @@
// callee saves for frames above this one.
class JniCallingConvention : public CallingConvention {
public:
- static JniCallingConvention* Create(Method* native_method,
+ static JniCallingConvention* Create(const Method* native_method,
InstructionSet instruction_set);
// Size of frame excluding space for outgoing args (its assumed Method* is
@@ -186,7 +186,7 @@
kObjectOrClass = 1
};
- explicit JniCallingConvention(Method* native_method) :
+ explicit JniCallingConvention(const Method* native_method) :
CallingConvention(native_method) {}
// Number of stack slots for outgoing arguments, above which the SIRT is
@@ -194,7 +194,7 @@
virtual size_t NumberOfOutgoingStackArgs() = 0;
protected:
- static size_t NumberOfExtraArgumentsForJni(Method* method);
+ static size_t NumberOfExtraArgumentsForJni(const Method* method);
};
} // namespace art
diff --git a/src/calling_convention_arm.cc b/src/calling_convention_arm.cc
index e4f7b19f..29003a2 100644
--- a/src/calling_convention_arm.cc
+++ b/src/calling_convention_arm.cc
@@ -17,7 +17,7 @@
return ArmManagedRegister::FromCoreRegister(IP); // R12
}
-static ManagedRegister ReturnRegisterForMethod(Method* method) {
+static ManagedRegister ReturnRegisterForMethod(const Method* method) {
if (method->IsReturnAFloat()) {
return ArmManagedRegister::FromCoreRegister(R0);
} else if (method->IsReturnADouble()) {
@@ -99,7 +99,8 @@
// JNI calling convention
-ArmJniCallingConvention::ArmJniCallingConvention(Method* method) : JniCallingConvention(method) {
+ArmJniCallingConvention::ArmJniCallingConvention(const Method* method)
+ : JniCallingConvention(method) {
// Compute padding to ensure longs and doubles are not split in AAPCS
// TODO: in terms of outgoing argument size this may be overly generous
// due to padding appearing in the registers
@@ -159,7 +160,7 @@
// in even register numbers and stack slots
void ArmJniCallingConvention::Next() {
JniCallingConvention::Next();
- Method* method = GetMethod();
+ const Method* method = GetMethod();
size_t arg_pos = itr_args_ - NumberOfExtraArgumentsForJni(method);
if ((itr_args_ >= 2) &&
(arg_pos < GetMethod()->NumArgs()) &&
@@ -184,7 +185,7 @@
};
ManagedRegister ArmJniCallingConvention::CurrentParamRegister() {
CHECK_LT(itr_slots_, 4u);
- Method* method = GetMethod();
+ const Method* method = GetMethod();
int arg_pos = itr_args_ - NumberOfExtraArgumentsForJni(method);
if ((itr_args_ >= 2) && method->IsParamALongOrDouble(arg_pos)) {
CHECK_EQ(itr_slots_, 2u);
@@ -202,7 +203,7 @@
}
size_t ArmJniCallingConvention::NumberOfOutgoingStackArgs() {
- Method* method = GetMethod();
+ const Method* method = GetMethod();
size_t static_args = method->IsStatic() ? 1 : 0; // count jclass
// regular argument parameters and this
size_t param_args = method->NumArgs() +
diff --git a/src/calling_convention_arm.h b/src/calling_convention_arm.h
index 984250e..2a056a8 100644
--- a/src/calling_convention_arm.h
+++ b/src/calling_convention_arm.h
@@ -10,7 +10,7 @@
class ArmManagedRuntimeCallingConvention : public ManagedRuntimeCallingConvention {
public:
- explicit ArmManagedRuntimeCallingConvention(Method* method) :
+ explicit ArmManagedRuntimeCallingConvention(const Method* method) :
ManagedRuntimeCallingConvention(method) {}
virtual ~ArmManagedRuntimeCallingConvention() {}
// Calling convention
@@ -29,7 +29,7 @@
class ArmJniCallingConvention : public JniCallingConvention {
public:
- explicit ArmJniCallingConvention(Method* method);
+ explicit ArmJniCallingConvention(const Method* method);
virtual ~ArmJniCallingConvention() {}
// Calling convention
virtual ManagedRegister ReturnRegister();
diff --git a/src/calling_convention_x86.cc b/src/calling_convention_x86.cc
index ad7921d..da76e17 100644
--- a/src/calling_convention_x86.cc
+++ b/src/calling_convention_x86.cc
@@ -22,7 +22,7 @@
return ManagedRegister::NoRegister(); // No free regs, so assembler uses push/pop
}
-static ManagedRegister ReturnRegisterForMethod(Method* method) {
+static ManagedRegister ReturnRegisterForMethod(const Method* method) {
if (method->IsReturnAFloatOrDouble()) {
return X86ManagedRegister::FromX87Register(ST0);
} else if (method->IsReturnALong()) {
diff --git a/src/calling_convention_x86.h b/src/calling_convention_x86.h
index cb27ef6..b796ba0 100644
--- a/src/calling_convention_x86.h
+++ b/src/calling_convention_x86.h
@@ -10,7 +10,7 @@
class X86ManagedRuntimeCallingConvention : public ManagedRuntimeCallingConvention {
public:
- explicit X86ManagedRuntimeCallingConvention(Method* method) :
+ explicit X86ManagedRuntimeCallingConvention(const Method* method) :
ManagedRuntimeCallingConvention(method) {}
virtual ~X86ManagedRuntimeCallingConvention() {}
// Calling convention
@@ -29,7 +29,7 @@
class X86JniCallingConvention : public JniCallingConvention {
public:
- explicit X86JniCallingConvention(Method* method) :
+ explicit X86JniCallingConvention(const Method* method) :
JniCallingConvention(method) {}
virtual ~X86JniCallingConvention() {}
// Calling convention
diff --git a/src/class_linker.cc b/src/class_linker.cc
index 1ec482a..2cbac12 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -2034,13 +2034,13 @@
bool ClassLinker::LinkInstanceFields(Class* klass) {
CHECK(klass != NULL);
- return LinkFields(klass, true);
+ return LinkFields(klass, false);
}
bool ClassLinker::LinkStaticFields(Class* klass) {
CHECK(klass != NULL);
size_t allocated_class_size = klass->GetClassSize();
- bool success = LinkFields(klass, false);
+ bool success = LinkFields(klass, true);
CHECK_EQ(allocated_class_size, klass->GetClassSize());
return success;
}
@@ -2068,26 +2068,26 @@
}
};
-bool ClassLinker::LinkFields(Class* klass, bool instance) {
+bool ClassLinker::LinkFields(Class* klass, bool is_static) {
size_t num_fields =
- instance ? klass->NumInstanceFields() : klass->NumStaticFields();
+ is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
ObjectArray<Field>* fields =
- instance ? klass->GetIFields() : klass->GetSFields();
+ is_static ? klass->GetSFields() : klass->GetIFields();
// Initialize size and field_offset
size_t size;
MemberOffset field_offset(0);
- if (instance) {
+ if (is_static) {
+ size = klass->GetClassSize();
+ field_offset = Class::FieldsOffset();
+ } else {
Class* super_class = klass->GetSuperClass();
if (super_class != NULL) {
CHECK(super_class->IsResolved());
field_offset = MemberOffset(super_class->GetObjectSize());
}
size = field_offset.Uint32Value();
- } else {
- size = klass->GetClassSize();
- field_offset = Class::FieldsOffset();
}
CHECK_EQ(num_fields == 0, fields == NULL);
@@ -2161,7 +2161,7 @@
}
// We lie to the GC about the java.lang.ref.Reference.referent field, so it doesn't scan it.
- if (instance && klass->GetDescriptor()->Equals("Ljava/lang/ref/Reference;")) {
+ if (!is_static && klass->GetDescriptor()->Equals("Ljava/lang/ref/Reference;")) {
// We know there are no non-reference fields in the Reference classes, and we know
// that 'referent' is alphabetically last, so this is easy...
CHECK_EQ(num_reference_fields, num_fields);
@@ -2176,7 +2176,7 @@
for (size_t i = 0; i < num_fields; i++) {
Field* field = fields->Get(i);
if (false) { // enable to debug field layout
- LOG(INFO) << "LinkFields: " << (instance ? "instance" : "static")
+ LOG(INFO) << "LinkFields: " << (is_static ? "static" : "instance")
<< " class=" << PrettyClass(klass)
<< " field=" << PrettyField(field)
<< " offset=" << field->GetField32(MemberOffset(Field::OffsetOffset()), false);
@@ -2201,14 +2201,14 @@
#endif
size = field_offset.Uint32Value();
// Update klass
- if (instance) {
+ if (is_static) {
+ klass->SetNumReferenceStaticFields(num_reference_fields);
+ klass->SetClassSize(size);
+ } else {
klass->SetNumReferenceInstanceFields(num_reference_fields);
if (!klass->IsVariableSize()) {
klass->SetObjectSize(size);
}
- } else {
- klass->SetNumReferenceStaticFields(num_reference_fields);
- klass->SetClassSize(size);
}
return true;
}
@@ -2226,20 +2226,20 @@
return;
}
}
- CreateReferenceOffsets(klass, true, reference_offsets);
+ CreateReferenceOffsets(klass, false, reference_offsets);
}
void ClassLinker::CreateReferenceStaticOffsets(Class* klass) {
- CreateReferenceOffsets(klass, false, 0);
+ CreateReferenceOffsets(klass, true, 0);
}
-void ClassLinker::CreateReferenceOffsets(Class* klass, bool instance,
+void ClassLinker::CreateReferenceOffsets(Class* klass, bool is_static,
uint32_t reference_offsets) {
size_t num_reference_fields =
- instance ? klass->NumReferenceInstanceFieldsDuringLinking()
- : klass->NumReferenceStaticFieldsDuringLinking();
+ is_static ? klass->NumReferenceStaticFieldsDuringLinking()
+ : klass->NumReferenceInstanceFieldsDuringLinking();
const ObjectArray<Field>* fields =
- instance ? klass->GetIFields() : klass->GetSFields();
+ is_static ? klass->GetSFields() : klass->GetIFields();
// All of the fields that contain object references are guaranteed
// to be at the beginning of the fields list.
for (size_t i = 0; i < num_reference_fields; ++i) {
@@ -2258,10 +2258,10 @@
}
}
// Update fields in klass
- if (instance) {
- klass->SetReferenceInstanceOffsets(reference_offsets);
- } else {
+ if (is_static) {
klass->SetReferenceStaticOffsets(reference_offsets);
+ } else {
+ klass->SetReferenceInstanceOffsets(reference_offsets);
}
}
diff --git a/src/class_linker.h b/src/class_linker.h
index 304d37f..6d17a10 100644
--- a/src/class_linker.h
+++ b/src/class_linker.h
@@ -291,12 +291,12 @@
bool LinkStaticFields(Class* klass);
bool LinkInstanceFields(Class* klass);
- bool LinkFields(Class *klass, bool instance);
+ bool LinkFields(Class *klass, bool is_static);
void CreateReferenceInstanceOffsets(Class* klass);
void CreateReferenceStaticOffsets(Class* klass);
- void CreateReferenceOffsets(Class *klass, bool instance,
+ void CreateReferenceOffsets(Class *klass, bool is_static,
uint32_t reference_offsets);
// For use by ImageWriter to find DexCaches for its roots
diff --git a/src/class_linker_test.cc b/src/class_linker_test.cc
index 9ae64a3..025f9e3 100644
--- a/src/class_linker_test.cc
+++ b/src/class_linker_test.cc
@@ -304,7 +304,9 @@
template <typename T>
struct CheckOffsets {
- bool instance;
+ CheckOffsets(bool is_static, const char* class_descriptor)
+ : is_static(is_static), class_descriptor(class_descriptor) {}
+ bool is_static;
std::string class_descriptor;
std::vector<CheckOffset> offsets;
@@ -314,8 +316,8 @@
bool error = false;
- if (!klass->IsClassClass() && instance) {
- size_t expected_size = instance ? klass->GetObjectSize() : klass->GetClassSize();
+ if (!klass->IsClassClass() && !is_static) {
+ size_t expected_size = is_static ? klass->GetClassSize(): klass->GetObjectSize();
if (sizeof(T) != expected_size) {
LG << "Class size mismatch:"
<< " class=" << class_descriptor
@@ -325,7 +327,7 @@
}
}
- size_t num_fields = instance ? klass->NumInstanceFields() : klass->NumStaticFields();
+ size_t num_fields = is_static ? klass->NumStaticFields() : klass->NumInstanceFields();
if (offsets.size() != num_fields) {
LG << "Field count mismatch:"
<< " class=" << class_descriptor
@@ -335,7 +337,7 @@
}
for (size_t i = 0; i < offsets.size(); i++) {
- Field* field = instance ? klass->GetInstanceField(i) : klass->GetStaticField(i);
+ Field* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
if (!field->GetName()->Equals(offsets[i].java_name)) {
error = true;
}
@@ -343,7 +345,7 @@
if (error) {
for (size_t i = 0; i < offsets.size(); i++) {
CheckOffset& offset = offsets[i];
- Field* field = instance ? klass->GetInstanceField(i) : klass->GetStaticField(i);
+ Field* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
if (!field->GetName()->Equals(offsets[i].java_name)) {
LG << "JAVA FIELD ORDER MISMATCH NEXT LINE:";
}
@@ -356,7 +358,7 @@
for (size_t i = 0; i < offsets.size(); i++) {
CheckOffset& offset = offsets[i];
- Field* field = instance ? klass->GetInstanceField(i) : klass->GetStaticField(i);
+ Field* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
if (field->GetOffset().Uint32Value() != offset.cpp_offset) {
error = true;
}
@@ -364,7 +366,7 @@
if (error) {
for (size_t i = 0; i < offsets.size(); i++) {
CheckOffset& offset = offsets[i];
- Field* field = instance ? klass->GetInstanceField(i) : klass->GetStaticField(i);
+ Field* field = is_static ? klass->GetStaticField(i) : klass->GetInstanceField(i);
if (field->GetOffset().Uint32Value() != offset.cpp_offset) {
LG << "OFFSET MISMATCH NEXT LINE:";
}
@@ -375,15 +377,16 @@
return !error;
};
+
+ private:
+ DISALLOW_IMPLICIT_CONSTRUCTORS(CheckOffsets);
};
// Note that ClassLinkerTest.ValidateFieldOrderOfJavaCppUnionClasses
// is first since if it is failing, others are unlikely to succeed.
struct ObjectOffsets : public CheckOffsets<Object> {
- ObjectOffsets() {
- instance = true;
- class_descriptor = "Ljava/lang/Object;";
+ ObjectOffsets() : CheckOffsets<Object>(false, "Ljava/lang/Object;") {
// alphabetical references
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Object, klass_), "shadow$_klass_"));
@@ -394,17 +397,14 @@
};
struct AccessibleObjectOffsets : public CheckOffsets<AccessibleObject> {
- AccessibleObjectOffsets() {
- instance = true;
- class_descriptor = "Ljava/lang/reflect/AccessibleObject;";
+ AccessibleObjectOffsets()
+ : CheckOffsets<AccessibleObject>(false, "Ljava/lang/reflect/AccessibleObject;") {
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(AccessibleObject, java_flag_), "flag"));
};
};
struct FieldOffsets : public CheckOffsets<Field> {
- FieldOffsets() {
- instance = true;
- class_descriptor = "Ljava/lang/reflect/Field;";
+ FieldOffsets() : CheckOffsets<Field>(false, "Ljava/lang/reflect/Field;") {
// alphabetical references
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Field, declaring_class_), "declaringClass"));
@@ -422,9 +422,7 @@
};
struct MethodOffsets : public CheckOffsets<Method> {
- MethodOffsets() {
- instance = true;
- class_descriptor = "Ljava/lang/reflect/Method;";
+ MethodOffsets() : CheckOffsets<Method>(false, "Ljava/lang/reflect/Method;") {
// alphabetical references
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, declaring_class_), "declaringClass"));
@@ -436,20 +434,16 @@
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, name_), "name"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, java_parameter_types_), "parameterTypes"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, java_return_type_), "returnType"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, code_array_), "shadow$_code_array_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_code_and_direct_methods_), "shadow$_dex_cache_code_and_direct_methods_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_initialized_static_storage_), "shadow$_dex_cache_initialized_static_storage_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_resolved_fields_), "shadow$_dex_cache_resolved_fields_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_resolved_methods_), "shadow$_dex_cache_resolved_methods_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_resolved_types_), "shadow$_dex_cache_resolved_types_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, dex_cache_strings_), "shadow$_dex_cache_strings_"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, invoke_stub_array_), "shadow$_invoke_stub_array_"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, mapping_table_), "shadow$_mapping_table_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, register_map_data_), "shadow$_register_map_data_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, register_map_header_), "shadow$_register_map_header_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, shorty_), "shadow$_shorty_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, signature_), "shadow$_signature_"));
- offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, vmap_table_), "shadow$_vmap_table_"));
// alphabetical 32-bit
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, java_generic_types_are_initialized_), "genericTypesAreInitialized"));
@@ -461,6 +455,7 @@
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, frame_size_in_bytes_), "shadow$_frame_size_in_bytes_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, invoke_stub_), "shadow$_invoke_stub_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, java_return_type_idx_), "shadow$_java_return_type_idx_"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, mapping_table_), "shadow$_mapping_table_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, method_index_), "shadow$_method_index_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, native_method_), "shadow$_native_method_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, num_ins_), "shadow$_num_ins_"));
@@ -468,6 +463,7 @@
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, num_registers_), "shadow$_num_registers_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, proto_idx_), "shadow$_proto_idx_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, return_pc_offset_in_bytes_), "shadow$_return_pc_offset_in_bytes_"));
+ offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, vmap_table_), "shadow$_vmap_table_"));
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Method, java_slot_), "slot"));
};
};
@@ -480,9 +476,7 @@
};
struct ClassOffsets : public CheckOffsets<Class> {
- ClassOffsets() {
- instance = true;
- class_descriptor = "Ljava/lang/Class;";
+ ClassOffsets() : CheckOffsets<Class>(false, "Ljava/lang/Class;") {
// alphabetical references
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Class, name_), "name"));
@@ -518,9 +512,7 @@
};
struct StringOffsets : public CheckOffsets<String> {
- StringOffsets() {
- instance = true;
- class_descriptor = "Ljava/lang/String;";
+ StringOffsets() : CheckOffsets<String>(false, "Ljava/lang/String;") {
// alphabetical references
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(String, array_), "value"));
@@ -533,9 +525,7 @@
};
struct ThrowableOffsets : public CheckOffsets<Throwable> {
- ThrowableOffsets() {
- instance = true;
- class_descriptor = "Ljava/lang/Throwable;";
+ ThrowableOffsets() : CheckOffsets<Throwable>(false, "Ljava/lang/Throwable;") {
// alphabetical references
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(Throwable, cause_), "cause"));
@@ -547,9 +537,7 @@
};
struct StackTraceElementOffsets : public CheckOffsets<StackTraceElement> {
- StackTraceElementOffsets() {
- instance = true;
- class_descriptor = "Ljava/lang/StackTraceElement;";
+ StackTraceElementOffsets() : CheckOffsets<StackTraceElement>(false, "Ljava/lang/StackTraceElement;") {
// alphabetical references
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(StackTraceElement, declaring_class_), "declaringClass"));
@@ -560,9 +548,7 @@
};
struct ClassLoaderOffsets : public CheckOffsets<ClassLoader> {
- ClassLoaderOffsets() {
- instance = true;
- class_descriptor = "Ljava/lang/ClassLoader;";
+ ClassLoaderOffsets() : CheckOffsets<ClassLoader>(false, "Ljava/lang/ClassLoader;") {
// alphabetical references
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(ClassLoader, packages_), "packages"));
@@ -571,9 +557,8 @@
};
struct BaseDexClassLoaderOffsets : public CheckOffsets<BaseDexClassLoader> {
- BaseDexClassLoaderOffsets() {
- instance = true;
- class_descriptor = "Ldalvik/system/BaseDexClassLoader;";
+ BaseDexClassLoaderOffsets()
+ : CheckOffsets<BaseDexClassLoader>(false, "Ldalvik/system/BaseDexClassLoader;") {
// alphabetical references
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(BaseDexClassLoader, original_path_), "originalPath"));
@@ -582,16 +567,12 @@
};
struct PathClassLoaderOffsets : public CheckOffsets<PathClassLoader> {
- PathClassLoaderOffsets() {
- instance = true;
- class_descriptor = "Ldalvik/system/PathClassLoader;";
- };
+ PathClassLoaderOffsets()
+ : CheckOffsets<PathClassLoader>(false, "Ldalvik/system/PathClassLoader;") {};
};
struct ClassClassOffsets : public CheckOffsets<ClassClass> {
- ClassClassOffsets() {
- instance = false;
- class_descriptor = "Ljava/lang/Class;";
+ ClassClassOffsets() : CheckOffsets<ClassClass>(true, "Ljava/lang/Class;") {
// padding 32-bit
CHECK_EQ(OFFSETOF_MEMBER(ClassClass, padding_) + 4,
@@ -603,9 +584,7 @@
};
struct StringClassOffsets : public CheckOffsets<StringClass> {
- StringClassOffsets() {
- instance = false;
- class_descriptor = "Ljava/lang/String;";
+ StringClassOffsets() : CheckOffsets<StringClass>(true, "Ljava/lang/String;") {
// alphabetical references
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(StringClass, ASCII_), "ASCII"));
@@ -620,9 +599,7 @@
};
struct FieldClassOffsets : public CheckOffsets<FieldClass> {
- FieldClassOffsets() {
- instance = false;
- class_descriptor = "Ljava/lang/reflect/Field;";
+ FieldClassOffsets() : CheckOffsets<FieldClass>(true, "Ljava/lang/reflect/Field;") {
// alphabetical references
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(FieldClass, ORDER_BY_NAME_AND_DECLARING_CLASS_), "ORDER_BY_NAME_AND_DECLARING_CLASS"));
@@ -640,9 +617,7 @@
};
struct MethodClassOffsets : public CheckOffsets<MethodClass> {
- MethodClassOffsets() {
- instance = false;
- class_descriptor = "Ljava/lang/reflect/Method;";
+ MethodClassOffsets() : CheckOffsets<MethodClass>(true, "Ljava/lang/reflect/Method;") {
// alphabetical references
offsets.push_back(CheckOffset(OFFSETOF_MEMBER(MethodClass, ORDER_BY_SIGNATURE_), "ORDER_BY_SIGNATURE"));
diff --git a/src/common_test.h b/src/common_test.h
index 84b97e9..1039ff1 100644
--- a/src/common_test.h
+++ b/src/common_test.h
@@ -16,6 +16,7 @@
#include "file.h"
#include "gtest/gtest.h"
#include "heap.h"
+#include "oat_file.h"
#include "os.h"
#include "runtime.h"
#include "stl_util.h"
@@ -79,10 +80,68 @@
class CommonTest : public testing::Test {
public:
- static void MakeExecutable(const ByteArray* byte_array) {
- uintptr_t data = reinterpret_cast<uintptr_t>(byte_array->GetData());
+
+ static void MakeExecutable(const ByteArray* code_array) {
+ CHECK(code_array != NULL);
+ MakeExecutable(code_array->GetData(), code_array->GetLength());
+ }
+
+ static void MakeExecutable(const std::vector<uint8_t>& code) {
+ CHECK_NE(code.size(), 0U);
+ MakeExecutable(&code[0], code.size());
+ }
+
+ void MakeExecutable(Method* method) {
+ CHECK(method != NULL);
+
+ const CompiledInvokeStub* compiled_invoke_stub = compiler_->GetCompiledInvokeStub(method);
+ CHECK(compiled_invoke_stub != NULL) << PrettyMethod(method);
+ const std::vector<uint8_t>& invoke_stub = compiled_invoke_stub->GetCode();
+ MakeExecutable(invoke_stub);
+ const Method::InvokeStub* method_invoke_stub
+ = reinterpret_cast<const Method::InvokeStub*>(&invoke_stub[0]);
+ LOG(INFO) << "MakeExecutable " << PrettyMethod(method)
+ << " invoke_stub=" << reinterpret_cast<void*>(method_invoke_stub);
+
+ if (!method->IsAbstract()) {
+ const CompiledMethod* compiled_method = compiler_->GetCompiledMethod(method);
+ CHECK(compiled_method != NULL) << PrettyMethod(method);
+ const std::vector<uint8_t>& code = compiled_method->GetCode();
+ MakeExecutable(code);
+ const void* method_code
+ = CompiledMethod::CodePointer(&code[0], compiled_method->GetInstructionSet());
+ LOG(INFO) << "MakeExecutable " << PrettyMethod(method) << " code=" << method_code;
+ OatFile::OatMethod oat_method(method_code,
+ compiled_method->GetFrameSizeInBytes(),
+ compiled_method->GetReturnPcOffsetInBytes(),
+ compiled_method->GetCoreSpillMask(),
+ compiled_method->GetFpSpillMask(),
+ &compiled_method->GetMappingTable()[0],
+ &compiled_method->GetVmapTable()[0],
+ method_invoke_stub);
+ oat_method.LinkMethod(method);
+ } else {
+ MakeExecutable(runtime_->GetAbstractMethodErrorStubArray());
+ const void* method_code = runtime_->GetAbstractMethodErrorStubArray()->GetData();
+ LOG(INFO) << "MakeExecutable " << PrettyMethod(method) << " code=" << method_code;
+ OatFile::OatMethod oat_method(method_code,
+ kStackAlignment,
+ 0,
+ 0,
+ 0,
+ NULL,
+ NULL,
+ method_invoke_stub);
+ oat_method.LinkMethod(method);
+ }
+ }
+
+ static void MakeExecutable(const void* code_start, size_t code_length) {
+ CHECK(code_start != NULL);
+ CHECK_NE(code_length, 0U);
+ uintptr_t data = reinterpret_cast<uintptr_t>(code_start);
uintptr_t base = RoundDown(data, kPageSize);
- uintptr_t limit = RoundUp(data + byte_array->GetLength(), kPageSize);
+ uintptr_t limit = RoundUp(data + code_length, kPageSize);
uintptr_t len = limit - base;
int result = mprotect(reinterpret_cast<void*>(base), len, PROT_READ | PROT_WRITE | PROT_EXEC);
CHECK_EQ(result, 0);
@@ -274,9 +333,9 @@
void CompileMethod(Method* method) {
CHECK(method != NULL);
compiler_->CompileOne(method);
+ MakeExecutable(method);
+
MakeExecutable(runtime_->GetJniStubArray());
- MakeExecutable(method->GetCodeArray());
- MakeExecutable(method->GetInvokeStubArray());
}
void CompileDirectMethod(const ClassLoader* class_loader,
diff --git a/src/compiled_method.cc b/src/compiled_method.cc
new file mode 100644
index 0000000..2846ab3
--- /dev/null
+++ b/src/compiled_method.cc
@@ -0,0 +1,157 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+#include "compiled_method.h"
+
+namespace art {
+
+CompiledMethod::CompiledMethod(InstructionSet instruction_set,
+ std::vector<short>& short_code,
+ const size_t frame_size_in_bytes,
+ const size_t return_pc_offset_in_bytes,
+ const uint32_t core_spill_mask,
+ const uint32_t fp_spill_mask,
+ std::vector<uint32_t>& mapping_table,
+ std::vector<uint16_t>& vmap_table) {
+ CHECK_NE(short_code.size(), 0U);
+
+ size_t code_byte_count = short_code.size() * sizeof(short_code[0]);
+ std::vector<uint8_t> byte_code(code_byte_count);
+ memcpy(&byte_code[0], &short_code[0], code_byte_count);
+
+ std::vector<uint32_t> length_prefixed_mapping_table;
+ length_prefixed_mapping_table.push_back(mapping_table.size());
+ length_prefixed_mapping_table.insert(length_prefixed_mapping_table.end(),
+ mapping_table.begin(),
+ mapping_table.end());
+ DCHECK_EQ(mapping_table.size() + 1, length_prefixed_mapping_table.size());
+
+ std::vector<uint16_t> length_prefixed_vmap_table;
+ length_prefixed_vmap_table.push_back(vmap_table.size());
+ length_prefixed_vmap_table.insert(length_prefixed_vmap_table.end(),
+ vmap_table.begin(),
+ vmap_table.end());
+ DCHECK_EQ(vmap_table.size() + 1, length_prefixed_vmap_table.size());
+
+ instruction_set_ = instruction_set;
+ code_ = byte_code;
+ frame_size_in_bytes_ = frame_size_in_bytes;
+ return_pc_offset_in_bytes_ = return_pc_offset_in_bytes;
+ core_spill_mask_ = core_spill_mask;
+ fp_spill_mask_ = fp_spill_mask;
+ mapping_table_ = length_prefixed_mapping_table;
+ vmap_table_ = length_prefixed_vmap_table;
+}
+
+CompiledMethod::CompiledMethod(InstructionSet instruction_set,
+ std::vector<uint8_t>& code,
+ const size_t frame_size_in_bytes,
+ const size_t return_pc_offset_in_bytes,
+ const uint32_t core_spill_mask,
+ const uint32_t fp_spill_mask) {
+ CHECK_NE(code.size(), 0U);
+
+ instruction_set_ = instruction_set;
+ code_ = code;
+ frame_size_in_bytes_ = frame_size_in_bytes;
+ return_pc_offset_in_bytes_ = return_pc_offset_in_bytes;
+ core_spill_mask_ = core_spill_mask;
+ fp_spill_mask_ = fp_spill_mask;
+}
+
+CompiledMethod::~CompiledMethod() {}
+
+InstructionSet CompiledMethod::GetInstructionSet() const {
+ return instruction_set_;
+}
+
+const std::vector<uint8_t>& CompiledMethod::GetCode() const {
+ return code_;
+}
+
+size_t CompiledMethod::GetFrameSizeInBytes() const {
+ return frame_size_in_bytes_;
+}
+
+size_t CompiledMethod::GetReturnPcOffsetInBytes() const {
+ return return_pc_offset_in_bytes_;
+}
+
+uint32_t CompiledMethod::GetCoreSpillMask() const {
+ return core_spill_mask_;
+}
+
+uint32_t CompiledMethod::GetFpSpillMask() const {
+ return fp_spill_mask_;
+}
+
+const std::vector<uint32_t>& CompiledMethod::GetMappingTable() const {
+ return mapping_table_;
+}
+
+const std::vector<uint16_t>& CompiledMethod::GetVmapTable() const {
+ return vmap_table_;
+}
+
+uint32_t CompiledMethod::AlignCode(uint32_t offset) const {
+ return AlignCode(offset, instruction_set_);
+}
+
+uint32_t CompiledMethod::AlignCode(uint32_t offset, InstructionSet instruction_set) {
+ switch (instruction_set) {
+ case kArm:
+ case kThumb2:
+ return RoundUp(offset, kArmAlignment);
+ case kX86:
+ return offset;
+ default:
+ LOG(FATAL) << "Unknown InstructionSet " << (int) instruction_set;
+ return 0;
+ }
+}
+
+size_t CompiledMethod::CodeDelta() const {
+ switch (instruction_set_) {
+ case kArm:
+ case kX86:
+ return 0;
+ case kThumb2: {
+ // +1 to set the low-order bit so a BLX will switch to Thumb mode
+ return 1;
+ }
+ default:
+ LOG(FATAL) << "Unknown InstructionSet " << (int) instruction_set_;
+ return NULL;
+ }
+}
+
+const void* CompiledMethod::CodePointer(const void* code_pointer,
+ InstructionSet instruction_set) {
+ switch (instruction_set) {
+ case kArm:
+ case kX86:
+ return code_pointer;
+ case kThumb2: {
+ uintptr_t address = reinterpret_cast<uintptr_t>(code_pointer);
+ // Set the low-order bit so a BLX will switch to Thumb mode
+ address |= 0x1;
+ return reinterpret_cast<const void*>(address);
+ }
+ default:
+ LOG(FATAL) << "Unknown InstructionSet " << (int) instruction_set;
+ return NULL;
+ }
+}
+
+
+CompiledInvokeStub::CompiledInvokeStub(std::vector<uint8_t>& code) {
+ CHECK_NE(code.size(), 0U);
+ code_ = code;
+}
+
+CompiledInvokeStub::~CompiledInvokeStub() {}
+
+const std::vector<uint8_t>& CompiledInvokeStub::GetCode() const {
+ return code_;
+}
+
+} // namespace art
diff --git a/src/compiled_method.h b/src/compiled_method.h
new file mode 100644
index 0000000..e228ca8
--- /dev/null
+++ b/src/compiled_method.h
@@ -0,0 +1,83 @@
+// Copyright 2011 Google Inc. All Rights Reserved.
+
+#ifndef ART_SRC_COMPILED_METHOD_H_
+#define ART_SRC_COMPILED_METHOD_H_
+
+#include <vector>
+
+#include "constants.h"
+#include "utils.h"
+
+namespace art {
+
+class CompiledMethod {
+ public:
+ // Create an CompiledMethod from the oatCompileMethod
+ CompiledMethod(InstructionSet instruction_set,
+ std::vector<short>& code,
+ const size_t frame_size_in_bytes,
+ const size_t return_pc_offset_in_bytes,
+ const uint32_t core_spill_mask,
+ const uint32_t fp_spill_mask,
+ std::vector<uint32_t>& mapping_table,
+ std::vector<uint16_t>& vmap_table);
+
+ // Create an CompiledMethod from the JniCompiler
+ CompiledMethod(InstructionSet instruction_set,
+ std::vector<uint8_t>& code,
+ const size_t frame_size_in_bytes,
+ const size_t return_pc_offset_in_bytes,
+ const uint32_t core_spill_mask,
+ const uint32_t fp_spill_mask);
+
+ ~CompiledMethod();
+
+ InstructionSet GetInstructionSet() const;
+ const std::vector<uint8_t>& GetCode() const;
+ size_t GetFrameSizeInBytes() const;
+ size_t GetReturnPcOffsetInBytes() const;
+ uint32_t GetCoreSpillMask() const;
+ uint32_t GetFpSpillMask() const;
+ const std::vector<uint32_t>& GetMappingTable() const;
+ const std::vector<uint16_t>& GetVmapTable() const;
+
+ // Aligns an offset from a page aligned value to make it suitable
+ // for code storage. important to ensure that PC relative value
+ // computations work out as expected on ARM.
+ uint32_t AlignCode(uint32_t offset) const;
+ static uint32_t AlignCode(uint32_t offset, InstructionSet instruction_set);
+
+ // returns the difference between the code address and a usable PC.
+ // mainly to cope with kThumb2 where the lower bit must be set.
+ size_t CodeDelta() const;
+
+ // Returns a pointer suitable for invoking the code at the argument
+ // code_pointer address. Mainly to cope with kThumb2 where the
+ // lower bit must be set to indicate Thumb mode.
+ static const void* CodePointer(const void* code_pointer,
+ InstructionSet instruction_set);
+
+ private:
+ InstructionSet instruction_set_;
+ std::vector<uint8_t> code_;
+ size_t frame_size_in_bytes_;
+ size_t return_pc_offset_in_bytes_;
+ uint32_t core_spill_mask_;
+ uint32_t fp_spill_mask_;
+ std::vector<uint32_t> mapping_table_;
+ std::vector<uint16_t> vmap_table_;
+};
+
+class CompiledInvokeStub {
+ public:
+ CompiledInvokeStub(std::vector<uint8_t>& code);
+ ~CompiledInvokeStub();
+ const std::vector<uint8_t>& GetCode() const;
+ private:
+ std::vector<uint8_t> code_;
+};
+
+} // namespace art
+
+#endif // ART_SRC_COMPILED_METHOD_H_
+
diff --git a/src/compiler.cc b/src/compiler.cc
index 3b92267..3b98ea0 100644
--- a/src/compiler.cc
+++ b/src/compiler.cc
@@ -10,28 +10,37 @@
#include "dex_cache.h"
#include "jni_compiler.h"
#include "jni_internal.h"
+#include "oat_file.h"
#include "runtime.h"
+#include "stl_util.h"
-extern bool oatCompileMethod(const art::Compiler& compiler, art::Method*, art::InstructionSet);
+extern art::CompiledMethod* oatCompileMethod(const art::Compiler& compiler,
+ const art::Method*,
+ art::InstructionSet);
namespace art {
namespace arm {
ByteArray* CreateAbstractMethodErrorStub();
- void ArmCreateInvokeStub(Method* method);
+ CompiledInvokeStub* ArmCreateInvokeStub(const Method* method);
ByteArray* ArmCreateResolutionTrampoline(Runtime::TrampolineType type);
}
namespace x86 {
ByteArray* CreateAbstractMethodErrorStub();
- void X86CreateInvokeStub(Method* method);
+ CompiledInvokeStub* X86CreateInvokeStub(const Method* method);
ByteArray* X86CreateResolutionTrampoline(Runtime::TrampolineType type);
}
-Compiler::Compiler(InstructionSet insns) : instruction_set_(insns), jni_compiler_(insns),
- verbose_(false) {
+Compiler::Compiler(InstructionSet instruction_set)
+ : instruction_set_(instruction_set), jni_compiler_(instruction_set), verbose_(false) {
CHECK(!Runtime::Current()->IsStarted());
}
+Compiler::~Compiler() {
+ STLDeleteValues(&compiled_methods_);
+ STLDeleteValues(&compiled_invoke_stubs_);
+}
+
ByteArray* Compiler::CreateResolutionStub(InstructionSet instruction_set,
Runtime::TrampolineType type) {
if (instruction_set == kX86) {
@@ -62,7 +71,7 @@
SetCodeAndDirectMethods(class_loader);
}
-void Compiler::CompileOne(Method* method) {
+void Compiler::CompileOne(const Method* method) {
DCHECK(!Runtime::Current()->IsStarted());
const ClassLoader* class_loader = method->GetDeclaringClass()->GetClassLoader();
Resolve(class_loader);
@@ -276,7 +285,7 @@
}
}
-void Compiler::CompileClass(Class* klass) {
+void Compiler::CompileClass(const Class* klass) {
for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
CompileMethod(klass->GetDirectMethod(i));
}
@@ -285,35 +294,50 @@
}
}
-void Compiler::CompileMethod(Method* method) {
+void Compiler::CompileMethod(const Method* method) {
if (method->IsNative()) {
- jni_compiler_.Compile(method);
- // unregister will install the stub to lookup via dlsym
- // TODO: this is only necessary for tests
- if (!method->IsRegistered()) {
- method->UnregisterNative();
- }
+ CompiledMethod* compiled_method = jni_compiler_.Compile(method);
+ CHECK(compiled_method != NULL);
+ compiled_methods_[method] = compiled_method;
+ DCHECK_EQ(1U, compiled_methods_.count(method));
+ DCHECK(GetCompiledMethod(method) != NULL) << PrettyMethod(method);
} else if (method->IsAbstract()) {
- ByteArray* abstract_method_error_stub = Runtime::Current()->GetAbstractMethodErrorStubArray();
- if (instruction_set_ == kX86) {
- method->SetCodeArray(abstract_method_error_stub, kX86);
- } else {
- CHECK(instruction_set_ == kArm || instruction_set_ == kThumb2);
- method->SetCodeArray(abstract_method_error_stub, kArm);
- }
} else {
- oatCompileMethod(*this, method, kThumb2);
+ CompiledMethod* compiled_method = oatCompileMethod(*this, method, kThumb2);
+ CHECK(compiled_method != NULL);
+ compiled_methods_[method] = compiled_method;
+ DCHECK_EQ(1U, compiled_methods_.count(method));
+ DCHECK(GetCompiledMethod(method) != NULL) << PrettyMethod(method);
}
- CHECK(method->GetCode() != NULL) << PrettyMethod(method);
+ CompiledInvokeStub* compiled_invoke_stub = NULL;
if (instruction_set_ == kX86) {
- art::x86::X86CreateInvokeStub(method);
+ compiled_invoke_stub = art::x86::X86CreateInvokeStub(method);
} else {
CHECK(instruction_set_ == kArm || instruction_set_ == kThumb2);
// Generates invocation stub using ARM instruction set
- art::arm::ArmCreateInvokeStub(method);
+ compiled_invoke_stub = art::arm::ArmCreateInvokeStub(method);
}
- CHECK(method->GetInvokeStub() != NULL);
+ CHECK(compiled_invoke_stub != NULL);
+ compiled_invoke_stubs_[method] = compiled_invoke_stub;
+}
+
+const CompiledMethod* Compiler::GetCompiledMethod(const Method* method) const {
+ MethodTable::const_iterator it = compiled_methods_.find(method);
+ if (it == compiled_methods_.end()) {
+ return NULL;
+ }
+ CHECK(it->second != NULL);
+ return it->second;
+}
+
+const CompiledInvokeStub* Compiler::GetCompiledInvokeStub(const Method* method) const {
+ InvokeStubTable::const_iterator it = compiled_invoke_stubs_.find(method);
+ if (it == compiled_invoke_stubs_.end()) {
+ return NULL;
+ }
+ CHECK(it->second != NULL);
+ return it->second;
}
void Compiler::SetCodeAndDirectMethods(const ClassLoader* class_loader) {
@@ -332,17 +356,10 @@
CodeAndDirectMethods* code_and_direct_methods = dex_cache->GetCodeAndDirectMethods();
for (size_t i = 0; i < dex_cache->NumResolvedMethods(); i++) {
Method* method = dex_cache->GetResolvedMethod(i);
- if ((method == NULL) || (method->IsStatic() && !method->GetDeclaringClass()->IsInitialized())) {
+ if (method == NULL || method->IsDirect()) {
Runtime::TrampolineType type = Runtime::GetTrampolineType(method);
ByteArray* res_trampoline = runtime->GetResolutionStubArray(type);
- if (instruction_set_ == kX86) {
- code_and_direct_methods->SetResolvedDirectMethodTrampoline(i, res_trampoline, kX86);
- } else {
- CHECK(instruction_set_ == kArm || instruction_set_ == kThumb2);
- code_and_direct_methods->SetResolvedDirectMethodTrampoline(i, res_trampoline, kArm);
- }
- } else if (method->IsDirect()) {
- code_and_direct_methods->SetResolvedDirectMethod(i, method);
+ code_and_direct_methods->SetResolvedDirectMethodTrampoline(i, res_trampoline);
} else {
// TODO: we currently leave the entry blank for resolved
// non-direct methods. we could put in an error stub.
diff --git a/src/compiler.h b/src/compiler.h
index 0f6f02f..6059a2a 100644
--- a/src/compiler.h
+++ b/src/compiler.h
@@ -3,30 +3,37 @@
#ifndef ART_SRC_COMPILER_H_
#define ART_SRC_COMPILER_H_
+#include "compiled_method.h"
#include "constants.h"
#include "dex_file.h"
#include "jni_compiler.h"
+#include "oat_file.h"
#include "object.h"
#include "runtime.h"
-
-int oatVRegOffsetFromMethod(art::Method* method, int reg);
+#include "unordered_map.h"
namespace art {
class Compiler {
public:
- explicit Compiler(InstructionSet insns);
+ explicit Compiler(InstructionSet instruction_set);
+
+ ~Compiler();
// Compile all Methods of all the Classes of all the DexFiles that are part of a ClassLoader.
void CompileAll(const ClassLoader* class_loader);
// Compile a single Method
- void CompileOne(Method* method);
+ void CompileOne(const Method* method);
void SetVerbose(bool verbose) {
verbose_ = verbose;
}
+ InstructionSet GetInstructionSet() const {
+ return instruction_set_;
+ }
+
bool IsVerbose() const {
return verbose_;
}
@@ -34,10 +41,14 @@
// Stub to throw AbstractMethodError
static ByteArray* CreateAbstractMethodErrorStub(InstructionSet instruction_set);
+
// Generate the trampoline that's invoked by unresolved direct methods
static ByteArray* CreateResolutionStub(InstructionSet instruction_set,
Runtime::TrampolineType type);
+ const CompiledMethod* GetCompiledMethod(const Method* method) const;
+ const CompiledInvokeStub* GetCompiledInvokeStub(const Method* method) const;
+
private:
// Attempt to resolve all type, methods, fields, and strings
// referenced from code in the dex file following PathClassLoader
@@ -53,8 +64,8 @@
void Compile(const ClassLoader* class_loader);
void CompileDexFile(const ClassLoader* class_loader, const DexFile& dex_file);
- void CompileClass(Class* klass);
- void CompileMethod(Method* klass);
+ void CompileClass(const Class* klass);
+ void CompileMethod(const Method* method);
// After compiling, walk all the DexCaches and set the code and
// method pointers of CodeAndDirectMethods entries in the DexCaches.
@@ -64,6 +75,12 @@
InstructionSet instruction_set_;
JniCompiler jni_compiler_;
+ typedef std::tr1::unordered_map<const Method*, CompiledMethod*, ObjectIdentityHash> MethodTable;
+ MethodTable compiled_methods_;
+
+ typedef std::tr1::unordered_map<const Method*, CompiledInvokeStub*, ObjectIdentityHash> InvokeStubTable;
+ InvokeStubTable compiled_invoke_stubs_;
+
bool verbose_;
DISALLOW_COPY_AND_ASSIGN(Compiler);
diff --git a/src/compiler/Compiler.h b/src/compiler/Compiler.h
index f9e2478..28a689f 100644
--- a/src/compiler/Compiler.h
+++ b/src/compiler/Compiler.h
@@ -99,7 +99,9 @@
void oatArchDump(void);
bool oatStartup(void);
void oatShutdown(void);
-bool oatCompileMethod(const Compiler& compiler, Method* method, OatInstructionSetType);
+CompiledMethod* oatCompileMethod(const Compiler& compiler,
+ const Method* method,
+ OatInstructionSetType);
void oatDumpStats(void);
void oatScanAllClassPointers(void (*callback)(void* ptr));
void oatInitializeSSAConversion(struct CompilationUnit* cUnit);
diff --git a/src/compiler/Dalvik.h b/src/compiler/Dalvik.h
index 21b4297..422e20c0 100644
--- a/src/compiler/Dalvik.h
+++ b/src/compiler/Dalvik.h
@@ -60,6 +60,7 @@
typedef art::Field Field;
typedef art::JValue JValue;
typedef art::Method Method;
+typedef art::CompiledMethod CompiledMethod;
typedef art::Object Object;
typedef art::String String;
typedef art::Thread Thread;
diff --git a/src/compiler/Frontend.cc b/src/compiler/Frontend.cc
index 880341a..429d155 100644
--- a/src/compiler/Frontend.cc
+++ b/src/compiler/Frontend.cc
@@ -691,7 +691,7 @@
/*
* Compile a method.
*/
-bool oatCompileMethod(const Compiler& compiler, Method* method, art::InstructionSet insnSet)
+CompiledMethod* oatCompileMethod(const Compiler& compiler, const Method* method, art::InstructionSet insnSet)
{
if (compiler.IsVerbose()) {
LOG(INFO) << "Compiling " << PrettyMethod(method) << "...";
@@ -894,17 +894,11 @@
}
}
- art::ByteArray* managed_code =
- art::ByteArray::Alloc(cUnit.codeBuffer.size() * sizeof(cUnit.codeBuffer[0]));
- memcpy(managed_code->GetData(),
- reinterpret_cast<const int8_t*>(&cUnit.codeBuffer[0]),
- managed_code->GetLength());
- art::IntArray* mapping_table =
- art::IntArray::Alloc(cUnit.mappingTable.size());
- DCHECK_EQ(mapping_table->GetClass()->GetComponentSize(), sizeof(cUnit.mappingTable[0]));
- memcpy(mapping_table->GetData(),
- reinterpret_cast<const int32_t*>(&cUnit.mappingTable[0]),
- mapping_table->GetLength() * sizeof(cUnit.mappingTable[0]));
+ // Combine vmap tables - core regs, then fp regs - into vmapTable
+ std::vector<uint16_t> vmapTable;
+ for (size_t i = 0 ; i < cUnit.coreVmapTable.size(); i++) {
+ vmapTable.push_back(cUnit.coreVmapTable[i]);
+ }
// Add a marker to take place of lr
cUnit.coreVmapTable.push_back(INVALID_VREG);
// Combine vmap tables - core regs, then fp regs
@@ -914,25 +908,25 @@
DCHECK(cUnit.coreVmapTable.size() == (uint32_t)
(__builtin_popcount(cUnit.coreSpillMask) +
__builtin_popcount(cUnit.fpSpillMask)));
- art::ShortArray* vmap_table =
- art::ShortArray::Alloc(cUnit.coreVmapTable.size());
- memcpy(vmap_table->GetData(),
- reinterpret_cast<const int16_t*>(&cUnit.coreVmapTable[0]),
- vmap_table->GetLength() * sizeof(cUnit.coreVmapTable[0]));
- method->SetCodeArray(managed_code, art::kThumb2);
- method->SetMappingTable(mapping_table);
- method->SetVMapTable(vmap_table);
- method->SetFrameSizeInBytes(cUnit.frameSize);
- method->SetReturnPcOffsetInBytes(cUnit.frameSize - sizeof(intptr_t));
- method->SetCoreSpillMask(cUnit.coreSpillMask);
- method->SetFpSpillMask(cUnit.fpSpillMask);
+ vmapTable.push_back(-1);
+ for (size_t i = 0; i < cUnit.fpVmapTable.size(); i++) {
+ vmapTable.push_back(cUnit.fpVmapTable[i]);
+ }
+ CompiledMethod* result = new CompiledMethod(art::kThumb2,
+ cUnit.codeBuffer,
+ cUnit.frameSize,
+ cUnit.frameSize - sizeof(intptr_t),
+ cUnit.coreSpillMask,
+ cUnit.fpSpillMask,
+ cUnit.mappingTable,
+ cUnit.coreVmapTable);
+
if (compiler.IsVerbose()) {
LOG(INFO) << "Compiled " << PrettyMethod(method)
- << " code at " << reinterpret_cast<void*>(managed_code->GetData())
- << " (" << managed_code->GetLength() << " bytes)";
+ << " (" << (cUnit.codeBuffer.size() * sizeof(cUnit.codeBuffer[0])) << " bytes)";
}
- return true;
+ return result;
}
void oatInit(const Compiler& compiler)
diff --git a/src/compiler_test.cc b/src/compiler_test.cc
index e951ade..f261406 100644
--- a/src/compiler_test.cc
+++ b/src/compiler_test.cc
@@ -18,34 +18,6 @@
class CompilerTest : public CommonTest {
protected:
- void AssertStaticIntMethod(jint expected, const ClassLoader* class_loader,
- const char* class_name, const char* method, const char* signature,
- ...) {
- EnsureCompiled(class_loader, class_name, method, signature, false);
-#if defined(__arm__)
- va_list args;
- va_start(args, signature);
- jint result = env_->CallStaticIntMethodV(class_, mid_, args);
- va_end(args);
- LOG(INFO) << class_name << "." << method << "(...) result is " << result;
- EXPECT_EQ(expected, result);
-#endif // __arm__
- }
-
- void AssertStaticLongMethod(jlong expected, const ClassLoader* class_loader,
- const char* class_name, const char* method, const char* signature,
- ...) {
- EnsureCompiled(class_loader, class_name, method, signature, false);
-#if defined(__arm__)
- va_list args;
- va_start(args, signature);
- jlong result = env_->CallStaticLongMethodV(class_, mid_, args);
- va_end(args);
- LOG(INFO) << class_name << "." << method << "(...) result is " << result;
- EXPECT_EQ(expected, result);
-#endif // __arm__
- }
-
void CompileAll(const ClassLoader* class_loader) {
compiler_->CompileAll(class_loader);
MakeAllExecutable(class_loader);
@@ -83,27 +55,14 @@
Class* c = class_linker->FindClass(descriptor, class_loader);
CHECK(c != NULL);
for (size_t i = 0; i < c->NumDirectMethods(); i++) {
- MakeMethodExecutable(c->GetDirectMethod(i));
+ MakeExecutable(c->GetDirectMethod(i));
}
for (size_t i = 0; i < c->NumVirtualMethods(); i++) {
- MakeMethodExecutable(c->GetVirtualMethod(i));
+ MakeExecutable(c->GetVirtualMethod(i));
}
}
}
- void MakeMethodExecutable(Method* m) {
- if (m->GetCodeArray() != NULL) {
- MakeExecutable(m->GetCodeArray());
- } else {
- LOG(WARNING) << "no code for " << PrettyMethod(m);
- }
- if (m->GetInvokeStubArray() != NULL) {
- MakeExecutable(m->GetInvokeStubArray());
- } else {
- LOG(WARNING) << "no invoke stub for " << PrettyMethod(m);
- }
- }
-
JNIEnv* env_;
jclass class_;
jmethodID mid_;
@@ -165,6 +124,8 @@
}
TEST_F(CompilerTest, AbstractMethodErrorStub) {
+ CompileDirectMethod(NULL, "java.lang.Object", "<init>", "()V");
+
const ClassLoader* class_loader = LoadDex("AbstractMethod");
ASSERT_TRUE(class_loader != NULL);
EnsureCompiled(class_loader, "AbstractClass", "foo", "()V", true);
@@ -177,7 +138,7 @@
#if defined(__arm__)
Class* jlame = class_linker_->FindClass("Ljava/lang/AbstractMethodError;", class_loader);
- // Force non-virtal call to AbstractClass foo, will throw AbstractMethodError exception.
+ // Force non-virtual call to AbstractClass foo, will throw AbstractMethodError exception.
env_->CallNonvirtualVoidMethod(jobj_, class_, mid_);
EXPECT_TRUE(Thread::Current()->IsExceptionPending());
EXPECT_TRUE(Thread::Current()->GetException()->InstanceOf(jlame));
diff --git a/src/dex2oat.cc b/src/dex2oat.cc
index 8d181d6..d5db436 100644
--- a/src/dex2oat.cc
+++ b/src/dex2oat.cc
@@ -258,7 +258,7 @@
}
}
- if (!OatWriter::Create(oat_filename, class_loader)) {
+ if (!OatWriter::Create(oat_filename, class_loader, compiler)) {
fprintf(stderr, "Failed to create oat file %s\n", oat_filename.c_str());
return EXIT_FAILURE;
}
diff --git a/src/dex_cache.h b/src/dex_cache.h
index 7ca6825..a9776b7 100644
--- a/src/dex_cache.h
+++ b/src/dex_cache.h
@@ -26,22 +26,17 @@
return reinterpret_cast<Method*>(Get(MethodIndex(method_idx)));
}
- void SetResolvedDirectMethodTrampoline(uint32_t method_idx, ByteArray* code_array,
- InstructionSet instruction_set) {
- DCHECK(code_array != NULL);
+ void SetResolvedDirectMethodTrampoline(uint32_t method_idx, ByteArray* code_array) {
+ CHECK(code_array != NULL);
int32_t code = reinterpret_cast<int32_t>(code_array->GetData());
- if (instruction_set == kThumb2) {
- // Set the low-order bit so a BLX will switch to Thumb mode
- code = code | 0x1;
- }
Set(CodeIndex(method_idx), code);
Set(MethodIndex(method_idx), method_idx);
}
void SetResolvedDirectMethod(uint32_t method_idx, Method* method) {
CHECK(method != NULL);
- CHECK(method->IsDirect());
- // CHECK(method->GetCode() != NULL); // TODO enable when all code is compiling
+ CHECK(method->IsDirect()) << PrettyMethod(method);
+ CHECK(method->GetCode() != NULL) << PrettyMethod(method);
Set(CodeIndex(method_idx), reinterpret_cast<int32_t>(method->GetCode()));
Set(MethodIndex(method_idx), reinterpret_cast<int32_t>(method));
}
@@ -213,12 +208,6 @@
DISALLOW_IMPLICIT_CONSTRUCTORS(DexCache);
};
-struct DexCacheHash {
- size_t operator()(art::DexCache* const& obj) const {
- return reinterpret_cast<size_t>(&obj);
- }
-};
-
} // namespace art
#endif // ART_SRC_DEX_CACHE_H_
diff --git a/src/exception_test.cc b/src/exception_test.cc
index 49a5266..4662119 100644
--- a/src/exception_test.cc
+++ b/src/exception_test.cc
@@ -25,30 +25,34 @@
dex_ = &Runtime::Current()->GetClassLinker()->FindDexFile(my_klass_->GetDexCache());
- ByteArray* fake_code = ByteArray::Alloc(12);
- ASSERT_TRUE(fake_code != NULL);
- IntArray* fake_mapping_data = IntArray::Alloc(2);
- ASSERT_TRUE(fake_mapping_data != NULL);
- fake_mapping_data->Set(0, 3); // offset 3
- fake_mapping_data->Set(1, 3); // maps to dex offset 3
+ for (size_t i = 0 ; i < 12; i++) {
+ fake_code_.push_back(0x70000000 | i);
+ }
+
+ fake_mapping_data_.push_back(2); // first element is count of remaining elements
+ fake_mapping_data_.push_back(3); // offset 3
+ fake_mapping_data_.push_back(3); // maps to dex offset 3
method_f_ = my_klass_->FindVirtualMethod("f", "()I");
ASSERT_TRUE(method_f_ != NULL);
method_f_->SetFrameSizeInBytes(kStackAlignment);
- method_f_->SetReturnPcOffsetInBytes(kStackAlignment-kPointerSize);
- method_f_->SetCodeArray(fake_code, kThumb2);
- method_f_->SetMappingTable(fake_mapping_data);
+ method_f_->SetReturnPcOffsetInBytes(kStackAlignment - kPointerSize);
+ method_f_->SetCode(CompiledMethod::CodePointer(&fake_code_[0], kThumb2));
+ method_f_->SetMappingTable(&fake_mapping_data_[0]);
method_g_ = my_klass_->FindVirtualMethod("g", "(I)V");
ASSERT_TRUE(method_g_ != NULL);
method_g_->SetFrameSizeInBytes(kStackAlignment);
- method_g_->SetReturnPcOffsetInBytes(kStackAlignment-kPointerSize);
- method_g_->SetCodeArray(fake_code, kThumb2);
- method_g_->SetMappingTable(fake_mapping_data);
+ method_g_->SetReturnPcOffsetInBytes(kStackAlignment - kPointerSize);
+ method_g_->SetCode(CompiledMethod::CodePointer(&fake_code_[0], kThumb2));
+ method_g_->SetMappingTable(&fake_mapping_data_[0]);
}
const DexFile* dex_;
+ std::vector<uint8_t> fake_code_;
+ std::vector<uint32_t> fake_mapping_data_;
+
Method* method_f_;
Method* method_g_;
diff --git a/src/image_test.cc b/src/image_test.cc
index 903457f..2ef7489 100644
--- a/src/image_test.cc
+++ b/src/image_test.cc
@@ -18,7 +18,7 @@
TEST_F(ImageTest, WriteRead) {
ScratchFile tmp_oat;
- bool success_oat = OatWriter::Create(tmp_oat.GetFilename(), NULL);
+ bool success_oat = OatWriter::Create(tmp_oat.GetFilename(), NULL, *compiler_.get());
ASSERT_TRUE(success_oat);
ImageWriter writer;
@@ -37,6 +37,7 @@
ASSERT_EQ(1U, Heap::GetSpaces().size());
Space* space = Heap::GetSpaces()[0];
+ ASSERT_FALSE(space->IsImageSpace());
ASSERT_TRUE(space != NULL);
ASSERT_GE(sizeof(image_header) + space->Size(), static_cast<size_t>(file->Length()));
}
diff --git a/src/image_writer.cc b/src/image_writer.cc
index 8af9cf6..39f3e64 100644
--- a/src/image_writer.cc
+++ b/src/image_writer.cc
@@ -180,7 +180,7 @@
// Note that image_top_ is left at end of used space
oat_base_ = image_base_ + RoundUp(image_top_, kPageSize);
- byte* oat_limit = oat_base_ + oat_file_->GetSize();
+ const byte* oat_limit = oat_base_ + oat_file_->GetSize();
// return to write header at start of image with future location of image_roots
ImageHeader image_header(reinterpret_cast<uint32_t>(image_base_),
@@ -258,29 +258,42 @@
void ImageWriter::FixupMethod(const Method* orig, Method* copy) {
FixupInstanceFields(orig, copy);
- // OatWriter clears the code_array_ after writing the code.
- // It replaces the code_ with an offset value we now adjust to be a pointer.
- DCHECK(copy->code_array_ == NULL)
- << PrettyMethod(orig)
- << " orig_code_array_=" << orig->GetCodeArray() << " orig_code_=" << orig->GetCode()
- << " copy_code_array_=" << copy->code_array_ << " orig_code_=" << copy->code_
- << " jni_stub=" << Runtime::Current()->GetJniStubArray()
- << " ame_stub=" << Runtime::Current()->GetAbstractMethodErrorStubArray();
- copy->invoke_stub_ = reinterpret_cast<Method::InvokeStub*>(FixupCode(copy->invoke_stub_array_, reinterpret_cast<void*>(orig->invoke_stub_)));
+ // OatWriter replaces the code_ and invoke_stub_ with offset values.
+ // Here we readjust to a pointer relative to oat_base_
+
+ // Every type of method can have an invoke stub
+ uint32_t invoke_stub_offset = orig->GetOatInvokeStubOffset();
+ const byte* invoke_stub = (invoke_stub_offset != 0) ? (oat_base_ + invoke_stub_offset) : 0;
+ copy->invoke_stub_ = reinterpret_cast<const Method::InvokeStub*>(invoke_stub);
+
+ if (orig->IsAbstract()) {
+ // Abstract methods are pointed to a stub that will throw AbstractMethodError if they are called
+ ByteArray* orig_ame_stub_array_ = Runtime::Current()->GetAbstractMethodErrorStubArray();
+ ByteArray* copy_ame_stub_array_ = down_cast<ByteArray*>(GetImageAddress(orig_ame_stub_array_));
+ copy->code_ = copy_ame_stub_array_->GetData();
+ return;
+ }
+
+ // Non-abstract methods typically have code
+ uint32_t code_offset = orig->GetOatCodeOffset();
+ const byte* code = (code_offset != 0) ? (oat_base_ + code_offset) : 0;
+ copy->code_ = code;
+
if (orig->IsNative()) {
+ // The native method's pointer is directed to a stub to lookup via dlsym.
+ // Note this is not the code_ pointer, that is handled above.
ByteArray* orig_jni_stub_array_ = Runtime::Current()->GetJniStubArray();
ByteArray* copy_jni_stub_array_ = down_cast<ByteArray*>(GetImageAddress(orig_jni_stub_array_));
copy->native_method_ = copy_jni_stub_array_->GetData();
- copy->code_ = oat_base_ + orig->GetOatCodeOffset();
} else {
- DCHECK(copy->native_method_ == NULL) << copy->native_method_;
- if (orig->IsAbstract()) {
- ByteArray* orig_ame_stub_array_ = Runtime::Current()->GetAbstractMethodErrorStubArray();
- ByteArray* copy_ame_stub_array_ = down_cast<ByteArray*>(GetImageAddress(orig_ame_stub_array_));
- copy->code_ = copy_ame_stub_array_->GetData();
- } else {
- copy->code_ = oat_base_ + orig->GetOatCodeOffset();
- }
+ // normal (non-abstract non-native) methods have mapping tables to relocate
+ uint32_t mapping_table_off = orig->GetOatMappingTableOffset();
+ const byte* mapping_table = (mapping_table_off != 0) ? (oat_base_ + mapping_table_off) : 0;
+ copy->mapping_table_ = reinterpret_cast<const uint32_t*>(mapping_table);
+
+ uint32_t vmap_table_offset = orig->GetOatVmapTableOffset();
+ const byte* vmap_table = (vmap_table_offset != 0) ? (oat_base_ + vmap_table_offset) : 0;
+ copy->vmap_table_ = reinterpret_cast<const uint16_t*>(vmap_table);
}
}
diff --git a/src/image_writer.h b/src/image_writer.h
index fda33fe..3c17538 100644
--- a/src/image_writer.h
+++ b/src/image_writer.h
@@ -116,10 +116,10 @@
byte* image_base_;
// Target oat base address for the pointers from the output image to its oat file
- byte* oat_base_;
+ const byte* oat_base_;
// DexCaches seen while scanning for fixing up CodeAndDirectMethods
- typedef std::tr1::unordered_set<DexCache*, DexCacheHash> Set;
+ typedef std::tr1::unordered_set<DexCache*, ObjectIdentityHash> Set;
Set dex_caches_;
};
diff --git a/src/jni_compiler.cc b/src/jni_compiler.cc
index 83be88a..ffcbc11 100644
--- a/src/jni_compiler.cc
+++ b/src/jni_compiler.cc
@@ -7,11 +7,12 @@
#include "assembler.h"
#include "calling_convention.h"
+#include "compiled_method.h"
#include "constants.h"
#include "jni_internal.h"
+#include "logging.h"
#include "macros.h"
#include "managed_register.h"
-#include "logging.h"
#include "thread.h"
#include "UniquePtr.h"
@@ -38,12 +39,12 @@
}
}
-JniCompiler::JniCompiler(InstructionSet insns) {
- if (insns == kThumb2) {
+JniCompiler::JniCompiler(InstructionSet instruction_set) {
+ if (instruction_set == kThumb2) {
// currently only ARM code generation is supported
instruction_set_ = kArm;
} else {
- instruction_set_ = insns;
+ instruction_set_ = instruction_set;
}
}
@@ -54,7 +55,7 @@
// registers, a reference to the method object is supplied as part of this
// convention.
//
-void JniCompiler::Compile(Method* native_method) {
+CompiledMethod* JniCompiler::Compile(const Method* native_method) {
CHECK(native_method->IsNative());
// Calling conventions used to iterate over parameters to method
@@ -426,15 +427,15 @@
// 17. Finalize code generation
__ EmitSlowPaths();
size_t cs = __ CodeSize();
- ByteArray* managed_code = ByteArray::Alloc(cs);
- CHECK(managed_code != NULL);
- MemoryRegion code(managed_code->GetData(), managed_code->GetLength());
+ std::vector<uint8_t> managed_code(cs);
+ MemoryRegion code(&managed_code[0], managed_code.size());
__ FinalizeInstructions(code);
- native_method->SetCodeArray(managed_code, instruction_set_);
- native_method->SetFrameSizeInBytes(frame_size);
- native_method->SetReturnPcOffsetInBytes(jni_conv->ReturnPcOffset());
- native_method->SetCoreSpillMask(jni_conv->CoreSpillMask());
- native_method->SetFpSpillMask(jni_conv->FpSpillMask());
+ return new CompiledMethod(instruction_set_,
+ managed_code,
+ frame_size,
+ jni_conv->ReturnPcOffset(),
+ jni_conv->CoreSpillMask(),
+ jni_conv->FpSpillMask());
#undef __
}
diff --git a/src/jni_compiler.h b/src/jni_compiler.h
index 086d96e..a6d5602 100644
--- a/src/jni_compiler.h
+++ b/src/jni_compiler.h
@@ -3,6 +3,7 @@
#ifndef ART_SRC_JNI_COMPILER_H_
#define ART_SRC_JNI_COMPILER_H_
+#include "compiled_method.h"
#include "constants.h"
#include "macros.h"
#include "object.h"
@@ -10,6 +11,7 @@
namespace art {
class Assembler;
+class Compiler;
class JniCallingConvention;
class ManagedRegister;
class ManagedRuntimeCallingConvention;
@@ -20,10 +22,10 @@
// TODO: move the responsibility of managing memory to somewhere else
class JniCompiler {
public:
- explicit JniCompiler(InstructionSet insns);
+ explicit JniCompiler(InstructionSet instruction_set);
~JniCompiler();
- void Compile(Method* method);
+ CompiledMethod* Compile(const Method* method);
// Stub to perform native method symbol lookup via dlsym
// TODO: remove from JniCompiler
diff --git a/src/jni_internal_arm.cc b/src/jni_internal_arm.cc
index 8ba5717..ba13de7 100644
--- a/src/jni_internal_arm.cc
+++ b/src/jni_internal_arm.cc
@@ -5,6 +5,7 @@
#include <algorithm>
#include "assembler.h"
+#include "compiled_method.h"
#include "object.h"
namespace art {
@@ -27,7 +28,7 @@
// register and transfer arguments from the array into register and on
// the stack, if needed. On return, the thread register must be
// shuffled and the return value must be store into the result JValue.
-void ArmCreateInvokeStub(Method* method) {
+CompiledInvokeStub* ArmCreateInvokeStub(const Method* method) {
UniquePtr<ArmAssembler> assembler(
down_cast<ArmAssembler*>(Assembler::Create(kArm)));
#define __ assembler->
@@ -118,11 +119,10 @@
// Pop R4, R9 and the LR into PC
__ PopList(save | (1 << PC));
// TODO: store native_entry in the stub table
- ByteArray* code = ByteArray::Alloc(assembler->CodeSize());
- MemoryRegion region(code->GetData(), code->GetLength());
+ std::vector<uint8_t> code(assembler->CodeSize());
+ MemoryRegion region(&code[0], code.size());
assembler->FinalizeInstructions(region);
- method->SetInvokeStub(code);
- CHECK(method->GetInvokeStub() != NULL);
+ return new CompiledInvokeStub(code);
#undef __
}
diff --git a/src/jni_internal_x86.cc b/src/jni_internal_x86.cc
index 7128c6e..891971d 100644
--- a/src/jni_internal_x86.cc
+++ b/src/jni_internal_x86.cc
@@ -3,6 +3,7 @@
#include "jni_internal.h"
#include "assembler.h"
+#include "compiled_method.h"
#include "object.h"
namespace art {
@@ -24,7 +25,7 @@
// "running" state the remaining responsibilities of this routine are
// to save the native registers and set up the managed registers. On
// return, the return value must be store into the result JValue.
-void X86CreateInvokeStub(Method* method) {
+CompiledInvokeStub* X86CreateInvokeStub(const Method* method) {
UniquePtr<X86Assembler> assembler(
down_cast<X86Assembler*>(Assembler::Create(kX86)));
#define __ assembler->
@@ -79,11 +80,10 @@
}
__ ret();
// TODO: store native_entry in the stub table
- ByteArray* code = ByteArray::Alloc(assembler->CodeSize());
- MemoryRegion region(code->GetData(), code->GetLength());
+ std::vector<uint8_t> code(assembler->CodeSize());
+ MemoryRegion region(&code[0], code.size());
assembler->FinalizeInstructions(region);
- method->SetInvokeStub(code);
- CHECK(method->GetInvokeStub() != NULL);
+ return new CompiledInvokeStub(code);
#undef __
}
diff --git a/src/oat.cc b/src/oat.cc
index 191f26f..8bf8299 100644
--- a/src/oat.cc
+++ b/src/oat.cc
@@ -65,4 +65,33 @@
UpdateChecksum(&executable_offset_, sizeof(executable_offset));
}
+OatMethodOffsets::OatMethodOffsets()
+ : code_offset_(0),
+ frame_size_in_bytes_(0),
+ return_pc_offset_in_bytes_(0),
+ core_spill_mask_(0),
+ fp_spill_mask_(0),
+ mapping_table_offset_(0),
+ vmap_table_offset_(0),
+ invoke_stub_offset_(0) {}
+
+OatMethodOffsets::OatMethodOffsets(uint32_t code_offset,
+ uint32_t frame_size_in_bytes,
+ uint32_t return_pc_offset_in_bytes,
+ uint32_t core_spill_mask,
+ uint32_t fp_spill_mask,
+ uint32_t mapping_table_offset,
+ uint32_t vmap_table_offset,
+ uint32_t invoke_stub_offset)
+ : code_offset_(code_offset),
+ frame_size_in_bytes_(frame_size_in_bytes),
+ return_pc_offset_in_bytes_(return_pc_offset_in_bytes),
+ core_spill_mask_(core_spill_mask),
+ fp_spill_mask_(fp_spill_mask),
+ mapping_table_offset_(mapping_table_offset),
+ vmap_table_offset_(vmap_table_offset),
+ invoke_stub_offset_(invoke_stub_offset) {}
+
+OatMethodOffsets::~OatMethodOffsets() {}
+
} // namespace art
diff --git a/src/oat.h b/src/oat.h
index ca3e9e0..ff50599 100644
--- a/src/oat.h
+++ b/src/oat.h
@@ -36,6 +36,29 @@
DISALLOW_COPY_AND_ASSIGN(OatHeader);
};
+class PACKED OatMethodOffsets {
+ public:
+ OatMethodOffsets();
+ OatMethodOffsets(uint32_t code_offset,
+ uint32_t frame_size_in_bytes,
+ uint32_t return_pc_offset_in_bytes,
+ uint32_t core_spill_mask,
+ uint32_t fp_spill_mask,
+ uint32_t mapping_table_offset,
+ uint32_t vmap_table_offset,
+ uint32_t invoke_stub_offset);
+ ~OatMethodOffsets();
+
+ uint32_t code_offset_;
+ uint32_t frame_size_in_bytes_;
+ uint32_t return_pc_offset_in_bytes_;
+ uint32_t core_spill_mask_;
+ uint32_t fp_spill_mask_;
+ uint32_t mapping_table_offset_;
+ uint32_t vmap_table_offset_;
+ uint32_t invoke_stub_offset_;
+};
+
} // namespace art
#endif // ART_SRC_OAT_H_
diff --git a/src/oat_file.cc b/src/oat_file.cc
index 15221a6..95ef64c 100644
--- a/src/oat_file.cc
+++ b/src/oat_file.cc
@@ -146,22 +146,56 @@
uint32_t methods_offset = classes_pointer_[class_def_index];
const byte* methods_pointer = oat_file_->GetBase() + methods_offset;
CHECK_LT(methods_pointer, oat_file_->GetLimit());
- return OatClass(oat_file_, reinterpret_cast<const uint32_t*>(methods_pointer));
+ return OatClass(oat_file_, reinterpret_cast<const OatMethodOffsets*>(methods_pointer));
}
-OatFile::OatClass::OatClass(const OatFile* oat_file, const uint32_t* methods_pointer)
+OatFile::OatClass::OatClass(const OatFile* oat_file, const OatMethodOffsets* methods_pointer)
: oat_file_(oat_file), methods_pointer_(methods_pointer) {}
OatFile::OatClass::~OatClass() {}
-const void* OatFile::OatClass::GetMethodCode(uint32_t method_index) const {
- uint32_t code_offset = methods_pointer_[method_index];
- if (code_offset == 0) {
- return NULL;
- }
- const void* code_pointer = reinterpret_cast<const void*>(oat_file_->GetBase() + code_offset);
- CHECK_LT(code_pointer, oat_file_->GetLimit());
- return code_pointer;
+const OatFile::OatMethod OatFile::OatClass::GetOatMethod(uint32_t method_index) const {
+ const OatMethodOffsets& oat_method_offsets = methods_pointer_[method_index];
+ return OatMethod(
+ GetOatPointer<const void*>(oat_method_offsets.code_offset_),
+ oat_method_offsets.frame_size_in_bytes_,
+ oat_method_offsets.return_pc_offset_in_bytes_,
+ oat_method_offsets.core_spill_mask_,
+ oat_method_offsets.fp_spill_mask_,
+ GetOatPointer<const uint32_t*>(oat_method_offsets.mapping_table_offset_),
+ GetOatPointer<const uint16_t*>(oat_method_offsets.vmap_table_offset_),
+ GetOatPointer<const Method::InvokeStub*>(oat_method_offsets.invoke_stub_offset_));
+}
+
+OatFile::OatMethod::OatMethod(const void* code,
+ const size_t frame_size_in_bytes,
+ const size_t return_pc_offset_in_bytes,
+ const uint32_t core_spill_mask,
+ const uint32_t fp_spill_mask,
+ const uint32_t* mapping_table,
+ const uint16_t* vmap_table,
+ const Method::InvokeStub* invoke_stub) :
+ code_(code),
+ frame_size_in_bytes_(frame_size_in_bytes),
+ return_pc_offset_in_bytes_(return_pc_offset_in_bytes),
+ core_spill_mask_(core_spill_mask),
+ fp_spill_mask_(fp_spill_mask),
+ mapping_table_(mapping_table),
+ vmap_table_(vmap_table),
+ invoke_stub_(invoke_stub) {}
+
+OatFile::OatMethod::~OatMethod() {}
+
+void OatFile::OatMethod::LinkMethod(Method* method) {
+ CHECK(method != NULL);
+ method->SetCode(code_);
+ method->SetFrameSizeInBytes(frame_size_in_bytes_);
+ method->SetReturnPcOffsetInBytes(return_pc_offset_in_bytes_);
+ method->SetCoreSpillMask(core_spill_mask_);
+ method->SetFpSpillMask(fp_spill_mask_);
+ method->SetMappingTable(mapping_table_);
+ method->SetVmapTable(vmap_table_);
+ method->SetInvokeStub(invoke_stub_);
}
} // namespace art
diff --git a/src/oat_file.h b/src/oat_file.h
index 6027dda..0472c16 100644
--- a/src/oat_file.h
+++ b/src/oat_file.h
@@ -5,9 +5,11 @@
#include <vector>
+#include "constants.h"
#include "dex_file.h"
#include "mem_map.h"
#include "oat.h"
+#include "object.h"
namespace art {
@@ -30,20 +32,57 @@
class OatDexFile;
+ class OatMethod {
+ public:
+ // Create an OatMethod backed by an OatFile
+ OatMethod(const void* code,
+ const size_t frame_size_in_bytes,
+ const size_t return_pc_offset_in_bytes,
+ const uint32_t core_spill_mask,
+ const uint32_t fp_spill_mask,
+ const uint32_t* mapping_table,
+ const uint16_t* vmap_table,
+ const Method::InvokeStub* invoke_stub);
+
+ ~OatMethod();
+
+ // Link Method using the contents of this OatMethod
+ void LinkMethod(Method* method);
+
+ const void* code_;
+ size_t frame_size_in_bytes_;
+ size_t return_pc_offset_in_bytes_;
+ uint32_t core_spill_mask_;
+ uint32_t fp_spill_mask_;
+ const uint32_t* mapping_table_;
+ const uint16_t* vmap_table_;
+ const Method::InvokeStub* invoke_stub_;
+ };
+
class OatClass {
public:
- // get the code for the method based on its index into the class
+ // get the OatMethod entry based on its index into the class
// defintion. direct methods come first, followed by virtual
// methods. note that runtime created methods such as miranda
// methods are not included.
- const void* GetMethodCode(uint32_t method_index) const;
+ const OatMethod GetOatMethod(uint32_t method_idx) const;
~OatClass();
private:
- OatClass(const OatFile* oat_file, const uint32_t* methods_pointer);
+ OatClass(const OatFile* oat_file, const OatMethodOffsets* methods_pointer);
+
+ template<class T>
+ T GetOatPointer(uint32_t offset) const {
+ if (offset == 0) {
+ return NULL;
+ }
+ T pointer = reinterpret_cast<T>(oat_file_->GetBase() + offset);
+ CHECK_LT(pointer, reinterpret_cast<T>(oat_file_->GetLimit()));
+ return pointer;
+ }
const OatFile* oat_file_;
- const uint32_t* methods_pointer_;
+ const OatMethodOffsets* methods_pointer_;
friend class OatDexFile;
};
diff --git a/src/oat_test.cc b/src/oat_test.cc
index c3d012e..3137728 100644
--- a/src/oat_test.cc
+++ b/src/oat_test.cc
@@ -14,11 +14,12 @@
const ClassLoader* class_loader = NULL;
if (compile) {
+ compiler_.reset(new Compiler(kThumb2));
compiler_->CompileAll(class_loader);
}
ScratchFile tmp;
- bool success = OatWriter::Create(tmp.GetFilename(), class_loader);
+ bool success = OatWriter::Create(tmp.GetFilename(), class_loader, *compiler_.get());
ASSERT_TRUE(success);
if (compile) { // OatWriter strips the code, regenerate to compare
@@ -29,10 +30,7 @@
const OatHeader& oat_header = oat_file->GetOatHeader();
ASSERT_EQ(1U, oat_header.GetDexFileCount());
- const Runtime* runtime = Runtime::Current();
- ClassLinker* class_linker = runtime->GetClassLinker();
- ByteArray* jni_stub_array = runtime->GetJniStubArray();
- ByteArray* ame_stub_array = runtime->GetAbstractMethodErrorStubArray();
+ ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
const DexFile& dex_file = *java_lang_dex_file_.get();
const OatFile::OatDexFile& oat_dex_file = oat_file->GetOatDexFile(dex_file.GetLocation());
@@ -50,27 +48,57 @@
size_t method_index = 0;
for (size_t i = 0; i < klass->NumDirectMethods(); i++, method_index++) {
Method* method = klass->GetDirectMethod(i);
- const void* oat_code = oat_class.GetMethodCode(method_index);
- uintptr_t oat_code_aligned = RoundDown(reinterpret_cast<uintptr_t>(oat_code), 2);
- oat_code = reinterpret_cast<const void*>(oat_code_aligned);
- const ByteArray* code_array = method->GetCodeArray();
- if (code_array == NULL || code_array == jni_stub_array || code_array == ame_stub_array) {
- ASSERT_TRUE(oat_code == NULL);
+ const OatFile::OatMethod oat_method = oat_class.GetOatMethod(method_index);
+ const CompiledMethod* compiled_method = compiler_->GetCompiledMethod(method);
+
+ if (compiled_method == NULL) {
+ EXPECT_TRUE(oat_method.code_ == NULL) << PrettyMethod(method) << " " << oat_method.code_;
+ EXPECT_EQ(oat_method.frame_size_in_bytes_, static_cast<uint32_t>(kStackAlignment));
+ EXPECT_EQ(oat_method.return_pc_offset_in_bytes_, 0U);
+ EXPECT_EQ(oat_method.core_spill_mask_, 0U);
+ EXPECT_EQ(oat_method.fp_spill_mask_, 0U);
} else {
- ASSERT_EQ(0, memcmp(oat_code, code_array->GetData(), code_array->GetLength()));
+ const void* oat_code = oat_method.code_;
+ uintptr_t oat_code_aligned = RoundDown(reinterpret_cast<uintptr_t>(oat_code), 2);
+ oat_code = reinterpret_cast<const void*>(oat_code_aligned);
+
+ const std::vector<uint8_t>& code = compiled_method->GetCode();
+ size_t code_size = code.size() * sizeof(code[0]);
+ EXPECT_EQ(0, memcmp(oat_code, &code[0], code_size))
+ << PrettyMethod(method) << " " << code_size;
+ CHECK_EQ(0, memcmp(oat_code, &code[0], code_size));
+ EXPECT_EQ(oat_method.frame_size_in_bytes_, compiled_method->GetFrameSizeInBytes());
+ EXPECT_EQ(oat_method.return_pc_offset_in_bytes_, compiled_method->GetReturnPcOffsetInBytes());
+ EXPECT_EQ(oat_method.core_spill_mask_, compiled_method->GetCoreSpillMask());
+ EXPECT_EQ(oat_method.fp_spill_mask_, compiled_method->GetFpSpillMask());
}
}
for (size_t i = 0; i < num_virtual_methods; i++, method_index++) {
Method* method = klass->GetVirtualMethod(i);
- const void* oat_code = oat_class.GetMethodCode(method_index);
- uintptr_t oat_code_aligned = RoundDown(reinterpret_cast<uintptr_t>(oat_code), 2);
- oat_code = reinterpret_cast<const void*>(oat_code_aligned);
- const ByteArray* code_array = method->GetCodeArray();
- if (code_array == NULL || code_array == jni_stub_array || code_array == ame_stub_array) {
- ASSERT_TRUE(oat_code == NULL);
+ const OatFile::OatMethod oat_method = oat_class.GetOatMethod(method_index);
+ const CompiledMethod* compiled_method = compiler_->GetCompiledMethod(method);
+
+ if (compiled_method == NULL) {
+ EXPECT_TRUE(oat_method.code_ == NULL) << PrettyMethod(method) << " " << oat_method.code_;
+ EXPECT_EQ(oat_method.frame_size_in_bytes_, static_cast<uint32_t>(kStackAlignment));
+ EXPECT_EQ(oat_method.return_pc_offset_in_bytes_, 0U);
+ EXPECT_EQ(oat_method.core_spill_mask_, 0U);
+ EXPECT_EQ(oat_method.fp_spill_mask_, 0U);
} else {
- ASSERT_TRUE(oat_code != NULL);
- ASSERT_EQ(0, memcmp(oat_code, code_array->GetData(), code_array->GetLength()));
+ const void* oat_code = oat_method.code_;
+ EXPECT_TRUE(oat_code != NULL) << PrettyMethod(method);
+ uintptr_t oat_code_aligned = RoundDown(reinterpret_cast<uintptr_t>(oat_code), 2);
+ oat_code = reinterpret_cast<const void*>(oat_code_aligned);
+
+ const std::vector<uint8_t>& code = compiled_method->GetCode();
+ size_t code_size = code.size() * sizeof(code[0]);
+ EXPECT_EQ(0, memcmp(oat_code, &code[0], code_size))
+ << PrettyMethod(method) << " " << code_size;
+ CHECK_EQ(0, memcmp(oat_code, &code[0], code_size));
+ EXPECT_EQ(oat_method.frame_size_in_bytes_, compiled_method->GetFrameSizeInBytes());
+ EXPECT_EQ(oat_method.return_pc_offset_in_bytes_, compiled_method->GetReturnPcOffsetInBytes());
+ EXPECT_EQ(oat_method.core_spill_mask_, compiled_method->GetCoreSpillMask());
+ EXPECT_EQ(oat_method.fp_spill_mask_, compiled_method->GetFpSpillMask());
}
}
}
diff --git a/src/oat_writer.cc b/src/oat_writer.cc
index b8232d9..0722520 100644
--- a/src/oat_writer.cc
+++ b/src/oat_writer.cc
@@ -10,13 +10,18 @@
namespace art {
-bool OatWriter::Create(const std::string& filename, const ClassLoader* class_loader) {
+bool OatWriter::Create(const std::string& filename,
+ const ClassLoader* class_loader,
+ const Compiler& compiler) {
const std::vector<const DexFile*>& dex_files = ClassLoader::GetClassPath(class_loader);
- OatWriter oat_writer(dex_files, class_loader);
+ OatWriter oat_writer(dex_files, class_loader, compiler);
return oat_writer.Write(filename);
}
-OatWriter::OatWriter(const std::vector<const DexFile*>& dex_files, const ClassLoader* class_loader) {
+OatWriter::OatWriter(const std::vector<const DexFile*>& dex_files,
+ const ClassLoader* class_loader,
+ const Compiler& compiler) {
+ compiler_ = &compiler;
class_loader_ = class_loader;
dex_files_ = &dex_files;
@@ -141,7 +146,6 @@
CHECK_EQ(klass->GetClassLoader(), class_loader_);
CHECK_EQ(oat_methods_[oat_class_index]->method_offsets_.size(),
klass->NumDirectMethods() + num_virtual_methods);
- // Note that we leave the offset to the code in Method::code_
size_t class_def_method_index = 0;
for (size_t i = 0; i < klass->NumDirectMethods(); i++, class_def_method_index++) {
Method* method = klass->GetDirectMethod(i);
@@ -161,27 +165,99 @@
size_t oat_class_index,
size_t class_def_method_index,
Method* method) {
- Runtime* runtime = Runtime::Current();
- ByteArray* jni_stub_array = runtime->GetJniStubArray();
- ByteArray* ame_stub_array = runtime->GetAbstractMethodErrorStubArray();
+ // derived from CompiledMethod if available
+ uint32_t code_offset = 0;
+ uint32_t frame_size_in_bytes = kStackAlignment;
+ uint32_t return_pc_offset_in_bytes = 0;
+ uint32_t core_spill_mask = 0;
+ uint32_t fp_spill_mask = 0;
+ uint32_t mapping_table_offset = 0;
+ uint32_t vmap_table_offset = 0;
+ // derived from CompiledInvokeStub if available
+ uint32_t invoke_stub_offset = 0;
- const ByteArray* code_array = method->GetCodeArray();
- if (code_array == NULL || code_array == jni_stub_array || code_array == ame_stub_array) {
- oat_methods_[oat_class_index]->method_offsets_[class_def_method_index] = 0;
- method->SetOatCodeOffset(0);
- } else {
- offset = RoundUp(offset, kArmAlignment);
- uint32_t thumb_offset = (reinterpret_cast<const int8_t*>(method->GetCode())
- - code_array->GetData());
- uint32_t code_offset = offset + thumb_offset;
- oat_methods_[oat_class_index]->method_offsets_[class_def_method_index] = code_offset;
- method->SetOatCodeOffset(code_offset);
- offset += code_array->GetLength();
- oat_header_->UpdateChecksum(code_array->GetData(), code_array->GetLength());
+ const CompiledMethod* compiled_method = compiler_->GetCompiledMethod(method);
+ if (compiled_method != NULL) {
+
+ offset = compiled_method->AlignCode(offset);
+ DCHECK(IsAligned(offset, kArmAlignment)) << std::hex << offset;
+ const std::vector<uint8_t>& code = compiled_method->GetCode();
+ size_t code_size = code.size() * sizeof(code[0]);
+ uint32_t thumb_offset = compiled_method->CodeDelta();
+ code_offset = (code_size == 0) ? 0 : offset + thumb_offset;
+ offset += code_size;
+ oat_header_->UpdateChecksum(&code[0], code_size);
+
+ frame_size_in_bytes = compiled_method->GetFrameSizeInBytes();
+ return_pc_offset_in_bytes = compiled_method->GetReturnPcOffsetInBytes();
+ core_spill_mask = compiled_method->GetCoreSpillMask();
+ fp_spill_mask = compiled_method->GetFpSpillMask();
}
+
+ offset += sizeof(frame_size_in_bytes);
+ oat_header_->UpdateChecksum(&frame_size_in_bytes, sizeof(frame_size_in_bytes));
+
+ offset += sizeof(return_pc_offset_in_bytes);
+ oat_header_->UpdateChecksum(&return_pc_offset_in_bytes, sizeof(return_pc_offset_in_bytes));
+
+ offset += sizeof(core_spill_mask);
+ oat_header_->UpdateChecksum(&core_spill_mask, sizeof(core_spill_mask));
+
+ offset += sizeof(fp_spill_mask);
+ oat_header_->UpdateChecksum(&fp_spill_mask, sizeof(fp_spill_mask));
+
+ if (compiled_method != NULL) {
+
+ const std::vector<uint32_t>& mapping_table = compiled_method->GetMappingTable();
+ size_t mapping_table_size = mapping_table.size() * sizeof(mapping_table[0]);
+ mapping_table_offset = (mapping_table_size == 0) ? 0 : offset;
+ offset += mapping_table_size;
+ oat_header_->UpdateChecksum(&mapping_table[0], mapping_table_size);
+
+ const std::vector<uint16_t>& vmap_table = compiled_method->GetVmapTable();
+ size_t vmap_table_size = vmap_table.size() * sizeof(vmap_table[0]);
+ vmap_table_offset = (vmap_table_size == 0) ? 0 : offset;
+ offset += vmap_table_size;
+ oat_header_->UpdateChecksum(&vmap_table[0], vmap_table_size);
+ }
+
+ const CompiledInvokeStub* compiled_invoke_stub = compiler_->GetCompiledInvokeStub(method);
+ if (compiled_invoke_stub != NULL) {
+ offset = CompiledMethod::AlignCode(offset, compiler_->GetInstructionSet());
+ DCHECK(IsAligned(offset, kArmAlignment)) << std::hex << offset;
+ const std::vector<uint8_t>& invoke_stub = compiled_invoke_stub->GetCode();
+ size_t invoke_stub_size = invoke_stub.size() * sizeof(invoke_stub[0]);
+ invoke_stub_offset = (invoke_stub_size == 0) ? 0 : offset;
+ offset += invoke_stub_size;
+ oat_header_->UpdateChecksum(&invoke_stub[0], invoke_stub_size);
+ }
+
+ oat_methods_[oat_class_index]->method_offsets_[class_def_method_index]
+ = OatMethodOffsets(code_offset,
+ frame_size_in_bytes,
+ return_pc_offset_in_bytes,
+ core_spill_mask,
+ fp_spill_mask,
+ mapping_table_offset,
+ vmap_table_offset,
+ invoke_stub_offset);
+
+ // Note that we leave the offset and values back in the Method where ImageWriter will find them
+ method->SetOatCodeOffset(code_offset);
+ method->SetFrameSizeInBytes(frame_size_in_bytes);
+ method->SetReturnPcOffsetInBytes(return_pc_offset_in_bytes);
+ method->SetCoreSpillMask(core_spill_mask);
+ method->SetFpSpillMask(fp_spill_mask);
+ method->SetOatMappingTableOffset(mapping_table_offset);
+ method->SetOatVmapTableOffset(vmap_table_offset);
+ method->SetOatInvokeStubOffset(invoke_stub_offset);
+
return offset;
}
+#define DCHECK_CODE_OFFSET() \
+ DCHECK_EQ(static_cast<off_t>(code_offset), lseek(file->Fd(), 0, SEEK_CUR))
+
bool OatWriter::Write(const std::string& filename) {
UniquePtr<File> file(OS::OpenFile(filename.c_str(), true));
@@ -240,9 +316,11 @@
uint32_t code_offset = oat_header_->GetExecutableOffset();
off_t new_offset = lseek(file->Fd(), executable_offset_padding_length_, SEEK_CUR);
if (static_cast<uint32_t>(new_offset) != code_offset) {
- PLOG(ERROR) << "Failed to seek to oat code section";
+ PLOG(ERROR) << "Failed to seek to oat code section. Actual: " << new_offset
+ << " Expected: " << code_offset;
return 0;
}
+ DCHECK_CODE_OFFSET();
return code_offset;
}
@@ -277,14 +355,11 @@
size_t code_offset,
const DexFile& dex_file,
const DexFile::ClassDef& class_def) {
- const Runtime* runtime = Runtime::Current();
- ClassLinker* class_linker = runtime->GetClassLinker();
- ByteArray* ame_stub_array = runtime->GetAbstractMethodErrorStubArray();
-
const byte* class_data = dex_file.GetClassData(class_def);
DexFile::ClassDataHeader header = dex_file.ReadClassDataHeader(&class_data);
size_t num_virtual_methods = header.virtual_methods_size_;
const char* descriptor = dex_file.GetClassDescriptor(class_def);
+ ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Class* klass = class_linker->FindClass(descriptor, class_loader_);
// TODO: deduplicate code arrays
@@ -306,11 +381,7 @@
}
for (size_t i = num_virtual_methods; i < klass->NumVirtualMethods(); i++) {
Method* method = klass->GetVirtualMethod(i);
- const ByteArray* code_array = method->GetCodeArray();
- CHECK(code_array == NULL // if compiler not run
- || code_array == ame_stub_array) // otherwise
- << PrettyMethod(method) << " " << code_array;
- method->SetCodeArray(NULL, kNone);
+ CHECK(compiler_->GetCompiledMethod(method) == NULL) << PrettyMethod(method);
}
return code_offset;
}
@@ -318,32 +389,110 @@
size_t OatWriter::WriteCodeMethod(File* file,
size_t code_offset,
Method* method) {
- const Runtime* runtime = Runtime::Current();
- ByteArray* jni_stub_array = runtime->GetJniStubArray();
- ByteArray* ame_stub_array = runtime->GetAbstractMethodErrorStubArray();
-
- const ByteArray* code_array = method->GetCodeArray();
- if (code_array != NULL && code_array != jni_stub_array && code_array != ame_stub_array) {
- uint32_t aligned_code_offset = RoundUp(code_offset, kArmAlignment);
+ const CompiledMethod* compiled_method = compiler_->GetCompiledMethod(method);
+ if (compiled_method != NULL) {
+ uint32_t aligned_code_offset = compiled_method->AlignCode(code_offset);
uint32_t aligned_code_delta = aligned_code_offset - code_offset;
if (aligned_code_delta != 0) {
off_t new_offset = lseek(file->Fd(), aligned_code_delta, SEEK_CUR);
if (static_cast<uint32_t>(new_offset) != aligned_code_offset) {
- PLOG(ERROR) << "Failed to seek to align oat code";
+ PLOG(ERROR) << "Failed to seek to align oat code. Actual: " << new_offset
+ << " Expected: " << aligned_code_offset;
return false;
}
code_offset += aligned_code_delta;
+ DCHECK_CODE_OFFSET();
}
- if (!file->WriteFully(code_array->GetData(), code_array->GetLength())) {
+ DCHECK(IsAligned(code_offset, kArmAlignment)) << std::hex << code_offset;
+ const std::vector<uint8_t>& code = compiled_method->GetCode();
+ size_t code_size = code.size() * sizeof(code[0]);
+ DCHECK((code_size == 0 && method->GetOatCodeOffset() == 0)
+ || code_offset + compiled_method->CodeDelta() == method->GetOatCodeOffset());
+ if (!file->WriteFully(&code[0], code_size)) {
PLOG(ERROR) << "Failed to write method code for " << PrettyMethod(method);
return false;
}
- code_offset += code_array->GetLength();
+ code_offset += code_size;
+ DCHECK_CODE_OFFSET();
}
- // preserve code offset around code clearing
- uint32_t offset = method->GetOatCodeOffset();
- method->SetCodeArray(NULL, kNone);
- method->SetOatCodeOffset(offset);
+
+ uint32_t frame_size_in_bytes = method->GetFrameSizeInBytes();
+ uint32_t return_pc_offset_in_bytes = method->GetReturnPcOffsetInBytes();
+ uint32_t core_spill_mask = method->GetCoreSpillMask();
+ uint32_t fp_spill_mask = method->GetFpSpillMask();
+ if (!file->WriteFully(&frame_size_in_bytes, sizeof(frame_size_in_bytes))) {
+ PLOG(ERROR) << "Failed to write method frame size for " << PrettyMethod(method);
+ return false;
+ }
+ code_offset += sizeof(frame_size_in_bytes);
+ if (!file->WriteFully(&return_pc_offset_in_bytes, sizeof(return_pc_offset_in_bytes))) {
+ PLOG(ERROR) << "Failed to write method return pc offset for " << PrettyMethod(method);
+ return false;
+ }
+ code_offset += sizeof(return_pc_offset_in_bytes);
+ if (!file->WriteFully(&core_spill_mask, sizeof(core_spill_mask))) {
+ PLOG(ERROR) << "Failed to write method core spill mask for " << PrettyMethod(method);
+ return false;
+ }
+ code_offset += sizeof(core_spill_mask);
+ if (!file->WriteFully(&fp_spill_mask, sizeof(fp_spill_mask))) {
+ PLOG(ERROR) << "Failed to write method fp spill mask for " << PrettyMethod(method);
+ return false;
+ }
+ code_offset += sizeof(fp_spill_mask);
+
+ if (compiled_method != NULL) {
+ const std::vector<uint32_t>& mapping_table = compiled_method->GetMappingTable();
+ size_t mapping_table_size = mapping_table.size() * sizeof(mapping_table[0]);
+ DCHECK((mapping_table_size == 0 && method->GetOatMappingTableOffset() == 0)
+ || code_offset == method->GetOatMappingTableOffset());
+ if (!file->WriteFully(&mapping_table[0], mapping_table_size)) {
+ PLOG(ERROR) << "Failed to write mapping table for " << PrettyMethod(method);
+ return false;
+ }
+ code_offset += mapping_table_size;
+ DCHECK_CODE_OFFSET();
+
+ const std::vector<uint16_t>& vmap_table = compiled_method->GetVmapTable();
+ size_t vmap_table_size = vmap_table.size() * sizeof(vmap_table[0]);
+ DCHECK((vmap_table_size == 0 && method->GetOatVmapTableOffset() == 0)
+ || code_offset == method->GetOatVmapTableOffset());
+ if (!file->WriteFully(&vmap_table[0], vmap_table_size)) {
+ PLOG(ERROR) << "Failed to write vmap table for " << PrettyMethod(method);
+ return false;
+ }
+ code_offset += vmap_table_size;
+ DCHECK_CODE_OFFSET();
+ }
+
+ const CompiledInvokeStub* compiled_invoke_stub = compiler_->GetCompiledInvokeStub(method);
+ if (compiled_invoke_stub != NULL) {
+ uint32_t aligned_code_offset = CompiledMethod::AlignCode(code_offset,
+ compiler_->GetInstructionSet());
+ uint32_t aligned_code_delta = aligned_code_offset - code_offset;
+ if (aligned_code_delta != 0) {
+ off_t new_offset = lseek(file->Fd(), aligned_code_delta, SEEK_CUR);
+ if (static_cast<uint32_t>(new_offset) != aligned_code_offset) {
+ PLOG(ERROR) << "Failed to seek to align invoke stub code. Actual: " << new_offset
+ << " Expected: " << aligned_code_offset;
+ return false;
+ }
+ code_offset += aligned_code_delta;
+ DCHECK_CODE_OFFSET();
+ }
+ DCHECK(IsAligned(code_offset, kArmAlignment)) << std::hex << code_offset;
+ const std::vector<uint8_t>& invoke_stub = compiled_invoke_stub->GetCode();
+ size_t invoke_stub_size = invoke_stub.size() * sizeof(invoke_stub[0]);
+ DCHECK((invoke_stub_size == 0 && method->GetOatInvokeStubOffset() == 0)
+ || code_offset == method->GetOatInvokeStubOffset());
+ if (!file->WriteFully(&invoke_stub[0], invoke_stub_size)) {
+ PLOG(ERROR) << "Failed to write invoke stub code for " << PrettyMethod(method);
+ return false;
+ }
+ code_offset += invoke_stub_size;
+ DCHECK_CODE_OFFSET();
+ }
+
return code_offset;
}
diff --git a/src/oat_writer.h b/src/oat_writer.h
index 7cef892..a33ffc7 100644
--- a/src/oat_writer.h
+++ b/src/oat_writer.h
@@ -8,6 +8,7 @@
#include <cstddef>
#include "UniquePtr.h"
+#include "compiler.h"
#include "dex_cache.h"
#include "mem_map.h"
#include "oat.h"
@@ -30,29 +31,33 @@
// OatClasses[D]
//
// OatMethods[0] one variable sized OatMethods for each of C DexFile::ClassDefs
-// OatMethods[1] contains offsets to code
+// OatMethods[1] contains OatMethod entries with offsets to code, method properities, etc.
// ...
// OatMethods[C]
//
// padding if necessary so that the follow code will be page aligned
//
-// Method::GetCode() one variable sized code blob for each Method::GetCode() value
-// Method::GetCode()
-// Method::GetCode()
-// Method::GetCode()
-// Method::GetCode()
-// Method::GetCode()
+// CompiledMethod one variable sized blob with the contents of each CompiledMethod
+// CompiledMethod
+// CompiledMethod
+// CompiledMethod
+// CompiledMethod
+// CompiledMethod
// ...
-// Method::GetCode()
+// CompiledMethod
//
class OatWriter {
public:
// Write an oat file. Returns true on success, false on failure.
- static bool Create(const std::string& filename, const ClassLoader* class_loader);
+ static bool Create(const std::string& filename,
+ const ClassLoader* class_loader,
+ const Compiler& compiler);
private:
- OatWriter(const std::vector<const DexFile*>& dex_files, const ClassLoader* class_loader);
+ OatWriter(const std::vector<const DexFile*>& dex_files,
+ const ClassLoader* class_loader,
+ const Compiler& compiler);
~OatWriter();
size_t InitOatHeader();
@@ -128,12 +133,14 @@
bool Write(File* file) const;
// data to write
- std::vector<uint32_t> method_offsets_;
+ std::vector<OatMethodOffsets> method_offsets_;
private:
DISALLOW_COPY_AND_ASSIGN(OatMethods);
};
+ const Compiler* compiler_;
+
// TODO: remove the ClassLoader when the code storage moves out of Method
const ClassLoader* class_loader_;
diff --git a/src/oatdump.cc b/src/oatdump.cc
index 27dbdee..8113c2b 100644
--- a/src/oatdump.cc
+++ b/src/oatdump.cc
@@ -165,34 +165,12 @@
// object_bytes, RoundUp(object_bytes, kObjectAlignment) - object_bytes);
if (obj->IsMethod()) {
Method* method = obj->AsMethod();
- if (!method->IsPhony()) {
- const ByteArray* code = method->GetCodeArray();
- const int8_t* code_base = NULL;
- const int8_t* code_limit = NULL;
- if (code != NULL) {
- size_t code_bytes = code->GetLength();
- code_base = code->GetData();
- code_limit = code_base + code_bytes;
- if (method->IsNative()) {
- state->stats_.managed_to_native_code_bytes += code_bytes;
- } else {
- state->stats_.managed_code_bytes += code_bytes;
- }
- } else {
- code_base = reinterpret_cast<const int8_t*>(method->GetCode());
- }
- StringAppendF(&summary, "\tCODE %p-%p\n", code_base, code_limit);
+ if (!method->IsCalleeSaveMethod()) {
+ const int8_t* code =reinterpret_cast<const int8_t*>(method->GetCode());
+ StringAppendF(&summary, "\tCODE %p\n", code);
- const ByteArray* invoke = method->GetInvokeStubArray();
- const int8_t* invoke_base = NULL;
- const int8_t* invoke_limit = NULL;
- if (invoke != NULL) {
- size_t native_to_managed_code_bytes = invoke->GetLength();
- invoke_base = invoke->GetData();
- invoke_limit = invoke_base + native_to_managed_code_bytes;
- state->stats_.native_to_managed_code_bytes += native_to_managed_code_bytes;
- StringAppendF(&summary, "\tJNI STUB %p-%p\n", invoke_base, invoke_limit);
- }
+ const Method::InvokeStub* invoke_stub = method->GetInvokeStub();
+ StringAppendF(&summary, "\tJNI STUB %p\n", invoke_stub);
}
if (method->IsNative()) {
if (method->IsRegistered()) {
@@ -200,26 +178,26 @@
} else {
StringAppendF(&summary, "\tNATIVE UNREGISTERED\n");
}
- DCHECK(method->GetRegisterMapHeader() == NULL);
- DCHECK(method->GetRegisterMapData() == NULL);
- DCHECK(method->GetMappingTable() == NULL);
+ DCHECK(method->GetRegisterMapHeader() == NULL) << PrettyMethod(method);
+ DCHECK(method->GetRegisterMapData() == NULL) << PrettyMethod(method);
+ DCHECK(method->GetMappingTable() == NULL) << PrettyMethod(method);
} else if (method->IsAbstract()) {
StringAppendF(&summary, "\tABSTRACT\n");
- DCHECK(method->GetRegisterMapHeader() == NULL);
- DCHECK(method->GetRegisterMapData() == NULL);
- DCHECK(method->GetMappingTable() == NULL);
- } else if (method->IsPhony()) {
- StringAppendF(&summary, "\tPHONY\n");
- DCHECK(method->GetRegisterMapHeader() == NULL);
- DCHECK(method->GetRegisterMapData() == NULL);
- DCHECK(method->GetMappingTable() == NULL);
+ DCHECK(method->GetRegisterMapHeader() == NULL) << PrettyMethod(method);
+ DCHECK(method->GetRegisterMapData() == NULL) << PrettyMethod(method);
+ DCHECK(method->GetMappingTable() == NULL) << PrettyMethod(method);
+ } else if (method->IsCalleeSaveMethod()) {
+ StringAppendF(&summary, "\tCALLEE SAVE METHOD\n");
+ DCHECK(method->GetRegisterMapHeader() == NULL) << PrettyMethod(method);
+ DCHECK(method->GetRegisterMapData() == NULL) << PrettyMethod(method);
+ DCHECK(method->GetMappingTable() == NULL) << PrettyMethod(method);
} else {
size_t register_map_bytes = (method->GetRegisterMapHeader()->GetLength() +
method->GetRegisterMapData()->GetLength());
state->stats_.register_map_bytes += register_map_bytes;
if (method->GetMappingTable() != NULL) {
- size_t pc_mapping_table_bytes = method->GetMappingTable()->GetLength();
+ size_t pc_mapping_table_bytes = method->GetMappingTableLength();
state->stats_.pc_mapping_table_bytes += pc_mapping_table_bytes;
}
diff --git a/src/oatexec.cc b/src/oatexec.cc
index 9632ca2..f1d63c3 100644
--- a/src/oatexec.cc
+++ b/src/oatexec.cc
@@ -17,20 +17,20 @@
static bool IsMethodPublic(JNIEnv* env, jclass clazz, jmethodID method_id) {
ScopedLocalRef<jobject> reflected(env, env->ToReflectedMethod(clazz, method_id, JNI_FALSE));
if (reflected.get() == NULL) {
- fprintf(stderr, "Unable to get reflected method\n");
+ fprintf(stderr, "Failed to get reflected method\n");
return false;
}
// We now have a Method instance. We need to call its
// getModifiers() method.
ScopedLocalRef<jclass> method(env, env->FindClass("java/lang/reflect/Method"));
if (method.get() == NULL) {
- fprintf(stderr, "Unable to find class Method\n");
+ fprintf(stderr, "Failed to find class Method\n");
return false;
}
static const int PUBLIC = 0x0001; // java.lang.reflect.Modifiers.PUBLIC
jmethodID get_modifiers = env->GetMethodID(method.get(), "getModifiers", "()I");
if (get_modifiers == NULL) {
- fprintf(stderr, "Unable to find reflect.Method.getModifiers\n");
+ fprintf(stderr, "Failed to find reflect.Method.getModifiers\n");
return false;
}
int modifiers = env->CallIntMethod(reflected.get(), get_modifiers);
diff --git a/src/object.cc b/src/object.cc
index c43fe49..99cdbc8 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -620,21 +620,18 @@
}
uint32_t Method::ToDexPC(const uintptr_t pc) const {
- IntArray* mapping_table = GetMappingTable();
+ const uint32_t* mapping_table = GetMappingTable();
if (mapping_table == NULL) {
DCHECK(IsNative());
return DexFile::kDexNoIndex; // Special no mapping case
}
- size_t mapping_table_length = mapping_table->GetLength();
+ size_t mapping_table_length = GetMappingTableLength();
uint32_t sought_offset = pc - reinterpret_cast<uintptr_t>(GetCode());
- if (GetCodeArray() != NULL) {
- CHECK_LT(sought_offset, static_cast<uint32_t>(GetCodeArray()->GetLength()));
- }
uint32_t best_offset = 0;
uint32_t best_dex_offset = 0;
for (size_t i = 0; i < mapping_table_length; i += 2) {
- uint32_t map_offset = mapping_table->Get(i);
- uint32_t map_dex_offset = mapping_table->Get(i + 1);
+ uint32_t map_offset = mapping_table[i];
+ uint32_t map_dex_offset = mapping_table[i + 1];
if (map_offset == sought_offset) {
best_offset = map_offset;
best_dex_offset = map_dex_offset;
@@ -649,19 +646,16 @@
}
uintptr_t Method::ToNativePC(const uint32_t dex_pc) const {
- IntArray* mapping_table = GetMappingTable();
+ const uint32_t* mapping_table = GetMappingTable();
if (mapping_table == NULL) {
DCHECK(dex_pc == 0);
return 0; // Special no mapping/pc == 0 case
}
- size_t mapping_table_length = mapping_table->GetLength();
+ size_t mapping_table_length = GetMappingTableLength();
for (size_t i = 0; i < mapping_table_length; i += 2) {
- uint32_t map_offset = mapping_table->Get(i);
- uint32_t map_dex_offset = mapping_table->Get(i + 1);
+ uint32_t map_offset = mapping_table[i];
+ uint32_t map_dex_offset = mapping_table[i + 1];
if (map_dex_offset == dex_pc) {
- if (GetCodeArray() != NULL) {
- DCHECK_LT(map_offset, static_cast<uint32_t>(GetCodeArray()->GetLength()));
- }
return reinterpret_cast<uintptr_t>(GetCode()) + map_offset;
}
}
@@ -694,58 +688,6 @@
return DexFile::kDexNoIndex;
}
-void Method::SetCodeArray(ByteArray* code_array, InstructionSet instruction_set) {
-// TODO: restore this check or warning when compile time code storage is moved out of Method
-// CHECK(GetCode() == NULL || IsNative()) << PrettyMethod(this);
-// if (GetCode() != NULL && !IsNative()) {
-// LOG(WARNING) << "Calling SetCode more than once for " << PrettyMethod(this);
-// }
- SetFieldPtr<ByteArray*>(OFFSET_OF_OBJECT_MEMBER(Method, code_array_), code_array, false);
-
- void* code;
- if (code_array != NULL) {
- code = code_array->GetData();
- if (instruction_set == kThumb2) {
- uintptr_t address = reinterpret_cast<uintptr_t>(code);
- // Set the low-order bit so a BLX will switch to Thumb mode
- address |= 0x1;
- code = reinterpret_cast<void*>(address);
- }
- } else {
- code = NULL;
- }
- SetCode(code);
-}
-
-bool Method::IsWithinCode(uintptr_t pc) const {
- if (pc == 0) {
- // PC of 0 represents the beginning of a stack trace either a native or where we have a callee
- // save method that has no code
- DCHECK(IsNative() || IsPhony());
- return true;
- } else {
-#if defined(__arm__)
- pc &= ~0x1; // clear any possible thumb instruction mode bit
-#endif
- if (GetCodeArray() == NULL) {
- return true;
- }
- uint32_t rel_offset = pc - reinterpret_cast<uintptr_t>(GetCodeArray()->GetData());
- // Strictly the following test should be a less-than, however, if the last
- // instruction is a call to an exception throw we may see return addresses
- // that are 1 beyond the end of code.
- return rel_offset <= static_cast<uint32_t>(GetCodeArray()->GetLength());
- }
-}
-
-void Method::SetInvokeStub(const ByteArray* invoke_stub_array) {
- const InvokeStub* invoke_stub = reinterpret_cast<InvokeStub*>(invoke_stub_array->GetData());
- SetFieldPtr<const ByteArray*>(
- OFFSET_OF_OBJECT_MEMBER(Method, invoke_stub_array_), invoke_stub_array, false);
- SetFieldPtr<const InvokeStub*>(
- OFFSET_OF_OBJECT_MEMBER(Method, invoke_stub_), invoke_stub, false);
-}
-
void Method::Invoke(Thread* self, Object* receiver, byte* args, JValue* result) const {
// Push a transition back into managed code onto the linked list in thread.
CHECK_EQ(Thread::kRunnable, self->GetState());
@@ -779,7 +721,7 @@
self->PopNativeToManagedRecord(record);
}
-bool Method::IsRegistered() {
+bool Method::IsRegistered() const {
void* native_method = GetFieldPtr<void*>(OFFSET_OF_OBJECT_MEMBER(Method, native_method_), false);
void* jni_stub = Runtime::Current()->GetJniStubArray()->GetData();
return native_method != jni_stub;
diff --git a/src/object.h b/src/object.h
index 03fa359..de3075b 100644
--- a/src/object.h
+++ b/src/object.h
@@ -404,6 +404,16 @@
DISALLOW_IMPLICIT_CONSTRUCTORS(Object);
};
+struct ObjectIdentityHash {
+ size_t operator()(const art::Object* const& obj) const {
+#ifdef MOVING_GARBAGE_COLLECTOR
+ // TODO: we'll need to use the Object's internal concept of identity
+ UNIMPLEMENTED(FATAL);
+#endif
+ return reinterpret_cast<size_t>(obj);
+ }
+};
+
// C++ mirror of java.lang.reflect.AccessibleObject
class MANAGED AccessibleObject : public Object {
private:
@@ -667,8 +677,7 @@
}
void SetMethodIndex(uint16_t new_method_index) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(Method, method_index_),
- new_method_index, false);
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Method, method_index_), new_method_index, false);
}
static MemberOffset MethodIndexOffset() {
@@ -680,8 +689,7 @@
}
void SetCodeItemOffset(uint32_t new_code_off) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(Method, code_item_offset_),
- new_code_off, false);
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Method, code_item_offset_), new_code_off, false);
}
// Number of 32bit registers that would be required to hold all the arguments
@@ -694,22 +702,19 @@
uint16_t NumRegisters() const;
void SetNumRegisters(uint16_t new_num_registers) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(Method, num_registers_),
- new_num_registers, false);
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Method, num_registers_), new_num_registers, false);
}
uint16_t NumIns() const;
void SetNumIns(uint16_t new_num_ins) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(Method, num_ins_),
- new_num_ins, false);
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Method, num_ins_), new_num_ins, false);
}
uint16_t NumOuts() const;
void SetNumOuts(uint16_t new_num_outs) {
- SetField32(OFFSET_OF_OBJECT_MEMBER(Method, num_outs_),
- new_num_outs, false);
+ SetField32(OFFSET_OF_OBJECT_MEMBER(Method, num_outs_), new_num_outs, false);
}
uint32_t GetProtoIdx() const;
@@ -806,15 +811,11 @@
void Invoke(Thread* self, Object* receiver, byte* args, JValue* result) const;
- const ByteArray* GetCodeArray() const {
- return GetFieldPtr<const ByteArray*>(OFFSET_OF_OBJECT_MEMBER(Method, code_array_), false);
- }
-
const void* GetCode() const {
return GetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(Method, code_), false);
}
- void SetCode(void* code) {
+ void SetCode(const void* code) {
SetFieldPtr<const void*>(OFFSET_OF_OBJECT_MEMBER(Method, code_), code, false);
}
@@ -828,29 +829,77 @@
SetCode(reinterpret_cast<void*>(code_offset));
}
- void SetCodeArray(ByteArray* code_array, InstructionSet instruction_set);
-
static MemberOffset GetCodeOffset() {
return OFFSET_OF_OBJECT_MEMBER(Method, code_);
}
- // Is the given PC within the code array?
- bool IsWithinCode(uintptr_t pc) const;
-
- IntArray* GetMappingTable() const {
- return GetFieldObject<IntArray*>(OFFSET_OF_OBJECT_MEMBER(Method, mapping_table_), false);
+ const uint32_t* GetMappingTable() const {
+ const uint32_t* map = GetMappingTableRaw();
+ if (map == NULL) {
+ return map;
+ }
+ return map + 1;
}
- void SetMappingTable(IntArray* mapping_table) {
- SetFieldPtr<IntArray*>(OFFSET_OF_OBJECT_MEMBER(Method, mapping_table_), mapping_table, false);
+ uint32_t GetMappingTableLength() const {
+ const uint32_t* map = GetMappingTableRaw();
+ if (map == NULL) {
+ return 0;
+ }
+ return *map;
}
- ShortArray* GetVMapTable() const {
- return GetFieldObject<ShortArray*>(OFFSET_OF_OBJECT_MEMBER(Method, vmap_table_), false);
+ const uint32_t* GetMappingTableRaw() const {
+ return GetFieldPtr<const uint32_t*>(OFFSET_OF_OBJECT_MEMBER(Method, mapping_table_), false);
}
- void SetVMapTable(ShortArray* vmap_table) {
- SetFieldPtr<ShortArray*>(OFFSET_OF_OBJECT_MEMBER(Method, vmap_table_), vmap_table, false);
+ void SetMappingTable(const uint32_t* mapping_table) {
+ SetFieldPtr<const uint32_t*>(OFFSET_OF_OBJECT_MEMBER(Method, mapping_table_),
+ mapping_table, false);
+ }
+
+ uint32_t GetOatMappingTableOffset() const {
+ CHECK(!Runtime::Current()->IsStarted());
+ return reinterpret_cast<uint32_t>(GetMappingTableRaw());
+ }
+
+ void SetOatMappingTableOffset(uint32_t mapping_table_offset) {
+ CHECK(!Runtime::Current()->IsStarted());
+ SetMappingTable(reinterpret_cast<const uint32_t*>(mapping_table_offset));
+ }
+
+ const uint16_t* GetVmapTable() const {
+ const uint16_t* vmap = GetVmapTableRaw();
+ if (vmap == NULL) {
+ return vmap;
+ }
+ return vmap + 1;
+ }
+
+ uint16_t GetVmapTableLength() const {
+ const uint16_t* vmap = GetVmapTableRaw();
+ if (vmap == NULL) {
+ return 0;
+ }
+ return *vmap;
+ }
+
+ const uint16_t* GetVmapTableRaw() const {
+ return GetFieldPtr<const uint16_t*>(OFFSET_OF_OBJECT_MEMBER(Method, vmap_table_), false);
+ }
+
+ void SetVmapTable(const uint16_t* vmap_table) {
+ SetFieldPtr<const uint16_t*>(OFFSET_OF_OBJECT_MEMBER(Method, vmap_table_), vmap_table, false);
+ }
+
+ uint32_t GetOatVmapTableOffset() const {
+ CHECK(!Runtime::Current()->IsStarted());
+ return reinterpret_cast<uint32_t>(GetVmapTableRaw());
+ }
+
+ void SetOatVmapTableOffset(uint32_t vmap_table_offset) {
+ CHECK(!Runtime::Current()->IsStarted());
+ SetVmapTable(reinterpret_cast<uint16_t*>(vmap_table_offset));
}
size_t GetFrameSizeInBytes() const {
@@ -881,7 +930,7 @@
return_pc_offset_in_bytes, false);
}
- bool IsRegistered();
+ bool IsRegistered() const;
void RegisterNative(const void* native_method);
@@ -895,13 +944,6 @@
return reinterpret_cast<const void*>(GetField32(NativeMethodOffset(), false));
}
- ByteArray* GetInvokeStubArray() const {
- ByteArray* result = GetFieldPtr<ByteArray*>(
- OFFSET_OF_OBJECT_MEMBER(Method, invoke_stub_array_), false);
- // TODO: DCHECK(result != NULL); should be ahead of time compiled
- return result;
- }
-
// Native to managed invocation stub entry point
InvokeStub* GetInvokeStub() const {
InvokeStub* result = GetFieldPtr<InvokeStub*>(
@@ -910,6 +952,21 @@
return result;
}
+ void SetInvokeStub(InvokeStub* invoke_stub) {
+ SetFieldPtr<const InvokeStub*>(OFFSET_OF_OBJECT_MEMBER(Method, invoke_stub_),
+ invoke_stub, false);
+ }
+
+ uint32_t GetOatInvokeStubOffset() const {
+ CHECK(!Runtime::Current()->IsStarted());
+ return reinterpret_cast<uint32_t>(GetInvokeStub());
+ }
+
+ void SetOatInvokeStubOffset(uint32_t invoke_stub_offset) {
+ CHECK(!Runtime::Current()->IsStarted());
+ SetInvokeStub(reinterpret_cast<InvokeStub*>(invoke_stub_offset));
+ }
+
static MemberOffset GetInvokeStubOffset() {
return OFFSET_OF_OBJECT_MEMBER(Method, invoke_stub_);
}
@@ -926,8 +983,6 @@
return OFFSET_OF_OBJECT_MEMBER(Method, method_index_);
}
- void SetInvokeStub(const ByteArray* invoke_stub_array);
-
uint32_t GetCoreSpillMask() const {
return GetField32(OFFSET_OF_OBJECT_MEMBER(Method, core_spill_mask_), false);
}
@@ -947,7 +1002,7 @@
}
// Is this a hand crafted method used for something like describing callee saves?
- bool IsPhony() const {
+ bool IsCalleeSaveMethod() const {
Runtime* runtime = Runtime::Current();
bool result = false;
for (int i=0; i < Runtime::kLastCalleeSaveType; i++) {
@@ -1005,9 +1060,6 @@
ObjectArray<Class>* java_parameter_types_;
Class* java_return_type_;
- // Storage for code_
- const ByteArray* code_array_;
-
// short cuts to declaring_class_->dex_cache_ member for fast compiled code access
CodeAndDirectMethods* dex_cache_code_and_direct_methods_;
@@ -1026,12 +1078,6 @@
// short cuts to declaring_class_->dex_cache_ member for fast compiled code access
ObjectArray<String>* dex_cache_strings_;
- // Storage for invoke_stub_
- const ByteArray* invoke_stub_array_;
-
- // Storage for mapping_table_
- IntArray* mapping_table_;
-
// Byte arrays that hold data for the register maps
const ByteArray* register_map_data_;
const ByteArray* register_map_header_;
@@ -1051,9 +1097,6 @@
// (IDLjava/lang/Thread;)Ljava/lang/Object;
String* signature_;
- // Storage for Dalvik virtual register mapping_table_
- ShortArray* vmap_table_;
-
uint32_t java_generic_types_are_initialized_;
// Access flags; low 16 bits are defined by spec.
@@ -1081,6 +1124,8 @@
// Index of the return type
uint32_t java_return_type_idx_;
+ const uint32_t* mapping_table_;
+
// For concrete virtual methods, this is the offset of the method
// in Class::vtable_.
//
@@ -1105,6 +1150,8 @@
// Offset of return PC within frame for compiled code (in bytes)
size_t return_pc_offset_in_bytes_;
+ const uint16_t* vmap_table_;
+
uint32_t java_slot_;
static Class* java_lang_reflect_Constructor_;
diff --git a/src/runtime.cc b/src/runtime.cc
index 7e27918..e46cf88 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -640,7 +640,7 @@
}
method->SetName(intern_table_->InternStrong(name));
method->SetSignature(intern_table_->InternStrong("()V"));
- method->SetCodeArray(NULL, insns);
+ method->SetCode(NULL);
if ((insns == kThumb2) || (insns == kArm)) {
uint32_t ref_spills = (1 << art::arm::R5) | (1 << art::arm::R6) | (1 << art::arm::R7) |
(1 << art::arm::R8) | (1 << art::arm::R10) | (1 << art::arm::R11);
diff --git a/src/space.cc b/src/space.cc
index 248f7e8..ae35f57 100644
--- a/src/space.cc
+++ b/src/space.cc
@@ -115,7 +115,7 @@
}
UniquePtr<MemMap> map(MemMap::Map(image_header.GetImageBaseAddr(),
file->Length(),
- // TODO: selectively PROT_EXEC when image contains a code space
+ // TODO: selectively PROT_EXEC an image subset containing stubs
PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_PRIVATE | MAP_FIXED,
file->Fd(),
diff --git a/src/stack.cc b/src/stack.cc
index 9f01dab..985fd38 100644
--- a/src/stack.cc
+++ b/src/stack.cc
@@ -19,10 +19,12 @@
#include "compiler.h"
#include "object.h"
+int oatVRegOffsetFromMethod(art::Method* method, int reg);
+
namespace art {
bool Frame::HasMethod() const {
- return GetMethod() != NULL && (!GetMethod()->IsPhony());
+ return GetMethod() != NULL && (!GetMethod()->IsCalleeSaveMethod());
}
void Frame::Next() {
diff --git a/src/stack_walk.cc b/src/stack_walk.cc
index 2c29e75..a1f6e0f 100644
--- a/src/stack_walk.cc
+++ b/src/stack_walk.cc
@@ -43,7 +43,7 @@
// pc == NULL: m is either a native method or a phony method
return;
}
- if (m->IsPhony()) {
+ if (m->IsCalleeSaveMethod()) {
LOG(WARNING) << "no PC for " << PrettyMethod(m);
return;
}
diff --git a/src/thread.cc b/src/thread.cc
index 532b581..c50bf0a 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -968,7 +968,7 @@
while (frame.GetSP() != 0) {
for ( ; frame.GetMethod() != 0; frame.Next()) {
- DCHECK(frame.GetMethod()->IsWithinCode(pc));
+ // DCHECK(frame.GetMethod()->IsWithinCode(pc)); // TODO: restore IsWithinCode
visitor->VisitFrame(frame, pc);
pc = frame.GetReturnPC();
// Move the PC back 2 bytes as a call will frequently terminate the
@@ -993,7 +993,7 @@
if (frame.GetSP() != 0) {
for ( ; frame.GetMethod() != 0; frame.Next()) {
- DCHECK(frame.GetMethod()->IsWithinCode(pc));
+ // DCHECK(frame.GetMethod()->IsWithinCode(pc)); // TODO: restore IsWithinCode
visitor->VisitFrame(frame, pc);
pc = frame.GetReturnPC();
// Move the PC back 2 bytes as a call will frequently terminate the
@@ -1143,7 +1143,7 @@
return;
}
uint32_t dex_pc = DexFile::kDexNoIndex;
- if (method->IsPhony()) {
+ if (method->IsCalleeSaveMethod()) {
// ignore callee save method
} else if (method->IsNative()) {
native_method_count_++;
@@ -1229,13 +1229,13 @@
void VisitFrame(const Frame& frame, uintptr_t pc) {
Method* m = frame.GetMethod();
// Process register map (which native and callee save methods don't have)
- if (!m->IsNative() && !m->IsPhony()) {
+ if (!m->IsNative() && !m->IsCalleeSaveMethod()) {
UniquePtr<art::DexVerifier::RegisterMap> map(art::DexVerifier::GetExpandedRegisterMap(m));
const uint8_t* reg_bitmap = art::DexVerifier::RegisterMapGetLine(map.get(), m->ToDexPC(pc));
LOG(INFO) << "Visiting stack roots in " << PrettyMethod(m, false)
<< "@ PC: " << m->ToDexPC(pc);
CHECK(reg_bitmap != NULL);
- ShortArray* vmap = m->GetVMapTable();
+ const uint16_t* vmap = m->GetVmapTable();
// For all dex registers
for (int reg = 0; reg < m->NumRegisters(); ++reg) {
// Does this register hold a reference?
@@ -1244,8 +1244,8 @@
bool in_context = false;
uint32_t vmap_offset = 0xEBAD0FF5;
// TODO: take advantage of the registers being ordered
- for (int i = 0; i < vmap->GetLength(); i++) {
- if (vmap->Get(i) == reg) {
+ for (int i = 0; i < m->GetVmapTableLength(); i++) {
+ if (vmap[i] == reg) {
in_context = true;
vmap_offset = i;
break;
