src/share/vm/opto/coalesce.cpp

*** 52,64 ****
        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();
      for( j=0; j<cnt; j++ ) {
!       Node *n = b->_nodes[j];
        dump( n );
        tty->print("\t%s\t",n->Name());
  
        // Dump the inputs
        uint k;                   // Exit value of loop
--- 52,64 ----
        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->number_of_nodes();
      for( j=0; j<cnt; 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
*** 150,160 ****
    // 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];
      // Check for end of virtual copies; this is also the end of the
      // parallel renaming effort.
      if (n->_idx < _unique) {
        break;
      }
--- 150,160 ----
    // 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->get_node(i);
      // Check for end of virtual copies; this is also the end of the
      // parallel renaming effort.
      if (n->_idx < _unique) {
        break;
      }
*** 172,182 ****
    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];
      // Check for end of virtual copies; this is also the end of the
      // parallel renaming effort.
      if (n->_idx < _unique) {
        break;
      }
--- 172,182 ----
    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->get_node(i);
      // Check for end of virtual copies; this is also the end of the
      // parallel renaming effort.
      if (n->_idx < _unique) {
        break;
      }
*** 198,214 ****
  
      // 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);
      _phc._cfg.map_node_to_block(tmp, b);
      last_use_idx++;
    }
  
    // Insert just after last use
!   b->_nodes.insert(last_use_idx+1,copy);
  }
  
  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.
--- 198,214 ----
  
      // 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->insert_node(tmp, kill_src_idx);
      _phc._cfg.map_node_to_block(tmp, b);
      last_use_idx++;
    }
  
    // Insert just after last use
!   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.
*** 235,246 ****
      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++ ) {
!       Node *n = b->_nodes[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);
--- 235,246 ----
      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->number_of_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);
*** 258,268 ****
        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);
            l--;
            continue;
          }
        }
  
--- 258,268 ----
        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->remove_node(l);
            l--;
            continue;
          }
        }
  
*** 319,335 ****
              // 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);
                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);
              }
              // 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);
--- 319,335 ----
              // 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->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->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);
*** 374,384 ****
                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 );
                // 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);
--- 374,384 ----
                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->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);
*** 429,450 ****
      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++ ) {
!       Node *n = bs->_nodes[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];
      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();
--- 429,450 ----
      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->number_of_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->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();
*** 488,501 ****
    // 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, "" );
    dst_copy->replace_by( dst_copy->in(didx) );
    dst_copy->set_req( didx, NULL);
!   b->_nodes.remove(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);
--- 488,501 ----
    // 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->get_node(bindex) == dst_copy, "" );
    dst_copy->replace_by( dst_copy->in(didx) );
    dst_copy->set_req( didx, NULL);
!   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);
*** 521,532 ****
        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");
!     Node *x = b2->_nodes[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());
--- 521,532 ----
        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->number_of_nodes(), "index out of bounds");
!     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());
*** 774,784 ****
    }
    // 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];
      uint idx1 = copy1->is_Copy();
      if( !idx1 ) continue;       // Not a copy
  
      if( copy_copy(copy1,copy1,b,i) ) {
        i--;                      // Retry, same location in block
--- 774,784 ----
    }
    // 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->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