Class Node

chapter21/src/main/java/com/seaofnodes/simple/node/Node.java:19–728

All Nodes in the Sea of Nodes IR inherit from the Node class. The Node class provides common functionality used by all subtypes. Subtypes of Node specialize by overriding methods.

 * Subtypes of Node specialize by overriding methods.
 */
public abstract class Node implements Cloneable {

    /**
     * Each node has a unique dense Node ID within a compilation context
     * The ID is useful for debugging, for using as an offset in a bitvector,
     * as well as for computing equality of nodes (to be implemented later).
     */
    public int _nid;

    /**
     * Inputs to the node. These are use-def references to Nodes.
     * <p>
     * Generally fixed length, ordered, nulls allowed, no unused trailing space.
     * Ordering is required because e.g. "a/b" is different from "b/a".
     * The first input (offset 0) is often a {@link CFGNode} node.
     */
    public Ary<Node> _inputs;

    /**
     * Outputs reference Nodes that are not null and have this Node as an
     * input.  These nodes are users of this node, thus these are def-use
     * references to Nodes.
     * <p>
     * Outputs directly match inputs, making a directed graph that can be
     * walked in either direction.  These outputs are typically used for
     * efficient optimizations but otherwise have no semantics meaning.
     */
    public Ary<Node> _outputs;


    /**
     * Current computed type for this Node.  This value changes as the graph
     * changes and more knowledge is gained about the program.
     */
    public Type _type;


    Node(Node... inputs) {
        _nid = CODE.getUID(); // allocate unique dense ID
        _inputs = new Ary<>(Node.class);
        Collections.addAll(_inputs,inputs);
        _outputs = new Ary<>(Node.class);
        for( Node n : _inputs )
            if( n != null )
                n.addUse( this );
    }

    // Make a Node using the existing arrays of nodes.
    // Used by any pass rewriting all Node classes but not the edges.
    Node( Node n ) {
        assert CodeGen.CODE._phase.ordinal() >= CodeGen.Phase.InstSelect.ordinal();
        _nid = CODE.getUID(); // allocate unique dense ID
        _inputs  = new Ary<>(n==null ? new Node[0] : n._inputs.asAry());
        _outputs = new Ary<>(Node.class);
        _type = n==null ? Type.BOTTOM : n._type;
        _deps = null;
        _hash = 0;
    }