1 /*
2 * Copyright (c) 2008, 2016, 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 jdk.internal.vm.annotation.DontInline;
29 import jdk.internal.vm.annotation.ForceInline;
30 import jdk.internal.vm.annotation.Stable;
31
32 import java.lang.reflect.Array;
33 import java.util.Arrays;
34
35 import static java.lang.invoke.MethodHandleStatics.*;
36 import static java.lang.invoke.MethodHandleNatives.Constants.*;
37 import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;
38 import static java.lang.invoke.LambdaForm.*;
39 import static java.lang.invoke.LambdaForm.Kind.*;
40
41 /**
42 * Construction and caching of often-used invokers.
43 * @author jrose
44 */
45 class Invokers {
46 // exact type (sans leading target MH) for the outgoing call
47 private final MethodType targetType;
48
49 // Cached adapter information:
50 private final @Stable MethodHandle[] invokers = new MethodHandle[INV_LIMIT];
51 // Indexes into invokers:
52 static final int
53 INV_EXACT = 0, // MethodHandles.exactInvoker
54 INV_GENERIC = 1, // MethodHandles.invoker (generic invocation)
55 INV_BASIC = 2, // MethodHandles.basicInvoker
56 INV_LIMIT = 3;
57
58 /** Compute and cache information common to all collecting adapters
59 * that implement members of the erasure-family of the given erased type.
60 */
61 /*non-public*/ Invokers(MethodType targetType) {
62 this.targetType = targetType;
63 }
64
65 /*non-public*/ MethodHandle exactInvoker() {
66 MethodHandle invoker = cachedInvoker(INV_EXACT);
67 if (invoker != null) return invoker;
68 invoker = makeExactOrGeneralInvoker(true);
69 return setCachedInvoker(INV_EXACT, invoker);
70 }
71
72 /*non-public*/ MethodHandle genericInvoker() {
73 MethodHandle invoker = cachedInvoker(INV_GENERIC);
74 if (invoker != null) return invoker;
75 invoker = makeExactOrGeneralInvoker(false);
76 return setCachedInvoker(INV_GENERIC, invoker);
77 }
78
79 /*non-public*/ MethodHandle basicInvoker() {
80 MethodHandle invoker = cachedInvoker(INV_BASIC);
81 if (invoker != null) return invoker;
82 MethodType basicType = targetType.basicType();
83 if (basicType != targetType) {
84 // double cache; not used significantly
85 return setCachedInvoker(INV_BASIC, basicType.invokers().basicInvoker());
86 }
87 invoker = basicType.form().cachedMethodHandle(MethodTypeForm.MH_BASIC_INV);
88 if (invoker == null) {
89 MemberName method = invokeBasicMethod(basicType);
90 invoker = DirectMethodHandle.make(method);
91 assert(checkInvoker(invoker));
92 invoker = basicType.form().setCachedMethodHandle(MethodTypeForm.MH_BASIC_INV, invoker);
93 }
94 return setCachedInvoker(INV_BASIC, invoker);
95 }
96
97 /*non-public*/ MethodHandle varHandleMethodInvoker(VarHandle.AccessMode ak) {
98 // TODO cache invoker
99 return makeVarHandleMethodInvoker(ak, false);
100 }
101
102 /*non-public*/ MethodHandle varHandleMethodExactInvoker(VarHandle.AccessMode ak) {
103 // TODO cache invoker
104 return makeVarHandleMethodInvoker(ak, true);
105 }
106
107 private MethodHandle cachedInvoker(int idx) {
108 return invokers[idx];
109 }
110
111 private synchronized MethodHandle setCachedInvoker(int idx, final MethodHandle invoker) {
112 // Simulate a CAS, to avoid racy duplication of results.
113 MethodHandle prev = invokers[idx];
114 if (prev != null) return prev;
115 return invokers[idx] = invoker;
116 }
117
118 private MethodHandle makeExactOrGeneralInvoker(boolean isExact) {
119 MethodType mtype = targetType;
120 MethodType invokerType = mtype.invokerType();
121 int which = (isExact ? MethodTypeForm.LF_EX_INVOKER : MethodTypeForm.LF_GEN_INVOKER);
122 LambdaForm lform = invokeHandleForm(mtype, false, which);
123 MethodHandle invoker = BoundMethodHandle.bindSingle(invokerType, lform, mtype);
124 String whichName = (isExact ? "invokeExact" : "invoke");
125 invoker = invoker.withInternalMemberName(MemberName.makeMethodHandleInvoke(whichName, mtype), false);
126 assert(checkInvoker(invoker));
127 maybeCompileToBytecode(invoker);
128 return invoker;
129 }
130
131 private MethodHandle makeVarHandleMethodInvoker(VarHandle.AccessMode ak, boolean isExact) {
132 MethodType mtype = targetType;
133 MethodType invokerType = mtype.insertParameterTypes(0, VarHandle.class);
134
135 LambdaForm lform = varHandleMethodInvokerHandleForm(ak, mtype, isExact);
136 VarHandle.AccessDescriptor ad = new VarHandle.AccessDescriptor(mtype, ak.at.ordinal(), ak.ordinal());
137 MethodHandle invoker = BoundMethodHandle.bindSingle(invokerType, lform, ad);
138
139 invoker = invoker.withInternalMemberName(MemberName.makeVarHandleMethodInvoke(ak.methodName(), mtype), false);
140 assert(checkVarHandleInvoker(invoker));
141
142 maybeCompileToBytecode(invoker);
143 return invoker;
144 }
145
146 /** If the target type seems to be common enough, eagerly compile the invoker to bytecodes. */
147 private void maybeCompileToBytecode(MethodHandle invoker) {
148 final int EAGER_COMPILE_ARITY_LIMIT = 10;
149 if (targetType == targetType.erase() &&
150 targetType.parameterCount() < EAGER_COMPILE_ARITY_LIMIT) {
151 invoker.form.compileToBytecode();
152 }
153 }
154
155 // This next one is called from LambdaForm.NamedFunction.<init>.
156 /*non-public*/ static MemberName invokeBasicMethod(MethodType basicType) {
157 assert(basicType == basicType.basicType());
158 try {
159 //Lookup.findVirtual(MethodHandle.class, name, type);
160 return IMPL_LOOKUP.resolveOrFail(REF_invokeVirtual, MethodHandle.class, "invokeBasic", basicType);
161 } catch (ReflectiveOperationException ex) {
162 throw newInternalError("JVM cannot find invoker for "+basicType, ex);
163 }
164 }
165
166 private boolean checkInvoker(MethodHandle invoker) {
167 assert(targetType.invokerType().equals(invoker.type()))
168 : java.util.Arrays.asList(targetType, targetType.invokerType(), invoker);
169 assert(invoker.internalMemberName() == null ||
170 invoker.internalMemberName().getMethodType().equals(targetType));
171 assert(!invoker.isVarargsCollector());
172 return true;
173 }
174
175 private boolean checkVarHandleInvoker(MethodHandle invoker) {
176 MethodType invokerType = targetType.insertParameterTypes(0, VarHandle.class);
177 assert(invokerType.equals(invoker.type()))
178 : java.util.Arrays.asList(targetType, invokerType, invoker);
179 assert(invoker.internalMemberName() == null ||
180 invoker.internalMemberName().getMethodType().equals(targetType));
181 assert(!invoker.isVarargsCollector());
182 return true;
183 }
184
185 /**
186 * Find or create an invoker which passes unchanged a given number of arguments
187 * and spreads the rest from a trailing array argument.
188 * The invoker target type is the post-spread type {@code (TYPEOF(uarg*), TYPEOF(sarg*))=>RT}.
189 * All the {@code sarg}s must have a common type {@code C}. (If there are none, {@code Object} is assumed.}
190 * @param leadingArgCount the number of unchanged (non-spread) arguments
191 * @return {@code invoker.invokeExact(mh, uarg*, C[]{sarg*}) := (RT)mh.invoke(uarg*, sarg*)}
192 */
193 /*non-public*/ MethodHandle spreadInvoker(int leadingArgCount) {
194 int spreadArgCount = targetType.parameterCount() - leadingArgCount;
195 MethodType postSpreadType = targetType;
196 Class<?> argArrayType = impliedRestargType(postSpreadType, leadingArgCount);
197 if (postSpreadType.parameterSlotCount() <= MethodType.MAX_MH_INVOKER_ARITY) {
198 return genericInvoker().asSpreader(argArrayType, spreadArgCount);
199 }
200 // Cannot build a generic invoker here of type ginvoker.invoke(mh, a*[254]).
201 // Instead, factor sinvoker.invoke(mh, a) into ainvoker.invoke(filter(mh), a)
202 // where filter(mh) == mh.asSpreader(Object[], spreadArgCount)
203 MethodType preSpreadType = postSpreadType
204 .replaceParameterTypes(leadingArgCount, postSpreadType.parameterCount(), argArrayType);
205 MethodHandle arrayInvoker = MethodHandles.invoker(preSpreadType);
206 MethodHandle makeSpreader = MethodHandles.insertArguments(Lazy.MH_asSpreader, 1, argArrayType, spreadArgCount);
207 return MethodHandles.filterArgument(arrayInvoker, 0, makeSpreader);
208 }
209
210 private static Class<?> impliedRestargType(MethodType restargType, int fromPos) {
211 if (restargType.isGeneric()) return Object[].class; // can be nothing else
212 int maxPos = restargType.parameterCount();
213 if (fromPos >= maxPos) return Object[].class; // reasonable default
214 Class<?> argType = restargType.parameterType(fromPos);
215 for (int i = fromPos+1; i < maxPos; i++) {
216 if (argType != restargType.parameterType(i))
217 throw newIllegalArgumentException("need homogeneous rest arguments", restargType);
218 }
219 if (argType == Object.class) return Object[].class;
220 return Array.newInstance(argType, 0).getClass();
221 }
222
223 public String toString() {
224 return "Invokers"+targetType;
225 }
226
227 static MemberName methodHandleInvokeLinkerMethod(String name,
228 MethodType mtype,
229 Object[] appendixResult) {
230 int which;
231 switch (name) {
232 case "invokeExact": which = MethodTypeForm.LF_EX_LINKER; break;
233 case "invoke": which = MethodTypeForm.LF_GEN_LINKER; break;
234 default: throw new InternalError("not invoker: "+name);
235 }
236 LambdaForm lform;
237 if (mtype.parameterSlotCount() <= MethodType.MAX_MH_ARITY - MH_LINKER_ARG_APPENDED) {
238 lform = invokeHandleForm(mtype, false, which);
239 appendixResult[0] = mtype;
240 } else {
241 lform = invokeHandleForm(mtype, true, which);
242 }
243 return lform.vmentry;
244 }
245
246 // argument count to account for trailing "appendix value" (typically the mtype)
247 private static final int MH_LINKER_ARG_APPENDED = 1;
248
249 /** Returns an adapter for invokeExact or generic invoke, as a MH or constant pool linker.
250 * If !customized, caller is responsible for supplying, during adapter execution,
251 * a copy of the exact mtype. This is because the adapter might be generalized to
252 * a basic type.
253 * @param mtype the caller's method type (either basic or full-custom)
254 * @param customized whether to use a trailing appendix argument (to carry the mtype)
255 * @param which bit-encoded 0x01 whether it is a CP adapter ("linker") or MHs.invoker value ("invoker");
256 * 0x02 whether it is for invokeExact or generic invoke
257 */
258 static LambdaForm invokeHandleForm(MethodType mtype, boolean customized, int which) {
259 boolean isCached;
260 if (!customized) {
261 mtype = mtype.basicType(); // normalize Z to I, String to Object, etc.
262 isCached = true;
263 } else {
264 isCached = false; // maybe cache if mtype == mtype.basicType()
265 }
266 boolean isLinker, isGeneric;
267 Kind kind;
268 switch (which) {
269 case MethodTypeForm.LF_EX_LINKER: isLinker = true; isGeneric = false; kind = EXACT_LINKER; break;
270 case MethodTypeForm.LF_EX_INVOKER: isLinker = false; isGeneric = false; kind = EXACT_INVOKER; break;
271 case MethodTypeForm.LF_GEN_LINKER: isLinker = true; isGeneric = true; kind = GENERIC_LINKER; break;
272 case MethodTypeForm.LF_GEN_INVOKER: isLinker = false; isGeneric = true; kind = GENERIC_INVOKER; break;
273 default: throw new InternalError();
274 }
275 LambdaForm lform;
276 if (isCached) {
277 lform = mtype.form().cachedLambdaForm(which);
278 if (lform != null) return lform;
279 }
280 // exactInvokerForm (Object,Object)Object
281 // link with java.lang.invoke.MethodHandle.invokeBasic(MethodHandle,Object,Object)Object/invokeSpecial
282 final int THIS_MH = 0;
283 final int CALL_MH = THIS_MH + (isLinker ? 0 : 1);
284 final int ARG_BASE = CALL_MH + 1;
285 final int OUTARG_LIMIT = ARG_BASE + mtype.parameterCount();
286 final int INARG_LIMIT = OUTARG_LIMIT + (isLinker && !customized ? 1 : 0);
287 int nameCursor = OUTARG_LIMIT;
288 final int MTYPE_ARG = customized ? -1 : nameCursor++; // might be last in-argument
289 final int CHECK_TYPE = nameCursor++;
290 final int CHECK_CUSTOM = (CUSTOMIZE_THRESHOLD >= 0) ? nameCursor++ : -1;
291 final int LINKER_CALL = nameCursor++;
292 MethodType invokerFormType = mtype.invokerType();
293 if (isLinker) {
294 if (!customized)
295 invokerFormType = invokerFormType.appendParameterTypes(MemberName.class);
296 } else {
297 invokerFormType = invokerFormType.invokerType();
298 }
299 Name[] names = arguments(nameCursor - INARG_LIMIT, invokerFormType);
300 assert(names.length == nameCursor)
301 : Arrays.asList(mtype, customized, which, nameCursor, names.length);
302 if (MTYPE_ARG >= INARG_LIMIT) {
303 assert(names[MTYPE_ARG] == null);
304 BoundMethodHandle.SpeciesData speciesData = BoundMethodHandle.speciesData_L();
305 names[THIS_MH] = names[THIS_MH].withConstraint(speciesData);
306 NamedFunction getter = speciesData.getterFunction(0);
307 names[MTYPE_ARG] = new Name(getter, names[THIS_MH]);
308 // else if isLinker, then MTYPE is passed in from the caller (e.g., the JVM)
309 }
310
311 // Make the final call. If isGeneric, then prepend the result of type checking.
312 MethodType outCallType = mtype.basicType();
313 Object[] outArgs = Arrays.copyOfRange(names, CALL_MH, OUTARG_LIMIT, Object[].class);
314 Object mtypeArg = (customized ? mtype : names[MTYPE_ARG]);
315 if (!isGeneric) {
316 names[CHECK_TYPE] = new Name(getFunction(NF_checkExactType), names[CALL_MH], mtypeArg);
317 // mh.invokeExact(a*):R => checkExactType(mh, TYPEOF(a*:R)); mh.invokeBasic(a*)
318 } else {
319 names[CHECK_TYPE] = new Name(getFunction(NF_checkGenericType), names[CALL_MH], mtypeArg);
320 // mh.invokeGeneric(a*):R => checkGenericType(mh, TYPEOF(a*:R)).invokeBasic(a*)
321 outArgs[0] = names[CHECK_TYPE];
322 }
323 if (CHECK_CUSTOM != -1) {
324 names[CHECK_CUSTOM] = new Name(getFunction(NF_checkCustomized), outArgs[0]);
325 }
326 names[LINKER_CALL] = new Name(outCallType, outArgs);
327 if (customized) {
328 lform = new LambdaForm(INARG_LIMIT, names);
329 } else {
330 lform = new LambdaForm(INARG_LIMIT, names, kind);
331 }
332 if (isLinker)
333 lform.compileToBytecode(); // JVM needs a real methodOop
334 if (isCached)
335 lform = mtype.form().setCachedLambdaForm(which, lform);
336 return lform;
337 }
338
339
340 static MemberName varHandleInvokeLinkerMethod(VarHandle.AccessMode ak, MethodType mtype) {
341 LambdaForm lform;
342 if (mtype.parameterSlotCount() <= MethodType.MAX_MH_ARITY - MH_LINKER_ARG_APPENDED) {
343 lform = varHandleMethodGenericLinkerHandleForm(ak, mtype);
344 } else {
345 // TODO
346 throw newInternalError("Unsupported parameter slot count " + mtype.parameterSlotCount());
347 }
348 return lform.vmentry;
349 }
350
351 private static LambdaForm varHandleMethodGenericLinkerHandleForm(VarHandle.AccessMode ak,
352 MethodType mtype) {
353 // TODO Cache form?
354
355 final int THIS_VH = 0;
356 final int ARG_BASE = THIS_VH + 1;
357 final int ARG_LIMIT = ARG_BASE + mtype.parameterCount();
358 int nameCursor = ARG_LIMIT;
359 final int VAD_ARG = nameCursor++;
360 final int CHECK_TYPE = nameCursor++;
361 final int CHECK_CUSTOM = (CUSTOMIZE_THRESHOLD >= 0) ? nameCursor++ : -1;
362 final int LINKER_CALL = nameCursor++;
363
364 Name[] names = new Name[LINKER_CALL + 1];
365 names[THIS_VH] = argument(THIS_VH, BasicType.basicType(Object.class));
366 for (int i = 0; i < mtype.parameterCount(); i++) {
367 names[ARG_BASE + i] = argument(ARG_BASE + i, BasicType.basicType(mtype.parameterType(i)));
368 }
369 names[VAD_ARG] = new Name(ARG_LIMIT, BasicType.basicType(Object.class));
370
371 names[CHECK_TYPE] = new Name(getFunction(NF_checkVarHandleGenericType), names[THIS_VH], names[VAD_ARG]);
372
373 Object[] outArgs = new Object[ARG_LIMIT + 1];
374 outArgs[0] = names[CHECK_TYPE];
375 for (int i = 0; i < ARG_LIMIT; i++) {
376 outArgs[i + 1] = names[i];
377 }
378
379 if (CHECK_CUSTOM != -1) {
380 names[CHECK_CUSTOM] = new Name(getFunction(NF_checkCustomized), outArgs[0]);
381 }
382
383 MethodType outCallType = mtype.insertParameterTypes(0, VarHandle.class)
384 .basicType();
385 names[LINKER_CALL] = new Name(outCallType, outArgs);
386 LambdaForm lform = new LambdaForm(ARG_LIMIT + 1, names, VARHANDLE_LINKER);
387 if (LambdaForm.debugNames()) {
388 String name = ak.methodName() + ":VarHandle_invoke_MT_" +
389 shortenSignature(basicTypeSignature(mtype));
390 LambdaForm.associateWithDebugName(lform, name);
391 }
392 lform.compileToBytecode();
393 return lform;
394 }
395
396 private static LambdaForm varHandleMethodInvokerHandleForm(VarHandle.AccessMode ak,
397 MethodType mtype, boolean isExact) {
398 // TODO Cache form?
399
400 final int THIS_MH = 0;
401 final int CALL_VH = THIS_MH + 1;
402 final int ARG_BASE = CALL_VH + 1;
403 final int ARG_LIMIT = ARG_BASE + mtype.parameterCount();
404 int nameCursor = ARG_LIMIT;
405 final int VAD_ARG = nameCursor++;
406 final int CHECK_TYPE = nameCursor++;
407 final int LINKER_CALL = nameCursor++;
408
409 Name[] names = new Name[LINKER_CALL + 1];
410 names[THIS_MH] = argument(THIS_MH, BasicType.basicType(Object.class));
411 names[CALL_VH] = argument(CALL_VH, BasicType.basicType(Object.class));
412 for (int i = 0; i < mtype.parameterCount(); i++) {
413 names[ARG_BASE + i] = argument(ARG_BASE + i, BasicType.basicType(mtype.parameterType(i)));
414 }
415
416 BoundMethodHandle.SpeciesData speciesData = BoundMethodHandle.speciesData_L();
417 names[THIS_MH] = names[THIS_MH].withConstraint(speciesData);
418
419 NamedFunction getter = speciesData.getterFunction(0);
420 names[VAD_ARG] = new Name(getter, names[THIS_MH]);
421
422 if (isExact) {
423 names[CHECK_TYPE] = new Name(getFunction(NF_checkVarHandleExactType), names[CALL_VH], names[VAD_ARG]);
424 } else {
425 names[CHECK_TYPE] = new Name(getFunction(NF_checkVarHandleGenericType), names[CALL_VH], names[VAD_ARG]);
426 }
427 Object[] outArgs = new Object[ARG_LIMIT];
428 outArgs[0] = names[CHECK_TYPE];
429 for (int i = 1; i < ARG_LIMIT; i++) {
430 outArgs[i] = names[i];
431 }
432
433 MethodType outCallType = mtype.insertParameterTypes(0, VarHandle.class)
434 .basicType();
435 names[LINKER_CALL] = new Name(outCallType, outArgs);
436 Kind kind = isExact ? VARHANDLE_EXACT_INVOKER : VARHANDLE_INVOKER;
437 LambdaForm lform = new LambdaForm(ARG_LIMIT, names, kind);
438 if (LambdaForm.debugNames()) {
439 String name = ak.methodName() +
440 (isExact ? ":VarHandle_exactInvoker_" : ":VarHandle_invoker_") +
441 shortenSignature(basicTypeSignature(mtype));
442 LambdaForm.associateWithDebugName(lform, name);
443 }
444 lform.prepare();
445 return lform;
446 }
447
448 /*non-public*/ static
449 @ForceInline
450 MethodHandle checkVarHandleGenericType(VarHandle handle, VarHandle.AccessDescriptor ad) {
451 // Test for exact match on invoker types
452 // TODO match with erased types and add cast of return value to lambda form
453 MethodHandle mh = handle.getMethodHandle(ad.mode);
454 if (mh.type() == ad.symbolicMethodTypeInvoker) {
455 return mh;
456 }
457 else {
458 return mh.asType(ad.symbolicMethodTypeInvoker);
459 }
460 }
461
462 /*non-public*/ static
463 @ForceInline
464 MethodHandle checkVarHandleExactType(VarHandle handle, VarHandle.AccessDescriptor ad) {
465 MethodHandle mh = handle.getMethodHandle(ad.mode);
466 MethodType mt = mh.type();
467 if (mt != ad.symbolicMethodTypeInvoker) {
468 throw newWrongMethodTypeException(mt, ad.symbolicMethodTypeInvoker);
469 }
470 return mh;
471 }
472
473 /*non-public*/ static
474 WrongMethodTypeException newWrongMethodTypeException(MethodType actual, MethodType expected) {
475 // FIXME: merge with JVM logic for throwing WMTE
476 return new WrongMethodTypeException("expected "+expected+" but found "+actual);
477 }
478
479 /** Static definition of MethodHandle.invokeExact checking code. */
480 /*non-public*/ static
481 @ForceInline
482 void checkExactType(MethodHandle mh, MethodType expected) {
483 MethodType actual = mh.type();
484 if (actual != expected)
485 throw newWrongMethodTypeException(expected, actual);
486 }
487
488 /** Static definition of MethodHandle.invokeGeneric checking code.
489 * Directly returns the type-adjusted MH to invoke, as follows:
490 * {@code (R)MH.invoke(a*) => MH.asType(TYPEOF(a*:R)).invokeBasic(a*)}
491 */
492 /*non-public*/ static
493 @ForceInline
494 MethodHandle checkGenericType(MethodHandle mh, MethodType expected) {
495 return mh.asType(expected);
496 /* Maybe add more paths here. Possible optimizations:
497 * for (R)MH.invoke(a*),
498 * let MT0 = TYPEOF(a*:R), MT1 = MH.type
499 *
500 * if MT0==MT1 or MT1 can be safely called by MT0
501 * => MH.invokeBasic(a*)
502 * if MT1 can be safely called by MT0[R := Object]
503 * => MH.invokeBasic(a*) & checkcast(R)
504 * if MT1 can be safely called by MT0[* := Object]
505 * => checkcast(A)* & MH.invokeBasic(a*) & checkcast(R)
506 * if a big adapter BA can be pulled out of (MT0,MT1)
507 * => BA.invokeBasic(MT0,MH,a*)
508 * if a local adapter LA can cached on static CS0 = new GICS(MT0)
509 * => CS0.LA.invokeBasic(MH,a*)
510 * else
511 * => MH.asType(MT0).invokeBasic(A*)
512 */
513 }
514
515 static MemberName linkToCallSiteMethod(MethodType mtype) {
516 LambdaForm lform = callSiteForm(mtype, false);
517 return lform.vmentry;
518 }
519
520 static MemberName linkToTargetMethod(MethodType mtype) {
521 LambdaForm lform = callSiteForm(mtype, true);
522 return lform.vmentry;
523 }
524
525 // skipCallSite is true if we are optimizing a ConstantCallSite
526 private static LambdaForm callSiteForm(MethodType mtype, boolean skipCallSite) {
527 mtype = mtype.basicType(); // normalize Z to I, String to Object, etc.
528 final int which = (skipCallSite ? MethodTypeForm.LF_MH_LINKER : MethodTypeForm.LF_CS_LINKER);
529 LambdaForm lform = mtype.form().cachedLambdaForm(which);
530 if (lform != null) return lform;
531 // exactInvokerForm (Object,Object)Object
532 // link with java.lang.invoke.MethodHandle.invokeBasic(MethodHandle,Object,Object)Object/invokeSpecial
533 final int ARG_BASE = 0;
534 final int OUTARG_LIMIT = ARG_BASE + mtype.parameterCount();
535 final int INARG_LIMIT = OUTARG_LIMIT + 1;
536 int nameCursor = OUTARG_LIMIT;
537 final int APPENDIX_ARG = nameCursor++; // the last in-argument
538 final int CSITE_ARG = skipCallSite ? -1 : APPENDIX_ARG;
539 final int CALL_MH = skipCallSite ? APPENDIX_ARG : nameCursor++; // result of getTarget
540 final int LINKER_CALL = nameCursor++;
541 MethodType invokerFormType = mtype.appendParameterTypes(skipCallSite ? MethodHandle.class : CallSite.class);
542 Name[] names = arguments(nameCursor - INARG_LIMIT, invokerFormType);
543 assert(names.length == nameCursor);
544 assert(names[APPENDIX_ARG] != null);
545 if (!skipCallSite)
546 names[CALL_MH] = new Name(getFunction(NF_getCallSiteTarget), names[CSITE_ARG]);
547 // (site.)invokedynamic(a*):R => mh = site.getTarget(); mh.invokeBasic(a*)
548 final int PREPEND_MH = 0, PREPEND_COUNT = 1;
549 Object[] outArgs = Arrays.copyOfRange(names, ARG_BASE, OUTARG_LIMIT + PREPEND_COUNT, Object[].class);
550 // prepend MH argument:
551 System.arraycopy(outArgs, 0, outArgs, PREPEND_COUNT, outArgs.length - PREPEND_COUNT);
552 outArgs[PREPEND_MH] = names[CALL_MH];
553 names[LINKER_CALL] = new Name(mtype, outArgs);
554 lform = new LambdaForm(INARG_LIMIT, names,
555 (skipCallSite ? LINK_TO_TARGET_METHOD : LINK_TO_CALL_SITE));
556 lform.compileToBytecode(); // JVM needs a real methodOop
557 lform = mtype.form().setCachedLambdaForm(which, lform);
558 return lform;
559 }
560
561 /** Static definition of MethodHandle.invokeGeneric checking code. */
562 /*non-public*/ static
563 @ForceInline
564 MethodHandle getCallSiteTarget(CallSite site) {
565 return site.getTarget();
566 }
567
568 /*non-public*/ static
569 @ForceInline
570 void checkCustomized(MethodHandle mh) {
571 if (MethodHandleImpl.isCompileConstant(mh)) return;
572 if (mh.form.customized == null) {
573 maybeCustomize(mh);
574 }
575 }
576
577 /*non-public*/ static
578 @DontInline
579 void maybeCustomize(MethodHandle mh) {
580 byte count = mh.customizationCount;
581 if (count >= CUSTOMIZE_THRESHOLD) {
582 mh.customize();
583 } else {
584 mh.customizationCount = (byte)(count+1);
585 }
586 }
587
588 // Local constant functions:
589 private static final byte NF_checkExactType = 0,
590 NF_checkGenericType = 1,
591 NF_getCallSiteTarget = 2,
592 NF_checkCustomized = 3,
593 NF_checkVarHandleGenericType = 4,
594 NF_checkVarHandleExactType = 5,
595 NF_LIMIT = 6;
596
597 private static final @Stable NamedFunction[] NFS = new NamedFunction[NF_LIMIT];
598
599 private static NamedFunction getFunction(byte func) {
600 NamedFunction nf = NFS[func];
601 if (nf != null) {
602 return nf;
603 }
604 NFS[func] = nf = createFunction(func);
605 // Each nf must be statically invocable or we get tied up in our bootstraps.
606 assert(InvokerBytecodeGenerator.isStaticallyInvocable(nf));
607 return nf;
608 }
609
610 private static NamedFunction createFunction(byte func) {
611 try {
612 switch (func) {
613 case NF_checkExactType:
614 return new NamedFunction(Invokers.class
615 .getDeclaredMethod("checkExactType", MethodHandle.class, MethodType.class));
616 case NF_checkGenericType:
617 return new NamedFunction(Invokers.class
618 .getDeclaredMethod("checkGenericType", MethodHandle.class, MethodType.class));
619 case NF_getCallSiteTarget:
620 return new NamedFunction(Invokers.class
621 .getDeclaredMethod("getCallSiteTarget", CallSite.class));
622 case NF_checkCustomized:
623 return new NamedFunction(Invokers.class
624 .getDeclaredMethod("checkCustomized", MethodHandle.class));
625 case NF_checkVarHandleGenericType:
626 return new NamedFunction(Invokers.class
627 .getDeclaredMethod("checkVarHandleGenericType", VarHandle.class, VarHandle.AccessDescriptor.class));
628 case NF_checkVarHandleExactType:
629 return new NamedFunction(Invokers.class
630 .getDeclaredMethod("checkVarHandleExactType", VarHandle.class, VarHandle.AccessDescriptor.class));
631 default:
632 throw newInternalError("Unknown function: " + func);
633 }
634 } catch (ReflectiveOperationException ex) {
635 throw newInternalError(ex);
636 }
637 }
638
639 private static class Lazy {
640 private static final MethodHandle MH_asSpreader;
641
642 static {
643 try {
644 MH_asSpreader = IMPL_LOOKUP.findVirtual(MethodHandle.class, "asSpreader",
645 MethodType.methodType(MethodHandle.class, Class.class, int.class));
646 } catch (ReflectiveOperationException ex) {
647 throw newInternalError(ex);
648 }
649 }
650 }
651
652 static {
653 // The Holder class will contain pre-generated Invokers resolved
654 // speculatively using MemberName.getFactory().resolveOrNull. However, that
655 // doesn't initialize the class, which subtly breaks inlining etc. By forcing
656 // initialization of the Holder class we avoid these issues.
657 UNSAFE.ensureClassInitialized(Holder.class);
658 }
659
660 /* Placeholder class for Invokers generated ahead of time */
661 final class Holder {}
662 }