1 /*
   2  * Copyright (c) 1997, 2018, 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