Ejemplo n.º 1
0
 /**
  * Similar to {@link #deverbosifyInputsInPlace(com.oracle.graal.nodes.ValueNode)}, except that not
  * the parent but a fresh clone is updated upon any of its children changing.
  *
  * @return the original parent if no updated took place, a copy-on-write version of it otherwise.
  */
 private MethodCallTargetNode deverbosifyInputsCopyOnWrite(MethodCallTargetNode parent) {
   final CallTargetNode.InvokeKind ik = parent.invokeKind();
   final boolean shouldTryDevirt =
       (ik == CallTargetNode.InvokeKind.Interface || ik == CallTargetNode.InvokeKind.Virtual);
   boolean shouldDowncastReceiver = shouldTryDevirt;
   MethodCallTargetNode changed = null;
   for (ValueNode i : FlowUtil.distinctValueAndConditionInputs(parent)) {
     ValueNode j = (ValueNode) reasoner.deverbosify(i);
     if (shouldDowncastReceiver) {
       shouldDowncastReceiver = false;
       j = reasoner.downcast(j);
     }
     if (i != j) {
       assert j != parent;
       if (changed == null) {
         changed = (MethodCallTargetNode) parent.copyWithInputs();
         reasoner.added.add(changed);
         // copyWithInputs() implies graph.unique(changed)
         assert changed.isAlive();
         assert FlowUtil.lacksUsages(changed);
       }
       FlowUtil.replaceInPlace(changed, i, j);
     }
   }
   if (changed == null) {
     return parent;
   }
   FlowUtil.inferStampAndCheck(changed);
   /*
    * No need to rememberSubstitution() because not called from deverbosify(). In detail, it's
    * only deverbosify() that skips visited nodes (thus we'd better have recorded any
    * substitutions we want for them). Not this case.
    */
   return changed;
 }
Ejemplo n.º 2
0
 /**
  * Reduce input nodes based on the state at the program point for the argument (ie, based on
  * "valid facts" only, without relying on any floating-guard-assumption).
  *
  * <p>For each (direct or indirect) child, a copy-on-write version is made in case any of its
  * children changed, with the copy accommodating the updated children. If the parent was shared,
  * copy-on-write prevents the updates from becoming visible to anyone but the invoker of this
  * method.
  *
  * <p><b> Please note the parent node is mutated upon any descendant changing. No copy-on-write is
  * performed for the parent node itself. </b>
  *
  * <p>In more detail, for each direct {@link com.oracle.graal.nodes.ValueNode} input of the node
  * at hand,
  *
  * <ol>
  *   <li>Obtain a lazy-copied version (via spanning tree) of the DAG rooted at the input-usage in
  *       question. Lazy-copying is done by walking a spanning tree of the original DAG, stopping
  *       at non-FloatingNodes but transitively walking FloatingNodes and their inputs. Upon
  *       arriving at a (floating) node N, the state's facts are checked to determine whether a
  *       constant C can be used instead in the resulting lazy-copied DAG. A NodeBitMap is used to
  *       realize the spanning tree.
  *   <li>Provided one or more N-to-C node replacements took place, the resulting lazy-copied DAG
  *       has a parent different from the original (ie different object identity) which indicates
  *       the (copied, updated) DAG should replace the original via replaceFirstInput(), and
  *       inferStamp() should be invoked to reflect the updated inputs.
  * </ol>
  *
  * @return whether any reduction was performed on the inputs of the arguments.
  */
 public boolean deverbosifyInputsInPlace(ValueNode parent) {
   boolean changed = false;
   for (ValueNode i : FlowUtil.distinctValueAndConditionInputs(parent)) {
     assert !(i instanceof GuardNode) : "This phase not intended to run during MidTier";
     ValueNode j = (ValueNode) reasoner.deverbosify(i);
     if (i != j) {
       changed = true;
       FlowUtil.replaceInPlace(parent, i, j);
     }
   }
   if (changed) {
     FlowUtil.inferStampAndCheck(parent);
   }
   return changed;
 }
Ejemplo n.º 3
0
 /**
  * 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);
   }
 }