522 return java_lang_invoke_MethodType::as_signature(type_str, intern_if_not_found);
523 } else if (java_lang_Class::is_instance(type_str)) {
524 return java_lang_Class::as_signature(type_str, false);
525 } else if (java_lang_String::is_instance_inlined(type_str)) {
526 if (intern_if_not_found) {
527 return java_lang_String::as_symbol(type_str);
528 } else {
529 return java_lang_String::as_symbol_or_null(type_str);
530 }
531 } else {
532 THROW_MSG_(vmSymbols::java_lang_InternalError(), "unrecognized type", NULL);
533 }
534 }
535
536 static const char OBJ_SIG[] = "Ljava/lang/Object;";
537 enum { OBJ_SIG_LEN = 18 };
538
539 bool MethodHandles::is_basic_type_signature(Symbol* sig) {
540 assert(vmSymbols::object_signature()->utf8_length() == (int)OBJ_SIG_LEN, "");
541 assert(vmSymbols::object_signature()->equals(OBJ_SIG), "");
542 const int len = sig->utf8_length();
543 for (int i = 0; i < len; i++) {
544 switch (sig->char_at(i)) {
545 case JVM_SIGNATURE_CLASS:
546 // only java/lang/Object is valid here
547 if (sig->index_of_at(i, OBJ_SIG, OBJ_SIG_LEN) != i)
548 return false;
549 i += OBJ_SIG_LEN-1; //-1 because of i++ in loop
550 continue;
551 case JVM_SIGNATURE_FUNC:
552 case JVM_SIGNATURE_ENDFUNC:
553 case JVM_SIGNATURE_VOID:
554 case JVM_SIGNATURE_INT:
555 case JVM_SIGNATURE_LONG:
556 case JVM_SIGNATURE_FLOAT:
557 case JVM_SIGNATURE_DOUBLE:
558 continue;
559 default:
560 // subword types (T_BYTE etc.), arrays
561 return false;
562 }
563 }
564 return true;
565 }
566
567 Symbol* MethodHandles::lookup_basic_type_signature(Symbol* sig, bool keep_last_arg, TRAPS) {
568 Symbol* bsig = NULL;
569 if (sig == NULL) {
570 return sig;
571 } else if (is_basic_type_signature(sig)) {
572 sig->increment_refcount();
573 return sig; // that was easy
574 } else if (sig->char_at(0) != JVM_SIGNATURE_FUNC) {
575 BasicType bt = char2type(sig->char_at(0));
576 if (is_subword_type(bt)) {
577 bsig = vmSymbols::int_signature();
578 } else {
579 assert(is_reference_type(bt), "is_basic_type_signature was false");
580 bsig = vmSymbols::object_signature();
581 }
582 } else {
583 ResourceMark rm;
584 stringStream buffer(128);
585 buffer.put(JVM_SIGNATURE_FUNC);
586 int arg_pos = 0, keep_arg_pos = -1;
587 if (keep_last_arg)
588 keep_arg_pos = ArgumentCount(sig).size() - 1;
589 for (SignatureStream ss(sig); !ss.is_done(); ss.next()) {
590 BasicType bt = ss.type();
591 size_t this_arg_pos = buffer.size();
592 if (ss.at_return_type()) {
593 buffer.put(JVM_SIGNATURE_ENDFUNC);
594 }
595 if (arg_pos == keep_arg_pos) {
598 } else if (is_reference_type(bt)) {
599 buffer.write(OBJ_SIG, OBJ_SIG_LEN);
600 } else {
601 if (is_subword_type(bt))
602 bt = T_INT;
603 buffer.put(type2char(bt));
604 }
605 arg_pos++;
606 }
607 const char* sigstr = buffer.base();
608 int siglen = (int) buffer.size();
609 bsig = SymbolTable::new_symbol(sigstr, siglen);
610 }
611 assert(is_basic_type_signature(bsig) ||
612 // detune assert in case the injected argument is not a basic type:
613 keep_last_arg, "");
614 return bsig;
615 }
616
617 void MethodHandles::print_as_basic_type_signature_on(outputStream* st,
618 Symbol* sig,
619 bool keep_arrays,
620 bool keep_basic_names) {
621 st = st ? st : tty;
622 int len = sig->utf8_length();
623 int array = 0;
624 bool prev_type = false;
625 for (int i = 0; i < len; i++) {
626 char ch = sig->char_at(i);
627 switch (ch) {
628 case JVM_SIGNATURE_FUNC:
629 case JVM_SIGNATURE_ENDFUNC:
630 prev_type = false;
631 st->put(ch);
632 continue;
633 case JVM_SIGNATURE_ARRAY:
634 if (!keep_basic_names && keep_arrays)
635 st->put(ch);
636 array++;
637 continue;
638 case JVM_SIGNATURE_CLASS:
639 {
640 if (prev_type) st->put(',');
641 int start = i+1, slash = start;
642 while (++i < len && (ch = sig->char_at(i)) != JVM_SIGNATURE_ENDCLASS) {
643 if (ch == JVM_SIGNATURE_SLASH || ch == JVM_SIGNATURE_DOT || ch == '$') slash = i+1;
644 }
645 if (slash < i) start = slash;
646 if (!keep_basic_names) {
647 st->put(JVM_SIGNATURE_CLASS);
648 } else {
649 for (int j = start; j < i; j++)
650 st->put(sig->char_at(j));
651 prev_type = true;
652 }
653 break;
654 }
655 default:
656 {
657 if (array && char2type(ch) != T_ILLEGAL && !keep_arrays) {
658 ch = JVM_SIGNATURE_ARRAY;
659 array = 0;
660 }
661 if (prev_type) st->put(',');
662 const char* n = NULL;
663 if (keep_basic_names)
664 n = type2name(char2type(ch));
665 if (n == NULL) {
666 // unknown letter, or we don't want to know its name
667 st->put(ch);
668 } else {
669 st->print("%s", n);
670 prev_type = true;
671 }
672 break;
673 }
674 }
675 // Switch break goes here to take care of array suffix:
676 if (prev_type) {
677 while (array > 0) {
678 st->print("[]");
679 --array;
680 }
681 }
682 array = 0;
683 }
684 }
685
686
687
688 static oop object_java_mirror() {
689 return SystemDictionary::Object_klass()->java_mirror();
690 }
691
692 oop MethodHandles::field_name_or_null(Symbol* s) {
693 if (s == NULL) return NULL;
694 return StringTable::lookup(s);
695 }
696
697 oop MethodHandles::field_signature_type_or_null(Symbol* s) {
698 if (s == NULL) return NULL;
699 BasicType bt = FieldType::basic_type(s);
700 if (is_java_primitive(bt)) {
701 assert(s->utf8_length() == 1, "");
702 return java_lang_Class::primitive_mirror(bt);
703 }
704 // Here are some more short cuts for common types.
705 // They are optional, since reference types can be resolved lazily.
706 if (bt == T_OBJECT) {
707 if (s == vmSymbols::object_signature()) {
708 return object_java_mirror();
709 } else if (s == vmSymbols::class_signature()) {
710 return SystemDictionary::Class_klass()->java_mirror();
711 } else if (s == vmSymbols::string_signature()) {
712 return SystemDictionary::String_klass()->java_mirror();
713 }
714 }
715 return NULL;
716 }
717
718
719 // An unresolved member name is a mere symbolic reference.
965 int skip, objArrayHandle results, TRAPS) {
966 // %%% take caller into account!
967
968 Thread* thread = Thread::current();
969
970 if (k == NULL || !k->is_instance_klass()) return -1;
971
972 int rfill = 0, rlimit = results->length(), rskip = skip;
973 // overflow measurement:
974 int overflow = 0, overflow_limit = MAX2(1000, rlimit);
975
976 int match_flags = mflags;
977 bool search_superc = ((match_flags & SEARCH_SUPERCLASSES) != 0);
978 bool search_intfc = ((match_flags & SEARCH_INTERFACES) != 0);
979 bool local_only = !(search_superc | search_intfc);
980
981 if (name != NULL) {
982 if (name->utf8_length() == 0) return 0; // a match is not possible
983 }
984 if (sig != NULL) {
985 if (sig->utf8_length() == 0) return 0; // a match is not possible
986 if (sig->char_at(0) == JVM_SIGNATURE_FUNC)
987 match_flags &= ~(IS_FIELD | IS_TYPE);
988 else
989 match_flags &= ~(IS_CONSTRUCTOR | IS_METHOD);
990 }
991
992 if ((match_flags & IS_TYPE) != 0) {
993 // NYI, and Core Reflection works quite well for this query
994 }
995
996 if ((match_flags & IS_FIELD) != 0) {
997 InstanceKlass* ik = InstanceKlass::cast(k);
998 for (FieldStream st(ik, local_only, !search_intfc); !st.eos(); st.next()) {
999 if (name != NULL && st.name() != name)
1000 continue;
1001 if (sig != NULL && st.signature() != sig)
1002 continue;
1003 // passed the filters
1004 if (rskip > 0) {
1005 --rskip;
1006 } else if (rfill < rlimit) {
|
522 return java_lang_invoke_MethodType::as_signature(type_str, intern_if_not_found);
523 } else if (java_lang_Class::is_instance(type_str)) {
524 return java_lang_Class::as_signature(type_str, false);
525 } else if (java_lang_String::is_instance_inlined(type_str)) {
526 if (intern_if_not_found) {
527 return java_lang_String::as_symbol(type_str);
528 } else {
529 return java_lang_String::as_symbol_or_null(type_str);
530 }
531 } else {
532 THROW_MSG_(vmSymbols::java_lang_InternalError(), "unrecognized type", NULL);
533 }
534 }
535
536 static const char OBJ_SIG[] = "Ljava/lang/Object;";
537 enum { OBJ_SIG_LEN = 18 };
538
539 bool MethodHandles::is_basic_type_signature(Symbol* sig) {
540 assert(vmSymbols::object_signature()->utf8_length() == (int)OBJ_SIG_LEN, "");
541 assert(vmSymbols::object_signature()->equals(OBJ_SIG), "");
542 for (SignatureStream ss(sig, sig->starts_with(JVM_SIGNATURE_FUNC)); !ss.is_done(); ss.next()) {
543 switch (ss.type()) {
544 case T_OBJECT:
545 // only java/lang/Object is valid here
546 if (strncmp((char*) ss.raw_bytes(), OBJ_SIG, OBJ_SIG_LEN) != 0)
547 return false;
548 break;
549 case T_VOID:
550 case T_INT: case T_LONG: case T_FLOAT: case T_DOUBLE:
551 break;
552 default:
553 // subword types (T_BYTE etc.), Q-descriptors, arrays
554 return false;
555 }
556 }
557 return true;
558 }
559
560 Symbol* MethodHandles::lookup_basic_type_signature(Symbol* sig, bool keep_last_arg, TRAPS) {
561 Symbol* bsig = NULL;
562 if (sig == NULL) {
563 return sig;
564 } else if (is_basic_type_signature(sig)) {
565 sig->increment_refcount();
566 return sig; // that was easy
567 } else if (!sig->starts_with(JVM_SIGNATURE_FUNC)) {
568 BasicType bt = Signature::basic_type(sig);
569 if (is_subword_type(bt)) {
570 bsig = vmSymbols::int_signature();
571 } else {
572 assert(is_reference_type(bt), "is_basic_type_signature was false");
573 bsig = vmSymbols::object_signature();
574 }
575 } else {
576 ResourceMark rm;
577 stringStream buffer(128);
578 buffer.put(JVM_SIGNATURE_FUNC);
579 int arg_pos = 0, keep_arg_pos = -1;
580 if (keep_last_arg)
581 keep_arg_pos = ArgumentCount(sig).size() - 1;
582 for (SignatureStream ss(sig); !ss.is_done(); ss.next()) {
583 BasicType bt = ss.type();
584 size_t this_arg_pos = buffer.size();
585 if (ss.at_return_type()) {
586 buffer.put(JVM_SIGNATURE_ENDFUNC);
587 }
588 if (arg_pos == keep_arg_pos) {
591 } else if (is_reference_type(bt)) {
592 buffer.write(OBJ_SIG, OBJ_SIG_LEN);
593 } else {
594 if (is_subword_type(bt))
595 bt = T_INT;
596 buffer.put(type2char(bt));
597 }
598 arg_pos++;
599 }
600 const char* sigstr = buffer.base();
601 int siglen = (int) buffer.size();
602 bsig = SymbolTable::new_symbol(sigstr, siglen);
603 }
604 assert(is_basic_type_signature(bsig) ||
605 // detune assert in case the injected argument is not a basic type:
606 keep_last_arg, "");
607 return bsig;
608 }
609
610 void MethodHandles::print_as_basic_type_signature_on(outputStream* st,
611 Symbol* sig) {
612 st = st ? st : tty;
613 bool prev_type = false;
614 bool is_method = (sig->char_at(0) == JVM_SIGNATURE_FUNC);
615 if (is_method) st->put(JVM_SIGNATURE_FUNC);
616 for (SignatureStream ss(sig, is_method); !ss.is_done(); ss.next()) {
617 if (ss.at_return_type())
618 st->put(JVM_SIGNATURE_ENDFUNC);
619 else if (prev_type)
620 st->put(',');
621 const char* cp = (const char*) ss.raw_bytes();
622 if (ss.is_array()) {
623 st->put(JVM_SIGNATURE_ARRAY);
624 if (ss.array_prefix_length() == 1)
625 st->put(cp[1]);
626 else
627 st->put(JVM_SIGNATURE_CLASS);
628 } else {
629 st->put(cp[0]);
630 }
631 }
632 }
633
634
635
636 static oop object_java_mirror() {
637 return SystemDictionary::Object_klass()->java_mirror();
638 }
639
640 oop MethodHandles::field_name_or_null(Symbol* s) {
641 if (s == NULL) return NULL;
642 return StringTable::lookup(s);
643 }
644
645 oop MethodHandles::field_signature_type_or_null(Symbol* s) {
646 if (s == NULL) return NULL;
647 BasicType bt = Signature::basic_type(s);
648 if (is_java_primitive(bt)) {
649 assert(s->utf8_length() == 1, "");
650 return java_lang_Class::primitive_mirror(bt);
651 }
652 // Here are some more short cuts for common types.
653 // They are optional, since reference types can be resolved lazily.
654 if (bt == T_OBJECT) {
655 if (s == vmSymbols::object_signature()) {
656 return object_java_mirror();
657 } else if (s == vmSymbols::class_signature()) {
658 return SystemDictionary::Class_klass()->java_mirror();
659 } else if (s == vmSymbols::string_signature()) {
660 return SystemDictionary::String_klass()->java_mirror();
661 }
662 }
663 return NULL;
664 }
665
666
667 // An unresolved member name is a mere symbolic reference.
913 int skip, objArrayHandle results, TRAPS) {
914 // %%% take caller into account!
915
916 Thread* thread = Thread::current();
917
918 if (k == NULL || !k->is_instance_klass()) return -1;
919
920 int rfill = 0, rlimit = results->length(), rskip = skip;
921 // overflow measurement:
922 int overflow = 0, overflow_limit = MAX2(1000, rlimit);
923
924 int match_flags = mflags;
925 bool search_superc = ((match_flags & SEARCH_SUPERCLASSES) != 0);
926 bool search_intfc = ((match_flags & SEARCH_INTERFACES) != 0);
927 bool local_only = !(search_superc | search_intfc);
928
929 if (name != NULL) {
930 if (name->utf8_length() == 0) return 0; // a match is not possible
931 }
932 if (sig != NULL) {
933 if (sig->starts_with(JVM_SIGNATURE_FUNC))
934 match_flags &= ~(IS_FIELD | IS_TYPE);
935 else
936 match_flags &= ~(IS_CONSTRUCTOR | IS_METHOD);
937 }
938
939 if ((match_flags & IS_TYPE) != 0) {
940 // NYI, and Core Reflection works quite well for this query
941 }
942
943 if ((match_flags & IS_FIELD) != 0) {
944 InstanceKlass* ik = InstanceKlass::cast(k);
945 for (FieldStream st(ik, local_only, !search_intfc); !st.eos(); st.next()) {
946 if (name != NULL && st.name() != name)
947 continue;
948 if (sig != NULL && st.signature() != sig)
949 continue;
950 // passed the filters
951 if (rskip > 0) {
952 --rskip;
953 } else if (rfill < rlimit) {
|