Mercurial > hg > graal-jvmci-8

comparison src/share/vm/runtime/reflection.cpp @ 2177:3582bf76420e

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6990754: Use native memory and reference counting to implement SymbolTable Summary: move symbols from permgen into C heap and reference count them Reviewed-by: never, acorn, jmasa, stefank
author coleenp
date Thu, 27 Jan 2011 16:11:27 -0800
parents f95d63e2154a
children c7f3d0b4570f
comparison
equal deleted inserted replaced
2176:27e4ea99855d 2177:3582bf76420e
62 } 62 }
63 if (!vfst.at_end()) { 63 if (!vfst.at_end()) {
64 // this frame is a likely suspect 64 // this frame is a likely suspect
65 caller = vfst.method()->method_holder(); 65 caller = vfst.method()->method_holder();
66 line_number = vfst.method()->line_number_from_bci(vfst.bci()); 66 line_number = vfst.method()->line_number_from_bci(vfst.bci());
67 symbolOop s = instanceKlass::cast(vfst.method()->method_holder())->source_file_name(); 67 Symbol* s = instanceKlass::cast(vfst.method()->method_holder())->source_file_name();
68 if (s != NULL) { 68 if (s != NULL) {
69 source_file = s->as_C_string(); 69 source_file = s->as_C_string();
70 } 70 }
71 } 71 }
72 } 72 }
620 620
621 // 'inner' not declared as an inner klass in outer 621 // 'inner' not declared as an inner klass in outer
622 ResourceMark rm(THREAD); 622 ResourceMark rm(THREAD);
623 Exceptions::fthrow( 623 Exceptions::fthrow(
624 THREAD_AND_LOCATION, 624 THREAD_AND_LOCATION,
625 vmSymbolHandles::java_lang_IncompatibleClassChangeError(), 625 vmSymbols::java_lang_IncompatibleClassChangeError(),
626 "%s and %s disagree on InnerClasses attribute", 626 "%s and %s disagree on InnerClasses attribute",
627 outer->external_name(), 627 outer->external_name(),
628 inner->external_name() 628 inner->external_name()
629 ); 629 );
630 } 630 }
636 default: 636 default:
637 assert(ss->type() != T_VOID || ss->at_return_type(), "T_VOID should only appear as return type"); 637 assert(ss->type() != T_VOID || ss->at_return_type(), "T_VOID should only appear as return type");
638 return java_lang_Class::primitive_mirror(ss->type()); 638 return java_lang_Class::primitive_mirror(ss->type());
639 case T_OBJECT: 639 case T_OBJECT:
640 case T_ARRAY: 640 case T_ARRAY:
641 symbolOop name = ss->as_symbol(CHECK_NULL); 641 Symbol* name = ss->as_symbol(CHECK_NULL);
642 oop loader = instanceKlass::cast(method->method_holder())->class_loader(); 642 oop loader = instanceKlass::cast(method->method_holder())->class_loader();
643 oop protection_domain = instanceKlass::cast(method->method_holder())->protection_domain(); 643 oop protection_domain = instanceKlass::cast(method->method_holder())->protection_domain();
644 klassOop k = SystemDictionary::resolve_or_fail( 644 klassOop k = SystemDictionary::resolve_or_fail(
645 symbolHandle(THREAD, name), 645 name,
646 Handle(THREAD, loader), 646 Handle(THREAD, loader),
647 Handle(THREAD, protection_domain), 647 Handle(THREAD, protection_domain),
648 true, CHECK_NULL); 648 true, CHECK_NULL);
649 if (TraceClassResolution) { 649 if (TraceClassResolution) {
650 trace_class_resolution(k); 650 trace_class_resolution(k);
658 // Allocate array holding parameter types (java.lang.Class instances) 658 // Allocate array holding parameter types (java.lang.Class instances)
659 objArrayOop m = oopFactory::new_objArray(SystemDictionary::Class_klass(), parameter_count, CHECK_(objArrayHandle())); 659 objArrayOop m = oopFactory::new_objArray(SystemDictionary::Class_klass(), parameter_count, CHECK_(objArrayHandle()));
660 objArrayHandle mirrors (THREAD, m); 660 objArrayHandle mirrors (THREAD, m);
661 int index = 0; 661 int index = 0;
662 // Collect parameter types 662 // Collect parameter types
663 symbolHandle signature (THREAD, method->signature()); 663 ResourceMark rm(THREAD);
664 Symbol* signature = method->signature();
664 SignatureStream ss(signature); 665 SignatureStream ss(signature);
665 while (!ss.at_return_type()) { 666 while (!ss.at_return_type()) {
666 oop mirror = get_mirror_from_signature(method, &ss, CHECK_(objArrayHandle())); 667 oop mirror = get_mirror_from_signature(method, &ss, CHECK_(objArrayHandle()));
667 mirrors->obj_at_put(index++, mirror); 668 mirrors->obj_at_put(index++, mirror);
668 ss.next(); 669 ss.next();
679 objArrayHandle Reflection::get_exception_types(methodHandle method, TRAPS) { 680 objArrayHandle Reflection::get_exception_types(methodHandle method, TRAPS) {
680 return method->resolved_checked_exceptions(CHECK_(objArrayHandle())); 681 return method->resolved_checked_exceptions(CHECK_(objArrayHandle()));
681 } 682 }
682 683
683 684
684 Handle Reflection::new_type(symbolHandle signature, KlassHandle k, TRAPS) { 685 Handle Reflection::new_type(Symbol* signature, KlassHandle k, TRAPS) {
685 // Basic types 686 // Basic types
686 BasicType type = vmSymbols::signature_type(signature()); 687 BasicType type = vmSymbols::signature_type(signature);
687 if (type != T_OBJECT) { 688 if (type != T_OBJECT) {
688 return Handle(THREAD, Universe::java_mirror(type)); 689 return Handle(THREAD, Universe::java_mirror(type));
689 } 690 }
690 691
691 oop loader = instanceKlass::cast(k())->class_loader(); 692 oop loader = instanceKlass::cast(k())->class_loader();
712 (method()->name() == vmSymbols::class_initializer_name() 713 (method()->name() == vmSymbols::class_initializer_name()
713 && Klass::cast(method()->method_holder())->is_interface() && JDK_Version::is_jdk12x_version()), "should call new_constructor instead"); 714 && Klass::cast(method()->method_holder())->is_interface() && JDK_Version::is_jdk12x_version()), "should call new_constructor instead");
714 instanceKlassHandle holder (THREAD, method->method_holder()); 715 instanceKlassHandle holder (THREAD, method->method_holder());
715 int slot = method->method_idnum(); 716 int slot = method->method_idnum();
716 717
717 symbolHandle signature (THREAD, method->signature()); 718 Symbol* signature = method->signature();
718 int parameter_count = ArgumentCount(signature).size(); 719 int parameter_count = ArgumentCount(signature).size();
719 oop return_type_oop = NULL; 720 oop return_type_oop = NULL;
720 objArrayHandle parameter_types = get_parameter_types(method, parameter_count, &return_type_oop, CHECK_NULL); 721 objArrayHandle parameter_types = get_parameter_types(method, parameter_count, &return_type_oop, CHECK_NULL);
721 if (parameter_types.is_null() || return_type_oop == NULL) return NULL; 722 if (parameter_types.is_null() || return_type_oop == NULL) return NULL;
722 723
724 725
725 objArrayHandle exception_types = get_exception_types(method, CHECK_NULL); 726 objArrayHandle exception_types = get_exception_types(method, CHECK_NULL);
726 727
727 if (exception_types.is_null()) return NULL; 728 if (exception_types.is_null()) return NULL;
728 729
729 symbolHandle method_name(THREAD, method->name()); 730 Symbol* method_name = method->name();
730 Handle name; 731 Handle name;
731 if (intern_name) { 732 if (intern_name) {
732 // intern_name is only true with UseNewReflection 733 // intern_name is only true with UseNewReflection
733 oop name_oop = StringTable::intern(method_name(), CHECK_NULL); 734 oop name_oop = StringTable::intern(method_name, CHECK_NULL);
734 name = Handle(THREAD, name_oop); 735 name = Handle(THREAD, name_oop);
735 } else { 736 } else {
736 name = java_lang_String::create_from_symbol(method_name, CHECK_NULL); 737 name = java_lang_String::create_from_symbol(method_name, CHECK_NULL);
737 } 738 }
738 if (name.is_null()) return NULL; 739 if (name == NULL) return NULL;
739 740
740 int modifiers = method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS; 741 int modifiers = method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS;
741 742
742 Handle mh = java_lang_reflect_Method::create(CHECK_NULL); 743 Handle mh = java_lang_reflect_Method::create(CHECK_NULL);
743 744
749 java_lang_reflect_Method::set_exception_types(mh(), exception_types()); 750 java_lang_reflect_Method::set_exception_types(mh(), exception_types());
750 java_lang_reflect_Method::set_modifiers(mh(), modifiers); 751 java_lang_reflect_Method::set_modifiers(mh(), modifiers);
751 java_lang_reflect_Method::set_override(mh(), false); 752 java_lang_reflect_Method::set_override(mh(), false);
752 if (java_lang_reflect_Method::has_signature_field() && 753 if (java_lang_reflect_Method::has_signature_field() &&
753 method->generic_signature() != NULL) { 754 method->generic_signature() != NULL) {
754 symbolHandle gs(THREAD, method->generic_signature()); 755 Symbol* gs = method->generic_signature();
755 Handle sig = java_lang_String::create_from_symbol(gs, CHECK_NULL); 756 Handle sig = java_lang_String::create_from_symbol(gs, CHECK_NULL);
756 java_lang_reflect_Method::set_signature(mh(), sig()); 757 java_lang_reflect_Method::set_signature(mh(), sig());
757 } 758 }
758 if (java_lang_reflect_Method::has_annotations_field()) { 759 if (java_lang_reflect_Method::has_annotations_field()) {
759 java_lang_reflect_Method::set_annotations(mh(), method->annotations()); 760 java_lang_reflect_Method::set_annotations(mh(), method->annotations());
772 assert(method()->is_initializer(), "should call new_method instead"); 773 assert(method()->is_initializer(), "should call new_method instead");
773 774
774 instanceKlassHandle holder (THREAD, method->method_holder()); 775 instanceKlassHandle holder (THREAD, method->method_holder());
775 int slot = method->method_idnum(); 776 int slot = method->method_idnum();
776 777
777 symbolHandle signature (THREAD, method->signature()); 778 Symbol* signature = method->signature();
778 int parameter_count = ArgumentCount(signature).size(); 779 int parameter_count = ArgumentCount(signature).size();
779 objArrayHandle parameter_types = get_parameter_types(method, parameter_count, NULL, CHECK_NULL); 780 objArrayHandle parameter_types = get_parameter_types(method, parameter_count, NULL, CHECK_NULL);
780 if (parameter_types.is_null()) return NULL; 781 if (parameter_types.is_null()) return NULL;
781 782
782 objArrayHandle exception_types = get_exception_types(method, CHECK_NULL); 783 objArrayHandle exception_types = get_exception_types(method, CHECK_NULL);
792 java_lang_reflect_Constructor::set_exception_types(ch(), exception_types()); 793 java_lang_reflect_Constructor::set_exception_types(ch(), exception_types());
793 java_lang_reflect_Constructor::set_modifiers(ch(), modifiers); 794 java_lang_reflect_Constructor::set_modifiers(ch(), modifiers);
794 java_lang_reflect_Constructor::set_override(ch(), false); 795 java_lang_reflect_Constructor::set_override(ch(), false);
795 if (java_lang_reflect_Constructor::has_signature_field() && 796 if (java_lang_reflect_Constructor::has_signature_field() &&
796 method->generic_signature() != NULL) { 797 method->generic_signature() != NULL) {
797 symbolHandle gs(THREAD, method->generic_signature()); 798 Symbol* gs = method->generic_signature();
798 Handle sig = java_lang_String::create_from_symbol(gs, CHECK_NULL); 799 Handle sig = java_lang_String::create_from_symbol(gs, CHECK_NULL);
799 java_lang_reflect_Constructor::set_signature(ch(), sig()); 800 java_lang_reflect_Constructor::set_signature(ch(), sig());
800 } 801 }
801 if (java_lang_reflect_Constructor::has_annotations_field()) { 802 if (java_lang_reflect_Constructor::has_annotations_field()) {
802 java_lang_reflect_Constructor::set_annotations(ch(), method->annotations()); 803 java_lang_reflect_Constructor::set_annotations(ch(), method->annotations());
807 return ch(); 808 return ch();
808 } 809 }
809 810
810 811
811 oop Reflection::new_field(fieldDescriptor* fd, bool intern_name, TRAPS) { 812 oop Reflection::new_field(fieldDescriptor* fd, bool intern_name, TRAPS) {
812 symbolHandle field_name(THREAD, fd->name()); 813 Symbol* field_name = fd->name();
813 Handle name; 814 Handle name;
814 if (intern_name) { 815 if (intern_name) {
815 // intern_name is only true with UseNewReflection 816 // intern_name is only true with UseNewReflection
816 oop name_oop = StringTable::intern(field_name(), CHECK_NULL); 817 oop name_oop = StringTable::intern(field_name, CHECK_NULL);
817 name = Handle(THREAD, name_oop); 818 name = Handle(THREAD, name_oop);
818 } else { 819 } else {
819 name = java_lang_String::create_from_symbol(field_name, CHECK_NULL); 820 name = java_lang_String::create_from_symbol(field_name, CHECK_NULL);
820 } 821 }
821 symbolHandle signature (THREAD, fd->signature()); 822 Symbol* signature = fd->signature();
822 KlassHandle holder (THREAD, fd->field_holder()); 823 KlassHandle holder (THREAD, fd->field_holder());
823 Handle type = new_type(signature, holder, CHECK_NULL); 824 Handle type = new_type(signature, holder, CHECK_NULL);
824 Handle rh = java_lang_reflect_Field::create(CHECK_NULL); 825 Handle rh = java_lang_reflect_Field::create(CHECK_NULL);
825 826
826 java_lang_reflect_Field::set_clazz(rh(), Klass::cast(fd->field_holder())->java_mirror()); 827 java_lang_reflect_Field::set_clazz(rh(), Klass::cast(fd->field_holder())->java_mirror());
830 // Note the ACC_ANNOTATION bit, which is a per-class access flag, is never set here. 831 // Note the ACC_ANNOTATION bit, which is a per-class access flag, is never set here.
831 java_lang_reflect_Field::set_modifiers(rh(), fd->access_flags().as_int() & JVM_RECOGNIZED_FIELD_MODIFIERS); 832 java_lang_reflect_Field::set_modifiers(rh(), fd->access_flags().as_int() & JVM_RECOGNIZED_FIELD_MODIFIERS);
832 java_lang_reflect_Field::set_override(rh(), false); 833 java_lang_reflect_Field::set_override(rh(), false);
833 if (java_lang_reflect_Field::has_signature_field() && 834 if (java_lang_reflect_Field::has_signature_field() &&
834 fd->generic_signature() != NULL) { 835 fd->generic_signature() != NULL) {
835 symbolHandle gs(THREAD, fd->generic_signature()); 836 Symbol* gs = fd->generic_signature();
836 Handle sig = java_lang_String::create_from_symbol(gs, CHECK_NULL); 837 Handle sig = java_lang_String::create_from_symbol(gs, CHECK_NULL);
837 java_lang_reflect_Field::set_signature(rh(), sig()); 838 java_lang_reflect_Field::set_signature(rh(), sig());
838 } 839 }
839 if (java_lang_reflect_Field::has_annotations_field()) { 840 if (java_lang_reflect_Field::has_annotations_field()) {
840 java_lang_reflect_Field::set_annotations(rh(), fd->annotations()); 841 java_lang_reflect_Field::set_annotations(rh(), fd->annotations());
856 methodHandle Reflection::resolve_interface_call(instanceKlassHandle klass, methodHandle method, 857 methodHandle Reflection::resolve_interface_call(instanceKlassHandle klass, methodHandle method,
857 KlassHandle recv_klass, Handle receiver, TRAPS) { 858 KlassHandle recv_klass, Handle receiver, TRAPS) {
858 assert(!method.is_null() , "method should not be null"); 859 assert(!method.is_null() , "method should not be null");
859 860
860 CallInfo info; 861 CallInfo info;
861 symbolHandle signature (THREAD, method->signature()); 862 Symbol* signature = method->signature();
862 symbolHandle name (THREAD, method->name()); 863 Symbol* name = method->name();
863 LinkResolver::resolve_interface_call(info, receiver, recv_klass, klass, 864 LinkResolver::resolve_interface_call(info, receiver, recv_klass, klass,
864 name, signature, 865 name, signature,
865 KlassHandle(), false, true, 866 KlassHandle(), false, true,
866 CHECK_(methodHandle())); 867 CHECK_(methodHandle()));
867 return info.selected_method(); 868 return info.selected_method();
910 if (HAS_PENDING_EXCEPTION) { 911 if (HAS_PENDING_EXCEPTION) {
911 // Method resolution threw an exception; wrap it in an InvocationTargetException 912 // Method resolution threw an exception; wrap it in an InvocationTargetException
912 oop resolution_exception = PENDING_EXCEPTION; 913 oop resolution_exception = PENDING_EXCEPTION;
913 CLEAR_PENDING_EXCEPTION; 914 CLEAR_PENDING_EXCEPTION;
914 JavaCallArguments args(Handle(THREAD, resolution_exception)); 915 JavaCallArguments args(Handle(THREAD, resolution_exception));
915 THROW_ARG_0(vmSymbolHandles::java_lang_reflect_InvocationTargetException(), 916 THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(),
916 vmSymbolHandles::throwable_void_signature(), 917 vmSymbols::throwable_void_signature(),
917 &args); 918 &args);
918 } 919 }
919 } else { 920 } else {
920 method = resolve_interface_call(klass, reflected_method, target_klass, receiver, CHECK_(NULL)); 921 method = resolve_interface_call(klass, reflected_method, target_klass, receiver, CHECK_(NULL));
921 } 922 }
939 vmSymbols::java_lang_AbstractMethodError(), 940 vmSymbols::java_lang_AbstractMethodError(),
940 methodOopDesc::name_and_sig_as_C_string(Klass::cast(target_klass()), 941 methodOopDesc::name_and_sig_as_C_string(Klass::cast(target_klass()),
941 method->name(), 942 method->name(),
942 method->signature())); 943 method->signature()));
943 JavaCallArguments args(h_origexception); 944 JavaCallArguments args(h_origexception);
944 THROW_ARG_0(vmSymbolHandles::java_lang_reflect_InvocationTargetException(), 945 THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(),
945 vmSymbolHandles::throwable_void_signature(), 946 vmSymbols::throwable_void_signature(),
946 &args); 947 &args);
947 } else { 948 } else {
948 ResourceMark rm(THREAD); 949 ResourceMark rm(THREAD);
949 THROW_MSG_0(vmSymbols::java_lang_AbstractMethodError(), 950 THROW_MSG_0(vmSymbols::java_lang_AbstractMethodError(),
950 methodOopDesc::name_and_sig_as_C_string(Klass::cast(target_klass()), 951 methodOopDesc::name_and_sig_as_C_string(Klass::cast(target_klass()),
1041 if (HAS_PENDING_EXCEPTION) { 1042 if (HAS_PENDING_EXCEPTION) {
1042 // Method threw an exception; wrap it in an InvocationTargetException 1043 // Method threw an exception; wrap it in an InvocationTargetException
1043 oop target_exception = PENDING_EXCEPTION; 1044 oop target_exception = PENDING_EXCEPTION;
1044 CLEAR_PENDING_EXCEPTION; 1045 CLEAR_PENDING_EXCEPTION;
1045 JavaCallArguments args(Handle(THREAD, target_exception)); 1046 JavaCallArguments args(Handle(THREAD, target_exception));
1046 THROW_ARG_0(vmSymbolHandles::java_lang_reflect_InvocationTargetException(), 1047 THROW_ARG_0(vmSymbols::java_lang_reflect_InvocationTargetException(),
1047 vmSymbolHandles::throwable_void_signature(), 1048 vmSymbols::throwable_void_signature(),
1048 &args); 1049 &args);
1049 } else { 1050 } else {
1050 if (rtype == T_BOOLEAN || rtype == T_BYTE || rtype == T_CHAR || rtype == T_SHORT) 1051 if (rtype == T_BOOLEAN || rtype == T_BYTE || rtype == T_CHAR || rtype == T_SHORT)
1051 narrow((jvalue*) result.get_value_addr(), rtype, CHECK_NULL); 1052 narrow((jvalue*) result.get_value_addr(), rtype, CHECK_NULL);
1052 return box((jvalue*) result.get_value_addr(), rtype, CHECK_NULL); 1053 return box((jvalue*) result.get_value_addr(), rtype, CHECK_NULL);
1095 return true; 1096 return true;
1096 } 1097 }
1097 1098
1098 1099
1099 oop Reflection::new_field(FieldStream* st, TRAPS) { 1100 oop Reflection::new_field(FieldStream* st, TRAPS) {
1100 symbolHandle field_name(THREAD, st->name()); 1101 Symbol* field_name = st->name();
1101 Handle name = java_lang_String::create_from_symbol(field_name, CHECK_NULL); 1102 Handle name = java_lang_String::create_from_symbol(field_name, CHECK_NULL);
1102 symbolHandle signature(THREAD, st->signature()); 1103 Symbol* signature = st->signature();
1103 Handle type = new_type(signature, st->klass(), CHECK_NULL); 1104 Handle type = new_type(signature, st->klass(), CHECK_NULL);
1104 Handle rh = java_lang_reflect_Field::create(CHECK_NULL); 1105 Handle rh = java_lang_reflect_Field::create(CHECK_NULL);
1105 oop result = rh(); 1106 oop result = rh();
1106 1107
1107 java_lang_reflect_Field::set_clazz(result, st->klass()->java_mirror()); 1108 java_lang_reflect_Field::set_clazz(result, st->klass()->java_mirror());
1240 break; 1241 break;
1241 case T_OBJECT: 1242 case T_OBJECT:
1242 case T_ARRAY: { 1243 case T_ARRAY: {
1243 Handle obj(THREAD, (oop) value->l); 1244 Handle obj(THREAD, (oop) value->l);
1244 if (obj.not_null()) { 1245 if (obj.not_null()) {
1245 symbolHandle signature(THREAD, fd->signature()); 1246 Symbol* signature = fd->signature();
1246 Handle loader (THREAD, fd->loader()); 1247 Handle loader (THREAD, fd->loader());
1247 Handle protect (THREAD, Klass::cast(fd->field_holder())->protection_domain()); 1248 Handle protect (THREAD, Klass::cast(fd->field_holder())->protection_domain());
1248 klassOop k = SystemDictionary::resolve_or_fail(signature, loader, protect, true, CHECK); // may block 1249 klassOop k = SystemDictionary::resolve_or_fail(signature, loader, protect, true, CHECK); // may block
1249 if (!obj->is_a(k)) { 1250 if (!obj->is_a(k)) {
1250 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "field type mismatch"); 1251 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "field type mismatch");
1257 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "field type mismatch"); 1258 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "field type mismatch");
1258 } 1259 }
1259 } 1260 }
1260 1261
1261 1262
1262 oop Reflection::reflect_field(oop mirror, symbolOop field_name, jint which, TRAPS) { 1263 oop Reflection::reflect_field(oop mirror, Symbol* field_name, jint which, TRAPS) {
1263 // Exclude primitive types and array types 1264 // Exclude primitive types and array types
1264 if (java_lang_Class::is_primitive(mirror)) return NULL; 1265 if (java_lang_Class::is_primitive(mirror)) return NULL;
1265 if (Klass::cast(java_lang_Class::as_klassOop(mirror))->oop_is_array()) return NULL; 1266 if (Klass::cast(java_lang_Class::as_klassOop(mirror))->oop_is_array()) return NULL;
1266 1267
1267 instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(mirror)); 1268 instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(mirror));
1285 1286
1286 objArrayOop Reflection::reflect_fields(oop mirror, jint which, TRAPS) { 1287 objArrayOop Reflection::reflect_fields(oop mirror, jint which, TRAPS) {
1287 // Exclude primitive types and array types 1288 // Exclude primitive types and array types
1288 if (java_lang_Class::is_primitive(mirror) 1289 if (java_lang_Class::is_primitive(mirror)
1289 || Klass::cast(java_lang_Class::as_klassOop(mirror))->oop_is_array()) { 1290 || Klass::cast(java_lang_Class::as_klassOop(mirror))->oop_is_array()) {
1290 symbolHandle name = vmSymbolHandles::java_lang_reflect_Field(); 1291 Symbol* name = vmSymbols::java_lang_reflect_Field();
1291 klassOop klass = SystemDictionary::resolve_or_fail(name, true, CHECK_NULL); 1292 klassOop klass = SystemDictionary::resolve_or_fail(name, true, CHECK_NULL);
1292 return oopFactory::new_objArray(klass, 0, CHECK_NULL); // Return empty array 1293 return oopFactory::new_objArray(klass, 0, CHECK_NULL); // Return empty array
1293 } 1294 }
1294 1295
1295 instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(mirror)); 1296 instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(mirror));
1306 } 1307 }
1307 } 1308 }
1308 } 1309 }
1309 1310
1310 // Allocate result 1311 // Allocate result
1311 symbolHandle name = vmSymbolHandles::java_lang_reflect_Field(); 1312 Symbol* name = vmSymbols::java_lang_reflect_Field();
1312 klassOop klass = SystemDictionary::resolve_or_fail(name, true, CHECK_NULL); 1313 klassOop klass = SystemDictionary::resolve_or_fail(name, true, CHECK_NULL);
1313 objArrayOop r = oopFactory::new_objArray(klass, count, CHECK_NULL); 1314 objArrayOop r = oopFactory::new_objArray(klass, count, CHECK_NULL);
1314 objArrayHandle result (THREAD, r); 1315 objArrayHandle result (THREAD, r);
1315 1316
1316 // Fill in results backwards 1317 // Fill in results backwards
1325 } 1326 }
1326 return result(); 1327 return result();
1327 } 1328 }
1328 1329
1329 1330
1330 oop Reflection::reflect_method(oop mirror, symbolHandle method_name, objArrayHandle types, jint which, TRAPS) { 1331 oop Reflection::reflect_method(oop mirror, Symbol* method_name, objArrayHandle types, jint which, TRAPS) {
1331 if (java_lang_Class::is_primitive(mirror)) return NULL; 1332 if (java_lang_Class::is_primitive(mirror)) return NULL;
1332 klassOop klass = java_lang_Class::as_klassOop(mirror); 1333 klassOop klass = java_lang_Class::as_klassOop(mirror);
1333 if (Klass::cast(klass)->oop_is_array() && which == MEMBER_DECLARED) return NULL; 1334 if (Klass::cast(klass)->oop_is_array() && which == MEMBER_DECLARED) return NULL;
1334 1335
1335 if (Klass::cast(java_lang_Class::as_klassOop(mirror))->oop_is_array()) { 1336 if (Klass::cast(java_lang_Class::as_klassOop(mirror))->oop_is_array()) {
1349 // Note that we can ignore checks for overridden methods, since we go up the hierarchy. 1350 // Note that we can ignore checks for overridden methods, since we go up the hierarchy.
1350 { 1351 {
1351 for (MethodStream st(h_k, false, false); !st.eos(); st.next()) { 1352 for (MethodStream st(h_k, false, false); !st.eos(); st.next()) {
1352 methodHandle m(THREAD, st.method()); 1353 methodHandle m(THREAD, st.method());
1353 // For interfaces include static initializers since classic does that! 1354 // For interfaces include static initializers since classic does that!
1354 if (method_name() == m->name() && (include_clinit || (m->is_public() && !m->is_static() && !m->is_initializer()))) { 1355 if (method_name == m->name() && (include_clinit || (m->is_public() && !m->is_static() && !m->is_initializer()))) {
1355 symbolHandle signature(THREAD, m->signature()); 1356 Symbol* signature = m->signature();
1356 bool parameter_match = match_parameter_types(m, types, ArgumentCount(signature).size(), CHECK_NULL); 1357 bool parameter_match = match_parameter_types(m, types, ArgumentCount(signature).size(), CHECK_NULL);
1357 if (parameter_match) { 1358 if (parameter_match) {
1358 return new_method(m, false, false, THREAD); 1359 return new_method(m, false, false, THREAD);
1359 } 1360 }
1360 } 1361 }
1362 } 1363 }
1363 // Then the public static methods (works if method holder is an interface) 1364 // Then the public static methods (works if method holder is an interface)
1364 { 1365 {
1365 for (MethodStream st(h_k, false, false); !st.eos(); st.next()) { 1366 for (MethodStream st(h_k, false, false); !st.eos(); st.next()) {
1366 methodHandle m(THREAD, st.method()); 1367 methodHandle m(THREAD, st.method());
1367 if (method_name() == m->name() && m->is_public() && m->is_static() && !m->is_initializer()) { 1368 if (method_name == m->name() && m->is_public() && m->is_static() && !m->is_initializer()) {
1368 symbolHandle signature(THREAD, m->signature()); 1369 Symbol* signature = m->signature();
1369 bool parameter_match = match_parameter_types(m, types, ArgumentCount(signature).size(), CHECK_NULL); 1370 bool parameter_match = match_parameter_types(m, types, ArgumentCount(signature).size(), CHECK_NULL);
1370 if (parameter_match) { 1371 if (parameter_match) {
1371 return new_method(m, false, false, THREAD); 1372 return new_method(m, false, false, THREAD);
1372 } 1373 }
1373 } 1374 }
1377 case MEMBER_DECLARED: 1378 case MEMBER_DECLARED:
1378 // All local methods 1379 // All local methods
1379 { 1380 {
1380 for (MethodStream st(h_k, true, true); !st.eos(); st.next()) { 1381 for (MethodStream st(h_k, true, true); !st.eos(); st.next()) {
1381 methodHandle m(THREAD, st.method()); 1382 methodHandle m(THREAD, st.method());
1382 if (method_name() == m->name() && !m->is_initializer()) { 1383 if (method_name == m->name() && !m->is_initializer()) {
1383 symbolHandle signature(THREAD, m->signature()); 1384 Symbol* signature = m->signature();
1384 bool parameter_match = match_parameter_types(m, types, ArgumentCount(signature).size(), CHECK_NULL); 1385 bool parameter_match = match_parameter_types(m, types, ArgumentCount(signature).size(), CHECK_NULL);
1385 if (parameter_match) { 1386 if (parameter_match) {
1386 return new_method(m, false, false, THREAD); 1387 return new_method(m, false, false, THREAD);
1387 } 1388 }
1388 } 1389 }
1529 1530
1530 bool local_only = (which == MEMBER_DECLARED); 1531 bool local_only = (which == MEMBER_DECLARED);
1531 for (MethodStream st(h_k, true, true); !st.eos(); st.next()) { 1532 for (MethodStream st(h_k, true, true); !st.eos(); st.next()) {
1532 methodHandle m(THREAD, st.method()); 1533 methodHandle m(THREAD, st.method());
1533 if (m->name() == vmSymbols::object_initializer_name() && (local_only || m->is_public())) { 1534 if (m->name() == vmSymbols::object_initializer_name() && (local_only || m->is_public())) {
1534 symbolHandle signature(THREAD, m->signature()); 1535 Symbol* signature = m->signature();
1535 bool parameter_match = match_parameter_types(m, types, ArgumentCount(signature).size(), CHECK_NULL); 1536 bool parameter_match = match_parameter_types(m, types, ArgumentCount(signature).size(), CHECK_NULL);
1536 if (parameter_match) { 1537 if (parameter_match) {
1537 return new_constructor(m, THREAD); 1538 return new_constructor(m, THREAD);
1538 } 1539 }
1539 } 1540 }
1567 } 1568 }
1568 } 1569 }
1569 } 1570 }
1570 1571
1571 // Allocate result 1572 // Allocate result
1572 symbolHandle name = vmSymbolHandles::java_lang_reflect_Constructor(); 1573 Symbol* name = vmSymbols::java_lang_reflect_Constructor();
1573 klassOop klass = SystemDictionary::resolve_or_fail(name, true, CHECK_NULL); 1574 klassOop klass = SystemDictionary::resolve_or_fail(name, true, CHECK_NULL);
1574 objArrayOop r = oopFactory::new_objArray(klass, count, CHECK_NULL); 1575 objArrayOop r = oopFactory::new_objArray(klass, count, CHECK_NULL);
1575 objArrayHandle h_result (THREAD, r); 1576 objArrayHandle h_result (THREAD, r);
1576 1577
1577 // Fill in results backwards 1578 // Fill in results backwards