2674 MutexLocker mu(AdapterHandlerLibrary_lock);
2675 // make sure data structure is initialized
2676 initialize();
2677
2678 if (method->is_abstract()) {
2679 return _abstract_method_handler;
2680 }
2681
2682 // Fill in the signature array, for the calling-convention call.
2683 GrowableArray<SigEntry> sig_extended;
2684 {
2685 MutexUnlocker mul(AdapterHandlerLibrary_lock);
2686 Thread* THREAD = Thread::current();
2687 Klass* holder = method->method_holder();
2688 GrowableArray<BasicType> sig_bt_tmp;
2689
2690 int i = 0;
2691 if (!method->is_static()) { // Pass in receiver first
2692 if (holder->is_value()) {
2693 ValueKlass* vk = ValueKlass::cast(holder);
2694 if (!ValueTypePassFieldsAsArgs || vk->is__Value()) {
2695 // If we don't pass value types as arguments or if the holder of
2696 // the method is __Value, we must pass a reference.
2697 sig_extended.push(SigEntry(T_VALUETYPEPTR));
2698 } else {
2699 const Array<SigEntry>* sig_vk = vk->extended_sig();
2700 sig_extended.appendAll(sig_vk);
2701 }
2702 } else {
2703 sig_extended.push(SigEntry(T_OBJECT));
2704 }
2705 }
2706 for (SignatureStream ss(method->signature()); !ss.at_return_type(); ss.next()) {
2707 if (ss.type() == T_VALUETYPE) {
2708 Symbol* name = ss.as_symbol(CHECK_NULL);
2709 if (!ValueTypePassFieldsAsArgs || (name == vmSymbols::java_lang____Value())) {
2710 sig_extended.push(SigEntry(T_VALUETYPEPTR));
2711 } else {
2712 // Method handle intrinsics with a __Value argument may be created during
2713 // compilation. Only do a full system dictionary lookup if the argument name
2714 // is not __Value, to avoid lookups from the compiler thread.
2715 Klass* k = ss.as_klass(Handle(THREAD, holder->class_loader()),
2716 Handle(THREAD, holder->protection_domain()),
2717 SignatureStream::ReturnNull, CHECK_NULL);
2718 const Array<SigEntry>* sig_vk = ValueKlass::cast(k)->extended_sig();
2719 sig_extended.appendAll(sig_vk);
2720 }
2721 } else {
2722 sig_extended.push(SigEntry(ss.type()));
2723 if (ss.type() == T_LONG || ss.type() == T_DOUBLE) {
2724 sig_extended.push(SigEntry(T_VOID));
2725 }
2726 }
2727 }
2728 }
2729
2934 // Fill in the signature array, for the calling-convention call.
2935 const int total_args_passed = method->size_of_parameters();
2936
2937 BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, total_args_passed);
2938 VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, total_args_passed);
2939 int i=0;
2940 if (!method->is_static()) // Pass in receiver first
2941 sig_bt[i++] = T_OBJECT;
2942 SignatureStream ss(method->signature());
2943 for (; !ss.at_return_type(); ss.next()) {
2944 BasicType bt = ss.type();
2945 if (bt == T_VALUETYPE) {
2946 #ifdef ASSERT
2947 Thread* THREAD = Thread::current();
2948 // Avoid class loading from compiler thread
2949 if (THREAD->can_call_java()) {
2950 Handle class_loader(THREAD, method->method_holder()->class_loader());
2951 Handle protection_domain(THREAD, method->method_holder()->protection_domain());
2952 Klass* k = ss.as_klass(class_loader, protection_domain, SignatureStream::ReturnNull, THREAD);
2953 assert(k != NULL && !HAS_PENDING_EXCEPTION, "can't resolve klass");
2954 assert(ValueKlass::cast(k)->is__Value(), "other values not supported");
2955 }
2956 #endif
2957 bt = T_VALUETYPEPTR;
2958 }
2959 sig_bt[i++] = bt; // Collect remaining bits of signature
2960 if (ss.type() == T_LONG || ss.type() == T_DOUBLE)
2961 sig_bt[i++] = T_VOID; // Longs & doubles take 2 Java slots
2962 }
2963 assert(i == total_args_passed, "");
2964 BasicType ret_type = ss.type();
2965
2966 // Now get the compiled-Java layout as input (or output) arguments.
2967 // NOTE: Stubs for compiled entry points of method handle intrinsics
2968 // are just trampolines so the argument registers must be outgoing ones.
2969 const bool is_outgoing = method->is_method_handle_intrinsic();
2970 int comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, is_outgoing);
2971
2972 // Generate the compiled-to-native wrapper code
2973 nm = SharedRuntime::generate_native_wrapper(&_masm, method, compile_id, sig_bt, regs, ret_type);
2974
3034 s++; len--; // Skip opening paren
3035
3036 BasicType *sig_bt = NEW_RESOURCE_ARRAY(BasicType, 256);
3037 VMRegPair *regs = NEW_RESOURCE_ARRAY(VMRegPair, 256);
3038 int cnt = 0;
3039 if (has_receiver) {
3040 sig_bt[cnt++] = T_OBJECT; // Receiver is argument 0; not in signature
3041 }
3042
3043 while (*s != ')') { // Find closing right paren
3044 switch (*s++) { // Switch on signature character
3045 case 'B': sig_bt[cnt++] = T_BYTE; break;
3046 case 'C': sig_bt[cnt++] = T_CHAR; break;
3047 case 'D': sig_bt[cnt++] = T_DOUBLE; sig_bt[cnt++] = T_VOID; break;
3048 case 'F': sig_bt[cnt++] = T_FLOAT; break;
3049 case 'I': sig_bt[cnt++] = T_INT; break;
3050 case 'J': sig_bt[cnt++] = T_LONG; sig_bt[cnt++] = T_VOID; break;
3051 case 'S': sig_bt[cnt++] = T_SHORT; break;
3052 case 'Z': sig_bt[cnt++] = T_BOOLEAN; break;
3053 case 'V': sig_bt[cnt++] = T_VOID; break;
3054 case 'Q':
3055 case 'L': // Oop
3056 while (*s++ != ';'); // Skip signature
3057 sig_bt[cnt++] = T_OBJECT;
3058 break;
3059 case '[': { // Array
3060 do { // Skip optional size
3061 while (*s >= '0' && *s <= '9') s++;
3062 } while (*s++ == '['); // Nested arrays?
3063 // Skip element type
3064 if (s[-1] == 'L' || s[-1] == 'Q')
3065 while (*s++ != ';'); // Skip signature
3066 sig_bt[cnt++] = T_ARRAY;
3067 break;
3068 }
3069 default : ShouldNotReachHere();
3070 }
3071 }
3072
3073 if (has_appendix) {
3074 sig_bt[cnt++] = T_OBJECT;
3075 }
3076
3077 assert(cnt < 256, "grow table size");
3078
3079 int comp_args_on_stack;
3080 comp_args_on_stack = java_calling_convention(sig_bt, regs, cnt, true);
3081
3082 // the calling convention doesn't count out_preserve_stack_slots so
3083 // we must add that in to get "true" stack offsets.
3084
3488 vk->save_oop_fields(reg_map, handles);
3489
3490 // It's unsafe to safepoint until we are here
3491
3492 Handle new_vt;
3493 JRT_BLOCK;
3494 {
3495 Thread* THREAD = thread;
3496 oop vt = vk->realloc_result(reg_map, handles, callerFrame.is_interpreted_frame(), CHECK);
3497 new_vt = Handle(thread, vt);
3498
3499 #ifdef ASSERT
3500 javaVFrame* vf = javaVFrame::cast(vframe::new_vframe(&callerFrame, ®_map, thread));
3501 Method* m = vf->method();
3502 int bci = vf->bci();
3503 Bytecode_invoke inv(m, bci);
3504
3505 methodHandle callee = inv.static_target(thread);
3506 assert(!thread->has_pending_exception(), "call resolution should work");
3507 ValueKlass* verif_vk2 = callee->returned_value_type(thread);
3508 assert(verif_vk == verif_vk2 || verif_vk2->is__Value(), "Bad value klass");
3509 #endif
3510 }
3511 JRT_BLOCK_END;
3512
3513 thread->set_vm_result(new_vt());
3514 }
3515 JRT_END
3516
|
2674 MutexLocker mu(AdapterHandlerLibrary_lock);
2675 // make sure data structure is initialized
2676 initialize();
2677
2678 if (method->is_abstract()) {
2679 return _abstract_method_handler;
2680 }
2681
2682 // Fill in the signature array, for the calling-convention call.
2683 GrowableArray<SigEntry> sig_extended;
2684 {
2685 MutexUnlocker mul(AdapterHandlerLibrary_lock);
2686 Thread* THREAD = Thread::current();
2687 Klass* holder = method->method_holder();
2688 GrowableArray<BasicType> sig_bt_tmp;
2689
2690 int i = 0;
2691 if (!method->is_static()) { // Pass in receiver first
2692 if (holder->is_value()) {
2693 ValueKlass* vk = ValueKlass::cast(holder);
2694 if (!ValueTypePassFieldsAsArgs) {
2695 // If we don't pass value types as arguments or if the holder of
2696 // the method is __Value, we must pass a reference.
2697 sig_extended.push(SigEntry(T_VALUETYPEPTR));
2698 } else {
2699 const Array<SigEntry>* sig_vk = vk->extended_sig();
2700 sig_extended.appendAll(sig_vk);
2701 }
2702 } else {
2703 sig_extended.push(SigEntry(T_OBJECT));
2704 }
2705 }
2706 for (SignatureStream ss(method->signature()); !ss.at_return_type(); ss.next()) {
2707 if (ss.type() == T_VALUETYPE) {
2708 Symbol* name = ss.as_symbol(CHECK_NULL);
2709 if (!ValueTypePassFieldsAsArgs) {
2710 sig_extended.push(SigEntry(T_VALUETYPEPTR));
2711 } else {
2712 // Method handle intrinsics with a __Value argument may be created during
2713 // compilation. Only do a full system dictionary lookup if the argument name
2714 // is not __Value, to avoid lookups from the compiler thread.
2715 Klass* k = ss.as_klass(Handle(THREAD, holder->class_loader()),
2716 Handle(THREAD, holder->protection_domain()),
2717 SignatureStream::ReturnNull, CHECK_NULL);
2718 const Array<SigEntry>* sig_vk = ValueKlass::cast(k)->extended_sig();
2719 sig_extended.appendAll(sig_vk);
2720 }
2721 } else {
2722 sig_extended.push(SigEntry(ss.type()));
2723 if (ss.type() == T_LONG || ss.type() == T_DOUBLE) {
2724 sig_extended.push(SigEntry(T_VOID));
2725 }
2726 }
2727 }
2728 }
2729
2934 // Fill in the signature array, for the calling-convention call.
2935 const int total_args_passed = method->size_of_parameters();
2936
2937 BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, total_args_passed);
2938 VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, total_args_passed);
2939 int i=0;
2940 if (!method->is_static()) // Pass in receiver first
2941 sig_bt[i++] = T_OBJECT;
2942 SignatureStream ss(method->signature());
2943 for (; !ss.at_return_type(); ss.next()) {
2944 BasicType bt = ss.type();
2945 if (bt == T_VALUETYPE) {
2946 #ifdef ASSERT
2947 Thread* THREAD = Thread::current();
2948 // Avoid class loading from compiler thread
2949 if (THREAD->can_call_java()) {
2950 Handle class_loader(THREAD, method->method_holder()->class_loader());
2951 Handle protection_domain(THREAD, method->method_holder()->protection_domain());
2952 Klass* k = ss.as_klass(class_loader, protection_domain, SignatureStream::ReturnNull, THREAD);
2953 assert(k != NULL && !HAS_PENDING_EXCEPTION, "can't resolve klass");
2954 }
2955 #endif
2956 bt = T_VALUETYPEPTR;
2957 }
2958 sig_bt[i++] = bt; // Collect remaining bits of signature
2959 if (ss.type() == T_LONG || ss.type() == T_DOUBLE)
2960 sig_bt[i++] = T_VOID; // Longs & doubles take 2 Java slots
2961 }
2962 assert(i == total_args_passed, "");
2963 BasicType ret_type = ss.type();
2964
2965 // Now get the compiled-Java layout as input (or output) arguments.
2966 // NOTE: Stubs for compiled entry points of method handle intrinsics
2967 // are just trampolines so the argument registers must be outgoing ones.
2968 const bool is_outgoing = method->is_method_handle_intrinsic();
2969 int comp_args_on_stack = SharedRuntime::java_calling_convention(sig_bt, regs, total_args_passed, is_outgoing);
2970
2971 // Generate the compiled-to-native wrapper code
2972 nm = SharedRuntime::generate_native_wrapper(&_masm, method, compile_id, sig_bt, regs, ret_type);
2973
3033 s++; len--; // Skip opening paren
3034
3035 BasicType *sig_bt = NEW_RESOURCE_ARRAY(BasicType, 256);
3036 VMRegPair *regs = NEW_RESOURCE_ARRAY(VMRegPair, 256);
3037 int cnt = 0;
3038 if (has_receiver) {
3039 sig_bt[cnt++] = T_OBJECT; // Receiver is argument 0; not in signature
3040 }
3041
3042 while (*s != ')') { // Find closing right paren
3043 switch (*s++) { // Switch on signature character
3044 case 'B': sig_bt[cnt++] = T_BYTE; break;
3045 case 'C': sig_bt[cnt++] = T_CHAR; break;
3046 case 'D': sig_bt[cnt++] = T_DOUBLE; sig_bt[cnt++] = T_VOID; break;
3047 case 'F': sig_bt[cnt++] = T_FLOAT; break;
3048 case 'I': sig_bt[cnt++] = T_INT; break;
3049 case 'J': sig_bt[cnt++] = T_LONG; sig_bt[cnt++] = T_VOID; break;
3050 case 'S': sig_bt[cnt++] = T_SHORT; break;
3051 case 'Z': sig_bt[cnt++] = T_BOOLEAN; break;
3052 case 'V': sig_bt[cnt++] = T_VOID; break;
3053 case 'L': // Oop
3054 while (*s++ != ';'); // Skip signature
3055 sig_bt[cnt++] = T_OBJECT;
3056 break;
3057 case '[': { // Array
3058 do { // Skip optional size
3059 while (*s >= '0' && *s <= '9') s++;
3060 } while (*s++ == '['); // Nested arrays?
3061 // Skip element type
3062 if (s[-1] == 'L')
3063 while (*s++ != ';'); // Skip signature
3064 sig_bt[cnt++] = T_ARRAY;
3065 break;
3066 }
3067 default : ShouldNotReachHere();
3068 }
3069 }
3070
3071 if (has_appendix) {
3072 sig_bt[cnt++] = T_OBJECT;
3073 }
3074
3075 assert(cnt < 256, "grow table size");
3076
3077 int comp_args_on_stack;
3078 comp_args_on_stack = java_calling_convention(sig_bt, regs, cnt, true);
3079
3080 // the calling convention doesn't count out_preserve_stack_slots so
3081 // we must add that in to get "true" stack offsets.
3082
3486 vk->save_oop_fields(reg_map, handles);
3487
3488 // It's unsafe to safepoint until we are here
3489
3490 Handle new_vt;
3491 JRT_BLOCK;
3492 {
3493 Thread* THREAD = thread;
3494 oop vt = vk->realloc_result(reg_map, handles, callerFrame.is_interpreted_frame(), CHECK);
3495 new_vt = Handle(thread, vt);
3496
3497 #ifdef ASSERT
3498 javaVFrame* vf = javaVFrame::cast(vframe::new_vframe(&callerFrame, ®_map, thread));
3499 Method* m = vf->method();
3500 int bci = vf->bci();
3501 Bytecode_invoke inv(m, bci);
3502
3503 methodHandle callee = inv.static_target(thread);
3504 assert(!thread->has_pending_exception(), "call resolution should work");
3505 ValueKlass* verif_vk2 = callee->returned_value_type(thread);
3506 assert(verif_vk == verif_vk2, "Bad value klass");
3507 #endif
3508 }
3509 JRT_BLOCK_END;
3510
3511 thread->set_vm_result(new_vt());
3512 }
3513 JRT_END
3514
|