com.oracle.graal.nodes

Class IfNode

java.lang.Object

com.oracle.graal.graph.Node

com.oracle.graal.nodes.ValueNode

com.oracle.graal.nodes.FixedNode

com.oracle.graal.nodes.ControlSplitNode

com.oracle.graal.nodes.IfNode

All Implemented Interfaces:

IterableNodeType, Simplifiable, LIRLowerable, Cloneable, Formattable, KindProvider

public final class IfNode
extends ControlSplitNode
implements Simplifiable, LIRLowerable

The IfNode represents a branch that can go one of two directions depending on the outcome of a comparison.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
private static class	IfNode.MutableProfiledType

Nested classes/interfaces inherited from class com.oracle.graal.graph.Node

Node.ConstantNodeParameter, Node.InjectedNodeParameter, Node.Input, Node.NodeIntrinsic, Node.OptionalInput, Node.Successor, Node.ValueNumberable

Field Summary

Fields

Modifier and Type	Field and Description
(package private) LogicNode	condition
private static DebugMetric	CORRECTED_PROBABILITIES
(package private) AbstractBeginNode	falseSuccessor
private static double	NOT_RECORDED_CUTOFF If the not-recorded fraction of types for the new profile of instanceOfA is above this threshold, no profile is used for this instanceof after the swap.
private static double	NOT_RECORDED_SUBTYPE_B Arbitrary fraction of not recorded types that we'll guess are sub-types of B.
(package private) AbstractBeginNode	trueSuccessor
protected double	trueSuccessorProbability
static NodeClass<IfNode>	TYPE

Fields inherited from class com.oracle.graal.nodes.ValueNode

stamp

Fields inherited from class com.oracle.graal.graph.Node

NODE_LIST, NOT_ITERABLE, USE_UNSAFE_TO_CLONE, WithAllEdges, WithNoEdges, WithOnlyInputEdges, WithOnlySucessorEdges

Constructor Summary

Constructors

Constructor and Description
IfNode(LogicNode condition, AbstractBeginNode trueSuccessor, AbstractBeginNode falseSuccessor, double trueSuccessorProbability)
IfNode(LogicNode condition, FixedNode trueSuccessor, FixedNode falseSuccessor, double trueSuccessorProbability)

Method Summary

Modifier and Type	Method and Description
private static void	appendOrMerge(ResolvedJavaType type, double probability, int searchUntil, List<IfNode.MutableProfiledType> list)
private ConditionalNode	canonicalizeConditionalCascade(ValueNode trueValue, ValueNode falseValue)
private boolean	checkForUnsignedCompare(SimplifierTool tool) Recognize a couple patterns that can be merged into an unsigned compare.
private static boolean	checkFrameState(FixedNode start)
private void	cleanupMerge(SimplifierTool tool, MergeNode merge)
LogicNode	condition()
private void	connectEnds(List<EndNode> ends, Map<AbstractEndNode,ValueNode> phiValues, AbstractBeginNode successor, AbstractMergeNode oldMerge, SimplifierTool tool) Connects a set of ends to a given successor, inserting a merge node if there is more than one end.
static Constant[]	constantValues(ValueNode node, AbstractMergeNode merge, boolean allowNull) Gets an array of constants derived from a node that is either a ConstantNode or a PhiNode whose input values are all constants.
void	eliminateNegation()
AbstractBeginNode	falseSuccessor() Gets the false successor.
void	generate(NodeLIRBuilderTool gen)
AbstractBeginNode	getPrimarySuccessor() Primary successor of the control split.
AbstractBeginNode	getSuccessor(boolean result)
double	getTrueSuccessorProbability()
private MergeNode	insertMerge(AbstractBeginNode begin)
private static JavaTypeProfile	makeProfile(double totalProbability, double notRecorded, List<IfNode.MutableProfiledType> profiledTypes, TriState nullSeen)
private static boolean	prepareForSwap(ConstantReflectionProvider constantReflection, LogicNode a, LogicNode b, double probabilityA, double probabilityB)
double	probability(AbstractBeginNode successor)
private void	propagateZeroProbability(FixedNode startNode)
private void	pushNodesThroughIf(SimplifierTool tool)
private boolean	removeIntermediateMaterialization(SimplifierTool tool) Tries to connect code that initializes a variable directly with the successors of an if construct that switches on the variable.
private boolean	removeOrMaterializeIf(SimplifierTool tool) Tries to remove an empty if construct or replace an if construct with a materialization.
protected void	removeThroughFalseBranch(SimplifierTool tool)
private static boolean	sameDestination(AbstractBeginNode succ1, AbstractBeginNode succ2) Check it these two blocks end up at the same place.
void	setCondition(LogicNode x)
void	setFalseSuccessor(AbstractBeginNode node)
void	setTrueSuccessor(AbstractBeginNode node)
void	setTrueSuccessorProbability(double prob)
void	simplify(SimplifierTool tool) Must be overridden by subclasses that implement Simplifiable.
private boolean	splitIfAtPhi(SimplifierTool tool) Take an if that is immediately dominated by a merge with a single phi and split off any paths where the test would be statically decidable creating a new merge below the approriate side of the IfNode.
AbstractBeginNode	successor(boolean istrue) Gets the node corresponding to the specified outcome of the branch.
private static void	swapInstanceOfProfiles(double probabilityA, double probabilityB, InstanceOfNode instanceOfA, InstanceOfNode instanceOfB) Tries to reconstruct profiles for the swapped instanceof checks.
private static void	transferProxies(AbstractBeginNode successor, MergeNode falseMerge)
AbstractBeginNode	trueSuccessor() Gets the true successor.
private static boolean	valuesDistinct(ConstantReflectionProvider constantReflection, ValueNode a, ValueNode b)
boolean	verify()

Methods inherited from class com.oracle.graal.nodes.FixedNode

asNode

Methods inherited from class com.oracle.graal.nodes.ValueNode

asConstant, asJavaConstant, getKind, graph, inferStamp, isAllowedUsageType, isConstant, isConstantPredicate, isNullConstant, setStamp, stamp, updateStamp

Methods inherited from class com.oracle.graal.graph.Node

acceptInputs, acceptSuccessors, afterClone, assertFalse, assertTrue, cfgPredecessors, cfgSuccessors, clearInputs, clearSuccessors, copyWithInputs, copyWithInputs, equals, fail, formatTo, getDebugProperties, getDebugProperties, getId, getNodeClass, getUsageAt, getUsageCount, hashCode, hasNoUsages, hasUsages, inputs, isAlive, isDeleted, markDeleted, modCount, newIdentityMap, newIdentityMap, newIdentityMap, newMap, newMap, newMap, newSet, newSet, predecessor, pushInputs, removeUsage, replaceAndDelete, replaceAtMatchingUsages, replaceAtPredecessor, replaceAtUsages, replaceAtUsages, replaceAtUsages, replaceFirstInput, replaceFirstSuccessor, safeDelete, successors, toString, toString, updatePredecessor, updateUsages, updateUsagesInterface, usages, valueEquals, verifyEdges, verifyInputs

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

TYPE

public static final NodeClass<IfNode> TYPE

CORRECTED_PROBABILITIES

private static final DebugMetric CORRECTED_PROBABILITIES

trueSuccessor

AbstractBeginNode trueSuccessor

falseSuccessor

AbstractBeginNode falseSuccessor

condition

LogicNode condition

trueSuccessorProbability

protected double trueSuccessorProbability

NOT_RECORDED_SUBTYPE_B

private static final double NOT_RECORDED_SUBTYPE_B

Arbitrary fraction of not recorded types that we'll guess are sub-types of B. This is is used because we can not check if the unrecorded types are sub-types of B or not.

See Also:

Constant Field Values

NOT_RECORDED_CUTOFF

private static final double NOT_RECORDED_CUTOFF

If the not-recorded fraction of types for the new profile of instanceOfA is above this threshold, no profile is used for this instanceof after the swap. The idea is that the reconstructed profile would contain too much unknowns to be of any use.

See Also:

Constant Field Values

Constructor Detail

IfNode

public IfNode(LogicNode condition,
              FixedNode trueSuccessor,
              FixedNode falseSuccessor,
              double trueSuccessorProbability)

IfNode

public IfNode(LogicNode condition,
              AbstractBeginNode trueSuccessor,
              AbstractBeginNode falseSuccessor,
              double trueSuccessorProbability)

Method Detail

condition

public LogicNode condition()

setCondition

public void setCondition(LogicNode x)

trueSuccessor

public AbstractBeginNode trueSuccessor()

Gets the true successor.

Returns:

the true successor

falseSuccessor

public AbstractBeginNode falseSuccessor()

Gets the false successor.

Returns:

the false successor

getTrueSuccessorProbability

public double getTrueSuccessorProbability()

setTrueSuccessor

public void setTrueSuccessor(AbstractBeginNode node)

setFalseSuccessor

public void setFalseSuccessor(AbstractBeginNode node)

successor

public AbstractBeginNode successor(boolean istrue)

Gets the node corresponding to the specified outcome of the branch.

Parameters:

istrue - true if the true successor is requested, false otherwise

Returns:

the corresponding successor

setTrueSuccessorProbability

public void setTrueSuccessorProbability(double prob)

probability

public double probability(AbstractBeginNode successor)

Specified by:

probability in class ControlSplitNode

generate

public void generate(NodeLIRBuilderTool gen)

Specified by:

generate in interface LIRLowerable

verify

public boolean verify()

Overrides:

verify in class FixedNode

eliminateNegation

public void eliminateNegation()

simplify

public void simplify(SimplifierTool tool)

Description copied from class: Node

Must be overridden by subclasses that implement Simplifiable. The implementation in Node exists to obviate the need to cast a node before invoking Simplifiable.simplify(SimplifierTool).

Specified by:

simplify in interface Simplifiable

Overrides:

simplify in class Node

pushNodesThroughIf

private void pushNodesThroughIf(SimplifierTool tool)

checkForUnsignedCompare

private boolean checkForUnsignedCompare(SimplifierTool tool)

Recognize a couple patterns that can be merged into an unsigned compare.

Parameters:

tool -

Returns:

true if a replacement was done.

sameDestination

private static boolean sameDestination(AbstractBeginNode succ1,
                                       AbstractBeginNode succ2)

Check it these two blocks end up at the same place. Meeting at the same merge, or deoptimizing in the same way.

prepareForSwap

private static boolean prepareForSwap(ConstantReflectionProvider constantReflection,
                                      LogicNode a,
                                      LogicNode b,
                                      double probabilityA,
                                      double probabilityB)

swapInstanceOfProfiles

private static void swapInstanceOfProfiles(double probabilityA,
                                           double probabilityB,
                                           InstanceOfNode instanceOfA,
                                           InstanceOfNode instanceOfB)

Tries to reconstruct profiles for the swapped instanceof checks. The tested types must be mutually exclusive.

makeProfile

private static JavaTypeProfile makeProfile(double totalProbability,
                                           double notRecorded,
                                           List<IfNode.MutableProfiledType> profiledTypes,
                                           TriState nullSeen)

appendOrMerge

private static void appendOrMerge(ResolvedJavaType type,
                                  double probability,
                                  int searchUntil,
                                  List<IfNode.MutableProfiledType> list)

valuesDistinct

private static boolean valuesDistinct(ConstantReflectionProvider constantReflection,
                                      ValueNode a,
                                      ValueNode b)

removeOrMaterializeIf

private boolean removeOrMaterializeIf(SimplifierTool tool)

Tries to remove an empty if construct or replace an if construct with a materialization.

Returns:

true if a transformation was made, false otherwise

removeThroughFalseBranch

protected void removeThroughFalseBranch(SimplifierTool tool)

canonicalizeConditionalCascade

private ConditionalNode canonicalizeConditionalCascade(ValueNode trueValue,
                                                       ValueNode falseValue)

splitIfAtPhi

private boolean splitIfAtPhi(SimplifierTool tool)

Take an if that is immediately dominated by a merge with a single phi and split off any paths where the test would be statically decidable creating a new merge below the approriate side of the IfNode. Any undecidable tests will continue to use the original IfNode.

Parameters:

tool -

transferProxies

private static void transferProxies(AbstractBeginNode successor,
                                    MergeNode falseMerge)

cleanupMerge

private void cleanupMerge(SimplifierTool tool,
                          MergeNode merge)

insertMerge

private MergeNode insertMerge(AbstractBeginNode begin)

removeIntermediateMaterialization

private boolean removeIntermediateMaterialization(SimplifierTool tool)

Tries to connect code that initializes a variable directly with the successors of an if construct that switches on the variable. For example, the pseudo code below:

 contains(list, e, yes, no) {
     if (list == null || e == null) {
         condition = false;
     } else {
         condition = false;
         for (i in list) {
             if (i.equals(e)) {
                 condition = true;
                 break;
             }
         }
     }
     if (condition) {
         return yes;
     } else {
         return no;
     }
 }
 

will be transformed into:

 contains(list, e, yes, no) {
     if (list == null || e == null) {
         return no;
     } else {
         condition = false;
         for (i in list) {
             if (i.equals(e)) {
                 return yes;
             }
         }
         return no;
     }
 }
 

Returns:

true if a transformation was made, false otherwise

propagateZeroProbability

private void propagateZeroProbability(FixedNode startNode)

checkFrameState

private static boolean checkFrameState(FixedNode start)

connectEnds

private void connectEnds(List<EndNode> ends,
                         Map<AbstractEndNode,ValueNode> phiValues,
                         AbstractBeginNode successor,
                         AbstractMergeNode oldMerge,
                         SimplifierTool tool)

Connects a set of ends to a given successor, inserting a merge node if there is more than one end. If ends is not empty, then successor is added to tool's work list.

Parameters:

oldMerge - the merge being removed

phiValues - the values of the phi at the merge, keyed by the merge ends

constantValues

public static Constant[] constantValues(ValueNode node,
                                        AbstractMergeNode merge,
                                        boolean allowNull)

Gets an array of constants derived from a node that is either a ConstantNode or a PhiNode whose input values are all constants. The length of the returned array is equal to the number of ends terminating in a given merge node.

Returns:

null if node is neither a ConstantNode nor a PhiNode whose input values are all constants

getPrimarySuccessor

public AbstractBeginNode getPrimarySuccessor()

Description copied from class: ControlSplitNode

Primary successor of the control split. Data dependencies on the node have to be scheduled in the primary successor.

Specified by:

getPrimarySuccessor in class ControlSplitNode

Returns:

the primary successor

getSuccessor

public AbstractBeginNode getSuccessor(boolean result)