com.oracle.graal.compiler.gen

Class NodeLIRBuilder

java.lang.Object

com.oracle.graal.compiler.gen.NodeLIRBuilder

All Implemented Interfaces:

LIRGenerationDebugContext, NodeLIRBuilderTool, NodeValueMap

Direct Known Subclasses:

AMD64NodeLIRBuilder, SPARCNodeLIRBuilder

public abstract class NodeLIRBuilder
extends Object
implements NodeLIRBuilderTool, LIRGenerationDebugContext

This class traverses the HIR instructions and generates LIR instructions from them.

Field Summary

Fields

Modifier and Type	Field and Description
private ValueNode	currentInstruction
private DebugInfoBuilder	debugInfoBuilder
protected LIRGeneratorTool	gen
private ValueNode	lastInstructionPrinted
private Map<Class<? extends Node>,List<MatchStatement>>	matchRules
private NodeMap<Value>	nodeOperands

Constructor Summary

Constructors

Constructor and Description
NodeLIRBuilder(StructuredGraph graph, LIRGeneratorTool gen)

Method Summary

Modifier and Type	Method and Description
void	append(LIRInstruction op)
protected DebugInfoBuilder	createDebugInfoBuilder(StructuredGraph graph, NodeValueMap nodeValueMap)
private Value[]	createPhiIn(AbstractMergeNode merge)
private Value[]	createPhiOut(AbstractMergeNode merge, AbstractEndNode pred)
void	doBlock(Block block, StructuredGraph graph, BlockMap<List<Node>> blockMap)
private void	doRoot(ValueNode instr)
void	emitBranch(LogicNode node, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability)
void	emitCompareBranch(CompareNode compare, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability)
void	emitConditional(ConditionalNode conditional)
Variable	emitConditional(LogicNode node, Value trueValue, Value falseValue)
void	emitConstantBranch(boolean value, LabelRef trueSuccessorBlock, LabelRef falseSuccessorBlock)
protected abstract void	emitDirectCall(DirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState)
void	emitIf(IfNode x)
protected abstract void	emitIndirectCall(IndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState)
void	emitIntegerTestBranch(IntegerTestNode test, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability)
void	emitInvoke(Invoke x)
protected void	emitNode(ValueNode node)
private void	emitNullCheckBranch(IsNullNode node, LabelRef trueSuccessor, LabelRef falseSuccessor, double trueSuccessorProbability)
void	emitOverflowCheckBranch(AbstractBeginNode overflowSuccessor, AbstractBeginNode next, Stamp stamp, double probability)
protected void	emitPrologue(StructuredGraph graph)
void	emitSwitch(SwitchNode x) This method tries to create a switch implementation that is optimal for the given switch.
DebugInfoBuilder	getDebugInfoBuilder()
protected LIRKind	getExactPhiKind(PhiNode phi)
private static FrameState	getFrameState(DeoptimizingNode deopt)
LabelRef	getLIRBlock(FixedNode b)
LIRGeneratorTool	getLIRGeneratorTool()
private Value	getOperand(Node node)
protected LIRKind	getPhiKind(PhiNode phi)
Object	getSourceForOperand(Value value) Gets an object that represents the source of an LIR operand in a higher representation.
boolean	hasOperand(Node node)
private static boolean	isPhiInputFromBackedge(PhiNode phi, int index)
protected void	matchComplexExpressions(List<Node> nodes)
private void	moveToPhi(AbstractMergeNode merge, AbstractEndNode pred)
protected StandardOp.JumpOp	newJumpOp(LabelRef ref)
Value	operand(Node node) Returns the operand that has been previously initialized by setResult(ValueNode, Value) with the result of an instruction.
private Value	operandForPhi(ValuePhiNode phi)
protected abstract boolean	peephole(ValueNode valueNode)
void	setMatchResult(Node x, Value operand) Used by the MatchStatement machinery to override the generation LIR for some ValueNodes.
Value	setResult(ValueNode x, Value operand) Associates operand with the node in the current block.
LIRFrameState	state(DeoptimizingNode deopt)
LIRFrameState	stateFor(FrameState state)
LIRFrameState	stateForWithExceptionEdge(FrameState state, LabelRef exceptionEdge)
LIRFrameState	stateWithExceptionEdge(DeoptimizingNode deopt, LabelRef exceptionEdge)
ValueNode	valueForOperand(Value value) Gets the the ValueNode that produced a value.
private static boolean	verifyPHIKind(LIRKind derivedKind, LIRKind phiKind)
void	visitEndNode(AbstractEndNode end)
void	visitFullInfopointNode(FullInfopointNode i)
Value[]	visitInvokeArguments(CallingConvention invokeCc, Collection<ValueNode> arguments)
void	visitLoopEnd(LoopEndNode x) Runtime specific classes can override this to insert a safepoint at the end of a loop.
void	visitMerge(AbstractMergeNode x)
void	visitSimpleInfopointNode(SimpleInfopointNode i)

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.oracle.graal.nodes.spi.NodeLIRBuilderTool

visitBreakpointNode, visitSafepointNode

Methods inherited from interface com.oracle.graal.lir.debug.LIRGenerationDebugContext

getFromDebugContext, getSourceForOperandFromDebugContext

Field Detail

nodeOperands

private final NodeMap<Value> nodeOperands

debugInfoBuilder

private final DebugInfoBuilder debugInfoBuilder

gen

protected final LIRGeneratorTool gen

currentInstruction

private ValueNode currentInstruction

lastInstructionPrinted

private ValueNode lastInstructionPrinted

matchRules

private Map<Class<? extends Node>,List<MatchStatement>> matchRules

Constructor Detail

NodeLIRBuilder

public NodeLIRBuilder(StructuredGraph graph,
                      LIRGeneratorTool gen)

Method Detail

createDebugInfoBuilder

protected DebugInfoBuilder createDebugInfoBuilder(StructuredGraph graph,
                                                  NodeValueMap nodeValueMap)

operand

public Value operand(Node node)

Returns the operand that has been previously initialized by setResult(ValueNode, Value) with the result of an instruction. It's a code generation error to ask for the operand of ValueNode that doesn't have one yet.

Specified by:

operand in interface NodeValueMap

Parameters:

node - A node that produces a result value.

hasOperand

public boolean hasOperand(Node node)

Specified by:

hasOperand in interface NodeValueMap

Returns:

true if there is an operand associated with the node in the current block.

getOperand

private Value getOperand(Node node)

valueForOperand

public ValueNode valueForOperand(Value value)

Description copied from interface: NodeValueMap

Gets the the ValueNode that produced a value. If the value is not associated with a ValueNode null is returned. This method is intended for debugging purposes only.

Specified by:

valueForOperand in interface NodeValueMap

getSourceForOperand

public Object getSourceForOperand(Value value)

Description copied from interface: LIRGenerationDebugContext

Gets an object that represents the source of an LIR operand in a higher representation.

Specified by:

getSourceForOperand in interface LIRGenerationDebugContext

setResult

public Value setResult(ValueNode x,
                       Value operand)

Description copied from interface: NodeValueMap

Associates operand with the node in the current block.

Specified by:

setResult in interface NodeValueMap

Returns:

operand

setMatchResult

public void setMatchResult(Node x,
                           Value operand)

Used by the MatchStatement machinery to override the generation LIR for some ValueNodes.

getLIRBlock

public LabelRef getLIRBlock(FixedNode b)

append

public final void append(LIRInstruction op)

getExactPhiKind

protected LIRKind getExactPhiKind(PhiNode phi)

verifyPHIKind

private static boolean verifyPHIKind(LIRKind derivedKind,
                                     LIRKind phiKind)

isPhiInputFromBackedge

private static boolean isPhiInputFromBackedge(PhiNode phi,
                                              int index)

createPhiIn

private Value[] createPhiIn(AbstractMergeNode merge)

createPhiOut

private Value[] createPhiOut(AbstractMergeNode merge,
                             AbstractEndNode pred)

doBlock

public void doBlock(Block block,
                    StructuredGraph graph,
                    BlockMap<List<Node>> blockMap)

Specified by:

doBlock in interface NodeLIRBuilderTool

matchComplexExpressions

protected void matchComplexExpressions(List<Node> nodes)

peephole

protected abstract boolean peephole(ValueNode valueNode)

doRoot

private void doRoot(ValueNode instr)

emitNode

protected void emitNode(ValueNode node)

emitPrologue

protected void emitPrologue(StructuredGraph graph)

visitMerge

public void visitMerge(AbstractMergeNode x)

Specified by:

visitMerge in interface NodeLIRBuilderTool

visitEndNode

public void visitEndNode(AbstractEndNode end)

Specified by:

visitEndNode in interface NodeLIRBuilderTool

visitLoopEnd

public void visitLoopEnd(LoopEndNode x)

Runtime specific classes can override this to insert a safepoint at the end of a loop.

Specified by:

visitLoopEnd in interface NodeLIRBuilderTool

moveToPhi

private void moveToPhi(AbstractMergeNode merge,
                       AbstractEndNode pred)

newJumpOp

protected StandardOp.JumpOp newJumpOp(LabelRef ref)

getPhiKind

protected LIRKind getPhiKind(PhiNode phi)

operandForPhi

private Value operandForPhi(ValuePhiNode phi)

emitIf

public void emitIf(IfNode x)

Specified by:

emitIf in interface NodeLIRBuilderTool

emitBranch

public void emitBranch(LogicNode node,
                       LabelRef trueSuccessor,
                       LabelRef falseSuccessor,
                       double trueSuccessorProbability)

emitNullCheckBranch

private void emitNullCheckBranch(IsNullNode node,
                                 LabelRef trueSuccessor,
                                 LabelRef falseSuccessor,
                                 double trueSuccessorProbability)

emitCompareBranch

public void emitCompareBranch(CompareNode compare,
                              LabelRef trueSuccessor,
                              LabelRef falseSuccessor,
                              double trueSuccessorProbability)

emitIntegerTestBranch

public void emitIntegerTestBranch(IntegerTestNode test,
                                  LabelRef trueSuccessor,
                                  LabelRef falseSuccessor,
                                  double trueSuccessorProbability)

emitConstantBranch

public void emitConstantBranch(boolean value,
                               LabelRef trueSuccessorBlock,
                               LabelRef falseSuccessorBlock)

emitConditional

public void emitConditional(ConditionalNode conditional)

Specified by:

emitConditional in interface NodeLIRBuilderTool

emitConditional

public Variable emitConditional(LogicNode node,
                                Value trueValue,
                                Value falseValue)

emitInvoke

public void emitInvoke(Invoke x)

Specified by:

emitInvoke in interface NodeLIRBuilderTool

emitDirectCall

protected abstract void emitDirectCall(DirectCallTargetNode callTarget,
                                       Value result,
                                       Value[] parameters,
                                       Value[] temps,
                                       LIRFrameState callState)

emitIndirectCall

protected abstract void emitIndirectCall(IndirectCallTargetNode callTarget,
                                         Value result,
                                         Value[] parameters,
                                         Value[] temps,
                                         LIRFrameState callState)

visitInvokeArguments

public Value[] visitInvokeArguments(CallingConvention invokeCc,
                                    Collection<ValueNode> arguments)

Specified by:

visitInvokeArguments in interface NodeLIRBuilderTool

emitSwitch

public void emitSwitch(SwitchNode x)

This method tries to create a switch implementation that is optimal for the given switch. It will either generate a sequential if/then/else cascade, a set of range tests or a table switch. If the given switch does not contain int keys, it will always create a sequential implementation.

Specified by:

emitSwitch in interface NodeLIRBuilderTool

getDebugInfoBuilder

public DebugInfoBuilder getDebugInfoBuilder()

getFrameState

private static FrameState getFrameState(DeoptimizingNode deopt)

state

public LIRFrameState state(DeoptimizingNode deopt)

Specified by:

state in interface NodeLIRBuilderTool

stateWithExceptionEdge

public LIRFrameState stateWithExceptionEdge(DeoptimizingNode deopt,
                                            LabelRef exceptionEdge)

stateFor

public LIRFrameState stateFor(FrameState state)

stateForWithExceptionEdge

public LIRFrameState stateForWithExceptionEdge(FrameState state,
                                               LabelRef exceptionEdge)

emitOverflowCheckBranch

public void emitOverflowCheckBranch(AbstractBeginNode overflowSuccessor,
                                    AbstractBeginNode next,
                                    Stamp stamp,
                                    double probability)

Specified by:

emitOverflowCheckBranch in interface NodeLIRBuilderTool

visitFullInfopointNode

public void visitFullInfopointNode(FullInfopointNode i)

Specified by:

visitFullInfopointNode in interface NodeLIRBuilderTool

visitSimpleInfopointNode

public void visitSimpleInfopointNode(SimpleInfopointNode i)

Specified by:

visitSimpleInfopointNode in interface NodeLIRBuilderTool

getLIRGeneratorTool

public LIRGeneratorTool getLIRGeneratorTool()

Specified by:

getLIRGeneratorTool in interface NodeLIRBuilderTool