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 }