jdk8-mips64-public/hotspot: comparison src/share/vm/opto/loopnode.cpp

-:83b6305a5638
+:0acd345fd810
 // Check for SafePoint on backedge and remove
 Node *sfpt = x->in(LoopNode::LoopBackControl);
 if (sfpt->Opcode() == Op_SafePoint && is_deleteable_safept(sfpt)) {
 lazy_replace( sfpt, iftrue );
+if (loop->_safepts != NULL) {
+loop->_safepts->yank(sfpt);
+}
 loop->_tail = iftrue;
 }
 // Build a canonical trip test.
 // Clone code, as old values may be in use.
 lazy_replace( x, l );
 set_idom(l, init_control, dom_depth(x));
 // Check for immediately preceding SafePoint and remove
 Node *sfpt2 = le->in(0);
-if (sfpt2->Opcode() == Op_SafePoint && is_deleteable_safept(sfpt2))
+if (sfpt2->Opcode() == Op_SafePoint && is_deleteable_safept(sfpt2)) {
 lazy_replace( sfpt2, sfpt2->in(TypeFunc::Control));
+if (loop->_safepts != NULL) {
+loop->_safepts->yank(sfpt2);
+}
+}
 // Free up intermediate goo
 _igvn.remove_dead_node(hook);
 #ifdef ASSERT
 //     is encountered, to find the ncsfpt's that are closest to the tail.
 //
 void IdealLoopTree::check_safepts(VectorSet &visited, Node_List &stack) {
 // Bottom up traversal
 IdealLoopTree* ch = _child;
-while (ch != NULL) {
+if (_child) _child->check_safepts(visited, stack);
-ch->check_safepts(visited, stack);
+if (_next)  _next ->check_safepts(visited, stack);
-ch = ch->_next;
-}
 if (!_head->is_CountedLoop() && !_has_sfpt && _parent != NULL && !_irreducible) {
 bool  has_call         = false; // call on dom-path
 bool  has_local_ncsfpt = false; // ncsfpt on dom-path at this loop depth
 Node* nonlocal_ncsfpt  = NULL;  // ncsfpt on dom-path at a deeper depth
 if (_head->is_CountedLoop() ||
 phase->is_counted_loop(_head, this)) {
 _has_sfpt = 1;              // Indicate we do not need a safepoint here
-// Look for a safepoint to remove
+// Look for safepoints to remove.
-for (Node* n = tail(); n != _head; n = phase->idom(n))
+Node_List* sfpts = _safepts;
-if (n->Opcode() == Op_SafePoint && phase->get_loop(n) == this &&
+if (sfpts != NULL) {
-phase->is_deleteable_safept(n))
+for (uint i = 0; i < sfpts->size(); i++) {
-phase->lazy_replace(n,n->in(TypeFunc::Control));
+Node* n = sfpts->at(i);
+assert(phase->get_loop(n) == this, "");
+if (phase->is_deleteable_safept(n)) {
+phase->lazy_replace(n, n->in(TypeFunc::Control));
+}
+}
+}
 // Look for induction variables
 phase->replace_parallel_iv(this);
 } else if (_parent != NULL && !_irreducible) {
 // Not a counted loop.
-// Look for a safepoint on the idom-path to remove, preserving the first one
+// Look for a safepoint on the idom-path.
-bool found = false;
+Node* sfpt = tail();
-Node* n = tail();
+for (; sfpt != _head; sfpt = phase->idom(sfpt)) {
-for (; n != _head && !found; n = phase->idom(n)) {
+if (sfpt->Opcode() == Op_SafePoint && phase->get_loop(sfpt) == this)
-if (n->Opcode() == Op_SafePoint && phase->get_loop(n) == this)
+break; // Found one
-found = true; // Found one
+}
-}
+// Delete other safepoints in this loop.
-// Skip past it and delete the others
+Node_List* sfpts = _safepts;
-for (; n != _head; n = phase->idom(n)) {
+if (sfpts != NULL && sfpt != _head && sfpt->Opcode() == Op_SafePoint) {
-if (n->Opcode() == Op_SafePoint && phase->get_loop(n) == this &&
+for (uint i = 0; i < sfpts->size(); i++) {
-phase->is_deleteable_safept(n))
+Node* n = sfpts->at(i);
-phase->lazy_replace(n,n->in(TypeFunc::Control));
+assert(phase->get_loop(n) == this, "");
+if (n != sfpt && phase->is_deleteable_safept(n)) {
+phase->lazy_replace(n, n->in(TypeFunc::Control));
+}
+}
 }
 }
 // Recursively
 if (_child) _child->counted_loop( phase );
 // Disable loop optimizations if the loop has a scalar replaceable
 // allocation. This disabling may cause a potential performance lost
 // if the allocation is not eliminated for some reason.
 innermost->_allow_optimizations = false;
 innermost->_has_call = 1; // = true
+} else if (n->Opcode() == Op_SafePoint) {
+// Record all safepoints in this loop.
+if (innermost->_safepts == NULL) innermost->_safepts = new Node_List();
+innermost->_safepts->push(n);
 }
 }
 }
 // Flag as post-visited now
 // and thus could be avoided indefinitely)
 if( !_verify_only && !_verify_me && ilt->_has_sfpt && n->Opcode() == Op_SafePoint &&
 is_deleteable_safept(n)) {
 Node *in = n->in(TypeFunc::Control);
 lazy_replace(n,in);       // Pull safepoint now
+if (ilt->_safepts != NULL) {
+ilt->_safepts->yank(n);
+}
 // Carry on with the recursion "as if" we are walking
 // only the control input
 if( !visited.test_set( in->_idx ) ) {
 worklist.push(in);      // Visit this guy later, using worklist
 }

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/opto/loopnode.cpp

src/share/vm/opto/loopnode.cpp