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

comparison src/share/vm/opto/postaloc.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	650868c062a9

comparison

equal deleted inserted replaced

-:afbe18ae0905
+:adb9a7d94cb5
 NOT_PRODUCT( Compile::TracePhase t3("postAllocCopyRemoval", &_t_postAllocCopyRemoval, TimeCompiler); )
 ResourceMark rm;
 // Need a mapping from basic block Node_Lists.  We need a Node_List to
 // map from register number to value-producing Node.
-Node_List **blk2value = NEW_RESOURCE_ARRAY( Node_List *, _cfg._num_blocks+1);
+Node_List **blk2value = NEW_RESOURCE_ARRAY( Node_List *, _cfg.number_of_blocks() + 1);
-memset( blk2value, 0, sizeof(Node_List*)*(_cfg._num_blocks+1) );
+memset(blk2value, 0, sizeof(Node_List*) * (_cfg.number_of_blocks() + 1));
 // Need a mapping from basic block Node_Lists.  We need a Node_List to
 // map from register number to register-defining Node.
-Node_List **blk2regnd = NEW_RESOURCE_ARRAY( Node_List *, _cfg._num_blocks+1);
+Node_List **blk2regnd = NEW_RESOURCE_ARRAY( Node_List *, _cfg.number_of_blocks() + 1);
-memset( blk2regnd, 0, sizeof(Node_List*)*(_cfg._num_blocks+1) );
+memset(blk2regnd, 0, sizeof(Node_List*) * (_cfg.number_of_blocks() + 1));
 // We keep unused Node_Lists on a free_list to avoid wasting
 // memory.
 GrowableArray<Node_List*> free_list = GrowableArray<Node_List*>(16);
 // For all blocks
-for( uint i = 0; i < _cfg._num_blocks; i++ ) {
+for (uint i = 0; i < _cfg.number_of_blocks(); i++) {
 uint j;
-Block *b = _cfg._blocks[i];
+Block* block = _cfg.get_block(i);
 // Count of Phis in block
 uint phi_dex;
-for( phi_dex = 1; phi_dex < b->_nodes.size(); phi_dex++ ) {
+for (phi_dex = 1; phi_dex < block->_nodes.size(); phi_dex++) {
-Node *phi = b->_nodes[phi_dex];
+Node* phi = block->_nodes[phi_dex];
-if( !phi->is_Phi() )
+if (!phi->is_Phi()) {
 break;
+}
 }
 // If any predecessor has not been visited, we do not know the state
 // of registers at the start.  Check for this, while updating copies
 // along Phi input edges
 bool missing_some_inputs = false;
 Block *freed = NULL;
-for( j = 1; j < b->num_preds(); j++ ) {
+for (j = 1; j < block->num_preds(); j++) {
-Block *pb = _cfg.get_block_for_node(b->pred(j));
+Block* pb = _cfg.get_block_for_node(block->pred(j));
 // Remove copies along phi edges
-for( uint k=1; k<phi_dex; k++ )
+for (uint k = 1; k < phi_dex; k++) {
-elide_copy( b->_nodes[k], j, b, *blk2value[pb->_pre_order], *blk2regnd[pb->_pre_order], false );
+elide_copy(block->_nodes[k], j, block, *blk2value[pb->_pre_order], *blk2regnd[pb->_pre_order], false);
-if( blk2value[pb->_pre_order] ) { // Have a mapping on this edge?
+}
+if (blk2value[pb->_pre_order]) { // Have a mapping on this edge?
 // See if this predecessor's mappings have been used by everybody
 // who wants them.  If so, free 'em.
 uint k;
-for( k=0; k<pb->_num_succs; k++ ) {
+for (k = 0; k < pb->_num_succs; k++) {
-Block *pbsucc = pb->_succs[k];
+Block* pbsucc = pb->_succs[k];
-if( !blk2value[pbsucc->_pre_order] && pbsucc != b )
+if (!blk2value[pbsucc->_pre_order] && pbsucc != block) {
 break;              // Found a future user
 }
-if( k >= pb->_num_succs ) { // No more uses, free!
+}
+if (k >= pb->_num_succs) { // No more uses, free!
 freed = pb;           // Record last block freed
 free_list.push(blk2value[pb->_pre_order]);
 free_list.push(blk2regnd[pb->_pre_order]);
 }
 } else {                  // This block has unvisited (loopback) inputs
 Node_List &value = *(free_list.is_empty() ? new Node_List() : free_list.pop());
 assert( !freed || blk2value[freed->_pre_order] == &value, "" );
 value.map(_max_reg,NULL);
 regnd.map(_max_reg,NULL);
 // Set mappings as OUR mappings
-blk2value[b->_pre_order] = &value;
+blk2value[block->_pre_order] = &value;
-blk2regnd[b->_pre_order] = &regnd;
+blk2regnd[block->_pre_order] = &regnd;
 // Initialize value & regnd for this block
-if( missing_some_inputs ) {
+if (missing_some_inputs) {
 // Some predecessor has not yet been visited; zap map to empty
-for( uint k = 0; k < (uint)_max_reg; k++ ) {
+for (uint k = 0; k < (uint)_max_reg; k++) {
 value.map(k,NULL);
 regnd.map(k,NULL);
 }
 } else {
 if( !freed ) {            // Didn't get a freebie prior block
 // Must clone some data
-freed = _cfg.get_block_for_node(b->pred(1));
+freed = _cfg.get_block_for_node(block->pred(1));
 Node_List &f_value = *blk2value[freed->_pre_order];
 Node_List &f_regnd = *blk2regnd[freed->_pre_order];
 for( uint k = 0; k < (uint)_max_reg; k++ ) {
 value.map(k,f_value[k]);
 regnd.map(k,f_regnd[k]);
 }
 }
 // Merge all inputs together, setting to NULL any conflicts.
-for( j = 1; j < b->num_preds(); j++ ) {
+for (j = 1; j < block->num_preds(); j++) {
-Block *pb = _cfg.get_block_for_node(b->pred(j));
+Block* pb = _cfg.get_block_for_node(block->pred(j));
-if( pb == freed ) continue; // Did self already via freelist
+if (pb == freed) {
+continue; // Did self already via freelist
+}
 Node_List &p_regnd = *blk2regnd[pb->_pre_order];
 for( uint k = 0; k < (uint)_max_reg; k++ ) {
 if( regnd[k] != p_regnd[k] ) { // Conflict on reaching defs?
 value.map(k,NULL); // Then no value handy
 regnd.map(k,NULL);
 }
 }
 }
 // For all Phi's
-for( j = 1; j < phi_dex; j++ ) {
+for (j = 1; j < phi_dex; j++) {
 uint k;
-Node *phi = b->_nodes[j];
+Node *phi = block->_nodes[j];
 uint pidx = _lrg_map.live_range_id(phi);
 OptoReg::Name preg = lrgs(_lrg_map.live_range_id(phi)).reg();
 // Remove copies remaining on edges.  Check for junk phi.
 Node *u = NULL;
 for (k = 1; k < phi->req(); k++) {
 Node *x = phi->in(k);
 if( phi != x && u != x ) // Found a different input
 u = u ? NodeSentinel : x; // Capture unique input, or NodeSentinel for 2nd input
 }
-if( u != NodeSentinel ) {    // Junk Phi.  Remove
+if (u != NodeSentinel) {    // Junk Phi.  Remove
-b->_nodes.remove(j--);
+block->_nodes.remove(j--);
 phi_dex--;
 _cfg.unmap_node_from_block(phi);
 phi->replace_by(u);
 phi->disconnect_inputs(NULL, C);
 continue;
 }
 }
 }
 // For all remaining instructions
-for( j = phi_dex; j < b->_nodes.size(); j++ ) {
+for (j = phi_dex; j < block->_nodes.size(); j++) {
-Node *n = b->_nodes[j];
+Node* n = block->_nodes[j];
-if( n->outcnt() == 0 &&   // Dead?
+if(n->outcnt() == 0 &&   // Dead?
 n != C->top() &&      // (ignore TOP, it has no du info)
 !n->is_Proj() ) {     // fat-proj kills
-j -= yank_if_dead(n,b,&value,&regnd);
+j -= yank_if_dead(n, block, &value, &regnd);
 continue;
 }
 // Improve reaching-def info.  Occasionally post-alloc's liveness gives
 // up (at loop backedges, because we aren't doing a full flow pass).
 }
 const uint two_adr = n->is_Mach() ? n->as_Mach()->two_adr() : 0;
 // Remove copies along input edges
-for( k = 1; k < n->req(); k++ )
+for (k = 1; k < n->req(); k++) {
-j -= elide_copy( n, k, b, value, regnd, two_adr!=k );
+j -= elide_copy(n, k, block, value, regnd, two_adr != k);
+}
 // Unallocated Nodes define no registers
 uint lidx = _lrg_map.live_range_id(n);
 if (!lidx) {
 continue;
 if (n_regs == 1) {
 // If Node 'n' does not change the value mapped by the register,
 // then 'n' is a useless copy.  Do not update the register->node
 // mapping so 'n' will go dead.
 if( value[nreg] != val ) {
-if (eliminate_copy_of_constant(val, n, b, value, regnd, nreg, OptoReg::Bad)) {
+if (eliminate_copy_of_constant(val, n, block, value, regnd, nreg, OptoReg::Bad)) {
-j -= replace_and_yank_if_dead(n, nreg, b, value, regnd);
+j -= replace_and_yank_if_dead(n, nreg, block, value, regnd);
 } else {
 // Update the mapping: record new Node defined by the register
 regnd.map(nreg,n);
 // Update mapping for defined *value*, which is the defined
 // Node after skipping all copies.
 value.map(nreg,val);
 }
 } else if( !may_be_copy_of_callee(n) ) {
-assert( n->is_Copy(), "" );
+assert(n->is_Copy(), "");
-j -= replace_and_yank_if_dead(n, nreg, b, value, regnd);
+j -= replace_and_yank_if_dead(n, nreg, block, value, regnd);
 }
 } else if (RegMask::is_vector(n_ideal_reg)) {
 // If Node 'n' does not change the value mapped by the register,
 // then 'n' is a useless copy.  Do not update the register->node
 // mapping so 'n' will go dead.
 regnd.map(nreg_lo, n );
 value.map(nreg_lo,val);
 }
 } else if (n->is_Copy()) {
 // Note: vector can't be constant and can't be copy of calee.
-j -= replace_and_yank_if_dead(n, nreg, b, value, regnd);
+j -= replace_and_yank_if_dead(n, nreg, block, value, regnd);
 }
 } else {
 // If the value occupies a register pair, record same info
 // in both registers.
 OptoReg::Name nreg_lo = OptoReg::add(nreg,-1);
 // Find the actual other value
 RegMask tmp = lrgs(lidx).mask();
 tmp.Remove(nreg);
 nreg_lo = tmp.find_first_elem();
 }
-if( value[nreg] != val || value[nreg_lo] != val ) {
+if (value[nreg] != val || value[nreg_lo] != val) {
-if (eliminate_copy_of_constant(val, n, b, value, regnd, nreg, nreg_lo)) {
+if (eliminate_copy_of_constant(val, n, block, value, regnd, nreg, nreg_lo)) {
-j -= replace_and_yank_if_dead(n, nreg, b, value, regnd);
+j -= replace_and_yank_if_dead(n, nreg, block, value, regnd);
 } else {
 regnd.map(nreg   , n );
 regnd.map(nreg_lo, n );
 value.map(nreg   ,val);
 value.map(nreg_lo,val);
 }
-} else if( !may_be_copy_of_callee(n) ) {
+} else if (!may_be_copy_of_callee(n)) {
-assert( n->is_Copy(), "" );
+assert(n->is_Copy(), "");
-j -= replace_and_yank_if_dead(n, nreg, b, value, regnd);
+j -= replace_and_yank_if_dead(n, nreg, block, value, regnd);
 }
 }
 // Fat projections kill many registers
 if( n_ideal_reg == MachProjNode::fat_proj ) {

Mercurial > hg > graal-compiler

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