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.BMHSpecies 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.BMHSpecies 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 }