Examples with InvokeKind org.graalvm.compiler.nodes.CallTargetNode.InvokeKind used on opensource projects

Example 6 with InvokeKind

use of org.graalvm.compiler.nodes.CallTargetNode.InvokeKind in project graal by oracle.

the class JNIJavaCallWrapperMethod method buildGraph.

@Override
public StructuredGraph buildGraph(DebugContext debug, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) {
    UniverseMetaAccess metaAccess = (UniverseMetaAccess) providers.getMetaAccess();
    JNIGraphKit kit = new JNIGraphKit(debug, providers, method);
    StructuredGraph graph = kit.getGraph();
    FrameStateBuilder state = new FrameStateBuilder(null, method, graph);
    state.initializeForMethodStart(null, true, providers.getGraphBuilderPlugins());
    JavaKind vmThreadKind = metaAccess.lookupJavaType(JNIEnvironment.class).getJavaKind();
    ValueNode vmThread = kit.loadLocal(0, vmThreadKind);
    kit.append(new CEntryPointEnterNode(EnterAction.Enter, vmThread));
    ResolvedJavaMethod invokeMethod = providers.getMetaAccess().lookupJavaMethod(reflectMethod);
    Signature invokeSignature = invokeMethod.getSignature();
    List<Pair<ValueNode, ResolvedJavaType>> argsWithTypes = loadAndUnboxArguments(kit, providers, invokeMethod, invokeSignature);
    JavaKind returnKind = invokeSignature.getReturnKind();
    if (invokeMethod.isConstructor()) {
        // return `this` to implement NewObject
        assert returnKind == JavaKind.Void;
        returnKind = JavaKind.Object;
    }
    IfNode ifNode = kit.startIf(null, BranchProbabilityNode.FAST_PATH_PROBABILITY);
    kit.thenPart();
    LogicNode typeChecks = LogicConstantNode.tautology(kit.getGraph());
    ValueNode[] args = new ValueNode[argsWithTypes.size()];
    for (int i = 0; i < argsWithTypes.size(); i++) {
        ValueNode value = argsWithTypes.get(i).getLeft();
        ResolvedJavaType type = argsWithTypes.get(i).getRight();
        if (!type.isPrimitive() && !type.isJavaLangObject()) {
            TypeReference typeRef = TypeReference.createTrusted(kit.getAssumptions(), type);
            LogicNode instanceOf = kit.unique(InstanceOfNode.createAllowNull(typeRef, value, null, null));
            typeChecks = LogicNode.and(typeChecks, instanceOf, BranchProbabilityNode.FAST_PATH_PROBABILITY);
            FixedGuardNode guard = kit.append(new FixedGuardNode(instanceOf, DeoptimizationReason.ClassCastException, DeoptimizationAction.None, false));
            value = kit.append(PiNode.create(value, StampFactory.object(typeRef), guard));
        }
        args[i] = value;
    }
    // safe because logic nodes are floating
    ifNode.setCondition(typeChecks);
    InvokeKind kind = // 
    invokeMethod.isStatic() ? // 
    InvokeKind.Static : ((nonVirtual || invokeMethod.isConstructor()) ? InvokeKind.Special : InvokeKind.Virtual);
    ValueNode invokeResult = createInvoke(kit, invokeMethod, kind, state, kit.bci(), args);
    if (invokeMethod.isConstructor()) {
        // return `this` to implement NewObject
        invokeResult = args[0];
    }
    // illegal parameter types
    kit.elsePart();
    ConstantNode exceptionObject = kit.createObject(cachedArgumentClassCastException);
    kit.retainPendingException(exceptionObject);
    ValueNode typeMismatchValue = null;
    if (returnKind != JavaKind.Void) {
        typeMismatchValue = kit.unique(ConstantNode.defaultForKind(returnKind.getStackKind()));
    }
    AbstractMergeNode merge = kit.endIf();
    ValueNode returnValue = null;
    if (returnKind != JavaKind.Void) {
        ValueNode[] inputs = { invokeResult, typeMismatchValue };
        returnValue = kit.getGraph().addWithoutUnique(new ValuePhiNode(invokeResult.stamp(NodeView.DEFAULT), merge, inputs));
        state.push(returnKind, returnValue);
    }
    merge.setStateAfter(state.create(kit.bci(), merge));
    if (returnKind != JavaKind.Void) {
        state.pop(returnKind);
        if (returnKind.isObject()) {
            returnValue = kit.boxObjectInLocalHandle(returnValue);
        }
    }
    kit.append(new CEntryPointLeaveNode(LeaveAction.Leave));
    kit.createReturn(returnValue, returnKind);
    assert graph.verify();
    return graph;
}

Example 7 with InvokeKind

use of org.graalvm.compiler.nodes.CallTargetNode.InvokeKind in project graal by oracle.

the class AArch64HotSpotNodeLIRBuilder method emitDirectCall.

@Override
protected void emitDirectCall(DirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) {
    InvokeKind invokeKind = ((HotSpotDirectCallTargetNode) callTarget).invokeKind();
    if (invokeKind.isIndirect()) {
        append(new AArch64HotSpotDirectVirtualCallOp(callTarget.targetMethod(), result, parameters, temps, callState, invokeKind, getGen().config));
    } else {
        assert invokeKind.isDirect();
        HotSpotResolvedJavaMethod resolvedMethod = (HotSpotResolvedJavaMethod) callTarget.targetMethod();
        assert resolvedMethod.isConcrete() : "Cannot make direct call to abstract method.";
        append(new AArch64HotSpotDirectStaticCallOp(callTarget.targetMethod(), result, parameters, temps, callState, invokeKind, getGen().config));
    }
}

Example 8 with InvokeKind

use of org.graalvm.compiler.nodes.CallTargetNode.InvokeKind in project graal by oracle.

the class BytecodeParser method appendInvoke.

protected Invoke appendInvoke(InvokeKind initialInvokeKind, ResolvedJavaMethod initialTargetMethod, ValueNode[] args) {
    ResolvedJavaMethod targetMethod = initialTargetMethod;
    InvokeKind invokeKind = initialInvokeKind;
    if (initialInvokeKind.isIndirect()) {
        ResolvedJavaType contextType = this.frameState.getMethod().getDeclaringClass();
        ResolvedJavaMethod specialCallTarget = MethodCallTargetNode.findSpecialCallTarget(initialInvokeKind, args[0], initialTargetMethod, contextType);
        if (specialCallTarget != null) {
            invokeKind = InvokeKind.Special;
            targetMethod = specialCallTarget;
        }
    }
    JavaKind resultType = targetMethod.getSignature().getReturnKind();
    if (!parsingIntrinsic() && DeoptALot.getValue(options)) {
        append(new DeoptimizeNode(DeoptimizationAction.None, RuntimeConstraint));
        frameState.pushReturn(resultType, ConstantNode.defaultForKind(resultType, graph));
        return null;
    }
    JavaType returnType = targetMethod.getSignature().getReturnType(method.getDeclaringClass());
    if (graphBuilderConfig.eagerResolving() || parsingIntrinsic()) {
        returnType = returnType.resolve(targetMethod.getDeclaringClass());
    }
    if (invokeKind.hasReceiver()) {
        args[0] = emitExplicitExceptions(args[0]);
    }
    if (initialInvokeKind == InvokeKind.Special && !targetMethod.isConstructor()) {
        emitCheckForInvokeSuperSpecial(args);
    }
    InlineInfo inlineInfo = null;
    try {
        currentInvoke = new CurrentInvoke(args, invokeKind, returnType);
        if (tryNodePluginForInvocation(args, targetMethod)) {
            if (TraceParserPlugins.getValue(options)) {
                traceWithContext("used node plugin for %s", targetMethod.format("%h.%n(%p)"));
            }
            return null;
        }
        if (invokeKind.hasReceiver() && args[0].isNullConstant()) {
            append(new DeoptimizeNode(InvalidateRecompile, NullCheckException));
            return null;
        }
        if (!invokeKind.isIndirect() || (UseGuardedIntrinsics.getValue(options) && !GeneratePIC.getValue(options))) {
            if (tryInvocationPlugin(invokeKind, args, targetMethod, resultType, returnType)) {
                if (TraceParserPlugins.getValue(options)) {
                    traceWithContext("used invocation plugin for %s", targetMethod.format("%h.%n(%p)"));
                }
                return null;
            }
        }
        if (invokeKind.isDirect()) {
            inlineInfo = tryInline(args, targetMethod);
            if (inlineInfo == SUCCESSFULLY_INLINED) {
                return null;
            }
        }
    } finally {
        currentInvoke = null;
    }
    int invokeBci = bci();
    JavaTypeProfile profile = getProfileForInvoke(invokeKind);
    ExceptionEdgeAction edgeAction = getActionForInvokeExceptionEdge(inlineInfo);
    boolean partialIntrinsicExit = false;
    if (intrinsicContext != null && intrinsicContext.isCallToOriginal(targetMethod)) {
        partialIntrinsicExit = true;
        ResolvedJavaMethod originalMethod = intrinsicContext.getOriginalMethod();
        BytecodeParser intrinsicCallSiteParser = getNonIntrinsicAncestor();
        if (intrinsicCallSiteParser != null) {
            // When exiting a partial intrinsic, the invoke to the original
            // must use the same context as the call to the intrinsic.
            invokeBci = intrinsicCallSiteParser.bci();
            profile = intrinsicCallSiteParser.getProfileForInvoke(invokeKind);
            edgeAction = intrinsicCallSiteParser.getActionForInvokeExceptionEdge(inlineInfo);
        } else {
            // so the bci must be set to unknown, so that the inliner patches it later.
            assert intrinsicContext.isPostParseInlined();
            invokeBci = BytecodeFrame.UNKNOWN_BCI;
            profile = null;
            edgeAction = graph.method().getAnnotation(Snippet.class) == null ? ExceptionEdgeAction.INCLUDE_AND_HANDLE : ExceptionEdgeAction.OMIT;
        }
        if (originalMethod.isStatic()) {
            invokeKind = InvokeKind.Static;
        } else {
            // The original call to the intrinsic must have been devirtualized
            // otherwise we wouldn't be here.
            invokeKind = InvokeKind.Special;
        }
        Signature sig = originalMethod.getSignature();
        returnType = sig.getReturnType(method.getDeclaringClass());
        resultType = sig.getReturnKind();
        assert intrinsicContext.allowPartialIntrinsicArgumentMismatch() || checkPartialIntrinsicExit(intrinsicCallSiteParser == null ? null : intrinsicCallSiteParser.currentInvoke.args, args);
        targetMethod = originalMethod;
    }
    Invoke invoke = createNonInlinedInvoke(edgeAction, invokeBci, args, targetMethod, invokeKind, resultType, returnType, profile);
    if (partialIntrinsicExit) {
        // This invoke must never be later inlined as it might select the intrinsic graph.
        // Until there is a mechanism to guarantee that any late inlining will not select
        // the intrinsic graph, prevent this invoke from being inlined.
        invoke.setUseForInlining(false);
    }
    return invoke;
}