hotspot/src/share/vm/opto/block.cpp
author rasbold
Thu, 28 Aug 2008 10:22:12 -0700
changeset 1070 e03de091796e
parent 1 489c9b5090e2
child 1217 5eb97f366a6a
permissions -rw-r--r--
6611837: block frequency is zero Summary: insert_goto_at should set frequency for newly created blocks Reviewed-by: never
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
489c9b5090e2 Initial load
duke
parents:
diff changeset
     2
 * Copyright 1997-2006 Sun Microsystems, Inc.  All Rights Reserved.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    20
 * CA 95054 USA or visit www.sun.com if you need additional information or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    21
 * have any questions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
// Optimization - Graph Style
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
#include "incls/_precompiled.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
#include "incls/_block.cpp.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
//-----------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
void Block_Array::grow( uint i ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
  assert(i >= Max(), "must be an overflow");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
  debug_only(_limit = i+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
  if( i < _size )  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
  if( !_size ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
    _size = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
    _blocks = (Block**)_arena->Amalloc( _size * sizeof(Block*) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
    _blocks[0] = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
  uint old = _size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
  while( i >= _size ) _size <<= 1;      // Double to fit
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
  _blocks = (Block**)_arena->Arealloc( _blocks, old*sizeof(Block*),_size*sizeof(Block*));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
  Copy::zero_to_bytes( &_blocks[old], (_size-old)*sizeof(Block*) );
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
//=============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
void Block_List::remove(uint i) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  assert(i < _cnt, "index out of bounds");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  Copy::conjoint_words_to_lower((HeapWord*)&_blocks[i+1], (HeapWord*)&_blocks[i], ((_cnt-i-1)*sizeof(Block*)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
  pop(); // shrink list by one block
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
void Block_List::insert(uint i, Block *b) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  push(b); // grow list by one block
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  Copy::conjoint_words_to_higher((HeapWord*)&_blocks[i], (HeapWord*)&_blocks[i+1], ((_cnt-i-1)*sizeof(Block*)));
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  _blocks[i] = b;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
//=============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
uint Block::code_alignment() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  // Check for Root block
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
  if( _pre_order == 0 ) return CodeEntryAlignment;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
  // Check for Start block
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
  if( _pre_order == 1 ) return InteriorEntryAlignment;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  // Check for loop alignment
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
  Node *h = head();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  if( h->is_Loop() && h->as_Loop()->is_inner_loop() )  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
    // Pre- and post-loops have low trip count so do not bother with
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
    // NOPs for align loop head.  The constants are hidden from tuning
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
    // but only because my "divide by 4" heuristic surely gets nearly
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
    // all possible gain (a "do not align at all" heuristic has a
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
    // chance of getting a really tiny gain).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
    if( h->is_CountedLoop() && (h->as_CountedLoop()->is_pre_loop() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
                                h->as_CountedLoop()->is_post_loop()) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
      return (OptoLoopAlignment > 4) ? (OptoLoopAlignment>>2) : 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
    // Loops with low backedge frequency should not be aligned.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
    Node *n = h->in(LoopNode::LoopBackControl)->in(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
    if( n->is_MachIf() && n->as_MachIf()->_prob < 0.01 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
      return 1;             // Loop does not loop, more often than not!
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
    return OptoLoopAlignment; // Otherwise align loop head
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  return 1;                     // no particular alignment
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
//-----------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
// Compute the size of first 'inst_cnt' instructions in this block.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
// Return the number of instructions left to compute if the block has
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
// less then 'inst_cnt' instructions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
uint Block::compute_first_inst_size(uint& sum_size, uint inst_cnt,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
                                    PhaseRegAlloc* ra) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  uint last_inst = _nodes.size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  for( uint j = 0; j < last_inst && inst_cnt > 0; j++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
    uint inst_size = _nodes[j]->size(ra);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
    if( inst_size > 0 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
      inst_cnt--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
      uint sz = sum_size + inst_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
      if( sz <= (uint)OptoLoopAlignment ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
        // Compute size of instructions which fit into fetch buffer only
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
        // since all inst_cnt instructions will not fit even if we align them.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
        sum_size = sz;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
        return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
  return inst_cnt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
//-----------------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
uint Block::find_node( const Node *n ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  for( uint i = 0; i < _nodes.size(); i++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
    if( _nodes[i] == n )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
      return i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
// Find and remove n from block list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
void Block::find_remove( const Node *n ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  _nodes.remove(find_node(n));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
//------------------------------is_Empty---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
// Return empty status of a block.  Empty blocks contain only the head, other
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
// ideal nodes, and an optional trailing goto.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
int Block::is_Empty() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
  // Root or start block is not considered empty
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
  if (head()->is_Root() || head()->is_Start()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
    return not_empty;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  int success_result = completely_empty;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  int end_idx = _nodes.size()-1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  // Check for ending goto
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  if ((end_idx > 0) && (_nodes[end_idx]->is_Goto())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
    success_result = empty_with_goto;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
    end_idx--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  // Unreachable blocks are considered empty
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  if (num_preds() <= 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
    return success_result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
  // Ideal nodes are allowable in empty blocks: skip them  Only MachNodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
  // turn directly into code, because only MachNodes have non-trivial
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
  // emit() functions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
  while ((end_idx > 0) && !_nodes[end_idx]->is_Mach()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
    end_idx--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  // No room for any interesting instructions?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  if (end_idx == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
    return success_result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  return not_empty;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
//------------------------------has_uncommon_code------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
// Return true if the block's code implies that it is not likely to be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
// executed infrequently.  Check to see if the block ends in a Halt or
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
// a low probability call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
bool Block::has_uncommon_code() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
  Node* en = end();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  if (en->is_Goto())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
    en = en->in(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  if (en->is_Catch())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
    en = en->in(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  if (en->is_Proj() && en->in(0)->is_MachCall()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
    MachCallNode* call = en->in(0)->as_MachCall();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
    if (call->cnt() != COUNT_UNKNOWN && call->cnt() <= PROB_UNLIKELY_MAG(4)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
      // This is true for slow-path stubs like new_{instance,array},
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
      // slow_arraycopy, complete_monitor_locking, uncommon_trap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
      // The magic number corresponds to the probability of an uncommon_trap,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
      // even though it is a count not a probability.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  int op = en->is_Mach() ? en->as_Mach()->ideal_Opcode() : en->Opcode();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
  return op == Op_Halt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
//------------------------------is_uncommon------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
// True if block is low enough frequency or guarded by a test which
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
// mostly does not go here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
bool Block::is_uncommon( Block_Array &bbs ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  // Initial blocks must never be moved, so are never uncommon.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  if (head()->is_Root() || head()->is_Start())  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
  // Check for way-low freq
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  if( _freq < BLOCK_FREQUENCY(0.00001f) ) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  // Look for code shape indicating uncommon_trap or slow path
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  if (has_uncommon_code()) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  const float epsilon = 0.05f;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  const float guard_factor = PROB_UNLIKELY_MAG(4) / (1.f - epsilon);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
  uint uncommon_preds = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
  uint freq_preds = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
  uint uncommon_for_freq_preds = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  for( uint i=1; i<num_preds(); i++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
    Block* guard = bbs[pred(i)->_idx];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
    // Check to see if this block follows its guard 1 time out of 10000
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
    // or less.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
    // See list of magnitude-4 unlikely probabilities in cfgnode.hpp which
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
    // we intend to be "uncommon", such as slow-path TLE allocation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
    // predicted call failure, and uncommon trap triggers.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
    // Use an epsilon value of 5% to allow for variability in frequency
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
    // predictions and floating point calculations. The net effect is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
    // that guard_factor is set to 9500.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
    //
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
    // Ignore low-frequency blocks.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
    // The next check is (guard->_freq < 1.e-5 * 9500.).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
    if(guard->_freq*BLOCK_FREQUENCY(guard_factor) < BLOCK_FREQUENCY(0.00001f)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
      uncommon_preds++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
      freq_preds++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
      if( _freq < guard->_freq * guard_factor ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
        uncommon_for_freq_preds++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  if( num_preds() > 1 &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
      // The block is uncommon if all preds are uncommon or
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
      (uncommon_preds == (num_preds()-1) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
      // it is uncommon for all frequent preds.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
       uncommon_for_freq_preds == freq_preds) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
//------------------------------dump-------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
void Block::dump_bidx(const Block* orig) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  if (_pre_order) tty->print("B%d",_pre_order);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
  else tty->print("N%d", head()->_idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  if (Verbose && orig != this) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
    // Dump the original block's idx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
    tty->print(" (");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
    orig->dump_bidx(orig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
    tty->print(")");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
void Block::dump_pred(const Block_Array *bbs, Block* orig) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  if (is_connector()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
    for (uint i=1; i<num_preds(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
      Block *p = ((*bbs)[pred(i)->_idx]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
      p->dump_pred(bbs, orig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
    dump_bidx(orig);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
    tty->print(" ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
void Block::dump_head( const Block_Array *bbs ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  // Print the basic block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  dump_bidx(this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
  tty->print(": #\t");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  // Print the incoming CFG edges and the outgoing CFG edges
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  for( uint i=0; i<_num_succs; i++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
    non_connector_successor(i)->dump_bidx(_succs[i]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
    tty->print(" ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  tty->print("<- ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  if( head()->is_block_start() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    for (uint i=1; i<num_preds(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
      Node *s = pred(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
      if (bbs) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
        Block *p = (*bbs)[s->_idx];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
        p->dump_pred(bbs, p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
      } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
        while (!s->is_block_start())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
          s = s->in(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
        tty->print("N%d ", s->_idx );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
  } else
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
    tty->print("BLOCK HEAD IS JUNK  ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  // Print loop, if any
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
  const Block *bhead = this;    // Head of self-loop
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
  Node *bh = bhead->head();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
  if( bbs && bh->is_Loop() && !head()->is_Root() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
    LoopNode *loop = bh->as_Loop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
    const Block *bx = (*bbs)[loop->in(LoopNode::LoopBackControl)->_idx];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
    while (bx->is_connector()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
      bx = (*bbs)[bx->pred(1)->_idx];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
    tty->print("\tLoop: B%d-B%d ", bhead->_pre_order, bx->_pre_order);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
    // Dump any loop-specific bits, especially for CountedLoops.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
    loop->dump_spec(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  tty->print(" Freq: %g",_freq);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  if( Verbose || WizardMode ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
    tty->print(" IDom: %d/#%d", _idom ? _idom->_pre_order : 0, _dom_depth);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
    tty->print(" RegPressure: %d",_reg_pressure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
    tty->print(" IHRP Index: %d",_ihrp_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
    tty->print(" FRegPressure: %d",_freg_pressure);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
    tty->print(" FHRP Index: %d",_fhrp_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  tty->print_cr("");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
void Block::dump() const { dump(0); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
void Block::dump( const Block_Array *bbs ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  dump_head(bbs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
  uint cnt = _nodes.size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  for( uint i=0; i<cnt; i++ )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
    _nodes[i]->dump();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  tty->print("\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
//=============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
//------------------------------PhaseCFG---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
PhaseCFG::PhaseCFG( Arena *a, RootNode *r, Matcher &m ) :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  Phase(CFG),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  _bbs(a),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  _root(r)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  , _trace_opto_pipelining(TraceOptoPipelining || C->method_has_option("TraceOptoPipelining"))
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
{
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  // I'll need a few machine-specific GotoNodes.  Make an Ideal GotoNode,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  // then Match it into a machine-specific Node.  Then clone the machine
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  // Node on demand.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  Node *x = new (C, 1) GotoNode(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  x->init_req(0, x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  _goto = m.match_tree(x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
  assert(_goto != NULL, "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
  _goto->set_req(0,_goto);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  // Build the CFG in Reverse Post Order
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  _num_blocks = build_cfg();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
  _broot = _bbs[_root->_idx];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
//------------------------------build_cfg--------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
// Build a proper looking CFG.  Make every block begin with either a StartNode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
// or a RegionNode.  Make every block end with either a Goto, If or Return.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
// The RootNode both starts and ends it's own block.  Do this with a recursive
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
// backwards walk over the control edges.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
uint PhaseCFG::build_cfg() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  Arena *a = Thread::current()->resource_area();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  VectorSet visited(a);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  // Allocate stack with enough space to avoid frequent realloc
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  Node_Stack nstack(a, C->unique() >> 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  nstack.push(_root, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
  uint sum = 0;                 // Counter for blocks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  while (nstack.is_nonempty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
    // node and in's index from stack's top
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
    // 'np' is _root (see above) or RegionNode, StartNode: we push on stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
    // only nodes which point to the start of basic block (see below).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
    Node *np = nstack.node();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
    // idx > 0, except for the first node (_root) pushed on stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
    // at the beginning when idx == 0.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
    // We will use the condition (idx == 0) later to end the build.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
    uint idx = nstack.index();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
    Node *proj = np->in(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
    const Node *x = proj->is_block_proj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
    // Does the block end with a proper block-ending Node?  One of Return,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
    // If or Goto? (This check should be done for visited nodes also).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
    if (x == NULL) {                    // Does not end right...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
      Node *g = _goto->clone(); // Force it to end in a Goto
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
      g->set_req(0, proj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
      np->set_req(idx, g);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
      x = proj = g;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
    if (!visited.test_set(x->_idx)) { // Visit this block once
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
      // Skip any control-pinned middle'in stuff
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
      Node *p = proj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
      do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
        proj = p;                   // Update pointer to last Control
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
        p = p->in(0);               // Move control forward
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
      } while( !p->is_block_proj() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
               !p->is_block_start() );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
      // Make the block begin with one of Region or StartNode.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
      if( !p->is_block_start() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
        RegionNode *r = new (C, 2) RegionNode( 2 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
        r->init_req(1, p);         // Insert RegionNode in the way
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
        proj->set_req(0, r);        // Insert RegionNode in the way
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
        p = r;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
      // 'p' now points to the start of this basic block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
      // Put self in array of basic blocks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
      Block *bb = new (_bbs._arena) Block(_bbs._arena,p);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
      _bbs.map(p->_idx,bb);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
      _bbs.map(x->_idx,bb);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
      if( x != p )                  // Only for root is x == p
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
        bb->_nodes.push((Node*)x);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
      // Now handle predecessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
      ++sum;                        // Count 1 for self block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
      uint cnt = bb->num_preds();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
      for (int i = (cnt - 1); i > 0; i-- ) { // For all predecessors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
        Node *prevproj = p->in(i);  // Get prior input
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
        assert( !prevproj->is_Con(), "dead input not removed" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
        // Check to see if p->in(i) is a "control-dependent" CFG edge -
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
        // i.e., it splits at the source (via an IF or SWITCH) and merges
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
        // at the destination (via a many-input Region).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
        // This breaks critical edges.  The RegionNode to start the block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
        // will be added when <p,i> is pulled off the node stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
        if ( cnt > 2 ) {             // Merging many things?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
          assert( prevproj== bb->pred(i),"");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
          if(prevproj->is_block_proj() != prevproj) { // Control-dependent edge?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
            // Force a block on the control-dependent edge
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
            Node *g = _goto->clone();       // Force it to end in a Goto
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
            g->set_req(0,prevproj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
            p->set_req(i,g);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
        nstack.push(p, i);  // 'p' is RegionNode or StartNode
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
    } else { // Post-processing visited nodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
      nstack.pop();                 // remove node from stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
      // Check if it the fist node pushed on stack at the beginning.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
      if (idx == 0) break;          // end of the build
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
      // Find predecessor basic block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
      Block *pb = _bbs[x->_idx];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
      // Insert into nodes array, if not already there
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
      if( !_bbs.lookup(proj->_idx) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
        assert( x != proj, "" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
        // Map basic block of projection
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
        _bbs.map(proj->_idx,pb);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
        pb->_nodes.push(proj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
      // Insert self as a child of my predecessor block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
      pb->_succs.map(pb->_num_succs++, _bbs[np->_idx]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
      assert( pb->_nodes[ pb->_nodes.size() - pb->_num_succs ]->is_block_proj(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
              "too many control users, not a CFG?" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
  // Return number of basic blocks for all children and self
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
  return sum;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
//------------------------------insert_goto_at---------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
// Inserts a goto & corresponding basic block between
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
// block[block_no] and its succ_no'th successor block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
void PhaseCFG::insert_goto_at(uint block_no, uint succ_no) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  // get block with block_no
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  assert(block_no < _num_blocks, "illegal block number");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  Block* in  = _blocks[block_no];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  // get successor block succ_no
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  assert(succ_no < in->_num_succs, "illegal successor number");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  Block* out = in->_succs[succ_no];
1070
e03de091796e 6611837: block frequency is zero
rasbold
parents: 1
diff changeset
   470
  // Compute frequency of the new block. Do this before inserting
e03de091796e 6611837: block frequency is zero
rasbold
parents: 1
diff changeset
   471
  // new block in case succ_prob() needs to infer the probability from
e03de091796e 6611837: block frequency is zero
rasbold
parents: 1
diff changeset
   472
  // surrounding blocks.
e03de091796e 6611837: block frequency is zero
rasbold
parents: 1
diff changeset
   473
  float freq = in->_freq * in->succ_prob(succ_no);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
  // get ProjNode corresponding to the succ_no'th successor of the in block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
  ProjNode* proj = in->_nodes[in->_nodes.size() - in->_num_succs + succ_no]->as_Proj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
  // create region for basic block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  RegionNode* region = new (C, 2) RegionNode(2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  region->init_req(1, proj);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  // setup corresponding basic block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  Block* block = new (_bbs._arena) Block(_bbs._arena, region);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  _bbs.map(region->_idx, block);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  C->regalloc()->set_bad(region->_idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  // add a goto node
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
  Node* gto = _goto->clone(); // get a new goto node
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  gto->set_req(0, region);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  // add it to the basic block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  block->_nodes.push(gto);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  _bbs.map(gto->_idx, block);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  C->regalloc()->set_bad(gto->_idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  // hook up successor block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
  block->_succs.map(block->_num_succs++, out);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  // remap successor's predecessors if necessary
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
  for (uint i = 1; i < out->num_preds(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
    if (out->pred(i) == proj) out->head()->set_req(i, gto);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  // remap predecessor's successor to new block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  in->_succs.map(succ_no, block);
1070
e03de091796e 6611837: block frequency is zero
rasbold
parents: 1
diff changeset
   498
  // Set the frequency of the new block
e03de091796e 6611837: block frequency is zero
rasbold
parents: 1
diff changeset
   499
  block->_freq = freq;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  // add new basic block to basic block list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  _blocks.insert(block_no + 1, block);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  _num_blocks++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
//------------------------------no_flip_branch---------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
// Does this block end in a multiway branch that cannot have the default case
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
// flipped for another case?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
static bool no_flip_branch( Block *b ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
  int branch_idx = b->_nodes.size() - b->_num_succs-1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
  if( branch_idx < 1 ) return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  Node *bra = b->_nodes[branch_idx];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  if( bra->is_Catch() ) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  if( bra->is_Mach() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
    if( bra->is_MachNullCheck() ) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
    int iop = bra->as_Mach()->ideal_Opcode();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
    if( iop == Op_FastLock || iop == Op_FastUnlock )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
      return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
//------------------------------convert_NeverBranch_to_Goto--------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
// Check for NeverBranch at block end.  This needs to become a GOTO to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
// true target.  NeverBranch are treated as a conditional branch that always
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
// goes the same direction for most of the optimizer and are used to give a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
// fake exit path to infinite loops.  At this late stage they need to turn
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
// into Goto's so that when you enter the infinite loop you indeed hang.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
void PhaseCFG::convert_NeverBranch_to_Goto(Block *b) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  // Find true target
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  int end_idx = b->end_idx();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  int idx = b->_nodes[end_idx+1]->as_Proj()->_con;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
  Block *succ = b->_succs[idx];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  Node* gto = _goto->clone(); // get a new goto node
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
  gto->set_req(0, b->head());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  Node *bp = b->_nodes[end_idx];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
  b->_nodes.map(end_idx,gto); // Slam over NeverBranch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  _bbs.map(gto->_idx, b);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  C->regalloc()->set_bad(gto->_idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  b->_nodes.pop();              // Yank projections
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  b->_nodes.pop();              // Yank projections
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  b->_succs.map(0,succ);        // Map only successor
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  b->_num_succs = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  // remap successor's predecessors if necessary
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  uint j;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
  for( j = 1; j < succ->num_preds(); j++)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
    if( succ->pred(j)->in(0) == bp )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
      succ->head()->set_req(j, gto);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  // Kill alternate exit path
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  Block *dead = b->_succs[1-idx];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
  for( j = 1; j < dead->num_preds(); j++)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
    if( dead->pred(j)->in(0) == bp )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  // Scan through block, yanking dead path from
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  // all regions and phis.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
  dead->head()->del_req(j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  for( int k = 1; dead->_nodes[k]->is_Phi(); k++ )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
    dead->_nodes[k]->del_req(j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
//------------------------------MoveToNext-------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
// Helper function to move block bx to the slot following b_index. Return
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
// true if the move is successful, otherwise false
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
bool PhaseCFG::MoveToNext(Block* bx, uint b_index) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  if (bx == NULL) return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
  // Return false if bx is already scheduled.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
  uint bx_index = bx->_pre_order;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  if ((bx_index <= b_index) && (_blocks[bx_index] == bx)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  // Find the current index of block bx on the block list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  bx_index = b_index + 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  while( bx_index < _num_blocks && _blocks[bx_index] != bx ) bx_index++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  assert(_blocks[bx_index] == bx, "block not found");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
  // If the previous block conditionally falls into bx, return false,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
  // because moving bx will create an extra jump.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
  for(uint k = 1; k < bx->num_preds(); k++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
    Block* pred = _bbs[bx->pred(k)->_idx];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
    if (pred == _blocks[bx_index-1]) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
      if (pred->_num_succs != 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
        return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
  // Reinsert bx just past block 'b'
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
  _blocks.remove(bx_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  _blocks.insert(b_index + 1, bx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
//------------------------------MoveToEnd--------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
// Move empty and uncommon blocks to the end.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
void PhaseCFG::MoveToEnd(Block *b, uint i) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
  int e = b->is_Empty();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
  if (e != Block::not_empty) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
    if (e == Block::empty_with_goto) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
      // Remove the goto, but leave the block.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
      b->_nodes.pop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
    // Mark this block as a connector block, which will cause it to be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
    // ignored in certain functions such as non_connector_successor().
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
    b->set_connector();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
  // Move the empty block to the end, and don't recheck.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
  _blocks.remove(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
  _blocks.push(b);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
//------------------------------RemoveEmpty------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
// Remove empty basic blocks and useless branches.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
void PhaseCFG::RemoveEmpty() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
  // Move uncommon blocks to the end
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
  uint last = _num_blocks;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
  uint i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
  assert( _blocks[0] == _broot, "" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
  for( i = 1; i < last; i++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
    Block *b = _blocks[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
    // Check for NeverBranch at block end.  This needs to become a GOTO to the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
    // true target.  NeverBranch are treated as a conditional branch that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
    // always goes the same direction for most of the optimizer and are used
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
    // to give a fake exit path to infinite loops.  At this late stage they
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
    // need to turn into Goto's so that when you enter the infinite loop you
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
    // indeed hang.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
    if( b->_nodes[b->end_idx()]->Opcode() == Op_NeverBranch )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
      convert_NeverBranch_to_Goto(b);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
    // Look for uncommon blocks and move to end.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
    if( b->is_uncommon(_bbs) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
      MoveToEnd(b, i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
      last--;                   // No longer check for being uncommon!
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
      if( no_flip_branch(b) ) { // Fall-thru case must follow?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
        b = _blocks[i];         // Find the fall-thru block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
        MoveToEnd(b, i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
        last--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
      i--;                      // backup block counter post-increment
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
  // Remove empty blocks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
  uint j1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
  last = _num_blocks;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
  for( i=0; i < last; i++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
    Block *b = _blocks[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
    if (i > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
      if (b->is_Empty() != Block::not_empty) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
        MoveToEnd(b, i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
        last--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
        i--;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
  } // End of for all blocks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
  // Fixup final control flow for the blocks.  Remove jump-to-next
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
  // block.  If neither arm of a IF follows the conditional branch, we
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
  // have to add a second jump after the conditional.  We place the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
  // TRUE branch target in succs[0] for both GOTOs and IFs.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
  for( i=0; i < _num_blocks; i++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
    Block *b = _blocks[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
    b->_pre_order = i;          // turn pre-order into block-index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
    // Connector blocks need no further processing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
    if (b->is_connector()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
      assert((i+1) == _num_blocks || _blocks[i+1]->is_connector(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
             "All connector blocks should sink to the end");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
      continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
    assert(b->is_Empty() != Block::completely_empty,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
           "Empty blocks should be connectors");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
    Block *bnext = (i < _num_blocks-1) ? _blocks[i+1] : NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
    Block *bs0 = b->non_connector_successor(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
    // Check for multi-way branches where I cannot negate the test to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
    // exchange the true and false targets.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
    if( no_flip_branch( b ) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
      // Find fall through case - if must fall into its target
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
      int branch_idx = b->_nodes.size() - b->_num_succs;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
      for (uint j2 = 0; j2 < b->_num_succs; j2++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
        const ProjNode* p = b->_nodes[branch_idx + j2]->as_Proj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
        if (p->_con == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
          // successor j2 is fall through case
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
          if (b->non_connector_successor(j2) != bnext) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
            // but it is not the next block => insert a goto
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
            insert_goto_at(i, j2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
          // Put taken branch in slot 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
          if( j2 == 0 && b->_num_succs == 2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
            // Flip targets in succs map
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
            Block *tbs0 = b->_succs[0];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
            Block *tbs1 = b->_succs[1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
            b->_succs.map( 0, tbs1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
            b->_succs.map( 1, tbs0 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
          break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
      // Remove all CatchProjs
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
      for (j1 = 0; j1 < b->_num_succs; j1++) b->_nodes.pop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
    } else if (b->_num_succs == 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
      // Block ends in a Goto?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
      if (bnext == bs0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
        // We fall into next block; remove the Goto
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
        b->_nodes.pop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
    } else if( b->_num_succs == 2 ) { // Block ends in a If?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
      // Get opcode of 1st projection (matches _succs[0])
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
      // Note: Since this basic block has 2 exits, the last 2 nodes must
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
      //       be projections (in any order), the 3rd last node must be
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
      //       the IfNode (we have excluded other 2-way exits such as
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
      //       CatchNodes already).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
      MachNode *iff   = b->_nodes[b->_nodes.size()-3]->as_Mach();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
      ProjNode *proj0 = b->_nodes[b->_nodes.size()-2]->as_Proj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
      ProjNode *proj1 = b->_nodes[b->_nodes.size()-1]->as_Proj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
      // Assert that proj0 and succs[0] match up. Similarly for proj1 and succs[1].
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
      assert(proj0->raw_out(0) == b->_succs[0]->head(), "Mismatch successor 0");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
      assert(proj1->raw_out(0) == b->_succs[1]->head(), "Mismatch successor 1");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
      Block *bs1 = b->non_connector_successor(1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
      // Check for neither successor block following the current
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
      // block ending in a conditional. If so, move one of the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
      // successors after the current one, provided that the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
      // successor was previously unscheduled, but moveable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
      // (i.e., all paths to it involve a branch).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
      if( bnext != bs0 && bnext != bs1 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
        // Choose the more common successor based on the probability
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
        // of the conditional branch.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
        Block *bx = bs0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
        Block *by = bs1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
        // _prob is the probability of taking the true path. Make
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
        // p the probability of taking successor #1.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
        float p = iff->as_MachIf()->_prob;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
        if( proj0->Opcode() == Op_IfTrue ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
          p = 1.0 - p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
        // Prefer successor #1 if p > 0.5
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
        if (p > PROB_FAIR) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
          bx = bs1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
          by = bs0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
        // Attempt the more common successor first
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
        if (MoveToNext(bx, i)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
          bnext = bx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
        } else if (MoveToNext(by, i)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
          bnext = by;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
      // Check for conditional branching the wrong way.  Negate
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
      // conditional, if needed, so it falls into the following block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
      // and branches to the not-following block.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
      // Check for the next block being in succs[0].  We are going to branch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
      // to succs[0], so we want the fall-thru case as the next block in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
      // succs[1].
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
      if (bnext == bs0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
        // Fall-thru case in succs[0], so flip targets in succs map
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
        Block *tbs0 = b->_succs[0];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
        Block *tbs1 = b->_succs[1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
        b->_succs.map( 0, tbs1 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
        b->_succs.map( 1, tbs0 );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
        // Flip projection for each target
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
        { ProjNode *tmp = proj0; proj0 = proj1; proj1 = tmp; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
      } else if( bnext == bs1 ) { // Fall-thru is already in succs[1]
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
      } else {                  // Else need a double-branch
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
        // The existing conditional branch need not change.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
        // Add a unconditional branch to the false target.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
        // Alas, it must appear in its own block and adding a
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
        // block this late in the game is complicated.  Sigh.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
        insert_goto_at(i, 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
      // Make sure we TRUE branch to the target
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
      if( proj0->Opcode() == Op_IfFalse )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
        iff->negate();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
      b->_nodes.pop();          // Remove IfFalse & IfTrue projections
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
      b->_nodes.pop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
      // Multi-exit block, e.g. a switch statement
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
      // But we don't need to do anything here
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
  } // End of for all blocks
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
//------------------------------dump-------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
void PhaseCFG::_dump_cfg( const Node *end, VectorSet &visited  ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
  const Node *x = end->is_block_proj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
  assert( x, "not a CFG" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
  // Do not visit this block again
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
  if( visited.test_set(x->_idx) ) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
  // Skip through this block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
  const Node *p = x;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
  do {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
    p = p->in(0);               // Move control forward
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
    assert( !p->is_block_proj() || p->is_Root(), "not a CFG" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
  } while( !p->is_block_start() );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
  // Recursively visit
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
  for( uint i=1; i<p->req(); i++ )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
    _dump_cfg(p->in(i),visited);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
  // Dump the block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
  _bbs[p->_idx]->dump(&_bbs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
void PhaseCFG::dump( ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
  tty->print("\n--- CFG --- %d BBs\n",_num_blocks);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
  if( _blocks.size() ) {        // Did we do basic-block layout?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
    for( uint i=0; i<_num_blocks; i++ )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
      _blocks[i]->dump(&_bbs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
  } else {                      // Else do it with a DFS
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
    VectorSet visited(_bbs._arena);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
    _dump_cfg(_root,visited);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
void PhaseCFG::dump_headers() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  for( uint i = 0; i < _num_blocks; i++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
    if( _blocks[i] == NULL ) continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
    _blocks[i]->dump_head(&_bbs);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
void PhaseCFG::verify( ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
  // Verify sane CFG
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
  for( uint i = 0; i < _num_blocks; i++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
    Block *b = _blocks[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
    uint cnt = b->_nodes.size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
    uint j;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
    for( j = 0; j < cnt; j++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
      Node *n = b->_nodes[j];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
      assert( _bbs[n->_idx] == b, "" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
      if( j >= 1 && n->is_Mach() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
          n->as_Mach()->ideal_Opcode() == Op_CreateEx ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
        assert( j == 1 || b->_nodes[j-1]->is_Phi(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
                "CreateEx must be first instruction in block" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
      for( uint k = 0; k < n->req(); k++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
        Node *use = n->in(k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
        if( use && use != n ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
          assert( _bbs[use->_idx] || use->is_Con(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
                  "must have block; constants for debug info ok" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
    j = b->end_idx();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
    Node *bp = (Node*)b->_nodes[b->_nodes.size()-1]->is_block_proj();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
    assert( bp, "last instruction must be a block proj" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
    assert( bp == b->_nodes[j], "wrong number of successors for this block" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
    if( bp->is_Catch() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
      while( b->_nodes[--j]->Opcode() == Op_MachProj ) ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
      assert( b->_nodes[j]->is_Call(), "CatchProj must follow call" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
    else if( bp->is_Mach() && bp->as_Mach()->ideal_Opcode() == Op_If ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
      assert( b->_num_succs == 2, "Conditional branch must have two targets");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
//=============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
//------------------------------UnionFind--------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
UnionFind::UnionFind( uint max ) : _cnt(max), _max(max), _indices(NEW_RESOURCE_ARRAY(uint,max)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
  Copy::zero_to_bytes( _indices, sizeof(uint)*max );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
void UnionFind::extend( uint from_idx, uint to_idx ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
  _nesting.check();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
  if( from_idx >= _max ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
    uint size = 16;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
    while( size <= from_idx ) size <<=1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
    _indices = REALLOC_RESOURCE_ARRAY( uint, _indices, _max, size );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
    _max = size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
  while( _cnt <= from_idx ) _indices[_cnt++] = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
  _indices[from_idx] = to_idx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
void UnionFind::reset( uint max ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
  assert( max <= max_uint, "Must fit within uint" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
  // Force the Union-Find mapping to be at least this large
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
  extend(max,0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
  // Initialize to be the ID mapping.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
  for( uint i=0; i<_max; i++ ) map(i,i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
//------------------------------Find_compress----------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
// Straight out of Tarjan's union-find algorithm
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
uint UnionFind::Find_compress( uint idx ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
  uint cur  = idx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
  uint next = lookup(cur);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
  while( next != cur ) {        // Scan chain of equivalences
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
    assert( next < cur, "always union smaller" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
    cur = next;                 // until find a fixed-point
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
    next = lookup(cur);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
  // Core of union-find algorithm: update chain of
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
  // equivalences to be equal to the root.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
  while( idx != next ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
    uint tmp = lookup(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
    map(idx, next);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
    idx = tmp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
  return idx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
//------------------------------Find_const-------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
// Like Find above, but no path compress, so bad asymptotic behavior
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
uint UnionFind::Find_const( uint idx ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
  if( idx == 0 ) return idx;    // Ignore the zero idx
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
  // Off the end?  This can happen during debugging dumps
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
  // when data structures have not finished being updated.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
  if( idx >= _max ) return idx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
  uint next = lookup(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
  while( next != idx ) {        // Scan chain of equivalences
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
    assert( next < idx, "always union smaller" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
    idx = next;                 // until find a fixed-point
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
    next = lookup(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
  return next;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
//------------------------------Union------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
// union 2 sets together.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
void UnionFind::Union( uint idx1, uint idx2 ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
  uint src = Find(idx1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
  uint dst = Find(idx2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
  assert( src, "" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
  assert( dst, "" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
  assert( src < _max, "oob" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
  assert( dst < _max, "oob" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
  assert( src < dst, "always union smaller" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
  map(dst,src);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
}