jdk-sandbox: comparison hotspot/src/share/vm/runtime/reflection.cpp

equal deleted inserted replaced

-:582dd25571b2
+:96d498ec7ae1
 }
 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());
-symbolOop 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();
 }
 }
 }
 // 'inner' not declared as an inner klass in outer
 ResourceMark rm(THREAD);
 Exceptions::fthrow(
 THREAD_AND_LOCATION,
-vmSymbolHandles::java_lang_IncompatibleClassChangeError(),
+vmSymbols::java_lang_IncompatibleClassChangeError(),
 "%s and %s disagree on InnerClasses attribute",
 outer->external_name(),
 inner->external_name()
 );
 }
 default:
 assert(ss->type() != T_VOID || ss->at_return_type(), "T_VOID should only appear as return type");
 return java_lang_Class::primitive_mirror(ss->type());
 case T_OBJECT:
 case T_ARRAY:
-symbolOop name        = ss->as_symbol(CHECK_NULL);
+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(
-symbolHandle(THREAD, name),
+name,
 Handle(THREAD, loader),
 Handle(THREAD, protection_domain),
 true, CHECK_NULL);
 if (TraceClassResolution) {
 trace_class_resolution(k);
 // Allocate array holding parameter types (java.lang.Class instances)
 objArrayOop m = oopFactory::new_objArray(SystemDictionary::Class_klass(), parameter_count, CHECK_(objArrayHandle()));
 objArrayHandle mirrors (THREAD, m);
 int index = 0;
 // Collect parameter types
-symbolHandle signature (THREAD, method->signature());
+ResourceMark rm(THREAD);
+Symbol*  signature  = method->signature();
 SignatureStream ss(signature);
 while (!ss.at_return_type()) {
 oop mirror = get_mirror_from_signature(method, &ss, CHECK_(objArrayHandle()));
 mirrors->obj_at_put(index++, mirror);
 ss.next();
 objArrayHandle Reflection::get_exception_types(methodHandle method, TRAPS) {
 return method->resolved_checked_exceptions(CHECK_(objArrayHandle()));
 }
-Handle Reflection::new_type(symbolHandle signature, KlassHandle k, TRAPS) {
+Handle Reflection::new_type(Symbol* signature, KlassHandle k, TRAPS) {
 // Basic types
-BasicType type = vmSymbols::signature_type(signature());
+BasicType type = vmSymbols::signature_type(signature);
 if (type != T_OBJECT) {
 return Handle(THREAD, Universe::java_mirror(type));
 }
 oop loader = instanceKlass::cast(k())->class_loader();
 (method()->name() == vmSymbols::class_initializer_name()
 && Klass::cast(method()->method_holder())->is_interface() && JDK_Version::is_jdk12x_version()), "should call new_constructor instead");
 instanceKlassHandle holder (THREAD, method->method_holder());
 int slot = method->method_idnum();
-symbolHandle signature (THREAD, method->signature());
+Symbol*  signature  = method->signature();
 int parameter_count = ArgumentCount(signature).size();
 oop return_type_oop = NULL;
 objArrayHandle parameter_types = get_parameter_types(method, parameter_count, &return_type_oop, CHECK_NULL);
 if (parameter_types.is_null() || return_type_oop == NULL) return NULL;
 objArrayHandle exception_types = get_exception_types(method, CHECK_NULL);
 if (exception_types.is_null()) return NULL;
-symbolHandle method_name(THREAD, method->name());
+Symbol*  method_name = method->name();
 Handle name;
 if (intern_name) {
 // intern_name is only true with UseNewReflection
-oop name_oop = StringTable::intern(method_name(), CHECK_NULL);
+oop name_oop = StringTable::intern(method_name, CHECK_NULL);
 name = Handle(THREAD, name_oop);
 } else {
 name = java_lang_String::create_from_symbol(method_name, CHECK_NULL);
 }
-if (name.is_null()) return NULL;
+if (name == NULL) return NULL;
 int modifiers = method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS;
 Handle mh = java_lang_reflect_Method::create(CHECK_NULL);
 java_lang_reflect_Method::set_exception_types(mh(), exception_types());
 java_lang_reflect_Method::set_modifiers(mh(), modifiers);
 java_lang_reflect_Method::set_override(mh(), false);
 if (java_lang_reflect_Method::has_signature_field() &&
 method->generic_signature() != NULL) {
-symbolHandle gs(THREAD, method->generic_signature());
+Symbol*  gs = method->generic_signature();
 Handle sig = java_lang_String::create_from_symbol(gs, CHECK_NULL);
 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());
 assert(method()->is_initializer(), "should call new_method instead");
 instanceKlassHandle  holder (THREAD, method->method_holder());
 int slot = method->method_idnum();
-symbolHandle signature (THREAD, method->signature());
+Symbol*  signature  = method->signature();
 int parameter_count = ArgumentCount(signature).size();
 objArrayHandle parameter_types = get_parameter_types(method, parameter_count, NULL, CHECK_NULL);
 if (parameter_types.is_null()) return NULL;
 objArrayHandle exception_types = get_exception_types(method, CHECK_NULL);
 java_lang_reflect_Constructor::set_exception_types(ch(), exception_types());
 java_lang_reflect_Constructor::set_modifiers(ch(), modifiers);
 java_lang_reflect_Constructor::set_override(ch(), false);
 if (java_lang_reflect_Constructor::has_signature_field() &&
 method->generic_signature() != NULL) {
-symbolHandle gs(THREAD, method->generic_signature());
+Symbol*  gs = method->generic_signature();
 Handle sig = java_lang_String::create_from_symbol(gs, CHECK_NULL);
 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());
 return ch();
 }
 oop Reflection::new_field(fieldDescriptor* fd, bool intern_name, TRAPS) {
-symbolHandle field_name(THREAD, fd->name());
+Symbol*  field_name = fd->name();
 Handle name;
 if (intern_name) {
 // intern_name is only true with UseNewReflection
-oop name_oop = StringTable::intern(field_name(), CHECK_NULL);
+oop name_oop = StringTable::intern(field_name, CHECK_NULL);
 name = Handle(THREAD, name_oop);
 } else {
 name = java_lang_String::create_from_symbol(field_name, CHECK_NULL);
 }
-symbolHandle signature (THREAD, fd->signature());
+Symbol*  signature  = fd->signature();
 KlassHandle  holder    (THREAD, fd->field_holder());
 Handle type = new_type(signature, holder, CHECK_NULL);
 Handle rh  = java_lang_reflect_Field::create(CHECK_NULL);
 java_lang_reflect_Field::set_clazz(rh(), Klass::cast(fd->field_holder())->java_mirror());
 // Note the ACC_ANNOTATION bit, which is a per-class access flag, is never set here.
 java_lang_reflect_Field::set_modifiers(rh(), fd->access_flags().as_int() & JVM_RECOGNIZED_FIELD_MODIFIERS);
 java_lang_reflect_Field::set_override(rh(), false);
 if (java_lang_reflect_Field::has_signature_field() &&
 fd->generic_signature() != NULL) {
-symbolHandle gs(THREAD, fd->generic_signature());
+Symbol*  gs = fd->generic_signature();
 Handle sig = java_lang_String::create_from_symbol(gs, CHECK_NULL);
 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());
 methodHandle Reflection::resolve_interface_call(instanceKlassHandle klass, methodHandle method,
 KlassHandle recv_klass, Handle receiver, TRAPS) {
 assert(!method.is_null() , "method should not be null");
 CallInfo info;
-symbolHandle signature (THREAD, method->signature());
+Symbol*  signature  = method->signature();
-symbolHandle name      (THREAD, method->name());
+Symbol*  name       = method->name();
 LinkResolver::resolve_interface_call(info, receiver, recv_klass, klass,
 name, signature,
 KlassHandle(), false, true,
 CHECK_(methodHandle()));
 return info.selected_method();
 if (HAS_PENDING_EXCEPTION) {
 // Method resolution threw an exception; wrap it in an InvocationTargetException
 oop resolution_exception = PENDING_EXCEPTION;
 CLEAR_PENDING_EXCEPTION;
 JavaCallArguments args(Handle(THREAD, resolution_exception));
-THROW_ARG_0(vmSymbolHandles::java_lang_reflect_InvocationTargetException(),
+THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(),
-vmSymbolHandles::throwable_void_signature(),
+vmSymbols::throwable_void_signature(),
 &args);
 }
 } else {
 method = resolve_interface_call(klass, reflected_method, target_klass, receiver, CHECK_(NULL));
 }
 vmSymbols::java_lang_AbstractMethodError(),
 methodOopDesc::name_and_sig_as_C_string(Klass::cast(target_klass()),
 method->name(),
 method->signature()));
 JavaCallArguments args(h_origexception);
-THROW_ARG_0(vmSymbolHandles::java_lang_reflect_InvocationTargetException(),
+THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(),
-vmSymbolHandles::throwable_void_signature(),
+vmSymbols::throwable_void_signature(),
 &args);
 } else {
 ResourceMark rm(THREAD);
 THROW_MSG_0(vmSymbols::java_lang_AbstractMethodError(),
 methodOopDesc::name_and_sig_as_C_string(Klass::cast(target_klass()),
 if (HAS_PENDING_EXCEPTION) {
 // Method threw an exception; wrap it in an InvocationTargetException
 oop target_exception = PENDING_EXCEPTION;
 CLEAR_PENDING_EXCEPTION;
 JavaCallArguments args(Handle(THREAD, target_exception));
-THROW_ARG_0(vmSymbolHandles::java_lang_reflect_InvocationTargetException(),
+THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(),
-vmSymbolHandles::throwable_void_signature(),
+vmSymbols::throwable_void_signature(),
 &args);
 } else {
 if (rtype == T_BOOLEAN || rtype == T_BYTE || rtype == T_CHAR || rtype == T_SHORT)
 narrow((jvalue*) result.get_value_addr(), rtype, CHECK_NULL);
 return box((jvalue*) result.get_value_addr(), rtype, CHECK_NULL);
 return true;
 }
 oop Reflection::new_field(FieldStream* st, TRAPS) {
-symbolHandle field_name(THREAD, st->name());
+Symbol*  field_name = st->name();
 Handle name = java_lang_String::create_from_symbol(field_name, CHECK_NULL);
-symbolHandle signature(THREAD, st->signature());
+Symbol*  signature = st->signature();
 Handle type = new_type(signature, st->klass(), CHECK_NULL);
 Handle rh  = java_lang_reflect_Field::create(CHECK_NULL);
 oop result = rh();
 java_lang_reflect_Field::set_clazz(result, st->klass()->java_mirror());
 break;
 case T_OBJECT:
 case T_ARRAY: {
 Handle obj(THREAD, (oop) value->l);
 if (obj.not_null()) {
-symbolHandle signature(THREAD, fd->signature());
+Symbol*  signature = fd->signature();
 Handle       loader   (THREAD, fd->loader());
 Handle       protect  (THREAD, Klass::cast(fd->field_holder())->protection_domain());
 klassOop k = SystemDictionary::resolve_or_fail(signature, loader, protect, true, CHECK); // may block
 if (!obj->is_a(k)) {
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "field type mismatch");
 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "field type mismatch");
 }
 }
-oop Reflection::reflect_field(oop mirror, symbolOop field_name, jint which, TRAPS) {
+oop Reflection::reflect_field(oop mirror, Symbol* field_name, jint which, TRAPS) {
 // Exclude primitive types and array types
 if (java_lang_Class::is_primitive(mirror))                             return NULL;
 if (Klass::cast(java_lang_Class::as_klassOop(mirror))->oop_is_array()) return NULL;
 instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(mirror));
 objArrayOop Reflection::reflect_fields(oop mirror, jint which, TRAPS) {
 // Exclude primitive types and array types
 if (java_lang_Class::is_primitive(mirror)
 || Klass::cast(java_lang_Class::as_klassOop(mirror))->oop_is_array()) {
-symbolHandle name = vmSymbolHandles::java_lang_reflect_Field();
+Symbol* name = vmSymbols::java_lang_reflect_Field();
 klassOop klass = SystemDictionary::resolve_or_fail(name, true, CHECK_NULL);
 return oopFactory::new_objArray(klass, 0, CHECK_NULL);  // Return empty array
 }
 instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(mirror));
 }
 }
 }
 // Allocate result
-symbolHandle name = vmSymbolHandles::java_lang_reflect_Field();
+Symbol* name = vmSymbols::java_lang_reflect_Field();
 klassOop klass = SystemDictionary::resolve_or_fail(name, true, CHECK_NULL);
 objArrayOop r = oopFactory::new_objArray(klass, count, CHECK_NULL);
 objArrayHandle result (THREAD, r);
 // Fill in results backwards
 }
 return result();
 }
-oop Reflection::reflect_method(oop mirror, symbolHandle method_name, objArrayHandle types, jint which, TRAPS) {
+oop Reflection::reflect_method(oop mirror, Symbol* method_name, objArrayHandle types, jint which, TRAPS) {
 if (java_lang_Class::is_primitive(mirror))  return NULL;
 klassOop klass = java_lang_Class::as_klassOop(mirror);
 if (Klass::cast(klass)->oop_is_array() && which == MEMBER_DECLARED)  return NULL;
 if (Klass::cast(java_lang_Class::as_klassOop(mirror))->oop_is_array()) {
 // Note that we can ignore checks for overridden methods, since we go up the hierarchy.
 {
 for (MethodStream st(h_k, false, false); !st.eos(); st.next()) {
 methodHandle m(THREAD, st.method());
 // For interfaces include static initializers since classic does that!
-if (method_name() == m->name() && (include_clinit || (m->is_public() && !m->is_static() && !m->is_initializer()))) {
+if (method_name == m->name() && (include_clinit || (m->is_public() && !m->is_static() && !m->is_initializer()))) {
-symbolHandle signature(THREAD, m->signature());
+Symbol*  signature = m->signature();
 bool parameter_match = match_parameter_types(m, types, ArgumentCount(signature).size(), CHECK_NULL);
 if (parameter_match) {
 return new_method(m, false, false, THREAD);
 }
 }
 }
 // Then the public static methods (works if method holder is an interface)
 {
 for (MethodStream st(h_k, false, false); !st.eos(); st.next()) {
 methodHandle m(THREAD, st.method());
-if (method_name() == m->name() && m->is_public() && m->is_static() && !m->is_initializer()) {
+if (method_name == m->name() && m->is_public() && m->is_static() && !m->is_initializer()) {
-symbolHandle signature(THREAD, m->signature());
+Symbol*  signature = m->signature();
 bool parameter_match = match_parameter_types(m, types, ArgumentCount(signature).size(), CHECK_NULL);
 if (parameter_match) {
 return new_method(m, false, false, THREAD);
 }
 }
 case MEMBER_DECLARED:
 // All local methods
 {
 for (MethodStream st(h_k, true, true); !st.eos(); st.next()) {
 methodHandle m(THREAD, st.method());
-if (method_name() == m->name() && !m->is_initializer()) {
+if (method_name == m->name() && !m->is_initializer()) {
-symbolHandle signature(THREAD, m->signature());
+Symbol*  signature = m->signature();
 bool parameter_match = match_parameter_types(m, types, ArgumentCount(signature).size(), CHECK_NULL);
 if (parameter_match) {
 return new_method(m, false, false, THREAD);
 }
 }
 bool local_only = (which == MEMBER_DECLARED);
 for (MethodStream st(h_k, true, true); !st.eos(); st.next()) {
 methodHandle m(THREAD, st.method());
 if (m->name() == vmSymbols::object_initializer_name() && (local_only || m->is_public())) {
-symbolHandle signature(THREAD, m->signature());
+Symbol*  signature = m->signature();
 bool parameter_match = match_parameter_types(m, types, ArgumentCount(signature).size(), CHECK_NULL);
 if (parameter_match) {
 return new_constructor(m, THREAD);
 }
 }
 }
 }
 }
 // Allocate result
-symbolHandle name = vmSymbolHandles::java_lang_reflect_Constructor();
+Symbol* name = vmSymbols::java_lang_reflect_Constructor();
 klassOop klass = SystemDictionary::resolve_or_fail(name, true, CHECK_NULL);
 objArrayOop r = oopFactory::new_objArray(klass, count, CHECK_NULL);
 objArrayHandle h_result (THREAD, r);
 // Fill in results backwards

changeset 8076	96d498ec7ae1
parent 7397	5b173b4ca846
child 8725	8c1e3dd5fe1b