Mercurial > hg > graal-compiler
diff src/share/vm/runtime/reflection.cpp @ 6725:da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
Summary: Remove PermGen, allocate meta-data in metaspace linked to class loaders, rewrite GC walking, rewrite and rename metadata to be C++ classes
Reviewed-by: jmasa, stefank, never, coleenp, kvn, brutisso, mgerdin, dholmes, jrose, twisti, roland
Contributed-by: jmasa <jon.masamitsu@oracle.com>, stefank <stefan.karlsson@oracle.com>, mgerdin <mikael.gerdin@oracle.com>, never <tom.rodriguez@oracle.com>
author | coleenp |
---|---|
date | Sat, 01 Sep 2012 13:25:18 -0400 |
parents | 1d7922586cf6 |
children | d8ce2825b193 |
line wrap: on
line diff
--- a/src/share/vm/runtime/reflection.cpp Fri Aug 31 16:39:35 2012 -0700 +++ b/src/share/vm/runtime/reflection.cpp Sat Sep 01 13:25:18 2012 -0400 @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -46,24 +46,24 @@ #define JAVA_1_5_VERSION 49 -static void trace_class_resolution(klassOop to_class) { +static void trace_class_resolution(Klass* to_class) { ResourceMark rm; int line_number = -1; const char * source_file = NULL; - klassOop caller = NULL; + Klass* caller = NULL; JavaThread* jthread = JavaThread::current(); if (jthread->has_last_Java_frame()) { vframeStream vfst(jthread); // skip over any frames belonging to java.lang.Class while (!vfst.at_end() && - instanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class()) { + InstanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class()) { vfst.next(); } if (!vfst.at_end()) { // this frame is a likely suspect caller = vfst.method()->method_holder(); line_number = vfst.method()->line_number_from_bci(vfst.bci()); - Symbol* s = instanceKlass::cast(vfst.method()->method_holder())->source_file_name(); + Symbol* s = InstanceKlass::cast(vfst.method()->method_holder())->source_file_name(); if (s != NULL) { source_file = s->as_C_string(); } @@ -254,7 +254,7 @@ if (value_type == T_OBJECT) { oop obj = (oop) value->l; if (obj != NULL) { - klassOop element_klass = objArrayKlass::cast(a->klass())->element_klass(); + Klass* element_klass = objArrayKlass::cast(a->klass())->element_klass(); if (!obj->is_a(element_klass)) { THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "array element type mismatch"); } @@ -301,7 +301,7 @@ } -klassOop Reflection::basic_type_mirror_to_arrayklass(oop basic_type_mirror, TRAPS) { +Klass* Reflection::basic_type_mirror_to_arrayklass(oop basic_type_mirror, TRAPS) { assert(java_lang_Class::is_primitive(basic_type_mirror), "just checking"); BasicType type = java_lang_Class::primitive_type(basic_type_mirror); if (type == T_VOID) { @@ -312,7 +312,7 @@ } -oop Reflection:: basic_type_arrayklass_to_mirror(klassOop basic_type_arrayklass, TRAPS) { +oop Reflection:: basic_type_arrayklass_to_mirror(Klass* basic_type_arrayklass, TRAPS) { BasicType type = typeArrayKlass::cast(basic_type_arrayklass)->element_type(); return Universe::java_mirror(type); } @@ -326,10 +326,10 @@ THROW_0(vmSymbols::java_lang_NegativeArraySizeException()); } if (java_lang_Class::is_primitive(element_mirror)) { - klassOop tak = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL); + Klass* tak = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL); return typeArrayKlass::cast(tak)->allocate(length, THREAD); } else { - klassOop k = java_lang_Class::as_klassOop(element_mirror); + Klass* k = java_lang_Class::as_Klass(element_mirror); if (Klass::cast(k)->oop_is_array() && arrayKlass::cast(k)->dimension() >= MAX_DIM) { THROW_0(vmSymbols::java_lang_IllegalArgumentException()); } @@ -360,12 +360,12 @@ dimensions[i] = d; } - klassOop klass; + Klass* klass; int dim = len; if (java_lang_Class::is_primitive(element_mirror)) { klass = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL); } else { - klass = java_lang_Class::as_klassOop(element_mirror); + klass = java_lang_Class::as_Klass(element_mirror); if (Klass::cast(klass)->oop_is_array()) { int k_dim = arrayKlass::cast(klass)->dimension(); if (k_dim + len > MAX_DIM) { @@ -386,7 +386,7 @@ return NULL; } - klassOop klass = java_lang_Class::as_klassOop(mirror); + Klass* klass = java_lang_Class::as_Klass(mirror); if (!Klass::cast(klass)->oop_is_array()) { return NULL; } @@ -401,7 +401,7 @@ result2 = Klass::cast(objArrayKlass::cast(klass)->element_klass())->java_mirror(); } } else { - klassOop lower_dim = arrayKlass::cast(klass)->lower_dimension(); + Klass* lower_dim = arrayKlass::cast(klass)->lower_dimension(); assert(Klass::cast(lower_dim)->oop_is_array(), "just checking"); result2 = Klass::cast(lower_dim)->java_mirror(); } @@ -411,7 +411,7 @@ } -bool Reflection::reflect_check_access(klassOop field_class, AccessFlags acc, klassOop target_class, bool is_method_invoke, TRAPS) { +bool Reflection::reflect_check_access(Klass* field_class, AccessFlags acc, Klass* target_class, bool is_method_invoke, TRAPS) { // field_class : declaring class // acc : declared field access // target_class : for protected @@ -424,7 +424,7 @@ // that case (same as classic). ResourceMark rm(THREAD); assert(THREAD->is_Java_thread(), "sanity check"); - klassOop client_class = ((JavaThread *)THREAD)->security_get_caller_class(is_method_invoke ? 0 : 1); + Klass* client_class = ((JavaThread *)THREAD)->security_get_caller_class(is_method_invoke ? 0 : 1); if (client_class != field_class) { if (!verify_class_access(client_class, field_class, false) @@ -454,13 +454,13 @@ } -bool Reflection::verify_class_access(klassOop current_class, klassOop new_class, bool classloader_only) { +bool Reflection::verify_class_access(Klass* current_class, Klass* new_class, bool classloader_only) { // Verify that current_class can access new_class. If the classloader_only // flag is set, we automatically allow any accesses in which current_class // doesn't have a classloader. if ((current_class == NULL) || (current_class == new_class) || - (instanceKlass::cast(new_class)->is_public()) || + (InstanceKlass::cast(new_class)->is_public()) || is_same_class_package(current_class, new_class)) { return true; } @@ -475,13 +475,13 @@ return can_relax_access_check_for(current_class, new_class, classloader_only); } -static bool under_host_klass(instanceKlass* ik, klassOop host_klass) { +static bool under_host_klass(InstanceKlass* ik, Klass* host_klass) { DEBUG_ONLY(int inf_loop_check = 1000 * 1000 * 1000); for (;;) { - klassOop hc = (klassOop) ik->host_klass(); + Klass* hc = (Klass*) ik->host_klass(); if (hc == NULL) return false; if (hc == host_klass) return true; - ik = instanceKlass::cast(hc); + ik = InstanceKlass::cast(hc); // There's no way to make a host class loop short of patching memory. // Therefore there cannot be a loop here unles there's another bug. @@ -491,9 +491,9 @@ } bool Reflection::can_relax_access_check_for( - klassOop accessor, klassOop accessee, bool classloader_only) { - instanceKlass* accessor_ik = instanceKlass::cast(accessor); - instanceKlass* accessee_ik = instanceKlass::cast(accessee); + Klass* accessor, Klass* accessee, bool classloader_only) { + InstanceKlass* accessor_ik = InstanceKlass::cast(accessor); + InstanceKlass* accessee_ik = InstanceKlass::cast(accessee); // If either is on the other's host_klass chain, access is OK, // because one is inside the other. @@ -513,9 +513,9 @@ } } -bool Reflection::verify_field_access(klassOop current_class, - klassOop resolved_class, - klassOop field_class, +bool Reflection::verify_field_access(Klass* current_class, + Klass* resolved_class, + Klass* field_class, AccessFlags access, bool classloader_only, bool protected_restriction) { @@ -569,12 +569,12 @@ } -bool Reflection::is_same_class_package(klassOop class1, klassOop class2) { - return instanceKlass::cast(class1)->is_same_class_package(class2); +bool Reflection::is_same_class_package(Klass* class1, Klass* class2) { + return InstanceKlass::cast(class1)->is_same_class_package(class2); } -bool Reflection::is_same_package_member(klassOop class1, klassOop class2, TRAPS) { - return instanceKlass::cast(class1)->is_same_package_member(class2, THREAD); +bool Reflection::is_same_package_member(Klass* class1, Klass* class2, TRAPS) { + return InstanceKlass::cast(class1)->is_same_package_member(class2, THREAD); } @@ -592,9 +592,9 @@ int ooff = iter.outer_class_info_index(); if (inner_is_member && ioff != 0 && ooff != 0) { - klassOop o = cp->klass_at(ooff, CHECK); + Klass* o = cp->klass_at(ooff, CHECK); if (o == outer()) { - klassOop i = cp->klass_at(ioff, CHECK); + Klass* i = cp->klass_at(ioff, CHECK); if (i == inner()) { return; } @@ -602,7 +602,7 @@ } if (!inner_is_member && ioff != 0 && ooff == 0 && cp->klass_name_at_matches(inner, ioff)) { - klassOop i = cp->klass_at(ioff, CHECK); + Klass* i = cp->klass_at(ioff, CHECK); if (i == inner()) { return; } @@ -630,9 +630,9 @@ case T_OBJECT: case T_ARRAY: Symbol* name = ss->as_symbol(CHECK_NULL); - oop loader = instanceKlass::cast(method->method_holder())->class_loader(); - oop protection_domain = instanceKlass::cast(method->method_holder())->protection_domain(); - klassOop k = SystemDictionary::resolve_or_fail( + oop loader = InstanceKlass::cast(method->method_holder())->class_loader(); + oop protection_domain = InstanceKlass::cast(method->method_holder())->protection_domain(); + Klass* k = SystemDictionary::resolve_or_fail( name, Handle(THREAD, loader), Handle(THREAD, protection_domain), @@ -680,9 +680,9 @@ return Handle(THREAD, Universe::java_mirror(type)); } - oop loader = instanceKlass::cast(k())->class_loader(); + oop loader = InstanceKlass::cast(k())->class_loader(); oop protection_domain = Klass::cast(k())->protection_domain(); - klassOop result = SystemDictionary::resolve_or_fail(signature, + Klass* result = SystemDictionary::resolve_or_fail(signature, Handle(THREAD, loader), Handle(THREAD, protection_domain), true, CHECK_(Handle())); @@ -748,13 +748,16 @@ java_lang_reflect_Method::set_signature(mh(), sig()); } if (java_lang_reflect_Method::has_annotations_field()) { - java_lang_reflect_Method::set_annotations(mh(), method->annotations()); + typeArrayOop an_oop = Annotations::make_java_array(method->annotations(), CHECK_NULL); + java_lang_reflect_Method::set_annotations(mh(), an_oop); } if (java_lang_reflect_Method::has_parameter_annotations_field()) { - java_lang_reflect_Method::set_parameter_annotations(mh(), method->parameter_annotations()); + typeArrayOop an_oop = Annotations::make_java_array(method->parameter_annotations(), CHECK_NULL); + java_lang_reflect_Method::set_parameter_annotations(mh(), an_oop); } if (java_lang_reflect_Method::has_annotation_default_field()) { - java_lang_reflect_Method::set_annotation_default(mh(), method->annotation_default()); + typeArrayOop an_oop = Annotations::make_java_array(method->annotation_default(), CHECK_NULL); + java_lang_reflect_Method::set_annotation_default(mh(), an_oop); } return mh(); } @@ -791,10 +794,12 @@ java_lang_reflect_Constructor::set_signature(ch(), sig()); } if (java_lang_reflect_Constructor::has_annotations_field()) { - java_lang_reflect_Constructor::set_annotations(ch(), method->annotations()); + typeArrayOop an_oop = Annotations::make_java_array(method->annotations(), CHECK_NULL); + java_lang_reflect_Constructor::set_annotations(ch(), an_oop); } if (java_lang_reflect_Constructor::has_parameter_annotations_field()) { - java_lang_reflect_Constructor::set_parameter_annotations(ch(), method->parameter_annotations()); + typeArrayOop an_oop = Annotations::make_java_array(method->parameter_annotations(), CHECK_NULL); + java_lang_reflect_Constructor::set_parameter_annotations(ch(), an_oop); } return ch(); } @@ -811,7 +816,7 @@ name = java_lang_String::create_from_symbol(field_name, CHECK_NULL); } Symbol* signature = fd->signature(); - KlassHandle holder (THREAD, fd->field_holder()); + instanceKlassHandle holder (THREAD, fd->field_holder()); Handle type = new_type(signature, holder, CHECK_NULL); Handle rh = java_lang_reflect_Field::create(CHECK_NULL); @@ -829,7 +834,8 @@ java_lang_reflect_Field::set_signature(rh(), sig()); } if (java_lang_reflect_Field::has_annotations_field()) { - java_lang_reflect_Field::set_annotations(rh(), fd->annotations()); + typeArrayOop an_oop = Annotations::make_java_array(fd->annotations(), CHECK_NULL); + java_lang_reflect_Field::set_annotations(rh(), an_oop); } return rh(); } @@ -882,7 +888,7 @@ method = reflected_method; } else { // resolve based on the receiver - if (instanceKlass::cast(reflected_method->method_holder())->is_interface()) { + if (InstanceKlass::cast(reflected_method->method_holder())->is_interface()) { // resolve interface call if (ReflectionWrapResolutionErrors) { // new default: 6531596 @@ -905,10 +911,10 @@ // if the method can be overridden, we resolve using the vtable index. int index = reflected_method->vtable_index(); method = reflected_method; - if (index != methodOopDesc::nonvirtual_vtable_index) { + if (index != Method::nonvirtual_vtable_index) { // target_klass might be an arrayKlassOop but all vtables start at // the same place. The cast is to avoid virtual call and assertion. - instanceKlass* inst = (instanceKlass*)target_klass()->klass_part(); + InstanceKlass* inst = (InstanceKlass*)target_klass(); method = methodHandle(THREAD, inst->method_at_vtable(index)); } if (!method.is_null()) { @@ -919,7 +925,7 @@ ResourceMark rm(THREAD); Handle h_origexception = Exceptions::new_exception(THREAD, vmSymbols::java_lang_AbstractMethodError(), - methodOopDesc::name_and_sig_as_C_string(Klass::cast(target_klass()), + Method::name_and_sig_as_C_string(Klass::cast(target_klass()), method->name(), method->signature())); JavaCallArguments args(h_origexception); @@ -929,7 +935,7 @@ } else { ResourceMark rm(THREAD); THROW_MSG_0(vmSymbols::java_lang_AbstractMethodError(), - methodOopDesc::name_and_sig_as_C_string(Klass::cast(target_klass()), + Method::name_and_sig_as_C_string(Klass::cast(target_klass()), method->name(), method->signature())); } @@ -944,7 +950,7 @@ if (method.is_null()) { ResourceMark rm(THREAD); THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(), - methodOopDesc::name_and_sig_as_C_string(Klass::cast(klass()), + Method::name_and_sig_as_C_string(Klass::cast(klass()), reflected_method->name(), reflected_method->signature())); } @@ -1003,7 +1009,7 @@ } } else { if (arg != NULL) { - klassOop k = java_lang_Class::as_klassOop(type_mirror); + Klass* k = java_lang_Class::as_Klass(type_mirror); if (!arg->is_a(k)) { THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "argument type mismatch"); } @@ -1079,8 +1085,8 @@ rtype = T_OBJECT; } - instanceKlassHandle klass(THREAD, java_lang_Class::as_klassOop(mirror)); - methodOop m = klass->method_with_idnum(slot); + instanceKlassHandle klass(THREAD, java_lang_Class::as_Klass(mirror)); + Method* m = klass->method_with_idnum(slot); if (m == NULL) { THROW_MSG_0(vmSymbols::java_lang_InternalError(), "invoke"); } @@ -1096,8 +1102,8 @@ bool override = java_lang_reflect_Constructor::override(constructor_mirror) != 0; objArrayHandle ptypes(THREAD, objArrayOop(java_lang_reflect_Constructor::parameter_types(constructor_mirror))); - instanceKlassHandle klass(THREAD, java_lang_Class::as_klassOop(mirror)); - methodOop m = klass->method_with_idnum(slot); + instanceKlassHandle klass(THREAD, java_lang_Class::as_Klass(mirror)); + Method* m = klass->method_with_idnum(slot); if (m == NULL) { THROW_MSG_0(vmSymbols::java_lang_InternalError(), "invoke"); }