truffle: src/share/vm/opto/loopTransform.cpp comparison

comparison src/share/vm/opto/loopTransform.cpp @ 20804:7848fc12602b

Merge with jdk8u40-b25

author	Gilles Duboscq <gilles.m.duboscq@oracle.com>
date	Tue, 07 Apr 2015 14:58:49 +0200
parents	52b4284cb496 5b8e0f84f00f
children

comparison

equal deleted inserted replaced

-:84105dcdb05b
+:7848fc12602b
 // Return TRUE or FALSE if the loop should be peeled or not.  Peel if we can
 // make some loop-invariant test (usually a null-check) happen before the loop.
 bool IdealLoopTree::policy_peeling( PhaseIdealLoop *phase ) const {
 Node *test = ((IdealLoopTree*)this)->tail();
 int  body_size = ((IdealLoopTree*)this)->_body.size();
-int  live_node_count = phase->C->live_nodes();
 // Peeling does loop cloning which can result in O(N^2) node construction
 if( body_size > 255 /* Prevent overflow for large body_size */
-|| (body_size * body_size + live_node_count > MaxNodeLimit) ) {
+|| (body_size * body_size + phase->C->live_nodes()) > phase->C->max_node_limit() ) {
 return false;           // too large to safely clone
 }
 while( test != _head ) {      // Scan till run off top of loop
 if( test->is_If() ) {       // Test?
 Node *ctrl = phase->get_ctrl(test->in(1));
 uint tst_body_size = (new_body_size - EMPTY_LOOP_SIZE) / trip_count + EMPTY_LOOP_SIZE;
 if (body_size != tst_body_size) // Check for int overflow
 return false;
 if (new_body_size > unroll_limit ||
 // Unrolling can result in a large amount of node construction
-new_body_size >= MaxNodeLimit - (uint) phase->C->live_nodes()) {
+new_body_size >= phase->C->max_node_limit() - phase->C->live_nodes()) {
 return false;
 }
 // Do not unroll a loop with String intrinsics code.
 // String intrinsics are large and have loops.
 set_ctrl( n, find_non_split_ctrl(back_ctrl->in(0)) );
 }
 return n;
 }
+bool PhaseIdealLoop::cast_incr_before_loop(Node* incr, Node* ctrl, Node* loop) {
+Node* castii = new (C) CastIINode(incr, TypeInt::INT, true);
+castii->set_req(0, ctrl);
+register_new_node(castii, ctrl);
+for (DUIterator_Fast imax, i = incr->fast_outs(imax); i < imax; i++) {
+Node* n = incr->fast_out(i);
+if (n->is_Phi() && n->in(0) == loop) {
+int nrep = n->replace_edge(incr, castii);
+return true;
+}
+}
+return false;
+}
 //------------------------------insert_pre_post_loops--------------------------
 // Insert pre and post loops.  If peel_only is set, the pre-loop can not have
 // more iterations added.  It acts as a 'peel' only, no lower-bound RCE, no
 // alignment.  Useful to unroll loops that do no array accesses.
 void PhaseIdealLoop::insert_pre_post_loops( IdealLoopTree *loop, Node_List &old_new, bool peel_only ) {
 visited, clones);
 _igvn.hash_delete(main_phi);
 main_phi->set_req( LoopNode::EntryControl, fallpre );
 }
 }
+// Nodes inside the loop may be control dependent on a predicate
+// that was moved before the preloop. If the back branch of the main
+// or post loops becomes dead, those nodes won't be dependent on the
+// test that guards that loop nest anymore which could lead to an
+// incorrect array access because it executes independently of the
+// test that was guarding the loop nest. We add a special CastII on
+// the if branch that enters the loop, between the input induction
+// variable value and the induction variable Phi to preserve correct
+// dependencies.
+// CastII for the post loop:
+bool inserted = cast_incr_before_loop(zer_opaq->in(1), zer_taken, post_head);
+assert(inserted, "no castII inserted");
+// CastII for the main loop:
+inserted = cast_incr_before_loop(pre_incr, min_taken, main_head);
+assert(inserted, "no castII inserted");
 // Step B4: Shorten the pre-loop to run only 1 iteration (for now).
 // RCE and alignment may change this later.
 Node *cmp_end = pre_end->cmp_node();
 assert( cmp_end->in(2) == limit, "" );
 }
 }
 // Skip next optimizations if running low on nodes. Note that
 // policy_unswitching and policy_maximally_unroll have this check.
-uint nodes_left = MaxNodeLimit - (uint) phase->C->live_nodes();
+int nodes_left = phase->C->max_node_limit() - phase->C->live_nodes();
-if ((2 * _body.size()) > nodes_left) {
+if ((int)(2 * _body.size()) > nodes_left) {
 return true;
 }
 // Counted loops may be peeled, may need some iterations run up
 // front for RCE, and may want to align loop refs to a cache

Mercurial > hg > truffle

comparison src/share/vm/opto/loopTransform.cpp @ 20804:7848fc12602b