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/oop.inline.hpp"
32#include "prims/methodHandles.hpp"
33
34void MethodHandles::invoke_target(Method* method, TRAPS) {
35
36  JavaThread *thread = (JavaThread *) THREAD;
37  ZeroStack *stack = thread->zero_stack();
38  InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame();
39  interpreterState istate = frame->interpreter_state();
40
41  // Trim back the stack to put the parameters at the top
42  stack->set_sp(istate->stack() + 1);
43
44  Interpreter::invoke_method(method, method->from_interpreted_entry(), THREAD);
45
46  // Convert the result
47  istate->set_stack(stack->sp() - 1);
48
49}
50
51oop MethodHandles::popFromStack(TRAPS) {
52
53  JavaThread *thread = (JavaThread *) THREAD;
54  InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame();
55  interpreterState istate = frame->interpreter_state();
56  intptr_t* topOfStack = istate->stack();
57
58  oop top = STACK_OBJECT(-1);
59  MORE_STACK(-1);
60  istate->set_stack(topOfStack);
61
62  return top;
63
64}
65
66int MethodHandles::method_handle_entry_invokeBasic(Method* method, intptr_t UNUSED, TRAPS) {
67
68  JavaThread *thread = (JavaThread *) THREAD;
69  InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame();
70  interpreterState istate = frame->interpreter_state();
71  intptr_t* topOfStack = istate->stack();
72
73  // 'this' is a MethodHandle. We resolve the target method by accessing this.form.vmentry.vmtarget.
74  int numArgs = method->size_of_parameters();
75  oop lform1 = java_lang_invoke_MethodHandle::form(STACK_OBJECT(-numArgs)); // this.form
76  oop vmEntry1 = java_lang_invoke_LambdaForm::vmentry(lform1);
77  Method* vmtarget = (Method*) java_lang_invoke_MemberName::vmtarget(vmEntry1);
78
79  invoke_target(vmtarget, THREAD);
80
81  // No deoptimized frames on the stack
82  return 0;
83}
84
85int MethodHandles::method_handle_entry_linkToStaticOrSpecial(Method* method, intptr_t UNUSED, TRAPS) {
86
87  // Pop appendix argument from stack. This is a MemberName which we resolve to the
88  // target method.
89  oop vmentry = popFromStack(THREAD);
90
91  Method* vmtarget = (Method*) java_lang_invoke_MemberName::vmtarget(vmentry);
92
93  invoke_target(vmtarget, THREAD);
94
95  return 0;
96}
97
98int MethodHandles::method_handle_entry_linkToInterface(Method* method, intptr_t UNUSED, TRAPS) {
99  JavaThread *thread = (JavaThread *) THREAD;
100  InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame();
101  interpreterState istate = frame->interpreter_state();
102
103  // Pop appendix argument from stack. This is a MemberName which we resolve to the
104  // target method.
105  oop vmentry = popFromStack(THREAD);
106  intptr_t* topOfStack = istate->stack();
107
108  // Resolve target method by looking up in the receiver object's itable.
109  Klass* clazz = java_lang_Class::as_Klass(java_lang_invoke_MemberName::clazz(vmentry));
110  intptr_t vmindex = java_lang_invoke_MemberName::vmindex(vmentry);
111  Method* target = (Method*) java_lang_invoke_MemberName::vmtarget(vmentry);
112
113  int numArgs = target->size_of_parameters();
114  oop recv = STACK_OBJECT(-numArgs);
115
116  InstanceKlass* klass_part = InstanceKlass::cast(recv->klass());
117  itableOffsetEntry* ki = (itableOffsetEntry*) klass_part->start_of_itable();
118  int i;
119  for ( i = 0 ; i < klass_part->itable_length() ; i++, ki++ ) {
120    if (ki->interface_klass() == clazz) break;
121  }
122
123  itableMethodEntry* im = ki->first_method_entry(recv->klass());
124  Method* vmtarget = im[vmindex].method();
125
126  invoke_target(vmtarget, THREAD);
127
128  return 0;
129}
130
131int MethodHandles::method_handle_entry_linkToVirtual(Method* method, intptr_t UNUSED, TRAPS) {
132  JavaThread *thread = (JavaThread *) THREAD;
133
134  InterpreterFrame *frame = thread->top_zero_frame()->as_interpreter_frame();
135  interpreterState istate = frame->interpreter_state();
136
137  // Pop appendix argument from stack. This is a MemberName which we resolve to the
138  // target method.
139  oop vmentry = popFromStack(THREAD);
140  intptr_t* topOfStack = istate->stack();
141
142  // Resolve target method by looking up in the receiver object's vtable.
143  intptr_t vmindex = java_lang_invoke_MemberName::vmindex(vmentry);
144  Method* target = (Method*) java_lang_invoke_MemberName::vmtarget(vmentry);
145  int numArgs = target->size_of_parameters();
146  oop recv = STACK_OBJECT(-numArgs);
147  Klass* clazz = recv->klass();
148  Klass* klass_part = InstanceKlass::cast(clazz);
149  ResourceMark rm(THREAD);
150  klassVtable vtable = klass_part->vtable();
151  Method* vmtarget = vtable.method_at(vmindex);
152
153  invoke_target(vmtarget, THREAD);
154
155  return 0;
156}
157
158int MethodHandles::method_handle_entry_invalid(Method* method, intptr_t UNUSED, TRAPS) {
159  ShouldNotReachHere();
160  return 0;
161}
162
163address MethodHandles::generate_method_handle_interpreter_entry(MacroAssembler* masm,
164                                                                vmIntrinsics::ID iid) {
165  switch (iid) {
166  case vmIntrinsics::_invokeGeneric:
167  case vmIntrinsics::_compiledLambdaForm:
168    // Perhaps surprisingly, the symbolic references visible to Java are not directly used.
169    // They are linked to Java-generated adapters via MethodHandleNatives.linkMethod.
170    // They all allow an appendix argument.
171    return CppInterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_invalid);
172  case vmIntrinsics::_invokeBasic:
173    return CppInterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_invokeBasic);
174  case vmIntrinsics::_linkToStatic:
175  case vmIntrinsics::_linkToSpecial:
176    return CppInterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_linkToStaticOrSpecial);
177  case vmIntrinsics::_linkToInterface:
178    return CppInterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_linkToInterface);
179  case vmIntrinsics::_linkToVirtual:
180    return CppInterpreterGenerator::generate_entry_impl(masm, (address) MethodHandles::method_handle_entry_linkToVirtual);
181  default:
182    ShouldNotReachHere();
183    return NULL;
184  }
185}
186