--- a/hotspot/src/share/vm/oops/method.cpp Fri Feb 08 16:56:03 2013 -0800
+++ b/hotspot/src/share/vm/oops/method.cpp Mon Feb 11 14:06:22 2013 -0500
@@ -61,24 +61,14 @@
Method* Method::allocate(ClassLoaderData* loader_data,
int byte_code_size,
AccessFlags access_flags,
- int compressed_line_number_size,
- int localvariable_table_length,
- int exception_table_length,
- int checked_exceptions_length,
- int method_parameters_length,
- u2 generic_signature_index,
+ InlineTableSizes* sizes,
ConstMethod::MethodType method_type,
TRAPS) {
assert(!access_flags.is_native() || byte_code_size == 0,
"native methods should not contain byte codes");
ConstMethod* cm = ConstMethod::allocate(loader_data,
byte_code_size,
- compressed_line_number_size,
- localvariable_table_length,
- exception_table_length,
- checked_exceptions_length,
- method_parameters_length,
- generic_signature_index,
+ sizes,
method_type,
CHECK_NULL);
@@ -317,14 +307,6 @@
}
-void Method::set_interpreter_kind() {
- int kind = Interpreter::method_kind(this);
- assert(kind != Interpreter::invalid,
- "interpreter entry must be valid");
- set_interpreter_kind(kind);
-}
-
-
// Attempt to return method oop to original state. Clear any pointers
// (to objects outside the shared spaces). We won't be able to predict
// where they should point in a new JVM. Further initialize some
@@ -332,7 +314,6 @@
void Method::remove_unshareable_info() {
unlink_method();
- set_interpreter_kind();
}
@@ -1045,9 +1026,9 @@
methodHandle m;
{
+ InlineTableSizes sizes;
Method* m_oop = Method::allocate(loader_data, 0,
- accessFlags_from(flags_bits),
- 0, 0, 0, 0, 0, 0,
+ accessFlags_from(flags_bits), &sizes,
ConstMethod::NORMAL, CHECK_(empty));
m = methodHandle(THREAD, m_oop);
}
@@ -1096,22 +1077,35 @@
assert(!m->is_native(), "cannot rewrite native methods");
// Allocate new Method*
AccessFlags flags = m->access_flags();
- u2 generic_signature_index = m->generic_signature_index();
- int checked_exceptions_len = m->checked_exceptions_length();
- int localvariable_len = m->localvariable_table_length();
- int exception_table_len = m->exception_table_length();
- int method_parameters_len = m->method_parameters_length();
+
+ ConstMethod* cm = m->constMethod();
+ int checked_exceptions_len = cm->checked_exceptions_length();
+ int localvariable_len = cm->localvariable_table_length();
+ int exception_table_len = cm->exception_table_length();
+ int method_parameters_len = cm->method_parameters_length();
+ int method_annotations_len = cm->method_annotations_length();
+ int parameter_annotations_len = cm->parameter_annotations_length();
+ int type_annotations_len = cm->type_annotations_length();
+ int default_annotations_len = cm->default_annotations_length();
+
+ InlineTableSizes sizes(
+ localvariable_len,
+ new_compressed_linenumber_size,
+ exception_table_len,
+ checked_exceptions_len,
+ method_parameters_len,
+ cm->generic_signature_index(),
+ method_annotations_len,
+ parameter_annotations_len,
+ type_annotations_len,
+ default_annotations_len,
+ 0);
ClassLoaderData* loader_data = m->method_holder()->class_loader_data();
Method* newm_oop = Method::allocate(loader_data,
new_code_length,
flags,
- new_compressed_linenumber_size,
- localvariable_len,
- exception_table_len,
- checked_exceptions_len,
- method_parameters_len,
- generic_signature_index,
+ &sizes,
m->method_type(),
CHECK_(methodHandle()));
methodHandle newm (THREAD, newm_oop);
@@ -1311,29 +1305,6 @@
MethodHandles::print_as_basic_type_signature_on(st, signature(), true);
}
-// This is only done during class loading, so it is OK to assume method_idnum matches the methods() array
-static void reorder_based_on_method_index(Array<Method*>* methods,
- Array<AnnotationArray*>* annotations,
- GrowableArray<AnnotationArray*>* temp_array) {
- if (annotations == NULL) {
- return;
- }
-
- int length = methods->length();
- int i;
- // Copy to temp array
- temp_array->clear();
- for (i = 0; i < length; i++) {
- temp_array->append(annotations->at(i));
- }
-
- // Copy back using old method indices
- for (i = 0; i < length; i++) {
- Method* m = methods->at(i);
- annotations->at_put(i, temp_array->at(m->method_idnum()));
- }
-}
-
// Comparer for sorting an object array containing
// Method*s.
static int method_comparator(Method* a, Method* b) {
@@ -1341,48 +1312,13 @@
}
// This is only done during class loading, so it is OK to assume method_idnum matches the methods() array
-void Method::sort_methods(Array<Method*>* methods,
- Array<AnnotationArray*>* methods_annotations,
- Array<AnnotationArray*>* methods_parameter_annotations,
- Array<AnnotationArray*>* methods_default_annotations,
- Array<AnnotationArray*>* methods_type_annotations,
- bool idempotent) {
+void Method::sort_methods(Array<Method*>* methods, bool idempotent) {
int length = methods->length();
if (length > 1) {
- bool do_annotations = false;
- if (methods_annotations != NULL ||
- methods_parameter_annotations != NULL ||
- methods_default_annotations != NULL ||
- methods_type_annotations != NULL) {
- do_annotations = true;
- }
- if (do_annotations) {
- // Remember current method ordering so we can reorder annotations
- for (int i = 0; i < length; i++) {
- Method* m = methods->at(i);
- m->set_method_idnum(i);
- }
- }
{
No_Safepoint_Verifier nsv;
QuickSort::sort<Method*>(methods->data(), length, method_comparator, idempotent);
}
-
- // Sort annotations if necessary
- assert(methods_annotations == NULL || methods_annotations->length() == methods->length(), "");
- assert(methods_parameter_annotations == NULL || methods_parameter_annotations->length() == methods->length(), "");
- assert(methods_default_annotations == NULL || methods_default_annotations->length() == methods->length(), "");
- assert(methods_type_annotations == NULL || methods_type_annotations->length() == methods->length(), "");
- if (do_annotations) {
- ResourceMark rm;
- // Allocate temporary storage
- GrowableArray<AnnotationArray*>* temp_array = new GrowableArray<AnnotationArray*>(length);
- reorder_based_on_method_index(methods, methods_annotations, temp_array);
- reorder_based_on_method_index(methods, methods_parameter_annotations, temp_array);
- reorder_based_on_method_index(methods, methods_default_annotations, temp_array);
- reorder_based_on_method_index(methods, methods_type_annotations, temp_array);
- }
-
// Reset method ordering
for (int i = 0; i < length; i++) {
Method* m = methods->at(i);