graal-compiler: src/share/vm/opto/coalesce.cpp comparison

comparison src/share/vm/opto/coalesce.cpp @ 12071:adb9a7d94cb5

8023003: Cleanup the public interface to PhaseCFG Summary: public methods that don't need to be public should be private. Reviewed-by: kvn, twisti

author	adlertz
date	Fri, 16 Aug 2013 10:23:55 +0200
parents	d1034bd8cefc
children	4b2838704fd5

comparison

equal deleted inserted replaced

-:afbe18ae0905
+:adb9a7d94cb5
 #include "opto/indexSet.hpp"
 #include "opto/machnode.hpp"
 #include "opto/matcher.hpp"
 #include "opto/regmask.hpp"
-//=============================================================================
-//------------------------------Dump-------------------------------------------
 #ifndef PRODUCT
 void PhaseCoalesce::dump(Node *n) const {
 // Being a const function means I cannot use 'Find'
 uint r = _phc._lrg_map.find(n);
 tty->print("L%d/N%d ",r,n->_idx);
 }
-//------------------------------dump-------------------------------------------
 void PhaseCoalesce::dump() const {
 // I know I have a block layout now, so I can print blocks in a loop
-for( uint i=0; i<_phc._cfg._num_blocks; i++ ) {
+for( uint i=0; i<_phc._cfg.number_of_blocks(); i++ ) {
 uint j;
-Block *b = _phc._cfg._blocks[i];
+Block* b = _phc._cfg.get_block(i);
 // Print a nice block header
 tty->print("B%d: ",b->_pre_order);
 for( j=1; j<b->num_preds(); j++ )
 tty->print("B%d ", _phc._cfg.get_block_for_node(b->pred(j))->_pre_order);
 tty->print("-> ");
 tty->print("\n");
 }
 }
 #endif
-//------------------------------combine_these_two------------------------------
 // Combine the live ranges def'd by these 2 Nodes.  N2 is an input to N1.
 void PhaseCoalesce::combine_these_two(Node *n1, Node *n2) {
 uint lr1 = _phc._lrg_map.find(n1);
 uint lr2 = _phc._lrg_map.find(n2);
 if( lr1 != lr2 &&             // Different live ranges already AND
 lrg1->AND(lrg2->mask());
 }
 }
 }
-//------------------------------coalesce_driver--------------------------------
 // Copy coalescing
-void PhaseCoalesce::coalesce_driver( ) {
+void PhaseCoalesce::coalesce_driver() {
 verify();
 // Coalesce from high frequency to low
-for( uint i=0; i<_phc._cfg._num_blocks; i++ )
+for (uint i = 0; i < _phc._cfg.number_of_blocks(); i++) {
-coalesce( _phc._blks[i] );
+coalesce(_phc._blks[i]);
+}
 }
-//------------------------------insert_copy_with_overlap-----------------------
 // I am inserting copies to come out of SSA form.  In the general case, I am
 // doing a parallel renaming.  I'm in the Named world now, so I can't do a
 // general parallel renaming.  All the copies now use  "names" (live-ranges)
 // to carry values instead of the explicit use-def chains.  Suppose I need to
 // insert 2 copies into the same block.  They copy L161->L128 and L128->L132.
 // Insert just after last use
 b->_nodes.insert(last_use_idx+1,copy);
 }
-//------------------------------insert_copies----------------------------------
 void PhaseAggressiveCoalesce::insert_copies( Matcher &matcher ) {
 // We do LRGs compressing and fix a liveout data only here since the other
 // place in Split() is guarded by the assert which we never hit.
 _phc._lrg_map.compress_uf_map_for_nodes();
 // Fix block's liveout data for compressed live ranges.
 for (uint lrg = 1; lrg < _phc._lrg_map.max_lrg_id(); lrg++) {
 uint compressed_lrg = _phc._lrg_map.find(lrg);
 if (lrg != compressed_lrg) {
-for (uint bidx = 0; bidx < _phc._cfg._num_blocks; bidx++) {
+for (uint bidx = 0; bidx < _phc._cfg.number_of_blocks(); bidx++) {
-IndexSet *liveout = _phc._live->live(_phc._cfg._blocks[bidx]);
+IndexSet *liveout = _phc._live->live(_phc._cfg.get_block(bidx));
 if (liveout->member(lrg)) {
 liveout->remove(lrg);
 liveout->insert(compressed_lrg);
 }
 }
 // All new nodes added are actual copies to replace virtual copies.
 // Nodes with index less than '_unique' are original, non-virtual Nodes.
 _unique = C->unique();
-for( uint i=0; i<_phc._cfg._num_blocks; i++ ) {
+for (uint i = 0; i < _phc._cfg.number_of_blocks(); i++) {
 C->check_node_count(NodeLimitFudgeFactor, "out of nodes in coalesce");
 if (C->failing()) return;
-Block *b = _phc._cfg._blocks[i];
+Block *b = _phc._cfg.get_block(i);
 uint cnt = b->num_preds();  // Number of inputs to the Phi
 for( uint l = 1; l<b->_nodes.size(); l++ ) {
 Node *n = b->_nodes[l];
 } // End of for all instructions
 } // End of for all blocks
 }
-//=============================================================================
-//------------------------------coalesce---------------------------------------
 // Aggressive (but pessimistic) copy coalescing of a single block
 // The following coalesce pass represents a single round of aggressive
 // pessimistic coalesce.  "Aggressive" means no attempt to preserve
 // colorability when coalescing.  This occasionally means more spills, but
 combine_these_two(mach, mach->in(idx));
 }
 } // End of for all instructions in block
 }
-//=============================================================================
-//------------------------------PhaseConservativeCoalesce----------------------
 PhaseConservativeCoalesce::PhaseConservativeCoalesce(PhaseChaitin &chaitin) : PhaseCoalesce(chaitin) {
 _ulr.initialize(_phc._lrg_map.max_lrg_id());
 }
-//------------------------------verify-----------------------------------------
 void PhaseConservativeCoalesce::verify() {
 #ifdef ASSERT
 _phc.set_was_low();
 #endif
 }
-//------------------------------union_helper-----------------------------------
 void PhaseConservativeCoalesce::union_helper( Node *lr1_node, Node *lr2_node, uint lr1, uint lr2, Node *src_def, Node *dst_copy, Node *src_copy, Block *b, uint bindex ) {
 // Join live ranges.  Merge larger into smaller.  Union lr2 into lr1 in the
 // union-find tree
 _phc.Union( lr1_node, lr2_node );
 b = _phc._cfg.get_block_for_node(b->pred(1));
 _phc._live->live(b)->insert(lr1);
 }
 }
-//------------------------------compute_separating_interferences---------------
 // Factored code from copy_copy that computes extra interferences from
 // lengthening a live range by double-coalescing.
 uint PhaseConservativeCoalesce::compute_separating_interferences(Node *dst_copy, Node *src_copy, Block *b, uint bindex, RegMask &rm, uint reg_degree, uint rm_size, uint lr1, uint lr2 ) {
 assert(!lrgs(lr1)._fat_proj, "cannot coalesce fat_proj");
 } // End of else collect interferences for 1 node
 } // End of while forever, scan back for interferences
 return reg_degree;
 }
-//------------------------------update_ifg-------------------------------------
 void PhaseConservativeCoalesce::update_ifg(uint lr1, uint lr2, IndexSet *n_lr1, IndexSet *n_lr2) {
 // Some original neighbors of lr1 might have gone away
 // because the constrained register mask prevented them.
 // Remove lr1 from such neighbors.
 IndexSetIterator one(n_lr1);
 while ((neighbor = three.next()) != 0)
 if( _phc._ifg->neighbors(neighbor)->insert(lr1) )
 lrgs(neighbor).inc_degree( lrg1.compute_degree(lrgs(neighbor)) );
 }
-//------------------------------record_bias------------------------------------
 static void record_bias( const PhaseIFG *ifg, int lr1, int lr2 ) {
 // Tag copy bias here
 if( !ifg->lrgs(lr1)._copy_bias )
 ifg->lrgs(lr1)._copy_bias = lr2;
 if( !ifg->lrgs(lr2)._copy_bias )
 ifg->lrgs(lr2)._copy_bias = lr1;
 }
-//------------------------------copy_copy--------------------------------------
 // See if I can coalesce a series of multiple copies together.  I need the
 // final dest copy and the original src copy.  They can be the same Node.
 // Compute the compatible register masks.
 bool PhaseConservativeCoalesce::copy_copy(Node *dst_copy, Node *src_copy, Block *b, uint bindex) {
 //tty->print_cr("warning: slow verify happening");
 //_phc._ifg->verify( &_phc );
 return true;
 }
-//------------------------------coalesce---------------------------------------
 // Conservative (but pessimistic) copy coalescing of a single block
 void PhaseConservativeCoalesce::coalesce( Block *b ) {
 // Bail out on infrequent blocks
 if (b->is_uncommon(&_phc._cfg)) {
 return;

Mercurial > hg > graal-compiler

comparison src/share/vm/opto/coalesce.cpp @ 12071:adb9a7d94cb5