package org.graalvm.compiler.nodes.java;
import org.graalvm.compiler.core.common.type.Stamp;
import org.graalvm.compiler.core.common.type.StampFactory;
import org.graalvm.compiler.core.common.type.StampPair;
import org.graalvm.compiler.core.common.type.TypeReference;
import org.graalvm.compiler.graph.IterableNodeType;
import org.graalvm.compiler.graph.Node;
import org.graalvm.compiler.graph.NodeClass;
import org.graalvm.compiler.graph.spi.Simplifiable;
import org.graalvm.compiler.graph.spi.SimplifierTool;
import org.graalvm.compiler.nodeinfo.NodeInfo;
import org.graalvm.compiler.nodeinfo.Verbosity;
import org.graalvm.compiler.nodes.CallTargetNode;
import org.graalvm.compiler.nodes.FixedGuardNode;
import org.graalvm.compiler.nodes.Invoke;
import org.graalvm.compiler.nodes.LogicNode;
import org.graalvm.compiler.nodes.NodeView;
import org.graalvm.compiler.nodes.PiNode;
import org.graalvm.compiler.nodes.StructuredGraph;
import org.graalvm.compiler.nodes.ValueNode;
import org.graalvm.compiler.nodes.extended.ValueAnchorNode;
import org.graalvm.compiler.nodes.spi.UncheckedInterfaceProvider;
import org.graalvm.compiler.nodes.type.StampTool;
import jdk.vm.ci.code.BytecodeFrame;
import jdk.vm.ci.meta.Assumptions;
import jdk.vm.ci.meta.Assumptions.AssumptionResult;
import jdk.vm.ci.meta.DeoptimizationAction;
import jdk.vm.ci.meta.DeoptimizationReason;
import jdk.vm.ci.meta.JavaKind;
import jdk.vm.ci.meta.JavaTypeProfile;
import jdk.vm.ci.meta.ResolvedJavaMethod;
import jdk.vm.ci.meta.ResolvedJavaType;
@NodeInfo
public class MethodCallTargetNode extends CallTargetNode implements IterableNodeType, Simplifiable {
public static final NodeClass<MethodCallTargetNode> TYPE = NodeClass.create(MethodCallTargetNode.class);
protected JavaTypeProfile profile;
public MethodCallTargetNode(InvokeKind invokeKind, ResolvedJavaMethod targetMethod, ValueNode[] arguments, StampPair returnStamp, JavaTypeProfile profile) {
this(TYPE, invokeKind, targetMethod, arguments, returnStamp, profile);
}
protected MethodCallTargetNode(NodeClass<? extends MethodCallTargetNode> c, InvokeKind invokeKind, ResolvedJavaMethod targetMethod, ValueNode[] arguments, StampPair returnStamp,
JavaTypeProfile profile) {
super(c, arguments, targetMethod, invokeKind, returnStamp);
this.profile = profile;
}
public ValueNode receiver() {
return isStatic() ? null : arguments().get(0);
}
public boolean isStatic() {
return invokeKind() == InvokeKind.Static;
}
public JavaKind returnKind() {
return targetMethod().getSignature().getReturnKind();
}
public Invoke invoke() {
return (Invoke) this.usages().first();
}
@Override
public boolean verify() {
assert getUsageCount() <= 1 : "call target may only be used by a single invoke";
for (Node n : usages()) {
assertTrue(n instanceof Invoke, "call target can only be used from an invoke (%s)", n);
}
if (invokeKind().isDirect()) {
assertTrue(targetMethod().isConcrete(), "special calls or static calls are only allowed for concrete methods (%s)", targetMethod());
}
if (invokeKind() == InvokeKind.Static) {
assertTrue(targetMethod().isStatic(), "static calls are only allowed for static methods (%s)", targetMethod());
} else {
assertFalse(targetMethod().isStatic(), "static calls are only allowed for non-static methods (%s)", targetMethod());
}
return super.verify();
}
@Override
public String toString(Verbosity verbosity) {
if (verbosity == Verbosity.Long) {
return super.toString(Verbosity.Short) + "(" + targetMethod() + ")";
} else {
return super.toString(verbosity);
}
}
public static ResolvedJavaMethod findSpecialCallTarget(InvokeKind invokeKind, ValueNode receiver, ResolvedJavaMethod targetMethod, ResolvedJavaType contextType) {
if (invokeKind.isDirect()) {
return null;
}
if (targetMethod.canBeStaticallyBound()) {
return targetMethod;
}
return devirtualizeCall(invokeKind, targetMethod, contextType, receiver.graph().getAssumptions(), receiver.stamp(NodeView.DEFAULT));
}
public static ResolvedJavaMethod devirtualizeCall(InvokeKind invokeKind, ResolvedJavaMethod targetMethod, ResolvedJavaType contextType, Assumptions assumptions, Stamp receiverStamp) {
TypeReference type = StampTool.typeReferenceOrNull(receiverStamp);
if (type == null && invokeKind == InvokeKind.Virtual) {
type = TypeReference.createTrusted(assumptions, targetMethod.getDeclaringClass());
}
if (type != null) {
ResolvedJavaMethod resolvedMethod = type.getType().resolveConcreteMethod(targetMethod, contextType);
if (resolvedMethod != null && (resolvedMethod.canBeStaticallyBound() || type.isExact() || type.getType().isArray())) {
return resolvedMethod;
}
AssumptionResult<ResolvedJavaMethod> uniqueConcreteMethod = type.getType().findUniqueConcreteMethod(targetMethod);
if (uniqueConcreteMethod != null && uniqueConcreteMethod.canRecordTo(assumptions)) {
uniqueConcreteMethod.recordTo(assumptions);
return uniqueConcreteMethod.getResult();
}
}
return null;
}
@Override
public void simplify(SimplifierTool tool) {
if (invoke().getContextMethod() == null) {
assert (invoke().stateAfter() != null && BytecodeFrame.isPlaceholderBci(invoke().stateAfter().bci)) || BytecodeFrame.isPlaceholderBci(invoke().stateDuring().bci);
return;
}
ResolvedJavaType contextType = (invoke().stateAfter() == null && invoke().stateDuring() == null) ? null : invoke().getContextType();
ResolvedJavaMethod specialCallTarget = findSpecialCallTarget(invokeKind, receiver(), targetMethod, contextType);
if (specialCallTarget != null) {
this.setTargetMethod(specialCallTarget);
setInvokeKind(InvokeKind.Special);
return;
}
Assumptions assumptions = graph().getAssumptions();
if (invokeKind().isInterface() && assumptions != null) {
ValueNode receiver = receiver();
ResolvedJavaType declaredReceiverType = targetMethod().getDeclaringClass();
ResolvedJavaType referencedReceiverType = referencedType();
if (referencedReceiverType != null) {
if (declaredReceiverType.isInterface()) {
ResolvedJavaType singleImplementor = referencedReceiverType.getSingleImplementor();
if (singleImplementor != null && !singleImplementor.equals(declaredReceiverType)) {
TypeReference speculatedType = TypeReference.createTrusted(assumptions, singleImplementor);
if (tryCheckCastSingleImplementor(receiver, speculatedType)) {
return;
}
}
}
if (receiver instanceof UncheckedInterfaceProvider) {
UncheckedInterfaceProvider uncheckedInterfaceProvider = (UncheckedInterfaceProvider) receiver;
Stamp uncheckedStamp = uncheckedInterfaceProvider.uncheckedStamp();
if (uncheckedStamp != null) {
TypeReference speculatedType = StampTool.typeReferenceOrNull(uncheckedStamp);
if (speculatedType != null && referencedReceiverType.isAssignableFrom(speculatedType.getType())) {
tryCheckCastSingleImplementor(receiver, speculatedType);
}
}
}
}
}
}
private boolean tryCheckCastSingleImplementor(ValueNode receiver, TypeReference speculatedType) {
ResolvedJavaType singleImplementor = speculatedType.getType();
if (singleImplementor != null) {
ResolvedJavaMethod singleImplementorMethod = singleImplementor.resolveConcreteMethod(targetMethod(), invoke().getContextType());
if (singleImplementorMethod != null) {
ValueAnchorNode anchor = new ValueAnchorNode(null);
if (anchor != null) {
graph().add(anchor);
graph().addBeforeFixed(invoke().asNode(), anchor);
}
LogicNode condition = graph().addOrUniqueWithInputs(InstanceOfNode.create(speculatedType, receiver, getProfile(), anchor));
FixedGuardNode guard = graph().add(new FixedGuardNode(condition, DeoptimizationReason.OptimizedTypeCheckViolated, DeoptimizationAction.InvalidateRecompile, false));
graph().addBeforeFixed(invoke().asNode(), guard);
ValueNode valueNode = graph().addOrUnique(new PiNode(receiver, StampFactory.objectNonNull(speculatedType), guard));
arguments().set(0, valueNode);
if (speculatedType.isExact()) {
setInvokeKind(InvokeKind.Special);
} else {
setInvokeKind(InvokeKind.Virtual);
}
setTargetMethod(singleImplementorMethod);
return true;
}
}
return false;
}
public JavaTypeProfile getProfile() {
return profile;
}
@Override
public String targetName() {
if (targetMethod() == null) {
return "??Invalid!";
}
return targetMethod().format("%h.%n");
}
public static MethodCallTargetNode find(StructuredGraph graph, ResolvedJavaMethod method) {
for (MethodCallTargetNode target : graph.getNodes(MethodCallTargetNode.TYPE)) {
if (target.targetMethod().equals(method)) {
return target;
}
}
return null;
}
}