Back to index...

	/*
	* Copyright (c) 2017, 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 java.lang.invoke;

	import sun.invoke.util.Wrapper;

	import java.lang.invoke.AbstractConstantGroup.BSCIWithCache;
	import java.util.Arrays;

	import static java.lang.invoke.BootstrapCallInfo.makeBootstrapCallInfo;
	import static java.lang.invoke.ConstantGroup.makeConstantGroup;
	import static java.lang.invoke.MethodHandleNatives.*;
	import static java.lang.invoke.MethodHandleStatics.TRACE_METHOD_LINKAGE;
	import static java.lang.invoke.MethodHandles.Lookup;
	import static java.lang.invoke.MethodHandles.Lookup.IMPL_LOOKUP;

	final class BootstrapMethodInvoker {

	/**
	* Factored code for invoking a bootstrap method for invokedynamic
	* or a dynamic constant.
	* @param resultType the expected return type (either CallSite or a constant type)
	* @param bootstrapMethod the BSM to call
	* @param name the method name or constant name
	* @param type the method type or constant type
	* @param info information passed up from the JVM, to derive static arguments
	* @param callerClass the class containing the resolved method call or constant load
	* @param <T> the expected return type
	* @return the expected value, either a CallSite or a constant value
	*/
	static <T> T invoke(Class<T> resultType,
	MethodHandle bootstrapMethod,
	// Callee information:
	String name, Object type,
	// Extra arguments for BSM, if any:
	Object info,
	// Caller information:
	Class<?> callerClass) {
	MethodHandles.Lookup caller = IMPL_LOOKUP.in(callerClass);
	Object result;
	boolean pullMode = isPullModeBSM(bootstrapMethod); // default value is false
	boolean vmIsPushing = !staticArgumentsPulled(info); // default value is true
	MethodHandle pullModeBSM;
	// match the VM with the BSM
	if (vmIsPushing) {
	// VM is pushing arguments at us
	pullModeBSM = null;
	if (pullMode) {
	bootstrapMethod = pushMePullYou(bootstrapMethod, true);
	}
	} else {
	// VM wants us to pull args from it
	pullModeBSM = pullMode ? bootstrapMethod :
	pushMePullYou(bootstrapMethod, false);
	bootstrapMethod = null;
	}
	try {
	// As an optimization we special case various known BSMs,
	// such as LambdaMetafactory::metafactory and
	// StringConcatFactory::makeConcatWithConstants.
	//
	// By providing static type information or even invoking
	// exactly, we avoid emitting code to perform runtime
	// checking.
	info = maybeReBox(info);
	if (info == null) {
	// VM is allowed to pass up a null meaning no BSM args
	result = invoke(bootstrapMethod, caller, name, type);
	}
	else if (!info.getClass().isArray()) {
	// VM is allowed to pass up a single BSM arg directly

	// Call to StringConcatFactory::makeConcatWithConstants
	// with empty constant arguments?
	if (isStringConcatFactoryBSM(bootstrapMethod.type())) {
	result = (CallSite)bootstrapMethod
	.invokeExact(caller, name, (MethodType)type,
	(String)info, new Object[0]);
	} else {
	result = invoke(bootstrapMethod, caller, name, type, info);
	}
	}
	else if (info.getClass() == int[].class) {
	// VM is allowed to pass up a pair {argc, index}
	// referring to 'argc' BSM args at some place 'index'
	// in the guts of the VM (associated with callerClass).
	// The format of this index pair is private to the
	// handshake between the VM and this class only.
	// This supports "pulling" of arguments.
	// The VM is allowed to do this for any reason.
	// The code in this method makes up for any mismatches.
	BootstrapCallInfo<Object> bsci
	= new VM_BSCI<>(bootstrapMethod, name, type, caller, (int[])info);
	// Pull-mode API is (Lookup, BootstrapCallInfo) -> Object
	result = pullModeBSM.invoke(caller, bsci);
	}
	else {
	// VM is allowed to pass up a full array of resolved BSM args
	Object[] argv = (Object[]) info;
	maybeReBoxElements(argv);

	MethodType bsmType = bootstrapMethod.type();
	if (isLambdaMetafactoryIndyBSM(bsmType) && argv.length == 3) {
	result = (CallSite)bootstrapMethod
	.invokeExact(caller, name, (MethodType)type, (MethodType)argv[0],
	(MethodHandle)argv[1], (MethodType)argv[2]);
	} else if (isLambdaMetafactoryCondyBSM(bsmType) && argv.length == 3) {
	result = bootstrapMethod
	.invokeExact(caller, name, (Class<?>)type, (MethodType)argv[0],
	(MethodHandle)argv[1], (MethodType)argv[2]);
	} else if (isStringConcatFactoryBSM(bsmType) && argv.length >= 1) {
	String recipe = (String)argv[0];
	Object[] shiftedArgs = Arrays.copyOfRange(argv, 1, argv.length);
	result = (CallSite)bootstrapMethod.invokeExact(caller, name, (MethodType)type, recipe, shiftedArgs);
	} else if (isLambdaMetafactoryAltMetafactoryBSM(bsmType)) {
	result = (CallSite)bootstrapMethod.invokeExact(caller, name, (MethodType)type, argv);
	} else {
	switch (argv.length) {
	case 0:
	result = invoke(bootstrapMethod, caller, name, type);
	break;
	case 1:
	result = invoke(bootstrapMethod, caller, name, type,
	argv[0]);
	break;
	case 2:
	result = invoke(bootstrapMethod, caller, name, type,
	argv[0], argv[1]);
	break;
	case 3:
	result = invoke(bootstrapMethod, caller, name, type,
	argv[0], argv[1], argv[2]);
	break;
	case 4:
	result = invoke(bootstrapMethod, caller, name, type,
	argv[0], argv[1], argv[2], argv[3]);
	break;
	case 5:
	result = invoke(bootstrapMethod, caller, name, type,
	argv[0], argv[1], argv[2], argv[3], argv[4]);
	break;
	case 6:
	result = invoke(bootstrapMethod, caller, name, type,
	argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
	break;
	default:
	result = invokeWithManyArguments(bootstrapMethod, caller, name, type, argv);
	}
	}
	}
	if (resultType.isPrimitive()) {
	// Non-reference conversions are more than just plain casts.
	// By pushing the value through a funnel of the form (T x)->x,
	// the boxed result can be widened as needed. See MH::asType.
	MethodHandle funnel = MethodHandles.identity(resultType);
	result = funnel.invoke(result);
	// Now it is the wrapper type for resultType.
	resultType = Wrapper.asWrapperType(resultType);
	}
	return resultType.cast(result);
	}
	catch (Error e) {
	// Pass through an Error, including BootstrapMethodError, any other
	// form of linkage error, such as IllegalAccessError if the bootstrap
	// method is inaccessible, or say ThreadDeath/OutOfMemoryError
	// See the "Linking Exceptions" section for the invokedynamic
	// instruction in JVMS 6.5.
	throw e;
	}
	catch (Throwable ex) {
	// Wrap anything else in BootstrapMethodError
	throw new BootstrapMethodError("bootstrap method initialization exception", ex);
	}
	}

	// If we don't provide static type information for type, we'll generate runtime
	// checks. Let's try not to...

	private static Object invoke(MethodHandle bootstrapMethod, Lookup caller,
	String name, Object type) throws Throwable {
	if (type instanceof Class) {
	return bootstrapMethod.invoke(caller, name, (Class<?>)type);
	} else {
	return bootstrapMethod.invoke(caller, name, (MethodType)type);
	}
	}

	private static Object invoke(MethodHandle bootstrapMethod, Lookup caller,
	String name, Object type, Object arg0) throws Throwable {
	if (type instanceof Class) {
	return bootstrapMethod.invoke(caller, name, (Class<?>)type, arg0);
	} else {
	return bootstrapMethod.invoke(caller, name, (MethodType)type, arg0);
	}
	}

	private static Object invoke(MethodHandle bootstrapMethod, Lookup caller, String name,
	Object type, Object arg0, Object arg1) throws Throwable {
	if (type instanceof Class) {
	return bootstrapMethod.invoke(caller, name, (Class<?>)type, arg0, arg1);
	} else {
	return bootstrapMethod.invoke(caller, name, (MethodType)type, arg0, arg1);
	}
	}

	private static Object invoke(MethodHandle bootstrapMethod, Lookup caller, String name,
	Object type, Object arg0, Object arg1,
	Object arg2) throws Throwable {
	if (type instanceof Class) {
	return bootstrapMethod.invoke(caller, name, (Class<?>)type, arg0, arg1, arg2);
	} else {
	return bootstrapMethod.invoke(caller, name, (MethodType)type, arg0, arg1, arg2);
	}
	}

	private static Object invoke(MethodHandle bootstrapMethod, Lookup caller, String name,
	Object type, Object arg0, Object arg1,
	Object arg2, Object arg3) throws Throwable {
	if (type instanceof Class) {
	return bootstrapMethod.invoke(caller, name, (Class<?>)type, arg0, arg1, arg2, arg3);
	} else {
	return bootstrapMethod.invoke(caller, name, (MethodType)type, arg0, arg1, arg2, arg3);
	}
	}

	private static Object invoke(MethodHandle bootstrapMethod, Lookup caller,
	String name, Object type, Object arg0, Object arg1,
	Object arg2, Object arg3, Object arg4) throws Throwable {
	if (type instanceof Class) {
	return bootstrapMethod.invoke(caller, name, (Class<?>)type, arg0, arg1, arg2, arg3, arg4);
	} else {
	return bootstrapMethod.invoke(caller, name, (MethodType)type, arg0, arg1, arg2, arg3, arg4);
	}
	}

	private static Object invoke(MethodHandle bootstrapMethod, Lookup caller,
	String name, Object type, Object arg0, Object arg1,
	Object arg2, Object arg3, Object arg4, Object arg5) throws Throwable {
	if (type instanceof Class) {
	return bootstrapMethod.invoke(caller, name, (Class<?>)type, arg0, arg1, arg2, arg3, arg4, arg5);
	} else {
	return bootstrapMethod.invoke(caller, name, (MethodType)type, arg0, arg1, arg2, arg3, arg4, arg5);
	}
	}

	private static Object invokeWithManyArguments(MethodHandle bootstrapMethod, Lookup caller,
	String name, Object type, Object[] argv) throws Throwable {
	final int NON_SPREAD_ARG_COUNT = 3; // (caller, name, type)
	final int MAX_SAFE_SIZE = MethodType.MAX_MH_ARITY / 2 - NON_SPREAD_ARG_COUNT;
	if (argv.length >= MAX_SAFE_SIZE) {
	// to be on the safe side, use invokeWithArguments which handles jumbo lists
	Object[] newargv = new Object[NON_SPREAD_ARG_COUNT + argv.length];
	newargv[0] = caller;
	newargv[1] = name;
	newargv[2] = type;
	System.arraycopy(argv, 0, newargv, NON_SPREAD_ARG_COUNT, argv.length);
	return bootstrapMethod.invokeWithArguments(newargv);
	} else {
	MethodType invocationType = MethodType.genericMethodType(NON_SPREAD_ARG_COUNT + argv.length);
	MethodHandle typedBSM = bootstrapMethod.asType(invocationType);
	MethodHandle spreader = invocationType.invokers().spreadInvoker(NON_SPREAD_ARG_COUNT);
	return spreader.invokeExact(typedBSM, (Object) caller, (Object) name, type, argv);
	}
	}

	private static final MethodType LMF_INDY_MT = MethodType.methodType(CallSite.class,
	Lookup.class, String.class, MethodType.class, MethodType.class, MethodHandle.class, MethodType.class);

	private static final MethodType LMF_ALT_MT = MethodType.methodType(CallSite.class,
	Lookup.class, String.class, MethodType.class, Object[].class);

	private static final MethodType LMF_CONDY_MT = MethodType.methodType(Object.class,
	Lookup.class, String.class, Class.class, MethodType.class, MethodHandle.class, MethodType.class);

	private static final MethodType SCF_MT = MethodType.methodType(CallSite.class,
	Lookup.class, String.class, MethodType.class, String.class, Object[].class);

	/**
	* @return true iff the BSM method type exactly matches
	* {@see java.lang.invoke.StringConcatFactory#makeConcatWithConstants(MethodHandles.Lookup,
	* String,MethodType,String,Object...))}
	*/
	private static boolean isStringConcatFactoryBSM(MethodType bsmType) {
	return bsmType == SCF_MT;
	}

	/**
	* @return true iff the BSM method type exactly matches
	* {@see java.lang.invoke.LambdaMetafactory#metafactory(
	* MethodHandles.Lookup,String,Class,MethodType,MethodHandle,MethodType)}
	*/
	private static boolean isLambdaMetafactoryCondyBSM(MethodType bsmType) {
	return bsmType == LMF_CONDY_MT;
	}

	/**
	* @return true iff the BSM method type exactly matches
	* {@see java.lang.invoke.LambdaMetafactory#metafactory(
	* MethodHandles.Lookup,String,MethodType,MethodType,MethodHandle,MethodType)}
	*/
	private static boolean isLambdaMetafactoryIndyBSM(MethodType bsmType) {
	return bsmType == LMF_INDY_MT;
	}

	/**
	* @return true iff the BSM method type exactly matches
	* {@see java.lang.invoke.LambdaMetafactory#altMetafactory(
	* MethodHandles.Lookup,String,MethodType,Object[])}
	*/
	private static boolean isLambdaMetafactoryAltMetafactoryBSM(MethodType bsmType) {
	return bsmType == LMF_ALT_MT;
	}

	/** The JVM produces java.lang.Integer values to box
	* CONSTANT_Integer boxes but does not intern them.
	* Let's intern them. This is slightly wrong for
	* a {@code CONSTANT_Dynamic} which produces an
	* un-interned integer (e.g., {@code new Integer(0)}).
	*/
	private static Object maybeReBox(Object x) {
	if (x instanceof Integer) {
	int xi = (int) x;
	if (xi == (byte) xi)
	x = xi; // must rebox; see JLS 5.1.7
	}
	return x;
	}

	private static void maybeReBoxElements(Object[] xa) {
	for (int i = 0; i < xa.length; i++) {
	xa[i] = maybeReBox(xa[i]);
	}
	}

	/** Canonical VM-aware implementation of BootstrapCallInfo.
	* Knows how to dig into the JVM for lazily resolved (pull-mode) constants.
	*/
	private static final class VM_BSCI<T> extends BSCIWithCache<T> {
	private final int[] indexInfo;
	private final Class<?> caller; // for index resolution only

	VM_BSCI(MethodHandle bsm, String name, T type,
	Lookup lookup, int[] indexInfo) {
	super(bsm, name, type, indexInfo[0]);
	if (!lookup.hasPrivateAccess()) //D.I.D.
	throw new AssertionError("bad Lookup object");
	this.caller = lookup.lookupClass();
	this.indexInfo = indexInfo;
	// scoop up all the easy stuff right away:
	prefetchIntoCache(0, size());
	}

	@Override Object fillCache(int i) {
	Object[] buf = { null };
	copyConstants(i, i+1, buf, 0);
	Object res = wrapNull(buf[0]);
	cache[i] = res;
	int next = i + 1;
	if (next < cache.length && cache[next] == null)
	maybePrefetchIntoCache(next, false); // try to prefetch
	return res;
	}

	@Override public int copyConstants(int start, int end,
	Object[] buf, int pos) {
	int i = start, bufi = pos;
	while (i < end) {
	Object x = cache[i];
	if (x == null) break;
	buf[bufi++] = unwrapNull(x);
	i++;
	}
	// give up at first null and grab the rest in one big block
	if (i >= end) return i;
	Object[] temp = new Object[end - i];
	if (TRACE_METHOD_LINKAGE) {
	System.out.println("resolving more BSM arguments: " +
	Arrays.asList(caller.getSimpleName(), Arrays.toString(indexInfo), i, end));
	}
	copyOutBootstrapArguments(caller, indexInfo,
	i, end, temp, 0,
	true, null);
	for (Object x : temp) {
	x = maybeReBox(x);
	buf[bufi++] = x;
	cache[i++] = wrapNull(x);
	}
	if (end < cache.length && cache[end] == null)
	maybePrefetchIntoCache(end, true); // try to prefetch
	return i;
	}

	private static final int MIN_PF = 4;
	private void maybePrefetchIntoCache(int i, boolean bulk) {
	int len = cache.length;
	assert(0 <= i && i <= len);
	int pfLimit = i;
	if (bulk) pfLimit += i; // exponential prefetch expansion
	// try to prefetch at least MIN_PF elements
	if (pfLimit < i + MIN_PF) pfLimit = i + MIN_PF;
	if (pfLimit > len \|\| pfLimit < 0) pfLimit = len;
	// stop prefetching where cache is more full than empty
	int empty = 0, nonEmpty = 0, lastEmpty = i;
	for (int j = i; j < pfLimit; j++) {
	if (cache[j] == null) {
	empty++;
	lastEmpty = j;
	} else {
	nonEmpty++;
	if (nonEmpty > empty) {
	pfLimit = lastEmpty + 1;
	break;
	}
	if (pfLimit < len) pfLimit++;
	}
	}
	if (bulk && empty < MIN_PF && pfLimit < len)
	return; // not worth the effort
	prefetchIntoCache(i, pfLimit);
	}

	private void prefetchIntoCache(int i, int pfLimit) {
	if (pfLimit <= i) return; // corner case
	Object[] temp = new Object[pfLimit - i];
	if (TRACE_METHOD_LINKAGE) {
	System.out.println("prefetching BSM arguments: " +
	Arrays.asList(caller.getSimpleName(), Arrays.toString(indexInfo), i, pfLimit));
	}
	copyOutBootstrapArguments(caller, indexInfo,
	i, pfLimit, temp, 0,
	false, NOT_PRESENT);
	for (Object x : temp) {
	if (x != NOT_PRESENT && cache[i] == null) {
	cache[i] = wrapNull(maybeReBox(x));
	}
	i++;
	}
	}
	}

	/non-public/ static final
	class PushAdapter {
	// skeleton for push-mode BSM which wraps a pull-mode BSM:
	static Object pushToBootstrapMethod(MethodHandle pullModeBSM,
	MethodHandles.Lookup lookup, String name, Object type,
	Object... arguments) throws Throwable {
	ConstantGroup cons = makeConstantGroup(Arrays.asList(arguments));
	BootstrapCallInfo<?> bsci = makeBootstrapCallInfo(pullModeBSM, name, type, cons);
	if (TRACE_METHOD_LINKAGE)
	System.out.println("pull-mode BSM gets pushed arguments from fake BSCI");
	return pullModeBSM.invoke(lookup, bsci);
	}

	static final MethodHandle MH_pushToBootstrapMethod;
	static {
	final Class<?> THIS_CLASS = PushAdapter.class;
	try {
	MH_pushToBootstrapMethod = IMPL_LOOKUP
	.findStatic(THIS_CLASS, "pushToBootstrapMethod",
	MethodType.methodType(Object.class, MethodHandle.class,
	Lookup.class, String.class, Object.class, Object[].class));
	} catch (Throwable ex) {
	throw new InternalError(ex);
	}
	}
	}

	/non-public/ static final
	class PullAdapter {
	// skeleton for pull-mode BSM which wraps a push-mode BSM:
	static Object pullFromBootstrapMethod(MethodHandle pushModeBSM,
	MethodHandles.Lookup lookup,
	BootstrapCallInfo<?> bsci)
	throws Throwable {
	int argc = bsci.size();
	switch (argc) {
	case 0:
	return pushModeBSM.invoke(lookup, bsci.invocationName(), bsci.invocationType());
	case 1:
	return pushModeBSM.invoke(lookup, bsci.invocationName(), bsci.invocationType(),
	bsci.get(0));
	case 2:
	return pushModeBSM.invoke(lookup, bsci.invocationName(), bsci.invocationType(),
	bsci.get(0), bsci.get(1));
	case 3:
	return pushModeBSM.invoke(lookup, bsci.invocationName(), bsci.invocationType(),
	bsci.get(0), bsci.get(1), bsci.get(2));
	case 4:
	return pushModeBSM.invoke(lookup, bsci.invocationName(), bsci.invocationType(),
	bsci.get(0), bsci.get(1), bsci.get(2), bsci.get(3));
	case 5:
	return pushModeBSM.invoke(lookup, bsci.invocationName(), bsci.invocationType(),
	bsci.get(0), bsci.get(1), bsci.get(2), bsci.get(3), bsci.get(4));
	case 6:
	return pushModeBSM.invoke(lookup, bsci.invocationName(), bsci.invocationType(),
	bsci.get(0), bsci.get(1), bsci.get(2), bsci.get(3), bsci.get(4), bsci.get(5));
	default:
	final int NON_SPREAD_ARG_COUNT = 3; // (lookup, name, type)
	final int MAX_SAFE_SIZE = MethodType.MAX_MH_ARITY / 2 - NON_SPREAD_ARG_COUNT;
	if (argc >= MAX_SAFE_SIZE) {
	// to be on the safe side, use invokeWithArguments which handles jumbo lists
	Object[] newargv = new Object[NON_SPREAD_ARG_COUNT + argc];
	newargv[0] = lookup;
	newargv[1] = bsci.invocationName();
	newargv[2] = bsci.invocationType();
	bsci.copyConstants(0, argc, newargv, NON_SPREAD_ARG_COUNT);
	return pushModeBSM.invokeWithArguments(newargv);
	}
	MethodType invocationType = MethodType.genericMethodType(NON_SPREAD_ARG_COUNT + argc);
	MethodHandle typedBSM = pushModeBSM.asType(invocationType);
	MethodHandle spreader = invocationType.invokers().spreadInvoker(NON_SPREAD_ARG_COUNT);
	Object[] argv = new Object[argc];
	bsci.copyConstants(0, argc, argv, 0);
	return spreader.invokeExact(typedBSM, (Object) lookup, (Object) bsci.invocationName(), bsci.invocationType(), argv);
	}
	}

	static final MethodHandle MH_pullFromBootstrapMethod;

	static {
	final Class<?> THIS_CLASS = PullAdapter.class;
	try {
	MH_pullFromBootstrapMethod = IMPL_LOOKUP
	.findStatic(THIS_CLASS, "pullFromBootstrapMethod",
	MethodType.methodType(Object.class, MethodHandle.class,
	Lookup.class, BootstrapCallInfo.class));
	} catch (Throwable ex) {
	throw new InternalError(ex);
	}
	}
	}

	/** Given a push-mode BSM (taking one argument) convert it to a
	* pull-mode BSM (taking N pre-resolved arguments).
	* This method is used when, in fact, the JVM is passing up
	* pre-resolved arguments, but the BSM is expecting lazy stuff.
	* Or, when goToPushMode is true, do the reverse transform.
	* (The two transforms are exactly inverse.)
	*/
	static MethodHandle pushMePullYou(MethodHandle bsm, boolean goToPushMode) {
	if (TRACE_METHOD_LINKAGE) {
	System.out.println("converting BSM of type " + bsm.type() + " to "
	+ (goToPushMode ? "push mode" : "pull mode"));
	}
	assert(isPullModeBSM(bsm) == goToPushMode); // there must be a change
	if (goToPushMode) {
	return PushAdapter.MH_pushToBootstrapMethod.bindTo(bsm).withVarargs(true);
	} else {
	return PullAdapter.MH_pullFromBootstrapMethod.bindTo(bsm).withVarargs(false);
	}
	}
	}

Back to index...