1 /* 2 * Copyright (c) 1997, 2017, Oracle and/or its affiliates. All rights reserved. 3 * Copyright 2009, 2010, 2011 Red Hat, Inc. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 * 24 */ 25 26 #include "precompiled.hpp" 27 #include "interpreter/cppInterpreterGenerator.hpp" 28 #include "interpreter/interpreter.hpp" 29 #include "memory/allocation.inline.hpp" 30 #include "memory/resourceArea.hpp" 31 #include "oops/method.inline.hpp" 32 #include "oops/oop.inline.hpp" 33 #include "runtime/frame.inline.hpp" 34 #include "prims/methodHandles.hpp" 35 36 void MethodHandles::invoke_target(Method* method, TRAPS) { 37 38 JavaThread *thread = (JavaThread *) THREAD; 39 ZeroStack *stack = thread->zero_stack(); 40 InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); 41 interpreterState istate = frame->interpreter_state(); 42 43 // Trim back the stack to put the parameters at the top 44 stack->set_sp(istate->stack() + 1); 45 46 Interpreter::invoke_method(method, method->from_interpreted_entry(), THREAD); 47 48 // Convert the result 49 istate->set_stack(stack->sp() - 1); 50 51 } 52 53 oop MethodHandles::popFromStack(TRAPS) { 54 55 JavaThread *thread = (JavaThread *) THREAD; 56 InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); 57 interpreterState istate = frame->interpreter_state(); 58 intptr_t* topOfStack = istate->stack(); 59 60 oop top = STACK_OBJECT(-1); 61 MORE_STACK(-1); 62 istate->set_stack(topOfStack); 63 64 return top; 65 66 } 67 68 int MethodHandles::method_handle_entry_invokeBasic(Method* method, intptr_t UNUSED, TRAPS) { 69 70 JavaThread *thread = (JavaThread *) THREAD; 71 InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); 72 interpreterState istate = frame->interpreter_state(); 73 intptr_t* topOfStack = istate->stack(); 74 75 // 'this' is a MethodHandle. We resolve the target method by accessing this.form.vmentry.vmtarget. 76 int numArgs = method->size_of_parameters(); 77 oop lform1 = java_lang_invoke_MethodHandle::form(STACK_OBJECT(-numArgs)); // this.form 78 oop vmEntry1 = java_lang_invoke_LambdaForm::vmentry(lform1); 79 Method* vmtarget = (Method*) java_lang_invoke_MemberName::vmtarget(vmEntry1); 80 81 invoke_target(vmtarget, THREAD); 82 83 // No deoptimized frames on the stack 84 return 0; 85 } 86 87 int MethodHandles::method_handle_entry_linkToStaticOrSpecial(Method* method, intptr_t UNUSED, TRAPS) { 88 89 // Pop appendix argument from stack. This is a MemberName which we resolve to the 90 // target method. 91 oop vmentry = popFromStack(THREAD); 92 93 Method* vmtarget = (Method*) java_lang_invoke_MemberName::vmtarget(vmentry); 94 95 invoke_target(vmtarget, THREAD); 96 97 return 0; 98 } 99 100 int MethodHandles::method_handle_entry_linkToInterface(Method* method, intptr_t UNUSED, TRAPS) { 101 JavaThread *thread = (JavaThread *) THREAD; 102 InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); 103 interpreterState istate = frame->interpreter_state(); 104 105 // Pop appendix argument from stack. This is a MemberName which we resolve to the 106 // target method. 107 oop vmentry = popFromStack(THREAD); 108 intptr_t* topOfStack = istate->stack(); 109 110 // Resolve target method by looking up in the receiver object's itable. 111 Klass* clazz = java_lang_Class::as_Klass(java_lang_invoke_MemberName::clazz(vmentry)); 112 intptr_t vmindex = java_lang_invoke_MemberName::vmindex(vmentry); 113 Method* target = (Method*) java_lang_invoke_MemberName::vmtarget(vmentry); 114 115 int numArgs = target->size_of_parameters(); 116 oop recv = STACK_OBJECT(-numArgs); 117 118 InstanceKlass* klass_part = InstanceKlass::cast(recv->klass()); 119 itableOffsetEntry* ki = (itableOffsetEntry*) klass_part->start_of_itable(); 120 int i; 121 for ( i = 0 ; i < klass_part->itable_length() ; i++, ki++ ) { 122 if (ki->interface_klass() == clazz) break; 123 } 124 125 itableMethodEntry* im = ki->first_method_entry(recv->klass()); 126 Method* vmtarget = im[vmindex].method(); 127 128 invoke_target(vmtarget, THREAD); 129 130 return 0; 131 } 132 133 int MethodHandles::method_handle_entry_linkToVirtual(Method* method, intptr_t UNUSED, TRAPS) { 134 JavaThread *thread = (JavaThread *) THREAD; 135 136 InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame(); 137 interpreterState istate = frame->interpreter_state(); 138 139 // Pop appendix argument from stack. This is a MemberName which we resolve to the 140 // target method. 141 oop vmentry = popFromStack(THREAD); 142 intptr_t* topOfStack = istate->stack(); 143 144 // Resolve target method by looking up in the receiver object's vtable. 145 intptr_t vmindex = java_lang_invoke_MemberName::vmindex(vmentry); 146 Method* target = (Method*) java_lang_invoke_MemberName::vmtarget(vmentry); 147 int numArgs = target->size_of_parameters(); 148 oop recv = STACK_OBJECT(-numArgs); 149 Klass* clazz = recv->klass(); 150 Klass* klass_part = InstanceKlass::cast(clazz); 151 ResourceMark rm(THREAD); 152 klassVtable vtable = klass_part->vtable(); 153 Method* vmtarget = vtable.method_at(vmindex); 154 155 invoke_target(vmtarget, THREAD); 156 157 return 0; 158 } 159 160 int MethodHandles::method_handle_entry_invalid(Method* method, intptr_t UNUSED, TRAPS) { 161 ShouldNotReachHere(); 162 return 0; 163 } 164 165 address MethodHandles::generate_method_handle_interpreter_entry(MacroAssembler* masm, 166 vmIntrinsics::ID iid) { 167 switch (iid) { 168 case vmIntrinsics::_invokeGeneric: 169 case vmIntrinsics::_compiledLambdaForm: 170 // Perhaps surprisingly, the symbolic references visible to Java are not directly used. 171 // They are linked to Java-generated adapters via MethodHandleNatives.linkMethod. 172 // They all allow an appendix argument. 173 return CppInterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_invalid); 174 case vmIntrinsics::_invokeBasic: 175 return CppInterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_invokeBasic); 176 case vmIntrinsics::_linkToStatic: 177 case vmIntrinsics::_linkToSpecial: 178 return CppInterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_linkToStaticOrSpecial); 179 case vmIntrinsics::_linkToInterface: 180 return CppInterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_linkToInterface); 181 case vmIntrinsics::_linkToVirtual: 182 return CppInterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_linkToVirtual); 183 default: 184 ShouldNotReachHere(); 185 return NULL; 186 } 187 } 188 189 #ifndef PRODUCT 190 void MethodHandles::trace_method_handle(MacroAssembler* _masm, const char* adaptername) { 191 // This is just a stub. 192 } 193 #endif //PRODUCT