Mercurial > hg > graal-compiler
comparison src/cpu/zero/vm/cppInterpreter_zero.cpp @ 6926:a3e2f723f2a5
8000780: make Zero build and run with JDK8
Reviewed-by: coleenp, dholmes, twisti
Contributed-by: Roman Kennke <rkennke@redhat.com>
author | twisti |
---|---|
date | Mon, 29 Oct 2012 11:08:48 -0700 |
parents | da91efe96a93 |
children | 2cd5e15048e6 |
comparison
equal
deleted
inserted
replaced
6915:a516debe2cee | 6926:a3e2f723f2a5 |
---|---|
178 // Jump into the OSR method | 178 // Jump into the OSR method |
179 Interpreter::invoke_osr( | 179 Interpreter::invoke_osr( |
180 method, istate->osr_entry(), istate->osr_buf(), THREAD); | 180 method, istate->osr_entry(), istate->osr_buf(), THREAD); |
181 return; | 181 return; |
182 } | 182 } |
183 else if (istate->msg() == BytecodeInterpreter::call_method_handle) { | |
184 oop method_handle = istate->callee(); | |
185 | |
186 // Trim back the stack to put the parameters at the top | |
187 stack->set_sp(istate->stack() + 1); | |
188 | |
189 // Make the call | |
190 process_method_handle(method_handle, THREAD); | |
191 fixup_after_potential_safepoint(); | |
192 | |
193 // Convert the result | |
194 istate->set_stack(stack->sp() - 1); | |
195 | |
196 // Restore the stack | |
197 stack->set_sp(istate->stack_limit() + 1); | |
198 | |
199 // Resume the interpreter | |
200 istate->set_msg(BytecodeInterpreter::method_resume); | |
201 } | |
202 else { | 183 else { |
203 ShouldNotReachHere(); | 184 ShouldNotReachHere(); |
204 } | 185 } |
205 } | 186 } |
206 | 187 |
533 break; | 514 break; |
534 } | 515 } |
535 if (entry->is_volatile()) { | 516 if (entry->is_volatile()) { |
536 switch (entry->flag_state()) { | 517 switch (entry->flag_state()) { |
537 case ctos: | 518 case ctos: |
538 SET_LOCALS_INT(object->char_field_acquire(entry->f2()), 0); | 519 SET_LOCALS_INT(object->char_field_acquire(entry->f2_as_index()), 0); |
539 break; | 520 break; |
540 | 521 |
541 case btos: | 522 case btos: |
542 SET_LOCALS_INT(object->byte_field_acquire(entry->f2()), 0); | 523 SET_LOCALS_INT(object->byte_field_acquire(entry->f2_as_index()), 0); |
543 break; | 524 break; |
544 | 525 |
545 case stos: | 526 case stos: |
546 SET_LOCALS_INT(object->short_field_acquire(entry->f2()), 0); | 527 SET_LOCALS_INT(object->short_field_acquire(entry->f2_as_index()), 0); |
547 break; | 528 break; |
548 | 529 |
549 case itos: | 530 case itos: |
550 SET_LOCALS_INT(object->int_field_acquire(entry->f2()), 0); | 531 SET_LOCALS_INT(object->int_field_acquire(entry->f2_as_index()), 0); |
551 break; | 532 break; |
552 | 533 |
553 case ltos: | 534 case ltos: |
554 SET_LOCALS_LONG(object->long_field_acquire(entry->f2()), 0); | 535 SET_LOCALS_LONG(object->long_field_acquire(entry->f2_as_index()), 0); |
555 break; | 536 break; |
556 | 537 |
557 case ftos: | 538 case ftos: |
558 SET_LOCALS_FLOAT(object->float_field_acquire(entry->f2()), 0); | 539 SET_LOCALS_FLOAT(object->float_field_acquire(entry->f2_as_index()), 0); |
559 break; | 540 break; |
560 | 541 |
561 case dtos: | 542 case dtos: |
562 SET_LOCALS_DOUBLE(object->double_field_acquire(entry->f2()), 0); | 543 SET_LOCALS_DOUBLE(object->double_field_acquire(entry->f2_as_index()), 0); |
563 break; | 544 break; |
564 | 545 |
565 case atos: | 546 case atos: |
566 SET_LOCALS_OBJECT(object->obj_field_acquire(entry->f2()), 0); | 547 SET_LOCALS_OBJECT(object->obj_field_acquire(entry->f2_as_index()), 0); |
567 break; | 548 break; |
568 | 549 |
569 default: | 550 default: |
570 ShouldNotReachHere(); | 551 ShouldNotReachHere(); |
571 } | 552 } |
572 } | 553 } |
573 else { | 554 else { |
574 switch (entry->flag_state()) { | 555 switch (entry->flag_state()) { |
575 case ctos: | 556 case ctos: |
576 SET_LOCALS_INT(object->char_field(entry->f2()), 0); | 557 SET_LOCALS_INT(object->char_field(entry->f2_as_index()), 0); |
577 break; | 558 break; |
578 | 559 |
579 case btos: | 560 case btos: |
580 SET_LOCALS_INT(object->byte_field(entry->f2()), 0); | 561 SET_LOCALS_INT(object->byte_field(entry->f2_as_index()), 0); |
581 break; | 562 break; |
582 | 563 |
583 case stos: | 564 case stos: |
584 SET_LOCALS_INT(object->short_field(entry->f2()), 0); | 565 SET_LOCALS_INT(object->short_field(entry->f2_as_index()), 0); |
585 break; | 566 break; |
586 | 567 |
587 case itos: | 568 case itos: |
588 SET_LOCALS_INT(object->int_field(entry->f2()), 0); | 569 SET_LOCALS_INT(object->int_field(entry->f2_as_index()), 0); |
589 break; | 570 break; |
590 | 571 |
591 case ltos: | 572 case ltos: |
592 SET_LOCALS_LONG(object->long_field(entry->f2()), 0); | 573 SET_LOCALS_LONG(object->long_field(entry->f2_as_index()), 0); |
593 break; | 574 break; |
594 | 575 |
595 case ftos: | 576 case ftos: |
596 SET_LOCALS_FLOAT(object->float_field(entry->f2()), 0); | 577 SET_LOCALS_FLOAT(object->float_field(entry->f2_as_index()), 0); |
597 break; | 578 break; |
598 | 579 |
599 case dtos: | 580 case dtos: |
600 SET_LOCALS_DOUBLE(object->double_field(entry->f2()), 0); | 581 SET_LOCALS_DOUBLE(object->double_field(entry->f2_as_index()), 0); |
601 break; | 582 break; |
602 | 583 |
603 case atos: | 584 case atos: |
604 SET_LOCALS_OBJECT(object->obj_field(entry->f2()), 0); | 585 SET_LOCALS_OBJECT(object->obj_field(entry->f2_as_index()), 0); |
605 break; | 586 break; |
606 | 587 |
607 default: | 588 default: |
608 ShouldNotReachHere(); | 589 ShouldNotReachHere(); |
609 } | 590 } |
625 // Pop our parameters | 606 // Pop our parameters |
626 stack->set_sp(stack->sp() + method->size_of_parameters()); | 607 stack->set_sp(stack->sp() + method->size_of_parameters()); |
627 | 608 |
628 // No deoptimized frames on the stack | 609 // No deoptimized frames on the stack |
629 return 0; | 610 return 0; |
630 } | |
631 | |
632 int CppInterpreter::method_handle_entry(Method* method, | |
633 intptr_t UNUSED, TRAPS) { | |
634 JavaThread *thread = (JavaThread *) THREAD; | |
635 ZeroStack *stack = thread->zero_stack(); | |
636 int argument_slots = method->size_of_parameters(); | |
637 int result_slots = type2size[result_type_of(method)]; | |
638 intptr_t *vmslots = stack->sp(); | |
639 intptr_t *unwind_sp = vmslots + argument_slots; | |
640 | |
641 // Find the MethodType | |
642 address p = (address) method; | |
643 for (jint* pc = method->method_type_offsets_chain(); (*pc) != -1; pc++) { | |
644 p = *(address*)(p + (*pc)); | |
645 } | |
646 oop method_type = (oop) p; | |
647 | |
648 // The MethodHandle is in the slot after the arguments | |
649 int num_vmslots = argument_slots - 1; | |
650 oop method_handle = VMSLOTS_OBJECT(num_vmslots); | |
651 | |
652 // InvokeGeneric requires some extra shuffling | |
653 oop mhtype = java_lang_invoke_MethodHandle::type(method_handle); | |
654 bool is_exact = mhtype == method_type; | |
655 if (!is_exact) { | |
656 if (true || // FIXME | |
657 method->intrinsic_id() == vmIntrinsics::_invokeExact) { | |
658 CALL_VM_NOCHECK_NOFIX( | |
659 SharedRuntime::throw_WrongMethodTypeException( | |
660 thread, method_type, mhtype)); | |
661 // NB all oops trashed! | |
662 assert(HAS_PENDING_EXCEPTION, "should do"); | |
663 stack->set_sp(unwind_sp); | |
664 return 0; | |
665 } | |
666 assert(method->intrinsic_id() == vmIntrinsics::_invokeGeneric, "should be"); | |
667 | |
668 // Load up an adapter from the calling type | |
669 // NB the x86 code for this (in methodHandles_x86.cpp, search for | |
670 // "genericInvoker") is really really odd. I'm hoping it's trying | |
671 // to accomodate odd VM/class library combinations I can ignore. | |
672 oop adapter = NULL; //FIXME: load the adapter from the CP cache | |
673 IF (adapter == NULL) { | |
674 CALL_VM_NOCHECK_NOFIX( | |
675 SharedRuntime::throw_WrongMethodTypeException( | |
676 thread, method_type, mhtype)); | |
677 // NB all oops trashed! | |
678 assert(HAS_PENDING_EXCEPTION, "should do"); | |
679 stack->set_sp(unwind_sp); | |
680 return 0; | |
681 } | |
682 | |
683 // Adapters are shared among form-families of method-type. The | |
684 // type being called is passed as a trusted first argument so that | |
685 // the adapter knows the actual types of its arguments and return | |
686 // values. | |
687 insert_vmslots(num_vmslots + 1, 1, THREAD); | |
688 if (HAS_PENDING_EXCEPTION) { | |
689 // NB all oops trashed! | |
690 stack->set_sp(unwind_sp); | |
691 return 0; | |
692 } | |
693 | |
694 vmslots = stack->sp(); | |
695 num_vmslots++; | |
696 SET_VMSLOTS_OBJECT(method_type, num_vmslots); | |
697 | |
698 method_handle = adapter; | |
699 } | |
700 | |
701 // Start processing | |
702 process_method_handle(method_handle, THREAD); | |
703 if (HAS_PENDING_EXCEPTION) | |
704 result_slots = 0; | |
705 | |
706 // If this is an invokeExact then the eventual callee will not | |
707 // have unwound the method handle argument so we have to do it. | |
708 // If a result is being returned the it will be above the method | |
709 // handle argument we're unwinding. | |
710 if (is_exact) { | |
711 intptr_t result[2]; | |
712 for (int i = 0; i < result_slots; i++) | |
713 result[i] = stack->pop(); | |
714 stack->pop(); | |
715 for (int i = result_slots - 1; i >= 0; i--) | |
716 stack->push(result[i]); | |
717 } | |
718 | |
719 // Check | |
720 assert(stack->sp() == unwind_sp - result_slots, "should be"); | |
721 | |
722 // No deoptimized frames on the stack | |
723 return 0; | |
724 } | |
725 | |
726 void CppInterpreter::process_method_handle(oop method_handle, TRAPS) { | |
727 JavaThread *thread = (JavaThread *) THREAD; | |
728 ZeroStack *stack = thread->zero_stack(); | |
729 intptr_t *vmslots = stack->sp(); | |
730 | |
731 bool direct_to_method = false; | |
732 BasicType src_rtype = T_ILLEGAL; | |
733 BasicType dst_rtype = T_ILLEGAL; | |
734 | |
735 MethodHandleEntry *entry = | |
736 java_lang_invoke_MethodHandle::vmentry(method_handle); | |
737 MethodHandles::EntryKind entry_kind = | |
738 (MethodHandles::EntryKind) (((intptr_t) entry) & 0xffffffff); | |
739 | |
740 Method* method = NULL; | |
741 switch (entry_kind) { | |
742 case MethodHandles::_invokestatic_mh: | |
743 direct_to_method = true; | |
744 break; | |
745 | |
746 case MethodHandles::_invokespecial_mh: | |
747 case MethodHandles::_invokevirtual_mh: | |
748 case MethodHandles::_invokeinterface_mh: | |
749 { | |
750 oop receiver = | |
751 VMSLOTS_OBJECT( | |
752 java_lang_invoke_MethodHandle::vmslots(method_handle) - 1); | |
753 if (receiver == NULL) { | |
754 stack->set_sp(calculate_unwind_sp(stack, method_handle)); | |
755 CALL_VM_NOCHECK_NOFIX( | |
756 throw_exception( | |
757 thread, vmSymbols::java_lang_NullPointerException())); | |
758 // NB all oops trashed! | |
759 assert(HAS_PENDING_EXCEPTION, "should do"); | |
760 return; | |
761 } | |
762 if (entry_kind != MethodHandles::_invokespecial_mh) { | |
763 intptr_t index = java_lang_invoke_DirectMethodHandle::vmindex(method_handle); | |
764 InstanceKlass* rcvrKlass = | |
765 (InstanceKlass *) receiver->klass(); | |
766 if (entry_kind == MethodHandles::_invokevirtual_mh) { | |
767 method = (Method*) rcvrKlass->start_of_vtable()[index]; | |
768 } | |
769 else { | |
770 oop iclass = java_lang_invoke_MethodHandle::next_target(method_handle); | |
771 itableOffsetEntry* ki = | |
772 (itableOffsetEntry *) rcvrKlass->start_of_itable(); | |
773 int i, length = rcvrKlass->itable_length(); | |
774 for (i = 0; i < length; i++, ki++ ) { | |
775 if (ki->interface_klass() == iclass) | |
776 break; | |
777 } | |
778 if (i == length) { | |
779 stack->set_sp(calculate_unwind_sp(stack, method_handle)); | |
780 CALL_VM_NOCHECK_NOFIX( | |
781 throw_exception( | |
782 thread, vmSymbols::java_lang_IncompatibleClassChangeError())); | |
783 // NB all oops trashed! | |
784 assert(HAS_PENDING_EXCEPTION, "should do"); | |
785 return; | |
786 } | |
787 itableMethodEntry* im = ki->first_method_entry(receiver->klass()); | |
788 method = im[index].method(); | |
789 if (method == NULL) { | |
790 stack->set_sp(calculate_unwind_sp(stack, method_handle)); | |
791 CALL_VM_NOCHECK_NOFIX( | |
792 throw_exception( | |
793 thread, vmSymbols::java_lang_AbstractMethodError())); | |
794 // NB all oops trashed! | |
795 assert(HAS_PENDING_EXCEPTION, "should do"); | |
796 return; | |
797 } | |
798 } | |
799 } | |
800 } | |
801 direct_to_method = true; | |
802 break; | |
803 | |
804 case MethodHandles::_bound_ref_direct_mh: | |
805 case MethodHandles::_bound_int_direct_mh: | |
806 case MethodHandles::_bound_long_direct_mh: | |
807 direct_to_method = true; | |
808 // fall through | |
809 case MethodHandles::_bound_ref_mh: | |
810 case MethodHandles::_bound_int_mh: | |
811 case MethodHandles::_bound_long_mh: | |
812 { | |
813 BasicType arg_type = T_ILLEGAL; | |
814 int arg_mask = -1; | |
815 int arg_slots = -1; | |
816 MethodHandles::get_ek_bound_mh_info( | |
817 entry_kind, arg_type, arg_mask, arg_slots); | |
818 int arg_slot = | |
819 java_lang_invoke_BoundMethodHandle::vmargslot(method_handle); | |
820 | |
821 // Create the new slot(s) | |
822 intptr_t *unwind_sp = calculate_unwind_sp(stack, method_handle); | |
823 insert_vmslots(arg_slot, arg_slots, THREAD); | |
824 if (HAS_PENDING_EXCEPTION) { | |
825 // all oops trashed | |
826 stack->set_sp(unwind_sp); | |
827 return; | |
828 } | |
829 vmslots = stack->sp(); | |
830 | |
831 // Store bound argument into new stack slot | |
832 oop arg = java_lang_invoke_BoundMethodHandle::argument(method_handle); | |
833 if (arg_type == T_OBJECT) { | |
834 assert(arg_slots == 1, "should be"); | |
835 SET_VMSLOTS_OBJECT(arg, arg_slot); | |
836 } | |
837 else { | |
838 jvalue arg_value; | |
839 arg_type = java_lang_boxing_object::get_value(arg, &arg_value); | |
840 switch (arg_type) { | |
841 case T_BOOLEAN: | |
842 SET_VMSLOTS_INT(arg_value.z, arg_slot); | |
843 break; | |
844 case T_CHAR: | |
845 SET_VMSLOTS_INT(arg_value.c, arg_slot); | |
846 break; | |
847 case T_BYTE: | |
848 SET_VMSLOTS_INT(arg_value.b, arg_slot); | |
849 break; | |
850 case T_SHORT: | |
851 SET_VMSLOTS_INT(arg_value.s, arg_slot); | |
852 break; | |
853 case T_INT: | |
854 SET_VMSLOTS_INT(arg_value.i, arg_slot); | |
855 break; | |
856 case T_FLOAT: | |
857 SET_VMSLOTS_FLOAT(arg_value.f, arg_slot); | |
858 break; | |
859 case T_LONG: | |
860 SET_VMSLOTS_LONG(arg_value.j, arg_slot + 1); | |
861 break; | |
862 case T_DOUBLE: | |
863 SET_VMSLOTS_DOUBLE(arg_value.d, arg_slot + 1); | |
864 break; | |
865 default: | |
866 tty->print_cr("unhandled type %s", type2name(arg_type)); | |
867 ShouldNotReachHere(); | |
868 } | |
869 } | |
870 } | |
871 break; | |
872 | |
873 case MethodHandles::_adapter_retype_only: | |
874 case MethodHandles::_adapter_retype_raw: | |
875 src_rtype = result_type_of_handle( | |
876 java_lang_invoke_MethodHandle::next_target(method_handle)); | |
877 dst_rtype = result_type_of_handle(method_handle); | |
878 break; | |
879 | |
880 case MethodHandles::_adapter_check_cast: | |
881 { | |
882 int arg_slot = | |
883 java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); | |
884 oop arg = VMSLOTS_OBJECT(arg_slot); | |
885 if (arg != NULL) { | |
886 Klass* objKlassOop = arg->klass(); | |
887 Klass* klassOf = java_lang_Class::as_Klass( | |
888 java_lang_invoke_AdapterMethodHandle::argument(method_handle)); | |
889 | |
890 if (objKlassOop != klassOf && | |
891 !objKlassOop->is_subtype_of(klassOf)) { | |
892 ResourceMark rm(THREAD); | |
893 const char* objName = Klass::cast(objKlassOop)->external_name(); | |
894 const char* klassName = Klass::cast(klassOf)->external_name(); | |
895 char* message = SharedRuntime::generate_class_cast_message( | |
896 objName, klassName); | |
897 | |
898 stack->set_sp(calculate_unwind_sp(stack, method_handle)); | |
899 CALL_VM_NOCHECK_NOFIX( | |
900 throw_exception( | |
901 thread, vmSymbols::java_lang_ClassCastException(), message)); | |
902 // NB all oops trashed! | |
903 assert(HAS_PENDING_EXCEPTION, "should do"); | |
904 return; | |
905 } | |
906 } | |
907 } | |
908 break; | |
909 | |
910 case MethodHandles::_adapter_dup_args: | |
911 { | |
912 int arg_slot = | |
913 java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); | |
914 int conv = | |
915 java_lang_invoke_AdapterMethodHandle::conversion(method_handle); | |
916 int num_slots = -MethodHandles::adapter_conversion_stack_move(conv); | |
917 assert(num_slots > 0, "should be"); | |
918 | |
919 // Create the new slot(s) | |
920 intptr_t *unwind_sp = calculate_unwind_sp(stack, method_handle); | |
921 stack->overflow_check(num_slots, THREAD); | |
922 if (HAS_PENDING_EXCEPTION) { | |
923 // all oops trashed | |
924 stack->set_sp(unwind_sp); | |
925 return; | |
926 } | |
927 | |
928 // Duplicate the arguments | |
929 for (int i = num_slots - 1; i >= 0; i--) | |
930 stack->push(*VMSLOTS_SLOT(arg_slot + i)); | |
931 | |
932 vmslots = stack->sp(); // unused, but let the compiler figure that out | |
933 } | |
934 break; | |
935 | |
936 case MethodHandles::_adapter_drop_args: | |
937 { | |
938 int arg_slot = | |
939 java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); | |
940 int conv = | |
941 java_lang_invoke_AdapterMethodHandle::conversion(method_handle); | |
942 int num_slots = MethodHandles::adapter_conversion_stack_move(conv); | |
943 assert(num_slots > 0, "should be"); | |
944 | |
945 remove_vmslots(arg_slot, num_slots, THREAD); // doesn't trap | |
946 vmslots = stack->sp(); // unused, but let the compiler figure that out | |
947 } | |
948 break; | |
949 | |
950 case MethodHandles::_adapter_opt_swap_1: | |
951 case MethodHandles::_adapter_opt_swap_2: | |
952 case MethodHandles::_adapter_opt_rot_1_up: | |
953 case MethodHandles::_adapter_opt_rot_1_down: | |
954 case MethodHandles::_adapter_opt_rot_2_up: | |
955 case MethodHandles::_adapter_opt_rot_2_down: | |
956 { | |
957 int arg1 = | |
958 java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); | |
959 int conv = | |
960 java_lang_invoke_AdapterMethodHandle::conversion(method_handle); | |
961 int arg2 = MethodHandles::adapter_conversion_vminfo(conv); | |
962 | |
963 int swap_bytes = 0, rotate = 0; | |
964 MethodHandles::get_ek_adapter_opt_swap_rot_info( | |
965 entry_kind, swap_bytes, rotate); | |
966 int swap_slots = swap_bytes >> LogBytesPerWord; | |
967 | |
968 intptr_t tmp; | |
969 switch (rotate) { | |
970 case 0: // swap | |
971 for (int i = 0; i < swap_slots; i++) { | |
972 tmp = *VMSLOTS_SLOT(arg1 + i); | |
973 SET_VMSLOTS_SLOT(VMSLOTS_SLOT(arg2 + i), arg1 + i); | |
974 SET_VMSLOTS_SLOT(&tmp, arg2 + i); | |
975 } | |
976 break; | |
977 | |
978 case 1: // up | |
979 assert(arg1 - swap_slots > arg2, "should be"); | |
980 | |
981 tmp = *VMSLOTS_SLOT(arg1); | |
982 for (int i = arg1 - swap_slots; i >= arg2; i--) | |
983 SET_VMSLOTS_SLOT(VMSLOTS_SLOT(i), i + swap_slots); | |
984 SET_VMSLOTS_SLOT(&tmp, arg2); | |
985 | |
986 break; | |
987 | |
988 case -1: // down | |
989 assert(arg2 - swap_slots > arg1, "should be"); | |
990 | |
991 tmp = *VMSLOTS_SLOT(arg1); | |
992 for (int i = arg1 + swap_slots; i <= arg2; i++) | |
993 SET_VMSLOTS_SLOT(VMSLOTS_SLOT(i), i - swap_slots); | |
994 SET_VMSLOTS_SLOT(&tmp, arg2); | |
995 break; | |
996 | |
997 default: | |
998 ShouldNotReachHere(); | |
999 } | |
1000 } | |
1001 break; | |
1002 | |
1003 case MethodHandles::_adapter_opt_i2l: | |
1004 { | |
1005 int arg_slot = | |
1006 java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); | |
1007 int arg = VMSLOTS_INT(arg_slot); | |
1008 intptr_t *unwind_sp = calculate_unwind_sp(stack, method_handle); | |
1009 insert_vmslots(arg_slot, 1, THREAD); | |
1010 if (HAS_PENDING_EXCEPTION) { | |
1011 // all oops trashed | |
1012 stack->set_sp(unwind_sp); | |
1013 return; | |
1014 } | |
1015 vmslots = stack->sp(); | |
1016 arg_slot++; | |
1017 SET_VMSLOTS_LONG(arg, arg_slot); | |
1018 } | |
1019 break; | |
1020 | |
1021 case MethodHandles::_adapter_opt_unboxi: | |
1022 case MethodHandles::_adapter_opt_unboxl: | |
1023 { | |
1024 int arg_slot = | |
1025 java_lang_invoke_AdapterMethodHandle::vmargslot(method_handle); | |
1026 oop arg = VMSLOTS_OBJECT(arg_slot); | |
1027 jvalue arg_value; | |
1028 if (arg == NULL) { | |
1029 // queue a nullpointer exception for the caller | |
1030 stack->set_sp(calculate_unwind_sp(stack, method_handle)); | |
1031 CALL_VM_NOCHECK_NOFIX( | |
1032 throw_exception( | |
1033 thread, vmSymbols::java_lang_NullPointerException())); | |
1034 // NB all oops trashed! | |
1035 assert(HAS_PENDING_EXCEPTION, "should do"); | |
1036 return; | |
1037 } | |
1038 BasicType arg_type = java_lang_boxing_object::get_value(arg, &arg_value); | |
1039 if (arg_type == T_LONG || arg_type == T_DOUBLE) { | |
1040 intptr_t *unwind_sp = calculate_unwind_sp(stack, method_handle); | |
1041 insert_vmslots(arg_slot, 1, THREAD); | |
1042 if (HAS_PENDING_EXCEPTION) { | |
1043 // all oops trashed | |
1044 stack->set_sp(unwind_sp); | |
1045 return; | |
1046 } | |
1047 vmslots = stack->sp(); | |
1048 arg_slot++; | |
1049 } | |
1050 switch (arg_type) { | |
1051 case T_BOOLEAN: | |
1052 SET_VMSLOTS_INT(arg_value.z, arg_slot); | |
1053 break; | |
1054 case T_CHAR: | |
1055 SET_VMSLOTS_INT(arg_value.c, arg_slot); | |
1056 break; | |
1057 case T_BYTE: | |
1058 SET_VMSLOTS_INT(arg_value.b, arg_slot); | |
1059 break; | |
1060 case T_SHORT: | |
1061 SET_VMSLOTS_INT(arg_value.s, arg_slot); | |
1062 break; | |
1063 case T_INT: | |
1064 SET_VMSLOTS_INT(arg_value.i, arg_slot); | |
1065 break; | |
1066 case T_FLOAT: | |
1067 SET_VMSLOTS_FLOAT(arg_value.f, arg_slot); | |
1068 break; | |
1069 case T_LONG: | |
1070 SET_VMSLOTS_LONG(arg_value.j, arg_slot); | |
1071 break; | |
1072 case T_DOUBLE: | |
1073 SET_VMSLOTS_DOUBLE(arg_value.d, arg_slot); | |
1074 break; | |
1075 default: | |
1076 tty->print_cr("unhandled type %s", type2name(arg_type)); | |
1077 ShouldNotReachHere(); | |
1078 } | |
1079 } | |
1080 break; | |
1081 | |
1082 default: | |
1083 tty->print_cr("unhandled entry_kind %s", | |
1084 MethodHandles::entry_name(entry_kind)); | |
1085 ShouldNotReachHere(); | |
1086 } | |
1087 | |
1088 // Continue along the chain | |
1089 if (direct_to_method) { | |
1090 if (method == NULL) { | |
1091 method = | |
1092 (Method*) java_lang_invoke_MethodHandle::vmtarget(method_handle); | |
1093 } | |
1094 address entry_point = method->from_interpreted_entry(); | |
1095 Interpreter::invoke_method(method, entry_point, THREAD); | |
1096 } | |
1097 else { | |
1098 process_method_handle( | |
1099 java_lang_invoke_MethodHandle::next_target(method_handle), THREAD); | |
1100 } | |
1101 // NB all oops now trashed | |
1102 | |
1103 // Adapt the result type, if necessary | |
1104 if (src_rtype != dst_rtype && !HAS_PENDING_EXCEPTION) { | |
1105 switch (dst_rtype) { | |
1106 case T_VOID: | |
1107 for (int i = 0; i < type2size[src_rtype]; i++) | |
1108 stack->pop(); | |
1109 return; | |
1110 | |
1111 case T_INT: | |
1112 switch (src_rtype) { | |
1113 case T_VOID: | |
1114 stack->overflow_check(1, CHECK); | |
1115 stack->push(0); | |
1116 return; | |
1117 | |
1118 case T_BOOLEAN: | |
1119 case T_CHAR: | |
1120 case T_BYTE: | |
1121 case T_SHORT: | |
1122 return; | |
1123 } | |
1124 // INT results sometimes need narrowing | |
1125 case T_BOOLEAN: | |
1126 case T_CHAR: | |
1127 case T_BYTE: | |
1128 case T_SHORT: | |
1129 switch (src_rtype) { | |
1130 case T_INT: | |
1131 return; | |
1132 } | |
1133 } | |
1134 | |
1135 tty->print_cr("unhandled conversion:"); | |
1136 tty->print_cr("src_rtype = %s", type2name(src_rtype)); | |
1137 tty->print_cr("dst_rtype = %s", type2name(dst_rtype)); | |
1138 ShouldNotReachHere(); | |
1139 } | |
1140 } | 611 } |
1141 | 612 |
1142 // The new slots will be inserted before slot insert_before. | 613 // The new slots will be inserted before slot insert_before. |
1143 // Slots < insert_before will have the same slot number after the insert. | 614 // Slots < insert_before will have the same slot number after the insert. |
1144 // Slots >= insert_before will become old_slot + num_slots. | 615 // Slots >= insert_before will become old_slot + num_slots. |
1378 | 849 |
1379 case Interpreter::abstract: | 850 case Interpreter::abstract: |
1380 entry_point = ((InterpreterGenerator*) this)->generate_abstract_entry(); | 851 entry_point = ((InterpreterGenerator*) this)->generate_abstract_entry(); |
1381 break; | 852 break; |
1382 | 853 |
1383 case Interpreter::method_handle: | |
1384 entry_point = ((InterpreterGenerator*) this)->generate_method_handle_entry(); | |
1385 break; | |
1386 | |
1387 case Interpreter::java_lang_math_sin: | 854 case Interpreter::java_lang_math_sin: |
1388 case Interpreter::java_lang_math_cos: | 855 case Interpreter::java_lang_math_cos: |
1389 case Interpreter::java_lang_math_tan: | 856 case Interpreter::java_lang_math_tan: |
1390 case Interpreter::java_lang_math_abs: | 857 case Interpreter::java_lang_math_abs: |
1391 case Interpreter::java_lang_math_log: | 858 case Interpreter::java_lang_math_log: |
1392 case Interpreter::java_lang_math_log10: | 859 case Interpreter::java_lang_math_log10: |
1393 case Interpreter::java_lang_math_sqrt: | 860 case Interpreter::java_lang_math_sqrt: |
861 case Interpreter::java_lang_math_pow: | |
862 case Interpreter::java_lang_math_exp: | |
1394 entry_point = ((InterpreterGenerator*) this)->generate_math_entry(kind); | 863 entry_point = ((InterpreterGenerator*) this)->generate_math_entry(kind); |
1395 break; | 864 break; |
1396 | 865 |
1397 case Interpreter::java_lang_ref_reference_get: | 866 case Interpreter::java_lang_ref_reference_get: |
1398 entry_point = ((InterpreterGenerator*)this)->generate_Reference_get_entry(); | 867 entry_point = ((InterpreterGenerator*)this)->generate_Reference_get_entry(); |