Node (Graal OpenJDK Project Documentation)

java.lang.Object
- com.oracle.graal.graph.Node

All Implemented Interfaces:

Cloneable, Formattable

Direct Known Subclasses:

EdgesTest.TestNode, Graph.PlaceHolderNode, NodeMapTest.TestNode, NodePosIteratorTest.TestNode, NodeUsagesTests.Def, NodeUsagesTests.Use, NodeValidationChecksTest.TestNode, TypedNodeIteratorTest.TestNode, TypedNodeIteratorTest2.NodeA, ValueNode, VirtualState
```
public abstract class Node
extends Object
implements Cloneable, Formattable
```
This class is the base class for all nodes. It represents a node that can be inserted in a Graph.
Once a node has been added to a graph, it has a graph-unique id(). Edges in the subclasses are represented with annotated fields. There are two kind of edges : Node.Input and Node.Successor. If a field, of a type compatible with Node, annotated with either Node.Input and Node.Successor is not null, then there is an edge from this node to the node this field points to.
Nodes which are be value numberable should implement the Node.ValueNumberable interface.
Replay Compilation
To enable deterministic replay compilation, node sets and node maps should be instantiated with the following methods:
Assertions and Verification
The Node class supplies the assertTrue(boolean, String, Object...) and assertFalse(boolean, String, Object...) methods, which will check the supplied boolean and throw a VerificationError if it has the wrong value. Both methods will always either throw an exception or return true. They can thus be used within an assert statement, so that the check is only performed if assertions are enabled.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`Node.ConstantNodeParameter` Denotes that a parameter of an intrinsic method must be a compile time constant at all call sites to the intrinsic method.
`static interface`	`Node.InjectedNodeParameter` Denotes an injected parameter in a node intrinsic constructor.
`static interface`	`Node.Input` Denotes a non-optional (non-null) node input.
`static interface`	`Node.NodeIntrinsic` Annotates a method that can be replaced by a compiler intrinsic.
`static interface`	`Node.OptionalInput` Denotes an optional (nullable) node input.
`static interface`	`Node.Successor`
`static interface`	`Node.ValueNumberable` Marker for a node that can be replaced by another node via global value numbering.

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) static int`	`ALIVE_ID_START`
`(package private) static int`	`DELETED_ID_START`
`(package private) Node[]`	`extraUsages`
`(package private) int`	`extraUsagesCount`
`private Graph`	`graph`
`(package private) int`	`id`
`(package private) static int`	`INITIAL_ID`
`(package private) static int`	`INLINE_USAGE_COUNT`
`private static Node[]`	`NO_NODES`
`static int`	`NODE_LIST`
`private NodeClass<? extends Node>`	`nodeClass`
`static int`	`NOT_ITERABLE`
`private Node`	`predecessor`
`static NodeClass<?>`	`TYPE`
`(package private) Node`	`typeCacheNext`
`(package private) Node`	`usage0` Head of usage list.
`(package private) Node`	`usage1`
`static boolean`	`USE_UNSAFE_TO_CLONE`
`static EnumSet<Edges.Type>`	`WithAllEdges`
`static EnumSet<Edges.Type>`	`WithNoEdges`
`static EnumSet<Edges.Type>`	`WithOnlyInputEdges`
`static EnumSet<Edges.Type>`	`WithOnlySucessorEdges`

Constructor Summary

Constructors
Constructor and Description

Node(NodeClass<? extends Node> c)

Constructors
Constructor and Description
`Node(NodeClass<? extends Node> c)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`acceptInputs(BiConsumer<Node,Node> consumer)` Applies the given consumer to all inputs of this node.
`void`	`acceptSuccessors(BiConsumer<Node,Node> consumer)` Applies the given consumer to all successors of this node.
`private void`	`addUsage(Node node)` Adds a given node to this node's usages.
`protected void`	`afterClone(Node other)`
`boolean`	`assertFalse(boolean condition, String message, Object... args)`
`boolean`	`assertTrue(boolean condition, String message, Object... args)`
`Iterable<? extends Node>`	`cfgPredecessors()`
`Iterable<? extends Node>`	`cfgSuccessors()` Returns an iterator that will provide all control-flow successors of this node.
`private boolean`	`checkDeletion()`
`private boolean`	`checkReplaceWith(Node other)`
`void`	`clearInputs()`
`void`	`clearSuccessors()`
`(package private) Node`	`clone(Graph into, EnumSet<Edges.Type> edgesToCopy)` Makes a copy of this node in(to) a given graph.
`private void`	`copyOrClearEdgesForClone(Node newNode, Edges.Type type, EnumSet<Edges.Type> edgesToCopy)`
`Node`	`copyWithInputs()`
`Node`	`copyWithInputs(boolean insertIntoGraph)`
`boolean`	`equals(Object obj)` Equality tests must rely solely on identity.
`protected VerificationError`	`fail(String message, Object... args)`
`void`	`formatTo(Formatter formatter, int flags, int width, int precision)`
`Map<Object,Object>`	`getDebugProperties()` Provides a `Map` of properties of this node for use in debugging (e.g., to view in the ideal graph visualizer).
`Map<Object,Object>`	`getDebugProperties(Map<Object,Object> map)` Fills a `Map` with properties of this node for use in debugging (e.g., to view in the ideal graph visualizer).
`int`	`getId()` Deprecated.
`NodeClass<? extends Node>`	`getNodeClass()`
`Node`	`getUsageAt(int index)`
`int`	`getUsageCount()` Gets the maximum number of usages this node has had at any point in time.
`Graph`	`graph()` Gets the graph context of this node.
`int`	`hashCode()` Nodes always use an identity hash code.
`boolean`	`hasNoUsages()` Checks whether this node has no usages.
`boolean`	`hasUsages()` Checks whether this node has usages.
`(package private) int`	`id()`
`(package private) void`	`incModCount()`
`(package private) void`	`incUsageModCount()`
`(package private) void`	`init(NodeClass<? extends Node> c)`
`(package private) void`	`initialize(Graph newGraph)`
`NodeClassIterable`	`inputs()` Returns an `iterable` which can be used to traverse all non-null input edges of this node.
`boolean`	`isAlive()`
`boolean`	`isAllowedUsageType(InputType type)`
`boolean`	`isDeleted()`
`void`	`markDeleted()`
`private void`	`maybeNotifyInputChanged(Node node)`
`private void`	`maybeNotifyZeroUsages(Node node)`
`int`	`modCount()`
`private void`	`movUsageFromEndTo(int destIndex)`
`static <K extends Node,V> Map<K,V>`	`newIdentityMap()`
`static <K extends Node,V> Map<K,V>`	`newIdentityMap(int expectedMaxSize)`
`static <K extends Node,V> Map<K,V>`	`newIdentityMap(Map<K,V> m)`
`static <K extends Node,V> Map<K,V>`	`newMap()`
`static <K extends Node,V> Map<K,V>`	`newMap(int expectedMaxSize)`
`static <K extends Node,V> Map<K,V>`	`newMap(Map<K,V> m)`
`static <E extends Node> Set<E>`	`newSet()`
`static <E extends Node> Set<E>`	`newSet(Collection<? extends E> c)`
`Node`	`predecessor()`
`void`	`pushInputs(NodeStack stack)`
`private boolean`	`removeThisFromUsages(Node n)`
`boolean`	`removeUsage(Node node)` Removes a given node from this node's usages.
`void`	`replaceAndDelete(Node other)`
`void`	`replaceAtMatchingUsages(Node other, NodePredicate usagePredicate)`
`void`	`replaceAtPredecessor(Node other)`
`void`	`replaceAtUsages(InputType type, Node other)`
`void`	`replaceAtUsages(Node other)`
`void`	`replaceAtUsages(Node other, Predicate<Node> filter)`
`void`	`replaceFirstInput(Node oldInput, Node newInput)`
`void`	`replaceFirstSuccessor(Node oldSuccessor, Node newSuccessor)`
`(package private) void`	`reverseUsageOrder()`
`void`	`safeDelete()` Removes this node from its graph.
`void`	`simplify(SimplifierTool tool)` Must be overridden by subclasses that implement `Simplifiable`.
`NodeClassIterable`	`successors()` Returns an `iterable` which can be used to traverse all non-null successor edges of this node.
`String`	`toString()` This method is a shortcut for `toString(Verbosity)` with `Verbosity.Short`.
`String`	`toString(Verbosity verbosity)` Creates a String representation for this node with a given `Verbosity`.
`private void`	`unregisterInputs()`
`private void`	`unregisterSuccessors()`
`protected void`	`updatePredecessor(Node oldSuccessor, Node newSuccessor)` Updates the predecessor of the given nodes after a successor slot is changed from oldSuccessor to newSuccessor: removes this node from oldSuccessor's predecessors and adds this node to newSuccessor's predecessors.
`protected void`	`updateUsages(Node oldInput, Node newInput)` Updates the usages sets of the given nodes after an input slot is changed from `oldInput` to `newInput` by removing this node from `oldInput`'s usages and adds this node to `newInput`'s usages.
`protected void`	`updateUsagesInterface(NodeInterface oldInput, NodeInterface newInput)`
`(package private) int`	`usageModCount()`
`NodeIterable<Node>`	`usages()` Gets the list of nodes that use this node (i.e., as an input).
`boolean`	`valueEquals(Node other)` Determines if this node's `data` fields are equal to the data fields of another node of the same type.
`boolean`	`verify()`
`boolean`	`verifyEdges()` Perform expensive verification of inputs, usages, predecessors and successors.
`boolean`	`verifyInputs()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

TYPE
```
public static final NodeClass<?> TYPE
```

USE_UNSAFE_TO_CLONE

public static final boolean USE_UNSAFE_TO_CLONE

DELETED_ID_START
```
static final int DELETED_ID_START
```
See Also:

Constant Field Values

INITIAL_ID
```
static final int INITIAL_ID
```
See Also:

Constant Field Values

ALIVE_ID_START
```
static final int ALIVE_ID_START
```
See Also:

Constant Field Values

graph
```
private Graph graph
```

id
```
int id
```

typeCacheNext
```
Node typeCacheNext
```

INLINE_USAGE_COUNT
```
static final int INLINE_USAGE_COUNT
```
See Also:

Constant Field Values

NO_NODES
```
private static final Node[] NO_NODES
```

usage0
```
Node usage0
```
Head of usage list. The elements of the usage list in order are usage0, usage1 and extraUsages. The first null entry terminates the list.

usage1
```
Node usage1
```

extraUsages
```
Node[] extraUsages
```

extraUsagesCount
```
int extraUsagesCount
```

predecessor
```
private Node predecessor
```

nodeClass

private NodeClass<? extends Node> nodeClass

NODE_LIST
```
public static final int NODE_LIST
```
See Also:

Constant Field Values

NOT_ITERABLE
```
public static final int NOT_ITERABLE
```
See Also:

Constant Field Values

WithNoEdges

public static final EnumSet<Edges.Type> WithNoEdges

WithAllEdges

public static final EnumSet<Edges.Type> WithAllEdges

WithOnlyInputEdges

public static final EnumSet<Edges.Type> WithOnlyInputEdges

WithOnlySucessorEdges

public static final EnumSet<Edges.Type> WithOnlySucessorEdges

Constructor Detail

Node

public Node(NodeClass<? extends Node> c)

Method Detail

init

final void init(NodeClass<? extends Node> c)

id
```
int id()
```

newSet

public static <E extends Node> Set<E> newSet()

See Also:: CollectionsFactory.newSet()

newSet

public static <E extends Node> Set<E> newSet(Collection<? extends E> c)

See Also:: newSet()

newMap

public static <K extends Node,V> Map<K,V> newMap()

newMap

public static <K extends Node,V> Map<K,V> newMap(Map<K,V> m)

newMap

public static <K extends Node,V> Map<K,V> newMap(int expectedMaxSize)

newIdentityMap

public static <K extends Node,V> Map<K,V> newIdentityMap()

newIdentityMap

public static <K extends Node,V> Map<K,V> newIdentityMap(Map<K,V> m)

newIdentityMap

public static <K extends Node,V> Map<K,V> newIdentityMap(int expectedMaxSize)

graph
```
public Graph graph()
```
Gets the graph context of this node.

inputs
```
public NodeClassIterable inputs()
```
Returns an iterable which can be used to traverse all non-null input edges of this node.

Returns:

an iterable for all non-null input edges.

acceptInputs
```
public void acceptInputs(BiConsumer<Node,Node> consumer)
```
Applies the given consumer to all inputs of this node.

Parameters:

consumer - the consumer to be applied to the inputs

successors
```
public NodeClassIterable successors()
```
Returns an iterable which can be used to traverse all non-null successor edges of this node.

Returns:

an iterable for all non-null successor edges.

acceptSuccessors
```
public void acceptSuccessors(BiConsumer<Node,Node> consumer)
```
Applies the given consumer to all successors of this node.

Parameters:

consumer - the consumer to be applied to the inputs

getUsageCount
```
public int getUsageCount()
```
Gets the maximum number of usages this node has had at any point in time.

usages
```
public final NodeIterable<Node> usages()
```
Gets the list of nodes that use this node (i.e., as an input).

hasNoUsages
```
public final boolean hasNoUsages()
```
Checks whether this node has no usages.

hasUsages
```
public final boolean hasUsages()
```
Checks whether this node has usages.

reverseUsageOrder
```
void reverseUsageOrder()
```

addUsage
```
private void addUsage(Node node)
```
Adds a given node to this node's usages.

Parameters:

node - the node to add

movUsageFromEndTo

private void movUsageFromEndTo(int destIndex)

removeUsage
```
public boolean removeUsage(Node node)
```
Removes a given node from this node's usages.

Parameters:

node - the node to remove

Returns:

whether or not usage was in the usage list

predecessor
```
public final Node predecessor()
```

modCount
```
public final int modCount()
```

incModCount
```
final void incModCount()
```

usageModCount
```
final int usageModCount()
```

incUsageModCount
```
final void incUsageModCount()
```

isDeleted
```
public boolean isDeleted()
```

isAlive
```
public boolean isAlive()
```

updateUsages
```
protected void updateUsages(Node oldInput,
                            Node newInput)
```
Updates the usages sets of the given nodes after an input slot is changed from oldInput to newInput by removing this node from oldInput's usages and adds this node to newInput's usages.

updateUsagesInterface

protected void updateUsagesInterface(NodeInterface oldInput,
                                     NodeInterface newInput)

updatePredecessor
```
protected void updatePredecessor(Node oldSuccessor,
                                 Node newSuccessor)
```
Updates the predecessor of the given nodes after a successor slot is changed from oldSuccessor to newSuccessor: removes this node from oldSuccessor's predecessors and adds this node to newSuccessor's predecessors.

initialize
```
void initialize(Graph newGraph)
```

getNodeClass

public final NodeClass<? extends Node> getNodeClass()

isAllowedUsageType

public boolean isAllowedUsageType(InputType type)

checkReplaceWith

private boolean checkReplaceWith(Node other)

replaceAtUsages

public final void replaceAtUsages(Node other)

replaceAtUsages

public final void replaceAtUsages(Node other,
                                  Predicate<Node> filter)

getUsageAt
```
public Node getUsageAt(int index)
```

replaceAtMatchingUsages

public void replaceAtMatchingUsages(Node other,
                                    NodePredicate usagePredicate)

replaceAtUsages

public void replaceAtUsages(InputType type,
                            Node other)

maybeNotifyInputChanged

private void maybeNotifyInputChanged(Node node)

maybeNotifyZeroUsages

private void maybeNotifyZeroUsages(Node node)

replaceAtPredecessor

public void replaceAtPredecessor(Node other)

replaceAndDelete

public void replaceAndDelete(Node other)

replaceFirstSuccessor

public void replaceFirstSuccessor(Node oldSuccessor,
                                  Node newSuccessor)

replaceFirstInput

public void replaceFirstInput(Node oldInput,
                              Node newInput)

unregisterInputs
```
private void unregisterInputs()
```

clearInputs
```
public void clearInputs()
```

removeThisFromUsages

private boolean removeThisFromUsages(Node n)

unregisterSuccessors
```
private void unregisterSuccessors()
```

clearSuccessors
```
public void clearSuccessors()
```

checkDeletion
```
private boolean checkDeletion()
```

safeDelete
```
public void safeDelete()
```
Removes this node from its graph. This node must have no usages and no predecessor.

markDeleted
```
public void markDeleted()
```

copyWithInputs
```
public final Node copyWithInputs()
```

copyWithInputs

public final Node copyWithInputs(boolean insertIntoGraph)

simplify
```
public void simplify(SimplifierTool tool)
```
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).

Parameters:

tool -

copyOrClearEdgesForClone

private void copyOrClearEdgesForClone(Node newNode,
                                      Edges.Type type,
                                      EnumSet<Edges.Type> edgesToCopy)

Parameters:: newNode - the result of cloning this node or raw allocating a copy of this node; type - the type of edges to process; edgesToCopy - if type is in this set, the edges are copied otherwise they are cleared

clone
```
final Node clone(Graph into,
                 EnumSet<Edges.Type> edgesToCopy)
```
Makes a copy of this node in(to) a given graph.

Parameters:

into - the graph in which the copy will be registered (which may be this node's graph) or null if the copy should not be registered in a graph

edgesToCopy - specifies the edges to be copied. The edges not specified in this set are initialized to their default value (i.e., null for a direct edge, an empty list for an edge list)

Returns:

the copy of this node

afterClone

protected void afterClone(Node other)

verifyInputs
```
public boolean verifyInputs()
```

verify
```
public boolean verify()
```

verifyEdges
```
public boolean verifyEdges()
```
Perform expensive verification of inputs, usages, predecessors and successors.

Returns:

true

assertTrue

public boolean assertTrue(boolean condition,
                          String message,
                          Object... args)

assertFalse

public boolean assertFalse(boolean condition,
                           String message,
                           Object... args)

fail

protected VerificationError fail(String message,
                                 Object... args)
                          throws GraalGraphJVMCIError

Throws:: GraalGraphJVMCIError

cfgPredecessors

public Iterable<? extends Node> cfgPredecessors()

cfgSuccessors
```
public Iterable<? extends Node> cfgSuccessors()
```
Returns an iterator that will provide all control-flow successors of this node. Normally this will be the contents of all fields marked as NodeSuccessor, but some node classes (like EndNode) may return different nodes. Note that the iterator may generate null values if the fields contain them.

hashCode
```
public final int hashCode()
```
Nodes always use an identity hash code.

Overrides:

hashCode in class Object

equals
```
public final boolean equals(Object obj)
```
Equality tests must rely solely on identity.

Overrides:

equals in class Object

getDebugProperties
```
public final Map<Object,Object> getDebugProperties()
```
Provides a Map of properties of this node for use in debugging (e.g., to view in the ideal graph visualizer).

getDebugProperties
```
public Map<Object,Object> getDebugProperties(Map<Object,Object> map)
```
Fills a Map with properties of this node for use in debugging (e.g., to view in the ideal graph visualizer). Subclasses overriding this method should also fill the map using their superclass.

Parameters:

map -

toString
```
public final String toString()
```
This method is a shortcut for toString(Verbosity) with Verbosity.Short.

Overrides:

toString in class Object

toString
```
public String toString(Verbosity verbosity)
```
Creates a String representation for this node with a given Verbosity.

getId
```
@Deprecated
public int getId()
```
Deprecated.

formatTo

public void formatTo(Formatter formatter,
                     int flags,
                     int width,
                     int precision)

Specified by:: formatTo in interface Formattable

valueEquals
```
public boolean valueEquals(Node other)
```
Determines if this node's data fields are equal to the data fields of another node of the same type. Primitive fields are compared by value and non-primitive fields are compared by Objects.equals(Object, Object). The result of this method undefined if other.getClass() != this.getClass().

Parameters:

other - a node of exactly the same type as this node

Returns:

true if the data fields of this object and other are equal

pushInputs

public final void pushInputs(NodeStack stack)

Class Node

Replay Compilation

Assertions and Verification

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

TYPE

USE_UNSAFE_TO_CLONE

DELETED_ID_START

INITIAL_ID

ALIVE_ID_START

graph

id

typeCacheNext

INLINE_USAGE_COUNT

NO_NODES

usage0

usage1

extraUsages

extraUsagesCount

predecessor

nodeClass

NODE_LIST

NOT_ITERABLE

WithNoEdges

WithAllEdges

WithOnlyInputEdges

WithOnlySucessorEdges

Constructor Detail

Node

Method Detail

init

id

newSet

newSet

newMap

newMap

newMap

newIdentityMap

newIdentityMap

newIdentityMap

graph

inputs

acceptInputs

successors

acceptSuccessors

getUsageCount

usages

hasNoUsages

hasUsages

reverseUsageOrder

addUsage

movUsageFromEndTo

removeUsage

predecessor

modCount

incModCount

usageModCount

incUsageModCount

isDeleted

isAlive

updateUsages

updateUsagesInterface

updatePredecessor

initialize

getNodeClass

isAllowedUsageType

checkReplaceWith

replaceAtUsages

replaceAtUsages

getUsageAt

replaceAtMatchingUsages

replaceAtUsages

maybeNotifyInputChanged

maybeNotifyZeroUsages

replaceAtPredecessor

replaceAndDelete