Lines Matching refs:node
32 #include "opto/node.hpp"
53 // Set a breakpoint here to identify where a particular node index is built.
86 void DUIterator_Common::sample(const Node* node) {
88 _node = node;
89 _outcnt = node->_outcnt;
90 _del_tick = node->_del_tick;
94 void DUIterator_Common::verify(const Node* node, bool at_end_ok) {
95 assert(_node == node, "consistent iterator source");
96 assert(_del_tick == node->_del_tick, "no unexpected deletions allowed");
101 const Node* node = _node;
106 assert(node->_del_tick >= _del_tick+1, "must have deleted an edge");
107 assert(node->_last_del == _last, "must have deleted the edge just produced");
109 _outcnt = node->_outcnt;
110 _del_tick = node->_del_tick;
120 // Note: It is legal (though odd) for an iterator over some node x
121 // to be reassigned to iterate over another node y. Some doubly-nested
123 const Node* node = that._node;
125 _node = node;
126 _outcnt = node->_outcnt;
127 _del_tick = node->_del_tick;
130 void DUIterator::sample(const Node* node) {
131 DUIterator_Common::sample(node); // Initialize the assertion data.
135 void DUIterator::verify(const Node* node, bool at_end_ok) {
136 DUIterator_Common::verify(node, at_end_ok);
137 assert(_idx < node->_outcnt + (uint)at_end_ok, "idx in range");
179 // If the loop has killed the node, do not require it to re-run.
190 void DUIterator_Fast::verify(const Node* node, bool at_end_ok) {
191 DUIterator_Common::verify(node, at_end_ok);
192 Node** out = node->_out;
193 uint cnt = node->_outcnt;
200 const Node* node = _node;
201 verify(node, true);
202 assert(_outp == node->_out + node->_outcnt, "limit still correct");
206 const Node* node = _node;
207 if (_outp == node->_out + _outcnt) {
210 assert(node->_outcnt+node->_del_tick == _outcnt+_del_tick, "no insertions allowed with deletion(s)");
213 _last = (Node*) node->_last_del;
216 assert(node->_outcnt < _outcnt, "no insertions allowed with deletion(s)");
220 verify(node, true);
225 const Node* node = _node;
228 assert(_outp == node->_out + node->_outcnt, "apply -= only to a limit (imax)");
229 // The reported number of deletions must match what the node saw.
230 assert(node->_del_tick == _del_tick + n, "must have deleted n edges");
232 _last = (Node*) node->_last_del;
241 void DUIterator_Last::verify(const Node* node, bool at_end_ok) {
244 DUIterator_Fast::verify(node, at_end_ok); // check _del_tick, etc.
246 assert(_outp == (node->_out + node->_outcnt) - 1, "pointer must point to end of nodes");
251 //verify(node, true);
260 const Node* node = _node;
261 verify(node, true);
262 assert(node->_last_del == _last, "must have deleted the edge just produced");
272 // The value NULL is reserved for the top node only.
276 // to pull Compile::current out of the new node's _out field,
288 // Out-of-line code from node constructors.
350 assert( is_not_dead(n0), "can not use dead node");
362 assert( is_not_dead(n0), "can not use dead node");
363 assert( is_not_dead(n1), "can not use dead node");
376 assert( is_not_dead(n0), "can not use dead node");
377 assert( is_not_dead(n1), "can not use dead node");
378 assert( is_not_dead(n2), "can not use dead node");
392 assert( is_not_dead(n0), "can not use dead node");
393 assert( is_not_dead(n1), "can not use dead node");
394 assert( is_not_dead(n2), "can not use dead node");
395 assert( is_not_dead(n3), "can not use dead node");
410 assert( is_not_dead(n0), "can not use dead node");
411 assert( is_not_dead(n1), "can not use dead node");
412 assert( is_not_dead(n2), "can not use dead node");
413 assert( is_not_dead(n3), "can not use dead node");
414 assert( is_not_dead(n4), "can not use dead node");
431 assert( is_not_dead(n0), "can not use dead node");
432 assert( is_not_dead(n1), "can not use dead node");
433 assert( is_not_dead(n2), "can not use dead node");
434 assert( is_not_dead(n3), "can not use dead node");
435 assert( is_not_dead(n4), "can not use dead node");
436 assert( is_not_dead(n5), "can not use dead node");
454 assert( is_not_dead(n0), "can not use dead node");
455 assert( is_not_dead(n1), "can not use dead node");
456 assert( is_not_dead(n2), "can not use dead node");
457 assert( is_not_dead(n3), "can not use dead node");
458 assert( is_not_dead(n4), "can not use dead node");
459 assert( is_not_dead(n5), "can not use dead node");
460 assert( is_not_dead(n6), "can not use dead node");
487 // Walk the old node's input list to duplicate its edges
514 // It should be the same offset since it is the clone of this node.
533 // Call this when changing the top node, to reassert the invariants
537 // This node has just become top. Kill its out array.
572 assert(outcnt() == 0, "deleting a node must not leave a dangling use");
590 // Free the input edge array and the node itself
625 // We will not actually delete the storage, but we'll make the node unusable.
662 assert(!is_top(), "cannot grow a top node's out array");
707 assert( is_not_dead(n), "can not use dead node");
728 assert( is_not_dead(n), "can not use dead node");
755 // Insert multiple out edges on the node.
768 "remove node from hash table before modifying it");
779 assert( is_not_dead(n), "can not use dead node");
890 assert( is_not_dead(n), "can not use dead node");
981 // Return a node that the given node is equivalent to.
987 // Compute a new Type for a node using the Type of the inputs.
1033 // for the returned root node. Example: reshape "X*31" with "(X<<5)-X".
1090 // Check if 'this' control node dominates or equal to 'sub' control node.
1154 // Was this Region node visited before?
1168 // The Region node was visited before only once.
1208 // Did not meet Root or Start node in pred. chain.
1214 // This control node is dead. Follow the subgraph below it making everything
1219 // Con's are a popular node to re-hit in the hash table again.
1232 // Keep dead node on stack until all uses are processed.
1238 if (use->in(0) == dead) { // Found another dead node
1239 assert (!use->is_Con(), "Control for Con node should be Root node.");
1241 nstack.push(use); // the dead node again.
1395 assert((tp != NULL), "unexpected node type");
1483 // Find an ancestor to this node in the control history with given _idx
1587 // Dump node-specific info
1744 // For each input edge to a node (ie - for each Use-Def edge), verify that
1806 assert(C->cached_top_node() == n, "TOP node must be unique");
1962 // Return a node with opcode "opc" and same inputs as "this" if one can
2055 --i; // Visit popped node