vm/opto/node.cpp

16  * 2 along with this work; if not, write to the Free Software Foundation,
60 // Set a breakpoint here to identify where a particular node index is built.
68     // we continue to assign negative numbers (!) consecutively.
111   // Note:  It is OK to delete multiple copies of the last-seen edge.
112   // Unfortunately, we have no way to verify that all the deletions delete
122   if (this == &that)  return;  // ignore assignment to self
124     // We need to initialize everything, overwriting garbage values.
129   // to be reassigned to iterate over another node y.  Some doubly-nested
130   // progress loops depend on being able to do this.
151     // Fix up _idx to meet asserts.
170     // We need to initialize everything, overwriting garbage values.
187   // If the loop has killed the node, do not require it to re-run.
190   // to re-synch an iteration index, but the loop did not correctly
204   // This last check is carefully designed to work for NO_OUT_ARRAY.
236   assert(_outp == node->_out + node->_outcnt, "apply -= only to a limit (imax)");
250   // at_end_ok means the _outp is allowed to underflow by 1
254   assert(_outp == (node->_out + node->_outcnt) - 1, "pointer must point to end of nodes");
258   // Do not require the limit address to be resynched.
279 // This constant used to initialize _out may be any non-null value.
296     // Allocate space for _in array to have double alignment.
304   // and we begin to initialize the new Node.
328     Node** to = _in;
330       to[i] = NULL;
486   // And reset the counters to 0
491   // Walk the old node's input list to duplicate its edges
502   // If the cloned node is a range check dependent CastII, add it to the list.
512   // impossible to break on the clone's moment of creation.
525     MachOper **to = (MachOper **)((size_t)(&mach->_opnds) +
528     mach->_opnds = to;
530       to[i] = from[i]->clone();
533   // cloning CallNode may need to clone JVMState
544 // Call this when changing the top node, to reassert the invariants
560 // Fancy destructor; eagerly attempt to reclaim Node numberings and storage
578   // See if the input array was allocated just prior to the object
636     Node** to = _in;
637     to[0] = NULL;
638     to[1] = NULL;
639     to[2] = NULL;
640     to[3] = NULL;
644   // Trimming to limit allows a uint8 to handle up to 255 edges.
650   // This assertion makes sure that Node::_max is wide enough to
667   // Trimming to limit allows a uint8 to handle up to 255 edges.
674   // This assertion makes sure that Node::_max is wide enough to
705   // Look to see if I can move precedence down one without reallocating
709   // Find a precedence edge to move
732   // Look to see if I can move precedence down one without reallocating
736   // Find a precedence edge to move
815   if (old == neww)  return 0;  // nothing to do
832  * Replace input edges in the range pointing to 'old' node.
835   if (old == neww)  return 0;  // nothing to do
847 // NULL out all inputs to eliminate incoming Def-Use edges.
954   // Find a precedence edge to move
1042 // Return a node that the given node is equivalent to.
1044   return this;                  // Default to no identities
1050   return bottom_type();         // Default to worst-case Type
1057 // In order to be efficient and flexible there are some subtle invariants
1058 // these Ideal calls need to hold.  Running with '+VerifyIterativeGVN' checks
1059 // these invariants, although its too slow to have on by default.  If you are
1060 // hacking an Ideal call, be sure to test with +VerifyIterativeGVN!
1065 // to an AddINode gives the same answer and same root, but you still have to
1069 // Identity call to return an old Node; basically if Identity can find
1074 // You cannot modify any old Nodes except for the 'this' pointer.  Due to
1082 // some new internal piece) you may use 'init_req' to set the initial
1107   return NULL;                  // Default to being Ideal already
1112 // for the transformations to happen.
1118     // Condition for back-to-back stores folding.
1157 // Check if 'this' control node dominates or equal to 'sub' control node.
1158 // We already know that if any path back to Root or Start reaches 'this',
1173   // Walk 'sub' backward up the chain to 'dom', watching for regions.
1174   // After seeing 'dom', continue up to Root or Start.
1190         // Region nodes were visited. Continue walk up to Start or Root
1191         // to make sure that it did not walk in a cycle.
1197       // Success if we met 'dom' along a path to Start or Root.
1199       // (This assumption is up to the caller to ensure!)
1205     // If sub == up, we found a self-loop.  Try to push past it.
1207       // Take loop entry path on the way up to 'dom'.
1210       // Always take in(1) path on the way up to 'dom' for clone regions
1212       // (usually used to merge fast/slow paths).
1224       // and worked our way up again to the loop header 'sub'.
1225       // So, take the first unexplored path on the way up to 'dom'.
1258       // Set 0 bit to indicate that both paths were taken.
1286   // Con's are a popular node to re-hit in the hash table again.
1305         igvn->hash_delete(use);       // Yank from hash table prior to mod
1308           use->set_req(0, top);       // Cut dead edge to prevent processing
1313           use->set_req(LoopNode::EntryControl, top);          // Cut dead edge to prevent processing
1356       // Kill all inputs to the dead guy
1358         Node *n = dead->in(i);      // Get input to dead guy
1368             // Push store's uses on worklist to enable folding optimization for
1369             // store/store and store/load to the same address.
1558 // Find an ancestor to this node in the control history with given _idx
1590   Node* fast = orig->debug_orig(); // tortoise & hare algorithm to detect loops
1769 //   start:         the node at which to start collecting.
1772 //   depth:         collect nodes up to this distance from the start node.
1773 //   include_start: whether to include the start node in the result collection.
1774 //   only_ctrl:     whether to regard control edges only during traversal.
1775 //   only_data:     whether to regard data edges only during traversal.
1833 // Dump a Node's control history to depth
1845 // Nodes can specify additional specifics to print in compact representation by
1876 // Dump a Node's related nodes up to a given depth (distance from the start
1924 // the default is to collect all data inputs (till level 1 if compact), and
1941 // An entry point to the low-level node collection facility, to start from a
1946 //   d:    the depth (distance from start node) to which nodes should be
1969     // Add all primary inputs reachable from the current level to the list, and
2054 // For each input edge to a node (ie - for each Use-Def edge), verify that
2075       assert( cnt > 0,"Failed to find Def-Use edge." );
2077       // walk the input array downcounting the input edges to n
2086       // Nothing to check.
2123     // Verify my input has a def-use edge to me
2125       // Count use-def edges from n to x
2130       // Count def-use edges from x to n
2204 // Clear all entries in _nodes to NULL but keep storage
2217   while( i >= _max ) _max <<= 1;        // Double to fit
2253 // Operation appears to be iteratively computed (such as an induction variable)
2254 // It is possible for this operation to return false for a loop-varying
2255 // value, if it appears (by local graph inspection) to be computed by a simple conditional.
2402 // Node_Stack is used to map nodes.