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

-:d678e3277048
+:6027dddc26c6
 register_new_node( inv_scale, inv_scale_ctrl );
 Node *var_scale = new (C, 3) LShiftINode( add_var, scale );
 register_new_node( var_scale, n_ctrl );
 Node *var_add = new (C, 3) AddINode( var_scale, inv_scale );
 register_new_node( var_add, n_ctrl );
-_igvn.hash_delete( n );
+_igvn.replace_node( n, var_add );
-_igvn.subsume_node( n, var_add );
 return var_add;
 }
 // Replace (I+V) with (V+I)
 if( n_op == Op_AddI ||
 Node *add1 = new (C, 4) AddPNode( n->in(1), n->in(2)->in(2), n->in(3) );
 // Stuff new AddP in the loop preheader
 register_new_node( add1, n_loop->_head->in(LoopNode::EntryControl) );
 Node *add2 = new (C, 4) AddPNode( n->in(1), add1, n->in(2)->in(3) );
 register_new_node( add2, n_ctrl );
-_igvn.hash_delete( n );
+_igvn.replace_node( n, add2 );
-_igvn.subsume_node( n, add2 );
 return add2;
 }
 }
 }
 Node *add1 = new (C, 4) AddPNode( n->in(1), n->in(2), I );
 // Stuff new AddP in the loop preheader
 register_new_node( add1, n_loop->_head->in(LoopNode::EntryControl) );
 Node *add2 = new (C, 4) AddPNode( n->in(1), add1, V );
 register_new_node( add2, n_ctrl );
-_igvn.hash_delete( n );
+_igvn.replace_node( n, add2 );
-_igvn.subsume_node( n, add2 );
 return add2;
 }
 }
 }
 }
 set_ctrl(inp, cmov_ctrl);
 }
 }
 Node *cmov = CMoveNode::make( C, cmov_ctrl, iff->in(1), phi->in(1+flip), phi->in(2-flip), _igvn.type(phi) );
 register_new_node( cmov, cmov_ctrl );
-_igvn.hash_delete(phi);
+_igvn.replace_node( phi, cmov );
-_igvn.subsume_node( phi, cmov );
 #ifndef PRODUCT
 if( VerifyLoopOptimizations ) verify();
 #endif
 }
 Node *phi = split_thru_phi( n, n_blk, policy );
 if( !phi ) return n;
 // Found a Phi to split thru!
 // Replace 'n' with the new phi
-_igvn.hash_delete(n);
+_igvn.replace_node( n, phi );
-_igvn.subsume_node( n, phi );
 // Moved a load around the loop, 'en-registering' something.
 if( n_blk->Opcode() == Op_Loop && n->is_Load() &&
 !phi->in(LoopNode::LoopBackControl)->is_Load() )
 C->set_major_progress();
 Node *phi = split_thru_phi( n, n_ctrl, policy );
 if( !phi ) return;
 // Found a Phi to split thru!
 // Replace 'n' with the new phi
-_igvn.hash_delete(n);
+_igvn.replace_node( n, phi );
-_igvn.subsume_node( n, phi );
 // Now split the bool up thru the phi
 Node *bolphi = split_thru_phi( bol, n_ctrl, -1 );
-_igvn.hash_delete(bol);
+_igvn.replace_node( bol, bolphi );
-_igvn.subsume_node( bol, bolphi );
 assert( iff->in(1) == bolphi, "" );
 if( bolphi->Value(&_igvn)->singleton() )
 return;
 // Conditional-move?  Must split up now
 if( !iff->is_If() ) {
 Node *cmovphi = split_thru_phi( iff, n_ctrl, -1 );
-_igvn.hash_delete(iff);
+_igvn.replace_node( iff, cmovphi );
-_igvn.subsume_node( iff, cmovphi );
 return;
 }
 // Now split the IF
 do_split_if( iff );
 // Check for Opaque2's who's loop has disappeared - who's input is in the
 // same loop nest as their output.  Remove 'em, they are no longer useful.
 if( n_op == Op_Opaque2 &&
 n->in(1) != NULL &&
 get_loop(get_ctrl(n)) == get_loop(get_ctrl(n->in(1))) ) {
-_igvn.add_users_to_worklist(n);
+_igvn.replace_node( n, n->in(1) );
-_igvn.hash_delete(n);
-_igvn.subsume_node( n, n->in(1) );
 }
 }
 //------------------------------split_if_with_blocks---------------------------
 // Check for aggressive application of 'split-if' optimization,
 // in AddPNode from tripping (when we end up with different
 // base & derived Phis that will become the same after
 // IGVN does CSE).
 Node *hit = _igvn.hash_find_insert(use);
 if( hit )             // Go ahead and re-hash for hits.
-_igvn.subsume_node( use, hit );
+_igvn.replace_node( use, hit );
 }
 // If 'use' was in the loop-exit block, it now needs to be sunk
 // below the post-loop merge point.
 sink_use( use, prev );

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

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

src/share/vm/opto/loopopts.cpp