@Test public void testJoin7() { Stamp aExact = StampFactory.exact(getType(A.class)); Stamp e = StampFactory.declared(getType(E.class)); Stamp join = join(aExact, e); Assert.assertTrue(StampTool.isPointerAlwaysNull(join)); Assert.assertNull(StampTool.typeOrNull(join)); Assert.assertFalse(StampTool.isExactType(join)); }
@Test public void testJoin6() { Stamp dExactNonNull = StampFactory.exactNonNull(getType(D.class)); Stamp alwaysNull = StampFactory.alwaysNull(); Stamp join = join(alwaysNull, dExactNonNull); Assert.assertFalse(join.isLegal()); Assert.assertFalse(StampTool.isPointerNonNull(join)); Assert.assertFalse(StampTool.isPointerAlwaysNull(join)); }
@Test public void testJoin5() { Stamp dExact = StampFactory.exact(getType(D.class)); Stamp c = StampFactory.declared(getType(C.class)); Stamp join = join(c, dExact); Assert.assertTrue(StampTool.isPointerAlwaysNull(join)); Assert.assertNull(StampTool.typeOrNull(join)); Assert.assertFalse(StampTool.isExactType(join)); }
@Test public void testJoin9() { Stamp bExact = StampFactory.exact(getType(B.class)); Stamp dExact = StampFactory.exact(getType(D.class)); Stamp join = join(bExact, dExact); Assert.assertTrue(StampTool.isPointerAlwaysNull(join)); Assert.assertNull(StampTool.typeOrNull(join)); Assert.assertNull(StampTool.typeOrNull(join)); }
/** * For one or more `invoke` arguments, flow-sensitive information may suggest their narrowing or * simplification. In those cases, a new {@link com.oracle.graal.nodes.java.MethodCallTargetNode * MethodCallTargetNode} is prepared just for this callsite, consuming reduced arguments. * * <p>Specializing the {@link com.oracle.graal.nodes.java.MethodCallTargetNode * MethodCallTargetNode} as described above may enable two optimizations: * * <ul> * <li>devirtualization of an {@link com.oracle.graal.nodes.CallTargetNode.InvokeKind#Interface} * or {@link com.oracle.graal.nodes.CallTargetNode.InvokeKind#Virtual} callsite * (devirtualization made possible after narrowing the type of the receiver) * <li>(future work) actual-argument-aware inlining, ie, to specialize callees on the types of * arguments other than the receiver (examples: multi-methods, the inlining problem, lambdas * as arguments). * </ul> * * <p>Precondition: inputs haven't been deverbosified yet. */ private void visitInvoke(Invoke invoke) { if (invoke.asNode().stamp() instanceof IllegalStamp) { return; // just to be safe } boolean isMethodCallTarget = invoke.callTarget() instanceof MethodCallTargetNode; if (!isMethodCallTarget) { return; } FlowUtil.replaceInPlace( invoke.asNode(), invoke.callTarget(), deverbosifyInputsCopyOnWrite((MethodCallTargetNode) invoke.callTarget())); MethodCallTargetNode callTarget = (MethodCallTargetNode) invoke.callTarget(); if (callTarget.invokeKind() != CallTargetNode.InvokeKind.Interface && callTarget.invokeKind() != CallTargetNode.InvokeKind.Virtual) { return; } ValueNode receiver = callTarget.receiver(); if (receiver == null) { return; } if (!FlowUtil.hasLegalObjectStamp(receiver)) { return; } Witness w = state.typeInfo(receiver); ResolvedJavaType type; ResolvedJavaType stampType = StampTool.typeOrNull(receiver); if (w == null || w.cluelessAboutType()) { // can't improve on stamp but wil try to devirtualize anyway type = stampType; } else { type = FlowUtil.tighten(w.type(), stampType); } if (type == null) { return; } ResolvedJavaMethod method = type.resolveMethod(callTarget.targetMethod(), invoke.getContextType()); if (method == null) { return; } if (method.canBeStaticallyBound() || Modifier.isFinal(type.getModifiers())) { metricMethodResolved.increment(); callTarget.setInvokeKind(CallTargetNode.InvokeKind.Special); callTarget.setTargetMethod(method); } }
@Test public void testJoin3() { Stamp d = StampFactory.declared(getType(D.class)); Stamp c = StampFactory.declared(getType(C.class)); Assert.assertTrue(StampTool.isPointerAlwaysNull(join(c, d))); }
public static Stamp sub(IntegerStamp stamp1, IntegerStamp stamp2) { return add(stamp1, (IntegerStamp) StampTool.negate(stamp2)); }