1 /*
2 * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package java.lang.invoke;
27
28 import java.util.Arrays;
29 import static java.lang.invoke.LambdaForm.*;
30 import static java.lang.invoke.MethodHandleStatics.*;
31
32 /**
33 * A method handle whose invocation behavior is determined by a target.
34 * The delegating MH itself can hold extra "intentions" beyond the simple behavior.
35 * @author jrose
36 */
37 /*non-public*/
38 abstract class DelegatingMethodHandle extends MethodHandle {
39 protected DelegatingMethodHandle(MethodHandle target) {
40 this(target.type(), target);
41 }
42
43 protected DelegatingMethodHandle(MethodType type, MethodHandle target) {
44 super(type, chooseDelegatingForm(target));
45 }
46
47 protected DelegatingMethodHandle(MethodType type, LambdaForm form) {
48 super(type, form);
49 }
50
51 /** Define this to extract the delegated target which supplies the invocation behavior. */
52 abstract protected MethodHandle getTarget();
53
54 @Override
55 abstract MethodHandle asTypeUncached(MethodType newType);
56
57 @Override
58 MemberName internalMemberName() {
59 return getTarget().internalMemberName();
60 }
61
62 @Override
63 boolean isInvokeSpecial() {
64 return getTarget().isInvokeSpecial();
65 }
66
67 @Override
68 Class<?> internalCallerClass() {
69 return getTarget().internalCallerClass();
70 }
71
72 @Override
73 MethodHandle copyWith(MethodType mt, LambdaForm lf) {
74 // FIXME: rethink 'copyWith' protocol; it is too low-level for use on all MHs
75 throw newIllegalArgumentException("do not use this");
76 }
77
78 @Override
79 String internalProperties() {
80 return "\n& Class="+getClass().getSimpleName()+
81 "\n& Target="+getTarget().debugString();
82 }
83
84 @Override
85 BoundMethodHandle rebind() {
86 return getTarget().rebind();
87 }
88
89 private static LambdaForm chooseDelegatingForm(MethodHandle target) {
90 if (target instanceof SimpleMethodHandle)
91 return target.internalForm(); // no need for an indirection
92 return makeReinvokerForm(target, MethodTypeForm.LF_DELEGATE, DelegatingMethodHandle.class, NF_getTarget);
93 }
94
95 static LambdaForm makeReinvokerForm(MethodHandle target,
96 int whichCache,
97 Object constraint,
98 NamedFunction getTargetFn) {
99 String debugString;
100 switch(whichCache) {
101 case MethodTypeForm.LF_REBIND: debugString = "BMH.reinvoke"; break;
102 case MethodTypeForm.LF_DELEGATE: debugString = "MH.delegate"; break;
103 default: debugString = "MH.reinvoke"; break;
104 }
105 // No pre-action needed.
106 return makeReinvokerForm(target, whichCache, constraint, debugString, true, getTargetFn, null);
107 }
108 /** Create a LF which simply reinvokes a target of the given basic type. */
109 static LambdaForm makeReinvokerForm(MethodHandle target,
110 int whichCache,
111 Object constraint,
112 String debugString,
113 boolean forceInline,
114 NamedFunction getTargetFn,
115 NamedFunction preActionFn) {
116 MethodType mtype = target.type().basicType();
117 boolean customized = (whichCache < 0 ||
118 mtype.parameterSlotCount() > MethodType.MAX_MH_INVOKER_ARITY);
119 boolean hasPreAction = (preActionFn != null);
120 LambdaForm form;
121 if (!customized) {
122 form = mtype.form().cachedLambdaForm(whichCache);
123 if (form != null) return form;
124 }
125 final int THIS_DMH = 0;
126 final int ARG_BASE = 1;
127 final int ARG_LIMIT = ARG_BASE + mtype.parameterCount();
128 int nameCursor = ARG_LIMIT;
129 final int PRE_ACTION = hasPreAction ? nameCursor++ : -1;
130 final int NEXT_MH = customized ? -1 : nameCursor++;
131 final int REINVOKE = nameCursor++;
132 LambdaForm.Name[] names = LambdaForm.arguments(nameCursor - ARG_LIMIT, mtype.invokerType());
133 assert(names.length == nameCursor);
134 names[THIS_DMH] = names[THIS_DMH].withConstraint(constraint);
135 Object[] targetArgs;
136 if (hasPreAction) {
137 names[PRE_ACTION] = new LambdaForm.Name(preActionFn, names[THIS_DMH]);
138 }
139 if (customized) {
140 targetArgs = Arrays.copyOfRange(names, ARG_BASE, ARG_LIMIT, Object[].class);
141 names[REINVOKE] = new LambdaForm.Name(target, targetArgs); // the invoker is the target itself
142 } else {
143 names[NEXT_MH] = new LambdaForm.Name(getTargetFn, names[THIS_DMH]);
144 targetArgs = Arrays.copyOfRange(names, THIS_DMH, ARG_LIMIT, Object[].class);
145 targetArgs[0] = names[NEXT_MH]; // overwrite this MH with next MH
146 names[REINVOKE] = new LambdaForm.Name(mtype, targetArgs);
147 }
148 form = new LambdaForm(debugString, ARG_LIMIT, names, forceInline);
149 if (!customized) {
150 form = mtype.form().setCachedLambdaForm(whichCache, form);
151 }
152 return form;
153 }
154
155 static final NamedFunction NF_getTarget;
156 static {
157 try {
158 NF_getTarget = new NamedFunction(DelegatingMethodHandle.class
159 .getDeclaredMethod("getTarget"));
160 } catch (ReflectiveOperationException ex) {
161 throw newInternalError(ex);
162 }
163 }
164 }