graal-jvmci-8: src/share/vm/opto/loopnode.cpp comparison

comparison src/share/vm/opto/loopnode.cpp @ 23660:b5f3a471e646

Merge.

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 01 Jun 2016 00:11:44 +0200
parents	501f014415d8
children	c9035b8e388b

comparison

equal deleted inserted replaced

-:d7cf78885a3a
+:b5f3a471e646
 limit = gvn->transform(new (C) AddINode(span,init_trip));
 set_subtree_ctrl( limit );
 } // LoopLimitCheck
-// Check for SafePoint on backedge and remove
+if (!UseCountedLoopSafepoints) {
-Node *sfpt = x->in(LoopNode::LoopBackControl);
+// Check for SafePoint on backedge and remove
-if (sfpt->Opcode() == Op_SafePoint && is_deleteable_safept(sfpt)) {
+Node *sfpt = x->in(LoopNode::LoopBackControl);
-lazy_replace( sfpt, iftrue );
+if (sfpt->Opcode() == Op_SafePoint && is_deleteable_safept(sfpt)) {
-if (loop->_safepts != NULL) {
+lazy_replace( sfpt, iftrue );
-loop->_safepts->yank(sfpt);
+if (loop->_safepts != NULL) {
-}
+loop->_safepts->yank(sfpt);
-loop->_tail = iftrue;
+}
+loop->_tail = iftrue;
+}
 }
 // Build a canonical trip test.
 // Clone code, as old values may be in use.
 incr = incr->clone();
 // Fix all data nodes placed at the old loop head.
 // Uses the lazy-update mechanism of 'get_ctrl'.
 lazy_replace( x, l );
 set_idom(l, init_control, dom_depth(x));
-// Check for immediately preceding SafePoint and remove
+if (!UseCountedLoopSafepoints) {
-Node *sfpt2 = le->in(0);
+// Check for immediately preceding SafePoint and remove
-if (sfpt2->Opcode() == Op_SafePoint && is_deleteable_safept(sfpt2)) {
+Node *sfpt2 = le->in(0);
-lazy_replace( sfpt2, sfpt2->in(TypeFunc::Control));
+if (sfpt2->Opcode() == Op_SafePoint && is_deleteable_safept(sfpt2)) {
-if (loop->_safepts != NULL) {
+lazy_replace( sfpt2, sfpt2->in(TypeFunc::Control));
-loop->_safepts->yank(sfpt2);
+if (loop->_safepts != NULL) {
+loop->_safepts->yank(sfpt2);
+}
 }
 }
 // Free up intermediate goo
 _igvn.remove_dead_node(hook);
 continue;
 }
 }
 }
+void IdealLoopTree::remove_safepoints(PhaseIdealLoop* phase, bool keep_one) {
+Node* keep = NULL;
+if (keep_one) {
+// Look for a safepoint on the idom-path.
+for (Node* i = tail(); i != _head; i = phase->idom(i)) {
+if (i->Opcode() == Op_SafePoint && phase->get_loop(i) == this) {
+keep = i;
+break; // Found one
+}
+}
+}
+// Don't remove any safepoints if it is requested to keep a single safepoint and
+// no safepoint was found on idom-path. It is not safe to remove any safepoint
+// in this case since there's no safepoint dominating all paths in the loop body.
+bool prune = !keep_one || keep != NULL;
+// Delete other safepoints in this loop.
+Node_List* sfpts = _safepts;
+if (prune && sfpts != NULL) {
+assert(keep == NULL || keep->Opcode() == Op_SafePoint, "not safepoint");
+for (uint i = 0; i < sfpts->size(); i++) {
+Node* n = sfpts->at(i);
+assert(phase->get_loop(n) == this, "");
+if (n != keep && phase->is_deleteable_safept(n)) {
+phase->lazy_replace(n, n->in(TypeFunc::Control));
+}
+}
+}
+}
 //------------------------------counted_loop-----------------------------------
 // Convert to counted loops where possible
 void IdealLoopTree::counted_loop( PhaseIdealLoop *phase ) {
 // For grins, set the inner-loop flag here
 if (_head->is_Loop()) _head->as_Loop()->set_inner_loop();
 }
 if (_head->is_CountedLoop() ||
 phase->is_counted_loop(_head, this)) {
-_has_sfpt = 1;              // Indicate we do not need a safepoint here
+if (!UseCountedLoopSafepoints) {
-// Look for safepoints to remove.
+// Indicate we do not need a safepoint here
-Node_List* sfpts = _safepts;
+_has_sfpt = 1;
-if (sfpts != NULL) {
+}
-for (uint i = 0; i < sfpts->size(); i++) {
-Node* n = sfpts->at(i);
+// Remove safepoints
-assert(phase->get_loop(n) == this, "");
+bool keep_one_sfpt = !(_has_call || _has_sfpt);
-if (phase->is_deleteable_safept(n)) {
+remove_safepoints(phase, keep_one_sfpt);
-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.
+// Not a counted loop. Keep one safepoint.
-// Look for a safepoint on the idom-path.
+bool keep_one_sfpt = true;
-Node* sfpt = tail();
+remove_safepoints(phase, keep_one_sfpt);
-for (; sfpt != _head; sfpt = phase->idom(sfpt)) {
-if (sfpt->Opcode() == Op_SafePoint && phase->get_loop(sfpt) == this)
-break; // Found one
-}
-// Delete other safepoints in this loop.
-Node_List* sfpts = _safepts;
-if (sfpts != NULL && sfpt != _head && sfpt->Opcode() == Op_SafePoint) {
-for (uint i = 0; i < sfpts->size(); i++) {
-Node* n = sfpts->at(i);
-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 );
 if (_next)  _next ->counted_loop( phase );
 if (cl->is_pre_loop ()) tty->print(" pre" );
 if (cl->is_main_loop()) tty->print(" main");
 if (cl->is_post_loop()) tty->print(" post");
 }
+if (_has_call) tty->print(" has_call");
+if (_has_sfpt) tty->print(" has_sfpt");
+if (_rce_candidate) tty->print(" rce");
+if (_safepts != NULL && _safepts->size() > 0) {
+tty->print(" sfpts={"); _safepts->dump_simple(); tty->print(" }");
+}
+if (_required_safept != NULL && _required_safept->size() > 0) {
+tty->print(" req={"); _required_safept->dump_simple(); tty->print(" }");
+}
 tty->cr();
 }
 //------------------------------dump-------------------------------------------
 // Dump loops by loop tree
 // node.  For CFG nodes, the _nodes array starts out and remains
 // holding the associated IdealLoopTree pointer.  For DATA nodes, the
 // _nodes array holds the earliest legal controlling CFG node.
 // Allocate stack with enough space to avoid frequent realloc
-int stack_size = (C->unique() >> 1) + 16; // (unique>>1)+16 from Java2D stats
+int stack_size = (C->live_nodes() >> 1) + 16; // (live_nodes>>1)+16 from Java2D stats
 Node_Stack nstack( a, stack_size );
 visited.Clear();
 Node_List worklist(a);
 // Don't need C->root() on worklist since
 _ltree_root->dump();
 }
 #endif
 if (skip_loop_opts) {
+// restore major progress flag
+for (int i = 0; i < old_progress; i++) {
+C->set_major_progress();
+}
 // Cleanup any modified bits
 _igvn.optimize();
 if (C->log() != NULL) {
 log_loop_tree(_ltree_root, _ltree_root, C->log());
 if (_dom_depth[i] > 0 && _idom[i] != NULL) {
 _dom_depth[i] = no_depth_marker;
 }
 }
 if (_dom_stk == NULL) {
-uint init_size = C->unique() / 100; // Guess that 1/100 is a reasonable initial size.
+uint init_size = C->live_nodes() / 100; // Guess that 1/100 is a reasonable initial size.
 if (init_size < 10) init_size = 10;
 _dom_stk = new GrowableArray<uint>(init_size);
 }
 // Compute new depth for each node.
 for (i = 0; i < _idom_size; i++) {
 // I need to inspect loop header pre-order numbers to properly nest my
 // loops.  This means I need to sort my childrens' loops by pre-order.
 // The sort is of size number-of-control-children, which generally limits
 // it to size 2 (i.e., I just choose between my 2 target loops).
 void PhaseIdealLoop::build_loop_tree() {
-// Allocate stack of size C->unique()/2 to avoid frequent realloc
+// Allocate stack of size C->live_nodes()/2 to avoid frequent realloc
-GrowableArray <Node *> bltstack(C->unique() >> 1);
+GrowableArray <Node *> bltstack(C->live_nodes() >> 1);
 Node *n = C->root();
 bltstack.push(n);
 int pre_order = 1;
 int stack_size;
 #ifndef PRODUCT
 //------------------------------dump-------------------------------------------
 void PhaseIdealLoop::dump( ) const {
 ResourceMark rm;
 Arena* arena = Thread::current()->resource_area();
-Node_Stack stack(arena, C->unique() >> 2);
+Node_Stack stack(arena, C->live_nodes() >> 2);
 Node_List rpo_list;
 VectorSet visited(arena);
 visited.set(C->top()->_idx);
 rpo( C->root(), stack, visited, rpo_list );
 // Dump root loop indexed by last element in PO order

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/opto/loopnode.cpp @ 23660:b5f3a471e646