org.graalvm.compiler.phases.common

Class ConditionalEliminationPhase.Instance

java.lang.Object

org.graalvm.compiler.phases.common.ConditionalEliminationPhase.Instance

All Implemented Interfaces:

ControlFlowGraph.RecursiveVisitor<ConditionalEliminationUtil.Marks>

Enclosing class:

ConditionalEliminationPhase

public static class ConditionalEliminationPhase.Instance
extends Object
implements ControlFlowGraph.RecursiveVisitor<ConditionalEliminationUtil.Marks>

Field Summary

Fields

Modifier and Type	Field and Description
protected BlockMap<List<Node>>	blockToNodes
protected ArrayDeque<ConditionalEliminationUtil.GuardedCondition>	conditions
protected DebugContext	debug
protected StructuredGraph	graph
protected NodeMap<ConditionalEliminationUtil.InfoElement>	map
protected org.graalvm.collections.EconomicMap<MergeNode,org.graalvm.collections.EconomicMap<ValuePhiNode,org.graalvm.compiler.phases.common.ConditionalEliminationPhase.PhiInfoElement>>	mergeMaps
protected NodeMap<Block>	nodeToBlock
protected CanonicalizerTool	tool
protected NodeStack	undoOperations

Constructor Summary

Constructors

Constructor and Description
Instance(StructuredGraph graph, BlockMap<List<Node>> blockToNodes, NodeMap<Block> nodeToBlock, CoreProviders context)

Method Summary

Modifier and Type	Method and Description
ConditionalEliminationUtil.Marks	enter(Block block)
void	exit(Block b, ConditionalEliminationUtil.Marks marks)
protected boolean	foldGuard(DeoptimizingGuard thisGuard, DeoptimizingGuard otherGuard, boolean outcome, Stamp guardedValueStamp, ConditionalEliminationUtil.GuardRewirer rewireGuardFunction)
protected boolean	foldPendingTest(DeoptimizingGuard thisGuard, ValueNode original, Stamp newStamp, ConditionalEliminationUtil.GuardRewirer rewireGuardFunction) Look for a preceding guard whose condition is implied by thisGuard.
protected ConditionalEliminationUtil.InfoElement	getInfoElements(ValueNode proxiedValue)
protected void	introducePisForPhis(MergeNode merge)
protected void	processAbstractBegin(AbstractBeginNode beginNode)
protected void	processConditionAnchor(ConditionAnchorNode node)
protected void	processEnd(EndNode end)
protected void	processFixedGuard(FixedGuardNode node)
protected void	processGuard(GuardNode node)
protected void	processIf(IfNode node)
protected void	processIntegerSwitch(AbstractBeginNode beginNode, IntegerSwitchNode integerSwitchNode)
protected void	processNode(Node node)
protected void	processNodes(Block block)
protected void	processTypeSwitch(AbstractBeginNode beginNode, TypeSwitchNode typeSwitch)
protected void	registerCondition(LogicNode condition, boolean negated, GuardingNode guard)
protected void	registerNewCondition(LogicNode condition, boolean negated, GuardingNode guard)
protected void	registerNewStamp(ValueNode maybeProxiedValue, Stamp newStamp, GuardingNode guard)
protected void	registerNewStamp(ValueNode maybeProxiedValue, Stamp newStamp, GuardingNode guard, boolean propagateThroughPis)
protected boolean	tryProveGuardCondition(DeoptimizingGuard thisGuard, LogicNode node, ConditionalEliminationUtil.GuardRewirer rewireGuardFunction)

Methods inherited from class java.lang.Object

clone, equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

map

protected final NodeMap<ConditionalEliminationUtil.InfoElement> map

blockToNodes

protected final BlockMap<List<Node>> blockToNodes

nodeToBlock

protected final NodeMap<Block> nodeToBlock

tool

protected final CanonicalizerTool tool

undoOperations

protected final NodeStack undoOperations

graph

protected final StructuredGraph graph

debug

protected final DebugContext debug

mergeMaps

protected final org.graalvm.collections.EconomicMap<MergeNode,org.graalvm.collections.EconomicMap<ValuePhiNode,org.graalvm.compiler.phases.common.ConditionalEliminationPhase.PhiInfoElement>> mergeMaps

conditions

protected final ArrayDeque<ConditionalEliminationUtil.GuardedCondition> conditions

Constructor Detail

Instance

public Instance(StructuredGraph graph,
                BlockMap<List<Node>> blockToNodes,
                NodeMap<Block> nodeToBlock,
                CoreProviders context)

Method Detail

processConditionAnchor

protected void processConditionAnchor(ConditionAnchorNode node)

processGuard

protected void processGuard(GuardNode node)

processFixedGuard

protected void processFixedGuard(FixedGuardNode node)

processIf

protected void processIf(IfNode node)

enter

public ConditionalEliminationUtil.Marks enter(Block block)

Specified by:

enter in interface ControlFlowGraph.RecursiveVisitor<ConditionalEliminationUtil.Marks>

processNodes

protected void processNodes(Block block)

processNode

protected void processNode(Node node)

introducePisForPhis

protected void introducePisForPhis(MergeNode merge)

processEnd

protected void processEnd(EndNode end)

registerNewCondition

protected void registerNewCondition(LogicNode condition,
                                    boolean negated,
                                    GuardingNode guard)

foldPendingTest

protected boolean foldPendingTest(DeoptimizingGuard thisGuard,
                                  ValueNode original,
                                  Stamp newStamp,
                                  ConditionalEliminationUtil.GuardRewirer rewireGuardFunction)

Look for a preceding guard whose condition is implied by thisGuard. If we find one, try to move this guard just above that preceding guard so that we can fold it:

     guard(C1); // preceding guard
     ...
     guard(C2); // thisGuard
 

If C2 => C1, transform to:

     guard(C2);
     ...
 

foldGuard

protected boolean foldGuard(DeoptimizingGuard thisGuard,
                            DeoptimizingGuard otherGuard,
                            boolean outcome,
                            Stamp guardedValueStamp,
                            ConditionalEliminationUtil.GuardRewirer rewireGuardFunction)

tryProveGuardCondition

protected boolean tryProveGuardCondition(DeoptimizingGuard thisGuard,
                                         LogicNode node,
                                         ConditionalEliminationUtil.GuardRewirer rewireGuardFunction)

registerCondition

protected void registerCondition(LogicNode condition,
                                 boolean negated,
                                 GuardingNode guard)

getInfoElements

protected ConditionalEliminationUtil.InfoElement getInfoElements(ValueNode proxiedValue)

registerNewStamp

protected void registerNewStamp(ValueNode maybeProxiedValue,
                                Stamp newStamp,
                                GuardingNode guard)

registerNewStamp

protected void registerNewStamp(ValueNode maybeProxiedValue,
                                Stamp newStamp,
                                GuardingNode guard,
                                boolean propagateThroughPis)

processAbstractBegin

protected void processAbstractBegin(AbstractBeginNode beginNode)

processIntegerSwitch

protected void processIntegerSwitch(AbstractBeginNode beginNode,
                                    IntegerSwitchNode integerSwitchNode)

processTypeSwitch

protected void processTypeSwitch(AbstractBeginNode beginNode,
                                 TypeSwitchNode typeSwitch)

exit

public void exit(Block b,
                 ConditionalEliminationUtil.Marks marks)

Specified by:

exit in interface ControlFlowGraph.RecursiveVisitor<ConditionalEliminationUtil.Marks>