archive/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2025-08-27 23:04:50 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

8007320: NPG: move method annotations

Browse source 
Allocate method annotations and attach to ConstMethod if present

Reviewed-by: dcubed, jiangli, sspitsyn, iklam
This commit is contained in:
Coleen Phillimore 2013-02-11 14:06:22 -05:00
parent ee53020f94
commit faea95b8d3
19 changed files with 862 additions and 838 deletions
Download patch file Download diff file Expand all files Collapse all files

122
hotspot/src/share/vm/oops/method.cpp
View file

@ -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 @@ Symbol* Method::klass_name() const {
}
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::set_interpreter_kind() {
void Method::remove_unshareable_info() {
unlink_method();
set_interpreter_kind();
}
@ -1045,9 +1026,9 @@ methodHandle Method::make_method_handle_intrinsic(vmIntrinsics::ID iid,
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 @@ methodHandle Method::clone_with_new_data(methodHandle m, u_char* new_code, int n
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 @@ void Method::print_short_name(outputStream* st) {
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 @@ static int method_comparator(Method* a, Method* b) {
}
// 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);