/* * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package sun.dyn; import sun.dyn.util.VerifyType; import sun.dyn.util.Wrapper; import java.dyn.*; import java.util.Arrays; import static sun.dyn.MethodHandleNatives.Constants.*; import static sun.dyn.MemberName.newIllegalArgumentException; /** * This method handle performs simple conversion or checking of a single argument. * @author jrose */ public class AdapterMethodHandle extends BoundMethodHandle { //MethodHandle vmtarget; // next AMH or BMH in chain or final DMH //Object argument; // parameter to the conversion if needed //int vmargslot; // which argument slot is affected private final int conversion; // the type of conversion: RETYPE_ONLY, etc. // Constructors in this class *must* be package scoped or private. private AdapterMethodHandle(MethodHandle target, MethodType newType, long conv, Object convArg) { super(newType, convArg, newType.parameterSlotDepth(1+convArgPos(conv))); this.conversion = convCode(conv); if (MethodHandleNatives.JVM_SUPPORT) { // JVM might update VM-specific bits of conversion (ignore) MethodHandleNatives.init(this, target, convArgPos(conv)); } } private AdapterMethodHandle(MethodHandle target, MethodType newType, long conv) { this(target, newType, conv, null); } private static final Access IMPL_TOKEN = Access.getToken(); // TO DO: When adapting another MH with a null conversion, clone // the target and change its type, instead of adding another layer. /** Can a JVM-level adapter directly implement the proposed * argument conversions, as if by MethodHandles.convertArguments? */ public static boolean canPairwiseConvert(MethodType newType, MethodType oldType) { // same number of args, of course int len = newType.parameterCount(); if (len != oldType.parameterCount()) return false; // Check return type. (Not much can be done with it.) Class exp = newType.returnType(); Class ret = oldType.returnType(); if (!VerifyType.isNullConversion(ret, exp)) return false; // Check args pairwise. for (int i = 0; i < len; i++) { Class src = newType.parameterType(i); // source type Class dst = oldType.parameterType(i); // destination type if (!canConvertArgument(src, dst)) return false; } return true; } /** Can a JVM-level adapter directly implement the proposed * argument conversion, as if by MethodHandles.convertArguments? */ public static boolean canConvertArgument(Class src, Class dst) { // ? Retool this logic to use RETYPE_ONLY, CHECK_CAST, etc., as opcodes, // so we don't need to repeat so much decision making. if (VerifyType.isNullConversion(src, dst)) { return true; } else if (src.isPrimitive()) { if (dst.isPrimitive()) return canPrimCast(src, dst); else return canBoxArgument(src, dst); } else { if (dst.isPrimitive()) return canUnboxArgument(src, dst); else return true; // any two refs can be interconverted } } /** * Create a JVM-level adapter method handle to conform the given method * handle to the similar newType, using only pairwise argument conversions. * For each argument, convert incoming argument to the exact type needed. * Only null conversions are allowed on the return value (until * the JVM supports ricochet adapters). * The argument conversions allowed are casting, unboxing, * integral widening or narrowing, and floating point widening or narrowing. * @param token access check * @param newType required call type * @param target original method handle * @return an adapter to the original handle with the desired new type, * or the original target if the types are already identical * or null if the adaptation cannot be made */ public static MethodHandle makePairwiseConvert(Access token, MethodType newType, MethodHandle target) { Access.check(token); MethodType oldType = target.type(); if (newType == oldType) return target; if (!canPairwiseConvert(newType, oldType)) return null; // (after this point, it is an assertion error to fail to convert) // Find last non-trivial conversion (if any). int lastConv = newType.parameterCount()-1; while (lastConv >= 0) { Class src = newType.parameterType(lastConv); // source type Class dst = oldType.parameterType(lastConv); // destination type if (VerifyType.isNullConversion(src, dst)) { --lastConv; } else { break; } } // Now build a chain of one or more adapters. MethodHandle adapter = target; MethodType midType = oldType.changeReturnType(newType.returnType()); for (int i = 0; i <= lastConv; i++) { Class src = newType.parameterType(i); // source type Class dst = midType.parameterType(i); // destination type if (VerifyType.isNullConversion(src, dst)) { // do nothing: difference is trivial continue; } // Work the current type backward toward the desired caller type: if (i != lastConv) { midType = midType.changeParameterType(i, src); } else { // When doing the last (or only) real conversion, // force all remaining null conversions to happen also. assert(VerifyType.isNullConversion(newType, midType.changeParameterType(i, src))); midType = newType; } // Tricky case analysis follows. // It parallels canConvertArgument() above. if (src.isPrimitive()) { if (dst.isPrimitive()) { adapter = makePrimCast(token, midType, adapter, i, dst); } else { adapter = makeBoxArgument(token, midType, adapter, i, dst); } } else { if (dst.isPrimitive()) { // Caller has boxed a primitive. Unbox it for the target. // The box type must correspond exactly to the primitive type. // This is simpler than the powerful set of widening // conversions supported by reflect.Method.invoke. // Those conversions require a big nest of if/then/else logic, // which we prefer to make a user responsibility. adapter = makeUnboxArgument(token, midType, adapter, i, dst); } else { // Simple reference conversion. // Note: Do not check for a class hierarchy relation // between src and dst. In all cases a 'null' argument // will pass the cast conversion. adapter = makeCheckCast(token, midType, adapter, i, dst); } } assert(adapter != null); assert(adapter.type() == midType); } if (adapter.type() != newType) { // Only trivial conversions remain. adapter = makeRetypeOnly(IMPL_TOKEN, newType, adapter); assert(adapter != null); // Actually, that's because there were no non-trivial ones: assert(lastConv == -1); } assert(adapter.type() == newType); return adapter; } /** * Create a JVM-level adapter method handle to permute the arguments * of the given method. * @param token access check * @param newType required call type * @param target original method handle * @param argumentMap for each target argument, position of its source in newType * @return an adapter to the original handle with the desired new type, * or the original target if the types are already identical * and the permutation is null * @throws IllegalArgumentException if the adaptation cannot be made * directly by a JVM-level adapter, without help from Java code */ public static MethodHandle makePermutation(Access token, MethodType newType, MethodHandle target, int[] argumentMap) { MethodType oldType = target.type(); boolean nullPermutation = true; for (int i = 0; i < argumentMap.length; i++) { int pos = argumentMap[i]; if (pos != i) nullPermutation = false; if (pos < 0 || pos >= newType.parameterCount()) { argumentMap = new int[0]; break; } } if (argumentMap.length != oldType.parameterCount()) throw newIllegalArgumentException("bad permutation: "+Arrays.toString(argumentMap)); if (nullPermutation) { MethodHandle res = makePairwiseConvert(token, newType, target); // well, that was easy if (res == null) throw newIllegalArgumentException("cannot convert pairwise: "+newType); return res; } // Check return type. (Not much can be done with it.) Class exp = newType.returnType(); Class ret = oldType.returnType(); if (!VerifyType.isNullConversion(ret, exp)) throw newIllegalArgumentException("bad return conversion for "+newType); // See if the argument types match up. for (int i = 0; i < argumentMap.length; i++) { int j = argumentMap[i]; Class src = newType.parameterType(j); Class dst = oldType.parameterType(i); if (!VerifyType.isNullConversion(src, dst)) throw newIllegalArgumentException("bad argument #"+j+" conversion for "+newType); } // Now figure out a nice mix of SWAP, ROT, DUP, and DROP adapters. // A workable greedy algorithm is as follows: // Drop unused outgoing arguments (right to left: shallowest first). // Duplicate doubly-used outgoing arguments (left to right: deepest first). // Then the remaining problem is a true argument permutation. // Marshal the outgoing arguments as required from left to right. // That is, find the deepest outgoing stack position that does not yet // have the correct argument value, and correct at least that position // by swapping or rotating in the misplaced value (from a shallower place). // If the misplaced value is followed by one or more consecutive values // (also misplaced) issue a rotation which brings as many as possible // into position. Otherwise make progress with either a swap or a // rotation. Prefer the swap as cheaper, but do not use it if it // breaks a slot pair. Prefer the rotation over the swap if it would // preserve more consecutive values shallower than the target position. // When more than one rotation will work (because the required value // is already adjacent to the target position), then use a rotation // which moves the old value in the target position adjacent to // one of its consecutive values. Also, prefer shorter rotation // spans, since they use fewer memory cycles for shuffling. throw new UnsupportedOperationException("NYI"); } private static byte basicType(Class type) { if (type == null) return T_VOID; switch (Wrapper.forBasicType(type)) { case BOOLEAN: return T_BOOLEAN; case CHAR: return T_CHAR; case FLOAT: return T_FLOAT; case DOUBLE: return T_DOUBLE; case BYTE: return T_BYTE; case SHORT: return T_SHORT; case INT: return T_INT; case LONG: return T_LONG; case OBJECT: return T_OBJECT; case VOID: return T_VOID; } return 99; // T_ILLEGAL or some such } /** Number of stack slots for the given type. * Two for T_DOUBLE and T_FLOAT, one for the rest. */ private static int type2size(int type) { assert(type >= T_BOOLEAN && type <= T_OBJECT); return (type == T_LONG || type == T_DOUBLE) ? 2 : 1; } private static int type2size(Class type) { return type2size(basicType(type)); } /** The given stackMove is the number of slots pushed. * It might be negative. Scale it (multiply) by the * VM's notion of how an address changes with a push, * to get the raw SP change for stackMove. * Then shift and mask it into the correct field. */ private static long insertStackMove(int stackMove) { // following variable must be long to avoid sign extension after '<<' long spChange = stackMove * MethodHandleNatives.JVM_STACK_MOVE_UNIT; return (spChange & CONV_STACK_MOVE_MASK) << CONV_STACK_MOVE_SHIFT; } /** Construct an adapter conversion descriptor for a single-argument conversion. */ private static long makeConv(int convOp, int argnum, int src, int dest) { assert(src == (src & 0xF)); assert(dest == (dest & 0xF)); assert(convOp >= OP_CHECK_CAST && convOp <= OP_PRIM_TO_REF); int stackMove = type2size(dest) - type2size(src); return ((long) argnum << 32 | (long) convOp << CONV_OP_SHIFT | (int) src << CONV_SRC_TYPE_SHIFT | (int) dest << CONV_DEST_TYPE_SHIFT | insertStackMove(stackMove) ); } private static long makeConv(int convOp, int argnum, int stackMove) { assert(convOp >= OP_DUP_ARGS && convOp <= OP_SPREAD_ARGS); byte src = 0, dest = 0; if (convOp >= OP_COLLECT_ARGS && convOp <= OP_SPREAD_ARGS) src = dest = T_OBJECT; return ((long) argnum << 32 | (long) convOp << CONV_OP_SHIFT | (int) src << CONV_SRC_TYPE_SHIFT | (int) dest << CONV_DEST_TYPE_SHIFT | insertStackMove(stackMove) ); } private static long makeSwapConv(int convOp, int srcArg, byte type, int destSlot) { assert(convOp >= OP_SWAP_ARGS && convOp <= OP_ROT_ARGS); return ((long) srcArg << 32 | (long) convOp << CONV_OP_SHIFT | (int) type << CONV_SRC_TYPE_SHIFT | (int) type << CONV_DEST_TYPE_SHIFT | (int) destSlot << CONV_VMINFO_SHIFT ); } private static long makeConv(int convOp) { assert(convOp == OP_RETYPE_ONLY || convOp == OP_RETYPE_RAW); return ((long)-1 << 32) | (convOp << CONV_OP_SHIFT); // stackMove, src, dst all zero } private static int convCode(long conv) { return (int)conv; } private static int convArgPos(long conv) { return (int)(conv >>> 32); } private static boolean convOpSupported(int convOp) { assert(convOp >= 0 && convOp <= CONV_OP_LIMIT); return ((1<> CONV_OP_SHIFT; } /* Return one plus the position of the first non-trivial difference * between the given types. This is not a symmetric operation; * we are considering adapting the targetType to adapterType. * Trivial differences are those which could be ignored by the JVM * without subverting the verifier. Otherwise, adaptable differences * are ones for which we could create an adapter to make the type change. * Return zero if there are no differences (other than trivial ones). * Return 1+N if N is the only adaptable argument difference. * Return the -2-N where N is the first of several adaptable * argument differences. * Return -1 if there there are differences which are not adaptable. */ private static int diffTypes(MethodType adapterType, MethodType targetType, boolean raw) { int diff; diff = diffReturnTypes(adapterType, targetType, raw); if (diff != 0) return diff; int nargs = adapterType.parameterCount(); if (nargs != targetType.parameterCount()) return -1; diff = diffParamTypes(adapterType, 0, targetType, 0, nargs, raw); //System.out.println("diff "+adapterType); //System.out.println(" "+diff+" "+targetType); return diff; } private static int diffReturnTypes(MethodType adapterType, MethodType targetType, boolean raw) { Class src = targetType.returnType(); Class dst = adapterType.returnType(); if ((!raw ? VerifyType.canPassUnchecked(src, dst) : VerifyType.canPassRaw(src, dst) ) > 0) return 0; // no significant difference if (raw && !src.isPrimitive() && !dst.isPrimitive()) return 0; // can force a reference return (very carefully!) //if (false) return 1; // never adaptable! return -1; // some significant difference } private static int diffParamTypes(MethodType adapterType, int astart, MethodType targetType, int tstart, int nargs, boolean raw) { assert(nargs >= 0); int res = 0; for (int i = 0; i < nargs; i++) { Class src = adapterType.parameterType(astart+i); Class dest = targetType.parameterType(tstart+i); if ((!raw ? VerifyType.canPassUnchecked(src, dest) : VerifyType.canPassRaw(src, dest) ) <= 0) { // found a difference; is it the only one so far? if (res != 0) return -1-res; // return -2-i for prev. i res = 1+i; } } return res; } /** Can a retyping adapter (alone) validly convert the target to newType? */ public static boolean canRetypeOnly(MethodType newType, MethodType targetType) { return canRetype(newType, targetType, false); } /** Can a retyping adapter (alone) convert the target to newType? * It is allowed to widen subword types and void to int, to make bitwise * conversions between float/int and double/long, and to perform unchecked * reference conversions on return. This last feature requires that the * caller be trusted, and perform explicit cast conversions on return values. */ public static boolean canRetypeRaw(MethodType newType, MethodType targetType) { return canRetype(newType, targetType, true); } static boolean canRetype(MethodType newType, MethodType targetType, boolean raw) { if (!convOpSupported(raw ? OP_RETYPE_RAW : OP_RETYPE_ONLY)) return false; int diff = diffTypes(newType, targetType, raw); // %%% This assert is too strong. Factor diff into VerifyType and reconcile. assert(raw || (diff == 0) == VerifyType.isNullConversion(newType, targetType)); return diff == 0; } /** Factory method: Performs no conversions; simply retypes the adapter. * Allows unchecked argument conversions pairwise, if they are safe. * Returns null if not possible. */ public static MethodHandle makeRetypeOnly(Access token, MethodType newType, MethodHandle target) { return makeRetype(token, newType, target, false); } public static MethodHandle makeRetypeRaw(Access token, MethodType newType, MethodHandle target) { return makeRetype(token, newType, target, true); } static MethodHandle makeRetype(Access token, MethodType newType, MethodHandle target, boolean raw) { Access.check(token); MethodType oldType = target.type(); if (oldType == newType) return target; if (!canRetype(newType, oldType, raw)) return null; // TO DO: clone the target guy, whatever he is, with new type. return new AdapterMethodHandle(target, newType, makeConv(raw ? OP_RETYPE_RAW : OP_RETYPE_ONLY)); } static MethodHandle makeTypeHandler(Access token, MethodHandle target, MethodHandle typeHandler) { Access.check(token); return new WithTypeHandler(target, typeHandler); } static class WithTypeHandler extends AdapterMethodHandle { final MethodHandle target, typeHandler; WithTypeHandler(MethodHandle target, MethodHandle typeHandler) { super(target, target.type(), makeConv(OP_RETYPE_ONLY)); this.target = target; this.typeHandler = typeHandler.asType(TYPE_HANDLER_TYPE); } public MethodHandle asType(MethodType newType) { if (this.type() == newType) return this; try { MethodHandle retyped = (MethodHandle) typeHandler.invokeExact(target, newType); // Contract: Must return the desired type, or throw WMT if (retyped.type() != newType) throw new WrongMethodTypeException(retyped.toString()); return retyped; } catch (Throwable ex) { if (ex instanceof Error) throw (Error)ex; if (ex instanceof RuntimeException) throw (RuntimeException)ex; throw new RuntimeException(ex); } } private static final MethodType TYPE_HANDLER_TYPE = MethodType.methodType(MethodHandle.class, MethodHandle.class, MethodType.class); } /** Can a checkcast adapter validly convert the target to newType? * The JVM supports all kind of reference casts, even silly ones. */ public static boolean canCheckCast(MethodType newType, MethodType targetType, int arg, Class castType) { if (!convOpSupported(OP_CHECK_CAST)) return false; Class src = newType.parameterType(arg); Class dst = targetType.parameterType(arg); if (!canCheckCast(src, castType) || !VerifyType.isNullConversion(castType, dst)) return false; int diff = diffTypes(newType, targetType, false); return (diff == arg+1); // arg is sole non-trivial diff } /** Can an primitive conversion adapter validly convert src to dst? */ public static boolean canCheckCast(Class src, Class dst) { return (!src.isPrimitive() && !dst.isPrimitive()); } /** Factory method: Forces a cast at the given argument. * The castType is the target of the cast, and can be any type * with a null conversion to the corresponding target parameter. * Return null if this cannot be done. */ public static MethodHandle makeCheckCast(Access token, MethodType newType, MethodHandle target, int arg, Class castType) { Access.check(token); if (!canCheckCast(newType, target.type(), arg, castType)) return null; long conv = makeConv(OP_CHECK_CAST, arg, T_OBJECT, T_OBJECT); return new AdapterMethodHandle(target, newType, conv, castType); } /** Can an primitive conversion adapter validly convert the target to newType? * The JVM currently supports all conversions except those between * floating and integral types. */ public static boolean canPrimCast(MethodType newType, MethodType targetType, int arg, Class convType) { if (!convOpSupported(OP_PRIM_TO_PRIM)) return false; Class src = newType.parameterType(arg); Class dst = targetType.parameterType(arg); if (!canPrimCast(src, convType) || !VerifyType.isNullConversion(convType, dst)) return false; int diff = diffTypes(newType, targetType, false); return (diff == arg+1); // arg is sole non-trivial diff } /** Can an primitive conversion adapter validly convert src to dst? */ public static boolean canPrimCast(Class src, Class dst) { if (src == dst || !src.isPrimitive() || !dst.isPrimitive()) { return false; } else if (Wrapper.forPrimitiveType(dst).isFloating()) { // both must be floating types return Wrapper.forPrimitiveType(src).isFloating(); } else { // both are integral, and all combinations work fine assert(Wrapper.forPrimitiveType(src).isIntegral() && Wrapper.forPrimitiveType(dst).isIntegral()); return true; } } /** Factory method: Truncate the given argument with zero or sign extension, * and/or convert between single and doubleword versions of integer or float. * The convType is the target of the conversion, and can be any type * with a null conversion to the corresponding target parameter. * Return null if this cannot be done. */ public static MethodHandle makePrimCast(Access token, MethodType newType, MethodHandle target, int arg, Class convType) { Access.check(token); MethodType oldType = target.type(); if (!canPrimCast(newType, oldType, arg, convType)) return null; Class src = newType.parameterType(arg); long conv = makeConv(OP_PRIM_TO_PRIM, arg, basicType(src), basicType(convType)); return new AdapterMethodHandle(target, newType, conv); } /** Can an unboxing conversion validly convert src to dst? * The JVM currently supports all kinds of casting and unboxing. * The convType is the unboxed type; it can be either a primitive or wrapper. */ public static boolean canUnboxArgument(MethodType newType, MethodType targetType, int arg, Class convType) { if (!convOpSupported(OP_REF_TO_PRIM)) return false; Class src = newType.parameterType(arg); Class dst = targetType.parameterType(arg); Class boxType = Wrapper.asWrapperType(convType); convType = Wrapper.asPrimitiveType(convType); if (!canCheckCast(src, boxType) || boxType == convType || !VerifyType.isNullConversion(convType, dst)) return false; int diff = diffTypes(newType, targetType, false); return (diff == arg+1); // arg is sole non-trivial diff } /** Can an primitive unboxing adapter validly convert src to dst? */ public static boolean canUnboxArgument(Class src, Class dst) { return (!src.isPrimitive() && Wrapper.asPrimitiveType(dst).isPrimitive()); } /** Factory method: Unbox the given argument. * Return null if this cannot be done. */ public static MethodHandle makeUnboxArgument(Access token, MethodType newType, MethodHandle target, int arg, Class convType) { MethodType oldType = target.type(); Class src = newType.parameterType(arg); Class dst = oldType.parameterType(arg); Class boxType = Wrapper.asWrapperType(convType); Class primType = Wrapper.asPrimitiveType(convType); if (!canUnboxArgument(newType, oldType, arg, convType)) return null; MethodType castDone = newType; if (!VerifyType.isNullConversion(src, boxType)) castDone = newType.changeParameterType(arg, boxType); long conv = makeConv(OP_REF_TO_PRIM, arg, T_OBJECT, basicType(primType)); MethodHandle adapter = new AdapterMethodHandle(target, castDone, conv, boxType); if (castDone == newType) return adapter; return makeCheckCast(token, newType, adapter, arg, boxType); } /** Can an primitive boxing adapter validly convert src to dst? */ public static boolean canBoxArgument(Class src, Class dst) { if (!convOpSupported(OP_PRIM_TO_REF)) return false; throw new UnsupportedOperationException("NYI"); } /** Factory method: Unbox the given argument. * Return null if this cannot be done. */ public static MethodHandle makeBoxArgument(Access token, MethodType newType, MethodHandle target, int arg, Class convType) { // this is difficult to do in the JVM because it must GC return null; } /** Can an adapter simply drop arguments to convert the target to newType? */ public static boolean canDropArguments(MethodType newType, MethodType targetType, int dropArgPos, int dropArgCount) { if (dropArgCount == 0) return canRetypeOnly(newType, targetType); if (!convOpSupported(OP_DROP_ARGS)) return false; if (diffReturnTypes(newType, targetType, false) != 0) return false; int nptypes = newType.parameterCount(); // parameter types must be the same up to the drop point if (dropArgPos != 0 && diffParamTypes(newType, 0, targetType, 0, dropArgPos, false) != 0) return false; int afterPos = dropArgPos + dropArgCount; int afterCount = nptypes - afterPos; if (dropArgPos < 0 || dropArgPos >= nptypes || dropArgCount < 1 || afterPos > nptypes || targetType.parameterCount() != nptypes - dropArgCount) return false; // parameter types after the drop point must also be the same if (afterCount != 0 && diffParamTypes(newType, afterPos, targetType, dropArgPos, afterCount, false) != 0) return false; return true; } /** Factory method: Drop selected arguments. * Allow unchecked retyping of remaining arguments, pairwise. * Return null if this is not possible. */ public static MethodHandle makeDropArguments(Access token, MethodType newType, MethodHandle target, int dropArgPos, int dropArgCount) { Access.check(token); if (dropArgCount == 0) return makeRetypeOnly(IMPL_TOKEN, newType, target); if (!canDropArguments(newType, target.type(), dropArgPos, dropArgCount)) return null; // in arglist: [0: ...keep1 | dpos: drop... | dpos+dcount: keep2... ] // out arglist: [0: ...keep1 | dpos: keep2... ] int keep2InPos = dropArgPos + dropArgCount; int dropSlot = newType.parameterSlotDepth(keep2InPos); int keep1InSlot = newType.parameterSlotDepth(dropArgPos); int slotCount = keep1InSlot - dropSlot; assert(slotCount >= dropArgCount); assert(target.type().parameterSlotCount() + slotCount == newType.parameterSlotCount()); long conv = makeConv(OP_DROP_ARGS, dropArgPos + dropArgCount - 1, -slotCount); return new AdapterMethodHandle(target, newType, conv); } /** Can an adapter duplicate an argument to convert the target to newType? */ public static boolean canDupArguments(MethodType newType, MethodType targetType, int dupArgPos, int dupArgCount) { if (!convOpSupported(OP_DUP_ARGS)) return false; if (diffReturnTypes(newType, targetType, false) != 0) return false; int nptypes = newType.parameterCount(); if (dupArgCount < 0 || dupArgPos + dupArgCount > nptypes) return false; if (targetType.parameterCount() != nptypes + dupArgCount) return false; // parameter types must be the same up to the duplicated arguments if (diffParamTypes(newType, 0, targetType, 0, nptypes, false) != 0) return false; // duplicated types must be, well, duplicates if (diffParamTypes(newType, dupArgPos, targetType, nptypes, dupArgCount, false) != 0) return false; return true; } /** Factory method: Duplicate the selected argument. * Return null if this is not possible. */ public static MethodHandle makeDupArguments(Access token, MethodType newType, MethodHandle target, int dupArgPos, int dupArgCount) { Access.check(token); if (!canDupArguments(newType, target.type(), dupArgPos, dupArgCount)) return null; if (dupArgCount == 0) return target; // in arglist: [0: ...keep1 | dpos: dup... | dpos+dcount: keep2... ] // out arglist: [0: ...keep1 | dpos: dup... | dpos+dcount: keep2... | dup... ] int keep2InPos = dupArgPos + dupArgCount; int dupSlot = newType.parameterSlotDepth(keep2InPos); int keep1InSlot = newType.parameterSlotDepth(dupArgPos); int slotCount = keep1InSlot - dupSlot; assert(target.type().parameterSlotCount() - slotCount == newType.parameterSlotCount()); long conv = makeConv(OP_DUP_ARGS, dupArgPos + dupArgCount - 1, slotCount); return new AdapterMethodHandle(target, newType, conv); } /** Can an adapter swap two arguments to convert the target to newType? */ public static boolean canSwapArguments(MethodType newType, MethodType targetType, int swapArg1, int swapArg2) { if (!convOpSupported(OP_SWAP_ARGS)) return false; if (diffReturnTypes(newType, targetType, false) != 0) return false; if (swapArg1 >= swapArg2) return false; // caller resp int nptypes = newType.parameterCount(); if (targetType.parameterCount() != nptypes) return false; if (swapArg1 < 0 || swapArg2 >= nptypes) return false; if (diffParamTypes(newType, 0, targetType, 0, swapArg1, false) != 0) return false; if (diffParamTypes(newType, swapArg1, targetType, swapArg2, 1, false) != 0) return false; if (diffParamTypes(newType, swapArg1+1, targetType, swapArg1+1, swapArg2-swapArg1-1, false) != 0) return false; if (diffParamTypes(newType, swapArg2, targetType, swapArg1, 1, false) != 0) return false; if (diffParamTypes(newType, swapArg2+1, targetType, swapArg2+1, nptypes-swapArg2-1, false) != 0) return false; return true; } /** Factory method: Swap the selected arguments. * Return null if this is not possible. */ public static MethodHandle makeSwapArguments(Access token, MethodType newType, MethodHandle target, int swapArg1, int swapArg2) { Access.check(token); if (swapArg1 == swapArg2) return target; if (swapArg1 > swapArg2) { int t = swapArg1; swapArg1 = swapArg2; swapArg2 = t; } if (!canSwapArguments(newType, target.type(), swapArg1, swapArg2)) return null; Class swapType = newType.parameterType(swapArg1); // in arglist: [0: ...keep1 | pos1: a1 | pos1+1: keep2... | pos2: a2 | pos2+1: keep3... ] // out arglist: [0: ...keep1 | pos1: a2 | pos1+1: keep2... | pos2: a1 | pos2+1: keep3... ] int swapSlot2 = newType.parameterSlotDepth(swapArg2 + 1); long conv = makeSwapConv(OP_SWAP_ARGS, swapArg1, basicType(swapType), swapSlot2); return new AdapterMethodHandle(target, newType, conv); } static int positiveRotation(int argCount, int rotateBy) { assert(argCount > 0); if (rotateBy >= 0) { if (rotateBy < argCount) return rotateBy; return rotateBy % argCount; } else if (rotateBy >= -argCount) { return rotateBy + argCount; } else { return (-1-((-1-rotateBy) % argCount)) + argCount; } } final static int MAX_ARG_ROTATION = 1; /** Can an adapter rotate arguments to convert the target to newType? */ public static boolean canRotateArguments(MethodType newType, MethodType targetType, int firstArg, int argCount, int rotateBy) { if (!convOpSupported(OP_ROT_ARGS)) return false; if (argCount <= 2) return false; // must be a swap, not a rotate rotateBy = positiveRotation(argCount, rotateBy); if (rotateBy == 0) return false; // no rotation if (rotateBy > MAX_ARG_ROTATION && rotateBy < argCount - MAX_ARG_ROTATION) return false; // too many argument positions // Rotate incoming args right N to the out args, N in 1..(argCouunt-1). if (diffReturnTypes(newType, targetType, false) != 0) return false; int nptypes = newType.parameterCount(); if (targetType.parameterCount() != nptypes) return false; if (firstArg < 0 || firstArg >= nptypes) return false; int argLimit = firstArg + argCount; if (argLimit > nptypes) return false; if (diffParamTypes(newType, 0, targetType, 0, firstArg, false) != 0) return false; int newChunk1 = argCount - rotateBy, newChunk2 = rotateBy; // swap new chunk1 with target chunk2 if (diffParamTypes(newType, firstArg, targetType, argLimit-newChunk1, newChunk1, false) != 0) return false; // swap new chunk2 with target chunk1 if (diffParamTypes(newType, firstArg+newChunk1, targetType, firstArg, newChunk2, false) != 0) return false; return true; } /** Factory method: Rotate the selected argument range. * Return null if this is not possible. */ public static MethodHandle makeRotateArguments(Access token, MethodType newType, MethodHandle target, int firstArg, int argCount, int rotateBy) { Access.check(token); rotateBy = positiveRotation(argCount, rotateBy); if (!canRotateArguments(newType, target.type(), firstArg, argCount, rotateBy)) return null; // Decide whether it should be done as a right or left rotation, // on the JVM stack. Return the number of stack slots to rotate by, // positive if right, negative if left. int limit = firstArg + argCount; int depth0 = newType.parameterSlotDepth(firstArg); int depth1 = newType.parameterSlotDepth(limit-rotateBy); int depth2 = newType.parameterSlotDepth(limit); int chunk1Slots = depth0 - depth1; assert(chunk1Slots > 0); int chunk2Slots = depth1 - depth2; assert(chunk2Slots > 0); // From here on out, it assumes a single-argument shift. assert(MAX_ARG_ROTATION == 1); int srcArg, dstArg; byte basicType; if (chunk2Slots <= chunk1Slots) { // Rotate right/down N (rotateBy = +N, N small, c2 small): // in arglist: [0: ...keep1 | arg1: c1... | limit-N: c2 | limit: keep2... ] // out arglist: [0: ...keep1 | arg1: c2 | arg1+N: c1... | limit: keep2... ] srcArg = limit-1; dstArg = firstArg; basicType = basicType(newType.parameterType(srcArg)); assert(chunk2Slots == type2size(basicType)); } else { // Rotate left/up N (rotateBy = -N, N small, c1 small): // in arglist: [0: ...keep1 | arg1: c1 | arg1+N: c2... | limit: keep2... ] // out arglist: [0: ...keep1 | arg1: c2 ... | limit-N: c1 | limit: keep2... ] srcArg = firstArg; dstArg = limit-1; basicType = basicType(newType.parameterType(srcArg)); assert(chunk1Slots == type2size(basicType)); } int dstSlot = newType.parameterSlotDepth(dstArg + 1); long conv = makeSwapConv(OP_ROT_ARGS, srcArg, basicType, dstSlot); return new AdapterMethodHandle(target, newType, conv); } /** Can an adapter spread an argument to convert the target to newType? */ public static boolean canSpreadArguments(MethodType newType, MethodType targetType, Class spreadArgType, int spreadArgPos, int spreadArgCount) { if (!convOpSupported(OP_SPREAD_ARGS)) return false; if (diffReturnTypes(newType, targetType, false) != 0) return false; int nptypes = newType.parameterCount(); // parameter types must be the same up to the spread point if (spreadArgPos != 0 && diffParamTypes(newType, 0, targetType, 0, spreadArgPos, false) != 0) return false; int afterPos = spreadArgPos + spreadArgCount; int afterCount = nptypes - (spreadArgPos + 1); if (spreadArgPos < 0 || spreadArgPos >= nptypes || spreadArgCount < 0 || targetType.parameterCount() != afterPos + afterCount) return false; // parameter types after the spread point must also be the same if (afterCount != 0 && diffParamTypes(newType, spreadArgPos+1, targetType, afterPos, afterCount, false) != 0) return false; // match the array element type to the spread arg types Class rawSpreadArgType = newType.parameterType(spreadArgPos); if (rawSpreadArgType != spreadArgType && !canCheckCast(rawSpreadArgType, spreadArgType)) return false; for (int i = 0; i < spreadArgCount; i++) { Class src = VerifyType.spreadArgElementType(spreadArgType, i); Class dst = targetType.parameterType(spreadArgPos + i); if (src == null || !VerifyType.isNullConversion(src, dst)) return false; } return true; } /** Factory method: Spread selected argument. */ public static MethodHandle makeSpreadArguments(Access token, MethodType newType, MethodHandle target, Class spreadArgType, int spreadArgPos, int spreadArgCount) { Access.check(token); MethodType targetType = target.type(); if (!canSpreadArguments(newType, targetType, spreadArgType, spreadArgPos, spreadArgCount)) return null; // in arglist: [0: ...keep1 | spos: spreadArg | spos+1: keep2... ] // out arglist: [0: ...keep1 | spos: spread... | spos+scount: keep2... ] int keep2OutPos = spreadArgPos + spreadArgCount; int spreadSlot = targetType.parameterSlotDepth(keep2OutPos); int keep1OutSlot = targetType.parameterSlotDepth(spreadArgPos); int slotCount = keep1OutSlot - spreadSlot; assert(spreadSlot == newType.parameterSlotDepth(spreadArgPos+1)); assert(slotCount >= spreadArgCount); long conv = makeConv(OP_SPREAD_ARGS, spreadArgPos, slotCount-1); MethodHandle res = new AdapterMethodHandle(target, newType, conv, spreadArgType); assert(res.type().parameterType(spreadArgPos) == spreadArgType); return res; } // TO DO: makeCollectArguments, makeFlyby, makeRicochet @Override public String toString() { return nonAdapter((MethodHandle)vmtarget).toString(); } private static MethodHandle nonAdapter(MethodHandle mh) { while (mh instanceof AdapterMethodHandle) { mh = (MethodHandle) mh.vmtarget; } return mh; } }