jdk-sandbox: comparison hotspot/src/share/vm/opto/coalesce.cpp

equal deleted inserted replaced

-:95cc0162a92d
+:7819ffdaf0ff
 tty->print("B%d ", _phc._cfg.get_block_for_node(b->pred(j))->_pre_order);
 tty->print("-> ");
 for( j=0; j<b->_num_succs; j++ )
 tty->print("B%d ",b->_succs[j]->_pre_order);
 tty->print(" IDom: B%d/#%d\n", b->_idom ? b->_idom->_pre_order : 0, b->_dom_depth);
-uint cnt = b->_nodes.size();
+uint cnt = b->number_of_nodes();
 for( j=0; j<cnt; j++ ) {
-Node *n = b->_nodes[j];
+Node *n = b->get_node(j);
 dump( n );
 tty->print("\t%s\t",n->Name());
 // Dump the inputs
 uint k;                   // Exit value of loop
 // Scan backwards for the locations of the last use of the dst_name.
 // I am about to clobber the dst_name, so the copy must be inserted
 // after the last use.  Last use is really first-use on a backwards scan.
 uint i = b->end_idx()-1;
 while(1) {
-Node *n = b->_nodes[i];
+Node *n = b->get_node(i);
 // Check for end of virtual copies; this is also the end of the
 // parallel renaming effort.
 if (n->_idx < _unique) {
 break;
 }
 uint kill_src_idx = b->end_idx();
 // There can be only 1 kill that exits any block and that is
 // the last kill.  Thus it is the first kill on a backwards scan.
 i = b->end_idx()-1;
 while (1) {
-Node *n = b->_nodes[i];
+Node *n = b->get_node(i);
 // Check for end of virtual copies; this is also the end of the
 // parallel renaming effort.
 if (n->_idx < _unique) {
 break;
 }
 // Insert new temp between copy and source
 tmp ->set_req(idx,copy->in(idx));
 copy->set_req(idx,tmp);
 // Save source in temp early, before source is killed
-b->_nodes.insert(kill_src_idx,tmp);
+b->insert_node(tmp, kill_src_idx);
 _phc._cfg.map_node_to_block(tmp, b);
 last_use_idx++;
 }
 // Insert just after last use
-b->_nodes.insert(last_use_idx+1,copy);
+b->insert_node(copy, last_use_idx + 1);
 }
 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.
 C->check_node_count(NodeLimitFudgeFactor, "out of nodes in coalesce");
 if (C->failing()) return;
 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++ ) {
+for( uint l = 1; l<b->number_of_nodes(); l++ ) {
-Node *n = b->_nodes[l];
+Node *n = b->get_node(l);
 // Do not use removed-copies, use copied value instead
 uint ncnt = n->req();
 for( uint k = 1; k<ncnt; k++ ) {
 Node *copy = n->in(k);
 if( cidx ) {
 Node *def = n->in(cidx);
 if (_phc._lrg_map.find(n) == _phc._lrg_map.find(def)) {
 n->replace_by(def);
 n->set_req(cidx,NULL);
-b->_nodes.remove(l);
+b->remove_node(l);
 l--;
 continue;
 }
 }
 // Rematerialize only constants as we do for Phi above.
 if(m->is_Mach() && m->as_Mach()->is_Con() &&
 m->as_Mach()->rematerialize()) {
 copy = m->clone();
 // Insert the copy in the basic block, just before us
-b->_nodes.insert(l++, copy);
+b->insert_node(copy, l++);
 l += _phc.clone_projs(b, l, m, copy, _phc._lrg_map);
 } else {
 const RegMask *rm = C->matcher()->idealreg2spillmask[m->ideal_reg()];
 copy = new (C) MachSpillCopyNode(m, *rm, *rm);
 // Insert the copy in the basic block, just before us
-b->_nodes.insert(l++, copy);
+b->insert_node(copy, l++);
 }
 // Insert the copy in the use-def chain
 n->set_req(idx, copy);
 // Extend ("register allocate") the names array for the copy.
 _phc._lrg_map.extend(copy->_idx, name);
 const RegMask *rm = C->matcher()->idealreg2spillmask[inp->ideal_reg()];
 Node *copy = new (C) MachSpillCopyNode( inp, *rm, *rm );
 // Insert the copy in the use-def chain
 n->set_req(inpidx, copy );
 // Insert the copy in the basic block, just before us
-b->_nodes.insert( l++, copy );
+b->insert_node(copy,  l++);
 // Extend ("register allocate") the names array for the copy.
 uint max_lrg_id = _phc._lrg_map.max_lrg_id();
 _phc.new_lrg(copy, max_lrg_id);
 _phc._lrg_map.set_max_lrg_id(max_lrg_id + 1);
 _phc._cfg.map_node_to_block(copy, b);
 while (_phc._cfg.get_block_for_node(bs->pred(j)) != b) {
 j++;
 }
 // Visit all the Phis in successor block
-for( uint k = 1; k<bs->_nodes.size(); k++ ) {
+for( uint k = 1; k<bs->number_of_nodes(); k++ ) {
-Node *n = bs->_nodes[k];
+Node *n = bs->get_node(k);
 if( !n->is_Phi() ) break;
 combine_these_two( n, n->in(j) );
 }
 } // End of for all successor blocks
 // Check _this_ block for 2-address instructions and copies.
 uint cnt = b->end_idx();
 for( i = 1; i<cnt; i++ ) {
-Node *n = b->_nodes[i];
+Node *n = b->get_node(i);
 uint idx;
 // 2-address instructions have a virtual Copy matching their input
 // to their output
 if (n->is_Mach() && (idx = n->as_Mach()->two_adr())) {
 MachNode *mach = n->as_Mach();
 // the dst_copy becomes useless.
 int didx = dst_copy->is_Copy();
 dst_copy->set_req( didx, src_def );
 // Add copy to free list
 // _phc.free_spillcopy(b->_nodes[bindex]);
-assert( b->_nodes[bindex] == dst_copy, "" );
+assert( b->get_node(bindex) == dst_copy, "" );
 dst_copy->replace_by( dst_copy->in(didx) );
 dst_copy->set_req( didx, NULL);
-b->_nodes.remove(bindex);
+b->remove_node(bindex);
 if( bindex < b->_ihrp_index ) b->_ihrp_index--;
 if( bindex < b->_fhrp_index ) b->_fhrp_index--;
 // Stretched lr1; add it to liveness of intermediate blocks
 Block *b2 = _phc._cfg.get_block_for_node(src_copy);
 assert( b2->num_preds() == 2, "cannot double coalesce across c-flow" );
 b2 = _phc._cfg.get_block_for_node(b2->pred(1));
 bindex2 = b2->end_idx()-1;
 }
 // Get prior instruction
-assert(bindex2 < b2->_nodes.size(), "index out of bounds");
+assert(bindex2 < b2->number_of_nodes(), "index out of bounds");
-Node *x = b2->_nodes[bindex2];
+Node *x = b2->get_node(bindex2);
 if( x == prev_copy ) {      // Previous copy in copy chain?
 if( prev_copy == src_copy)// Found end of chain and all interferences
 break;                  // So break out of loop
 // Else work back one in copy chain
 prev_copy = prev_copy->in(prev_copy->is_Copy());
 }
 // Check this block for copies.
 for( uint i = 1; i<b->end_idx(); i++ ) {
 // Check for actual copies on inputs.  Coalesce a copy into its
 // input if use and copy's input are compatible.
-Node *copy1 = b->_nodes[i];
+Node *copy1 = b->get_node(i);
 uint idx1 = copy1->is_Copy();
 if( !idx1 ) continue;       // Not a copy
 if( copy_copy(copy1,copy1,b,i) ) {
 i--;                      // Retry, same location in block

changeset 19717	7819ffdaf0ff
parent 19334	3aa9ca404965
child 19721	8ecbb2cdc965