java.lang.invoke.MutableCallSite Java Examples

private static void loadBuiltins(TypeImpl ti, ClassLoader cl, Map<String, JCasClassInfo> type2jcci, ArrayList<MutableCallSite> callSites_toSync) {
    String typeName = ti.getName();
    
    if (BuiltinTypeKinds.creatableBuiltinJCas.contains(typeName) || typeName.equals(CAS.TYPE_NAME_SOFA)) {
      JCasClassInfo jcci = getOrCreateJCasClassInfo(ti, cl, type2jcci, defaultLookup);
      assert jcci != null;
      // done while beginning to commit the staticTsi (before committed flag is set), for builtins  
      updateOrValidateAllCallSitesForJCasClass(jcci.jcasClass, ti, callSites_toSync);
      jcasClassesInfoForBuiltins[ti.getCode()] = jcci;
      
//      Class<?> builtinClass = maybeLoadJCas(ti, cl);
//      assert (builtinClass != null);  // builtin types must be present
//      // copy down to subtypes, if needed, done later
//      int jcasType = Misc.getStaticIntFieldNoInherit(builtinClass, "typeIndexID");
//      JCasClassInfo jcasClassInfo = createJCasClassInfo(builtinClass, ti, jcasType); 
//      jcasClassesInfoForBuiltins[ti.getCode()] = jcasClassInfo; 
    }
    
    for (TypeImpl subType : ti.getDirectSubtypes()) {
      loadBuiltins(subType, cl, type2jcci, callSites_toSync);
    }
  }
 

private static MethodHandle setCallSiteTarget(MutableCallSite callsite, MethodHandle target, MethodHandle test,
        MethodHandle generic) {
    MethodHandle callSiteTarget;
    if (target != null) {
        target = target.asType(callsite.type());
        if (test != null) {
            MethodHandle fallback = createFallback(callsite, generic);
            callSiteTarget = MethodHandles.guardWithTest(test, target, fallback);
        } else {
            callSiteTarget = target;
        }
    } else {
        callSiteTarget = target = generic;
    }
    callsite.setTarget(callSiteTarget);
    return target;
}
 

public static void testNonBoundCallSite() throws Throwable {
    mcs = new MutableCallSite(LOOKUP.findStatic(T.class, "f1", TYPE));

    // mcs.context == null
    MethodHandle mh = mcs.dynamicInvoker();
    execute(1, mh);

    // mcs.context == cls1
    Class<?> cls1 = UNSAFE.defineAnonymousClass(CallSiteDepContextTest.class, getClassFile("NonBound_1"), null);
    MethodHandle mh1 = LOOKUP.findStatic(cls1, METHOD_NAME, TYPE);

    execute(1, mh1);

    mcs.setTarget(LOOKUP.findStatic(T.class, "f2", TYPE));

    execute(2, mh, mh1);
}
 

/**
 * Core method for indy method selection using runtime types.
 */
public static Object selectMethod(MutableCallSite callSite, Class<?> sender, String methodName, int callID, Boolean safeNavigation, Boolean thisCall, Boolean spreadCall, Object dummyReceiver, Object[] arguments) throws Throwable {
    final MethodHandleWrapper mhw = fallback(callSite, sender, methodName, callID, safeNavigation, thisCall, spreadCall, dummyReceiver, arguments);

    if (callSite instanceof CacheableCallSite) {
        CacheableCallSite cacheableCallSite = (CacheableCallSite) callSite;

        final MethodHandle defaultTarget = cacheableCallSite.getDefaultTarget();
        final long fallbackCount = cacheableCallSite.incrementFallbackCount();
        if ((fallbackCount > INDY_FALLBACK_THRESHOLD) && (cacheableCallSite.getTarget() != defaultTarget)) {
            cacheableCallSite.setTarget(defaultTarget);
            if (LOG_ENABLED) LOG.info("call site target reset to default, preparing outside invocation");

            cacheableCallSite.resetFallbackCount();
        }

        if (defaultTarget == cacheableCallSite.getTarget()) {
            // correct the stale methodhandle in the inline cache of callsite
            // it is important but impacts the performance somehow when cache misses frequently
            doWithCallSite(callSite, arguments, (cs, receiver) -> cs.put(receiver.getClass().getName(), mhw));
        }
    }

    return mhw.getCachedMethodHandle().invokeExact(arguments);
}
 

/**
 * Returns the Selector
 */
public static Selector getSelector(MutableCallSite callSite, Class<?> sender, String methodName, int callID, boolean safeNavigation, boolean thisCall, boolean spreadCall, Object[] arguments) {
    CallType callType = CALL_TYPE_VALUES[callID];
    switch (callType) {
        case INIT:
            return new InitSelector(callSite, sender, methodName, callType, safeNavigation, thisCall, spreadCall, arguments);
        case METHOD:
            return new MethodSelector(callSite, sender, methodName, callType, safeNavigation, thisCall, spreadCall, arguments);
        case GET:
            return new PropertySelector(callSite, sender, methodName, callType, safeNavigation, thisCall, spreadCall, arguments);
        case SET:
            throw new GroovyBugError("your call tried to do a property set, which is not supported.");
        case CAST:
            return new CastSelector(callSite, arguments);
        default:
            throw new GroovyBugError("unexpected call type");
    }
}
 

public static CallSite gwtBootstrap(Lookup ignored, String name, MethodType type) throws Throwable {
	Lookup lookup = lookup();
	MethodHandle double_string = lookup.findStatic(BootstrapMethods.class, "dup", methodType(String.class, String.class));
	MethodHandle double_integer = lookup.findStatic(BootstrapMethods.class, "dup", methodType(String.class, Integer.class));
	MethodHandle double_object = lookup.findStatic(BootstrapMethods.class, "dup", methodType(String.class, Object.class));
	MethodHandle isInteger = lookup.findStatic(BootstrapMethods.class, "isInteger", methodType(boolean.class, Object.class));
	MethodHandle isString = lookup.findStatic(BootstrapMethods.class, "isString", methodType(boolean.class, Object.class));

	MethodHandle handle = guardWithTest(
			isString, 
			double_string.asType(methodType(String.class, Object.class)),
			double_object);
	handle = guardWithTest(
			isInteger,
			double_integer.asType(methodType(String.class, Object.class)),
			handle);
	return new MutableCallSite(handle);
}
 

@SuppressWarnings("unused")
private static MethodHandle nativeCallSetup(MutableCallSite callsite, String name, ExecutionContext cx) {
    RuntimeContext context = cx.getRuntimeContext();
    MethodHandle target;
    try {
        MethodHandle mh = context.getNativeCallResolver().apply(name, callsite.type());
        if (mh == null) {
            throw new IllegalArgumentException();
        }
        target = adaptNativeMethodHandle(mh);
        target = adaptMethodHandle(name, callsite.type(), target);
    } catch (IllegalArgumentException e) {
        target = invalidCallHandle(name, callsite.type());
    }
    callsite.setTarget(target);
    return target;
}
 

private static void concatSetup(MutableCallSite callsite, MethodType type) {
    MethodHandle target, test, generic;
    int numberOfStrings = type.parameterCount() - 1; // CharSequence..., ExecutionContext
    if (numberOfStrings <= CONCAT_MAX_SPECIALIZATION) {
        assert numberOfStrings >= CONCAT_MIN_PARAMS;
        int index = numberOfStrings - CONCAT_MIN_PARAMS;
        target = concatMH[index];
        test = testConcatMH[index];
        generic = concatConsMH[index];
    } else {
        final int index = CONCAT_MAX_SPECIALIZATION - CONCAT_MIN_PARAMS + 1;
        target = concatMH[index].asCollector(CharSequence[].class, numberOfStrings);
        test = testConcatMH[index].asCollector(CharSequence[].class, numberOfStrings);
        generic = concatConsMH[index].asCollector(CharSequence[].class, numberOfStrings);
    }
    setCallSiteTarget(callsite, target, test, generic);
}
 

private static void registerCallSitePlugins(InvocationPlugins plugins) {
    InvocationPlugin plugin = new InvocationPlugin() {
        @Override
        public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver receiver) {
            ValueNode callSite = receiver.get();
            ValueNode folded = CallSiteTargetNode.tryFold(GraphUtil.originalValue(callSite), b.getMetaAccess(), b.getAssumptions());
            if (folded != null) {
                b.addPush(JavaKind.Object, folded);
            } else {
                b.addPush(JavaKind.Object, new CallSiteTargetNode(b.getInvokeKind(), targetMethod, b.bci(), b.getInvokeReturnStamp(b.getAssumptions()), callSite));
            }
            return true;
        }

        @Override
        public boolean inlineOnly() {
            return true;
        }
    };
    plugins.register(plugin, ConstantCallSite.class, "getTarget", Receiver.class);
    plugins.register(plugin, MutableCallSite.class, "getTarget", Receiver.class);
    plugins.register(plugin, VolatileCallSite.class, "getTarget", Receiver.class);
}
 

private static MethodHandle bitOrSetup(MutableCallSite callsite, Number arg1, Number arg2, ExecutionContext cx) {
    Type type = getType(arg1, arg2);
    MethodHandle target;
    if (type == Type.Number) {
        target = bitOrNumberMH;
    } else if (type == Type.BigInt) {
        target = bitOrBigIntMH;
    } else {
        target = null;
    }
    return setCallSiteTarget(callsite, target, getTestForBinaryNumber(type), bitOrGenericMH);
}
 

private static MethodHandle shrSetup(MutableCallSite callsite, Number arg1, Number arg2, ExecutionContext cx) {
    Type type = getType(arg1, arg2);
    MethodHandle target;
    if (type == Type.Number) {
        target = shrNumberMH;
    } else if (type == Type.BigInt) {
        target = shrBigIntMH;
    } else {
        target = null;
    }
    return setCallSiteTarget(callsite, target, getTestForBinaryNumber(type), shrGenericMH);
}
 

private void updateCallSite(boolean desired_state, MethodHandle tester, MutableCallSite c, MethodHandle mh, MutableCallSite[] cs) {
  try {
    if (((boolean)tester.invokeExact()) != desired_state) {
      c.setTarget(mh);
      MutableCallSite.syncAll(cs);
    }
  } catch (Throwable e) {
    Misc.internalError(e);
  }
}
 

private static MethodHandle decSetup(MutableCallSite callsite, Number arg) {
    Type type = getType(arg);
    MethodHandle target;
    if (type == Type.Number) {
        target = decNumberMH;
    } else if (type == Type.BigInt) {
        target = decBigIntMH;
    } else {
        target = null;
    }
    return setCallSiteTarget(callsite, target, getTestForUnaryNumber(type), decGenericMH);
}
 

private static MethodHandle incSetup(MutableCallSite callsite, Number arg) {
    Type type = getType(arg);
    MethodHandle target;
    if (type == Type.Number) {
        target = incNumberMH;
    } else if (type == Type.BigInt) {
        target = incBigIntMH;
    } else {
        target = null;
    }
    return setCallSiteTarget(callsite, target, getTestForUnaryNumber(type), incGenericMH);
}
 

private static MethodHandle negSetup(MutableCallSite callsite, Number arg) {
    Type type = getType(arg);
    MethodHandle target;
    if (type == Type.Number) {
        target = negNumberMH;
    } else if (type == Type.BigInt) {
        target = negBigIntMH;
    } else {
        target = null;
    }
    return setCallSiteTarget(callsite, target, getTestForUnaryNumber(type), negGenericMH);
}
 

private static MethodHandle bitNotSetup(MutableCallSite callsite, Number arg) {
    Type type = getType(arg);
    MethodHandle target;
    if (type == Type.Number) {
        target = bitNotNumberMH;
    } else if (type == Type.BigInt) {
        target = bitNotBigIntMH;
    } else {
        target = null;
    }
    return setCallSiteTarget(callsite, target, getTestForUnaryNumber(type), bitNotGenericMH);
}
 

private static MethodHandle bitXorSetup(MutableCallSite callsite, Number arg1, Number arg2, ExecutionContext cx) {
    Type type = getType(arg1, arg2);
    MethodHandle target;
    if (type == Type.Number) {
        target = bitXorNumberMH;
    } else if (type == Type.BigInt) {
        target = bitXorBigIntMH;
    } else {
        target = null;
    }
    return setCallSiteTarget(callsite, target, getTestForBinaryNumber(type), bitXorGenericMH);
}
 

private static MethodHandle modSetup(MutableCallSite callsite, Number arg1, Number arg2, ExecutionContext cx) {
    Type type = getType(arg1, arg2);
    MethodHandle target;
    if (type == Type.Number) {
        target = modNumberMH;
    } else if (type == Type.BigInt) {
        target = modBigIntMH;
    } else {
        target = null;
    }
    return setCallSiteTarget(callsite, target, getTestForBinaryNumber(type), modGenericMH);
}
 

private static MethodHandle shlSetup(MutableCallSite callsite, Number arg1, Number arg2, ExecutionContext cx) {
    Type type = getType(arg1, arg2);
    MethodHandle target;
    if (type == Type.Number) {
        target = shlNumberMH;
    } else if (type == Type.BigInt) {
        target = shlBigIntMH;
    } else {
        target = null;
    }
    return setCallSiteTarget(callsite, target, getTestForBinaryNumber(type), shlGenericMH);
}
 

private static MethodHandle divSetup(MutableCallSite callsite, Number arg1, Number arg2, ExecutionContext cx) {
    Type type = getType(arg1, arg2);
    MethodHandle target;
    if (type == Type.Number) {
        target = divNumberMH;
    } else if (type == Type.BigInt) {
        target = divBigIntMH;
    } else {
        target = null;
    }
    return setCallSiteTarget(callsite, target, getTestForBinaryNumber(type), divGenericMH);
}
 

private static MethodHandle expSetup(MutableCallSite callsite, Number arg1, Number arg2, ExecutionContext cx) {
    Type type = getType(arg1, arg2);
    MethodHandle target;
    if (type == Type.Number) {
        target = expNumberMH;
    } else if (type == Type.BigInt) {
        target = expBigIntMH;
    } else {
        target = null;
    }
    return setCallSiteTarget(callsite, target, getTestForBinaryNumber(type), expGenericMH);
}
 

private static MethodHandle subSetup(MutableCallSite callsite, Number arg1, Number arg2, ExecutionContext cx) {
    Type type = getType(arg1, arg2);
    MethodHandle target;
    if (type == Type.Number) {
        target = subNumberMH;
    } else if (type == Type.BigInt) {
        target = subBigIntMH;
    } else {
        target = null;
    }
    return setCallSiteTarget(callsite, target, getTestForBinaryNumber(type), subGenericMH);
}
 

private static MethodHandle strictEqCmpSetup(MutableCallSite callsite, Object arg1, Object arg2) {
    // TODO(BigInt): Implement BigInt specializations.
    Type type = getType(arg1, arg2);
    MethodHandle target;
    if (type == Type.String) {
        target = strictEqCmpStringMH;
    } else if (type == Type.Number) {
        target = strictEqCmpNumberMH;
    } else if (type == Type.Boolean) {
        target = strictEqCmpBooleanMH;
    } else {
        target = null;
    }
    return setCallSiteTarget(callsite, target, getTestForBinary(type), strictEqCmpGenericMH);
}
 

private static MethodHandle eqCmpSetup(MutableCallSite callsite, Object arg1, Object arg2, ExecutionContext cx) {
    // TODO(BigInt): Implement BigInt specializations.
    Type type = getType(arg1, arg2);
    MethodHandle target;
    if (type == Type.String) {
        target = eqCmpStringMH;
    } else if (type == Type.Number) {
        target = eqCmpNumberMH;
    } else if (type == Type.Boolean) {
        target = eqCmpBooleanMH;
    } else {
        target = null;
    }
    return setCallSiteTarget(callsite, target, getTestForBinary(type), eqCmpGenericMH);
}
 

private static MethodHandle relCmpSetup(MutableCallSite callsite, RelationalOperator op, Object arg1, Object arg2,
        ExecutionContext cx) {
    Type type = getType(arg1, arg2);
    MethodHandle target;
    if (type == Type.String) {
        target = filterReturnValue(relCmpStringMH, op);
    } else if (type == Type.Number) {
        target = filterReturnValue(relCmpNumberMH, op);
    } else {
        target = null;
    }
    return setCallSiteTarget(callsite, target, getTestForBinary(type),
            filterReturnValue(MethodHandles.insertArguments(relCmpGenericMH, 2, op), op));
}
 

private static MethodHandle addSetup(MutableCallSite callsite, Object arg1, Object arg2, ExecutionContext cx) {
    Type type = getType(arg1, arg2);
    MethodHandle target;
    if (type == Type.String) {
        target = addStringMH;
    } else if (type == Type.Number) {
        target = addNumberMH;
    } else {
        target = null;
    }
    return setCallSiteTarget(callsite, target, getTestForBinary(type), addGenericMH);
}
 

private static <T> T doWithCallSite(MutableCallSite callSite, Object[] arguments, BiFunction<? super CacheableCallSite, ? super Object, ? extends T> f) {
    if (callSite instanceof CacheableCallSite) {
        CacheableCallSite cacheableCallSite = (CacheableCallSite) callSite;
        Object receiver = arguments[0];

        if (null == receiver) receiver = NullObject.getNullObject();

        return f.apply(cacheableCallSite, receiver);
    }

    throw new GroovyBugError("CacheableCallSite is expected, but the actual callsite is: " + callSite);
}
 

private static MethodHandleWrapper fallback(MutableCallSite callSite, Class<?> sender, String methodName, int callID, Boolean safeNavigation, Boolean thisCall, Boolean spreadCall, Object dummyReceiver, Object[] arguments) {
    Selector selector = Selector.getSelector(callSite, sender, methodName, callID, safeNavigation, thisCall, spreadCall, arguments);
    selector.setCallSiteTarget();

    return new MethodHandleWrapper(
            selector.handle.asSpreader(Object[].class, arguments.length).asType(MethodType.methodType(Object.class, Object[].class)),
            selector.handle,
            selector.cache
    );
}
 

/**
 * Get the cached methodhandle. if the related methodhandle is not found in the inline cache, cache and return it.
 */
public static Object fromCache(MutableCallSite callSite, Class<?> sender, String methodName, int callID, Boolean safeNavigation, Boolean thisCall, Boolean spreadCall, Object dummyReceiver, Object[] arguments) throws Throwable {
    FallbackSupplier fallbackSupplier = new FallbackSupplier(callSite, sender, methodName, callID, safeNavigation, thisCall, spreadCall, dummyReceiver, arguments);

    MethodHandleWrapper mhw =
            doWithCallSite(
                    callSite, arguments,
                    (cs, receiver) ->
                            cs.getAndPut(
                                    receiver.getClass().getName(),
                                    c -> {
                                        MethodHandleWrapper fbMhw = fallbackSupplier.get();
                                        return fbMhw.isCanSetTarget() ? fbMhw : NULL_METHOD_HANDLE_WRAPPER;
                                    }
                            )
            );

    if (NULL_METHOD_HANDLE_WRAPPER == mhw) {
        mhw = fallbackSupplier.get();
    }

    if (mhw.isCanSetTarget() && (callSite.getTarget() != mhw.getTargetMethodHandle()) && (mhw.getLatestHitCount() > INDY_OPTIMIZE_THRESHOLD)) {
        callSite.setTarget(mhw.getTargetMethodHandle());
        if (LOG_ENABLED) LOG.info("call site target set, preparing outside invocation");

        mhw.resetLatestHitCount();
    }

    return mhw.getCachedMethodHandle().invokeExact(arguments);
}
 

FallbackSupplier(MutableCallSite callSite, Class<?> sender, String methodName, int callID, Boolean safeNavigation, Boolean thisCall, Boolean spreadCall, Object dummyReceiver, Object[] arguments) {
    this.callSite = callSite;
    this.sender = sender;
    this.methodName = methodName;
    this.callID = callID;
    this.safeNavigation = safeNavigation;
    this.thisCall = thisCall;
    this.spreadCall = spreadCall;
    this.dummyReceiver = dummyReceiver;
    this.arguments = arguments;
}