hotspot/src/share/vm/opto/live.cpp
author ehelin
Mon, 12 Aug 2013 17:37:02 +0200
changeset 19979 ebe1dbb6e1aa
parent 19717 7819ffdaf0ff
child 20022 e6e3f5ff6d73
permissions -rw-r--r--
8015107: NPG: Use consistent naming for metaspace concepts Reviewed-by: coleenp, mgerdin, hseigel
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
     2
 * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
1
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
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 2154
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 2154
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 2154
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    26
#include "memory/allocation.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    27
#include "opto/callnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    28
#include "opto/chaitin.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    29
#include "opto/live.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 5547
diff changeset
    30
#include "opto/machnode.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
// Compute live-in/live-out.  We use a totally incremental algorithm.  The LIVE
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
// problem is monotonic.  The steady-state solution looks like this: pull a
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
// block from the worklist.  It has a set of delta's - values which are newly
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
// live-in from the block.  Push these to the live-out sets of all predecessor
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
// blocks.  At each predecessor, the new live-out values are ANDed with what is
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
// already live-out (extra stuff is added to the live-out sets).  Then the
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
// remaining new live-out values are ANDed with what is locally defined.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
// Leftover bits become the new live-in for the predecessor block, and the pred
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
// block is put on the worklist.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
//   The locally live-in stuff is computed once and added to predecessor
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 2030
diff changeset
    43
// live-out sets.  This separate compilation is done in the outer loop below.
17013
22a05c7f3314 8011621: live_ranges_in_separate_class.patch
neliasso
parents: 13969
diff changeset
    44
PhaseLive::PhaseLive( const PhaseCFG &cfg, const LRG_List &names, Arena *arena ) : Phase(LIVE), _cfg(cfg), _names(names), _arena(arena), _live(0) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
void PhaseLive::compute(uint maxlrg) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
  _maxlrg   = maxlrg;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  _worklist = new (_arena) Block_List();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
  // Init the sparse live arrays.  This data is live on exit from here!
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  // The _live info is the live-out info.
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
    53
  _live = (IndexSet*)_arena->Amalloc(sizeof(IndexSet) * _cfg.number_of_blocks());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  uint i;
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
    55
  for (i = 0; i < _cfg.number_of_blocks(); i++) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
    _live[i].initialize(_maxlrg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  // Init the sparse arrays for delta-sets.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  ResourceMark rm;              // Nuke temp storage on exit
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
  // Does the memory used by _defs and _deltas get reclaimed?  Does it matter?  TT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    63
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
  // Array of values defined locally in blocks
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
    65
  _defs = NEW_RESOURCE_ARRAY(IndexSet,_cfg.number_of_blocks());
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
    66
  for (i = 0; i < _cfg.number_of_blocks(); i++) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
    _defs[i].initialize(_maxlrg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  // Array of delta-set pointers, indexed by block pre_order-1.
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
    71
  _deltas = NEW_RESOURCE_ARRAY(IndexSet*,_cfg.number_of_blocks());
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
    72
  memset( _deltas, 0, sizeof(IndexSet*)* _cfg.number_of_blocks());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  _free_IndexSet = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  // Blocks having done pass-1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
  VectorSet first_pass(Thread::current()->resource_area());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  // Outer loop: must compute local live-in sets and push into predecessors.
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
    80
  for (uint j = _cfg.number_of_blocks(); j > 0; j--) {
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
    81
    Block* block = _cfg.get_block(j - 1);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
    // Compute the local live-in set.  Start with any new live-out bits.
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
    84
    IndexSet* use = getset(block);
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
    85
    IndexSet* def = &_defs[block->_pre_order-1];
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
    DEBUG_ONLY(IndexSet *def_outside = getfreeset();)
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
    uint i;
19717
7819ffdaf0ff 8023691: Create interface for nodes in class Block
adlertz
parents: 19330
diff changeset
    88
    for (i = block->number_of_nodes(); i > 1; i--) {
7819ffdaf0ff 8023691: Create interface for nodes in class Block
adlertz
parents: 19330
diff changeset
    89
      Node* n = block->get_node(i-1);
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
    90
      if (n->is_Phi()) {
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
    91
        break;
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
    92
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
      uint r = _names[n->_idx];
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
      assert(!def_outside->member(r), "Use of external LRG overlaps the same LRG defined in this block");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
      def->insert( r );
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
      use->remove( r );
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
      uint cnt = n->req();
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
    99
      for (uint k = 1; k < cnt; k++) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
        Node *nk = n->in(k);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
        uint nkidx = nk->_idx;
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   102
        if (_cfg.get_block_for_node(nk) != block) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
          uint u = _names[nkidx];
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   104
          use->insert(u);
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   105
          DEBUG_ONLY(def_outside->insert(u);)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
    def_outside->set_next(_free_IndexSet);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
    _free_IndexSet = def_outside;     // Drop onto free list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
    // Remove anything defined by Phis and the block start instruction
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   114
    for (uint k = i; k > 0; k--) {
19717
7819ffdaf0ff 8023691: Create interface for nodes in class Block
adlertz
parents: 19330
diff changeset
   115
      uint r = _names[block->get_node(k - 1)->_idx];
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   116
      def->insert(r);
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   117
      use->remove(r);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
    // Push these live-in things to predecessors
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   121
    for (uint l = 1; l < block->num_preds(); l++) {
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   122
      Block* p = _cfg.get_block_for_node(block->pred(l));
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   123
      add_liveout(p, use, first_pass);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
      // PhiNode uses go in the live-out set of prior blocks.
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   126
      for (uint k = i; k > 0; k--) {
19717
7819ffdaf0ff 8023691: Create interface for nodes in class Block
adlertz
parents: 19330
diff changeset
   127
        add_liveout(p, _names[block->get_node(k-1)->in(l)->_idx], first_pass);
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   128
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
    }
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   130
    freeset(block);
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   131
    first_pass.set(block->_pre_order);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
    // Inner loop: blocks that picked up new live-out values to be propagated
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   134
    while (_worklist->size()) {
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   135
      Block* block = _worklist->pop();
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   136
      IndexSet *delta = getset(block);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
      assert( delta->count(), "missing delta set" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
      // Add new-live-in to predecessors live-out sets
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   140
      for (uint l = 1; l < block->num_preds(); l++) {
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   141
        Block* predecessor = _cfg.get_block_for_node(block->pred(l));
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   142
        add_liveout(predecessor, delta, first_pass);
19279
4be3c2e6663c 8022284: Hide internal data structure in PhaseCFG
adlertz
parents: 17013
diff changeset
   143
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   145
      freeset(block);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
    } // End of while-worklist-not-empty
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  } // End of for-all-blocks-outer-loop
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
  // We explicitly clear all of the IndexSets which we are about to release.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
  // This allows us to recycle their internal memory into IndexSet's free list.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   153
  for (i = 0; i < _cfg.number_of_blocks(); i++) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
    _defs[i].clear();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
    if (_deltas[i]) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
      // Is this always true?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
      _deltas[i]->clear();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  IndexSet *free = _free_IndexSet;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  while (free != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
    IndexSet *temp = free;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
    free = free->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
    temp->clear();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
void PhaseLive::stats(uint iters) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
// Get an IndexSet for a block.  Return existing one, if any.  Make a new
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
// empty one if a prior one does not exist.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
IndexSet *PhaseLive::getset( Block *p ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  IndexSet *delta = _deltas[p->_pre_order-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  if( !delta )                  // Not on worklist?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
    // Get a free set; flag as being on worklist
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
    delta = _deltas[p->_pre_order-1] = getfreeset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  return delta;                 // Return set of new live-out items
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
// Pull from free list, or allocate.  Internal allocation on the returned set
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
// is always from thread local storage.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
IndexSet *PhaseLive::getfreeset( ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
  IndexSet *f = _free_IndexSet;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  if( !f ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
    f = new IndexSet;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
//    f->set_arena(Thread::current()->resource_area());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
    f->initialize(_maxlrg, Thread::current()->resource_area());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
    // Pull from free list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
    _free_IndexSet = f->next();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  //f->_cnt = 0;                        // Reset to empty
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
//    f->set_arena(Thread::current()->resource_area());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
    f->initialize(_maxlrg, Thread::current()->resource_area());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  return f;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
// Free an IndexSet from a block.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
void PhaseLive::freeset( const Block *p ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  IndexSet *f = _deltas[p->_pre_order-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  f->set_next(_free_IndexSet);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  _free_IndexSet = f;           // Drop onto free list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  _deltas[p->_pre_order-1] = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
// Add a live-out value to a given blocks live-out set.  If it is new, then
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
// also add it to the delta set and stick the block on the worklist.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
void PhaseLive::add_liveout( Block *p, uint r, VectorSet &first_pass ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  IndexSet *live = &_live[p->_pre_order-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  if( live->insert(r) ) {       // If actually inserted...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
    // We extended the live-out set.  See if the value is generated locally.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
    // If it is not, then we must extend the live-in set.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
    if( !_defs[p->_pre_order-1].member( r ) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
      if( !_deltas[p->_pre_order-1] && // Not on worklist?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
          first_pass.test(p->_pre_order) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
        _worklist->push(p);     // Actually go on worklist if already 1st pass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
      getset(p)->insert(r);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
// Add a vector of live-out values to a given blocks live-out set.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
void PhaseLive::add_liveout( Block *p, IndexSet *lo, VectorSet &first_pass ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  IndexSet *live = &_live[p->_pre_order-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  IndexSet *defs = &_defs[p->_pre_order-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
  IndexSet *on_worklist = _deltas[p->_pre_order-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  IndexSet *delta = on_worklist ? on_worklist : getfreeset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
  IndexSetIterator elements(lo);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
  uint r;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
  while ((r = elements.next()) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
    if( live->insert(r) &&      // If actually inserted...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
        !defs->member( r ) )    // and not defined locally
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
      delta->insert(r);         // Then add to live-in set
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
  if( delta->count() ) {                // If actually added things
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
    _deltas[p->_pre_order-1] = delta; // Flag as on worklist now
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
    if( !on_worklist &&         // Not on worklist?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
        first_pass.test(p->_pre_order) )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
      _worklist->push(p);       // Actually go on worklist if already 1st pass
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
  } else {                      // Nothing there; just free it
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
    delta->set_next(_free_IndexSet);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
    _free_IndexSet = delta;     // Drop onto free list
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
// Dump the live-out set for a block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
void PhaseLive::dump( const Block *b ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  tty->print("Block %d: ",b->_pre_order);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  tty->print("LiveOut: ");  _live[b->_pre_order-1].dump();
19717
7819ffdaf0ff 8023691: Create interface for nodes in class Block
adlertz
parents: 19330
diff changeset
   257
  uint cnt = b->number_of_nodes();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
  for( uint i=0; i<cnt; i++ ) {
19717
7819ffdaf0ff 8023691: Create interface for nodes in class Block
adlertz
parents: 19330
diff changeset
   259
    tty->print("L%d/", _names[b->get_node(i)->_idx] );
7819ffdaf0ff 8023691: Create interface for nodes in class Block
adlertz
parents: 19330
diff changeset
   260
    b->get_node(i)->dump();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
  tty->print("\n");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
// Verify that base pointers and derived pointers are still sane.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
void PhaseChaitin::verify_base_ptrs( ResourceArea *a ) const {
2014
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   267
#ifdef ASSERT
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   268
  Unique_Node_List worklist(a);
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   269
  for (uint i = 0; i < _cfg.number_of_blocks(); i++) {
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   270
    Block* block = _cfg.get_block(i);
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   271
    for (uint j = block->end_idx() + 1; j > 1; j--) {
19717
7819ffdaf0ff 8023691: Create interface for nodes in class Block
adlertz
parents: 19330
diff changeset
   272
      Node* n = block->get_node(j-1);
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   273
      if (n->is_Phi()) {
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   274
        break;
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   275
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
      // Found a safepoint?
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
   277
      if (n->is_MachSafePoint()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
        MachSafePointNode *sfpt = n->as_MachSafePoint();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
        JVMState* jvms = sfpt->jvms();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
        if (jvms != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
          // Now scan for a live derived pointer
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
          if (jvms->oopoff() < sfpt->req()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
            // Check each derived/base pair
2014
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   284
            for (uint idx = jvms->oopoff(); idx < sfpt->req(); idx++) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
              Node *check = sfpt->in(idx);
2014
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   286
              bool is_derived = ((idx - jvms->oopoff()) & 1) == 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
              // search upwards through spills and spill phis for AddP
2014
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   288
              worklist.clear();
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   289
              worklist.push(check);
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   290
              uint k = 0;
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   291
              while( k < worklist.size() ) {
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   292
                check = worklist.at(k);
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   293
                assert(check,"Bad base or derived pointer");
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   294
                // See PhaseChaitin::find_base_for_derived() for all cases.
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   295
                int isc = check->is_Copy();
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   296
                if( isc ) {
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   297
                  worklist.push(check->in(isc));
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   298
                } else if( check->is_Phi() ) {
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   299
                  for (uint m = 1; m < check->req(); m++)
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   300
                    worklist.push(check->in(m));
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   301
                } else if( check->is_Con() ) {
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   302
                  if (is_derived) {
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   303
                    // Derived is NULL+offset
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   304
                    assert(!is_derived || check->bottom_type()->is_ptr()->ptr() == TypePtr::Null,"Bad derived pointer");
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   305
                  } else {
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   306
                    assert(check->bottom_type()->is_ptr()->_offset == 0,"Bad base pointer");
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   307
                    // Base either ConP(NULL) or loadConP
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   308
                    if (check->is_Mach()) {
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   309
                      assert(check->as_Mach()->ideal_Opcode() == Op_ConP,"Bad base pointer");
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   310
                    } else {
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   311
                      assert(check->Opcode() == Op_ConP &&
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   312
                             check->bottom_type()->is_ptr()->ptr() == TypePtr::Null,"Bad base pointer");
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   313
                    }
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   314
                  }
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   315
                } else if( check->bottom_type()->is_ptr()->_offset == 0 ) {
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   316
                  if(check->is_Proj() || check->is_Mach() &&
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   317
                     (check->as_Mach()->ideal_Opcode() == Op_CreateEx ||
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   318
                      check->as_Mach()->ideal_Opcode() == Op_ThreadLocal ||
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   319
                      check->as_Mach()->ideal_Opcode() == Op_CMoveP ||
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   320
                      check->as_Mach()->ideal_Opcode() == Op_CheckCastPP ||
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   321
#ifdef _LP64
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   322
                      UseCompressedOops && check->as_Mach()->ideal_Opcode() == Op_CastPP ||
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   323
                      UseCompressedOops && check->as_Mach()->ideal_Opcode() == Op_DecodeN ||
19979
ebe1dbb6e1aa 8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents: 19717
diff changeset
   324
                      UseCompressedClassPointers && check->as_Mach()->ideal_Opcode() == Op_DecodeNKlass ||
2014
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   325
#endif
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   326
                      check->as_Mach()->ideal_Opcode() == Op_LoadP ||
2030
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   327
                      check->as_Mach()->ideal_Opcode() == Op_LoadKlass)) {
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   328
                    // Valid nodes
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   329
                  } else {
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   330
                    check->dump();
2014
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   331
                    assert(false,"Bad base or derived pointer");
2030
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   332
                  }
2014
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   333
                } else {
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   334
                  assert(is_derived,"Bad base pointer");
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   335
                  assert(check->is_Mach() && check->as_Mach()->ideal_Opcode() == Op_AddP,"Bad derived pointer");
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   336
                }
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   337
                k++;
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   338
                assert(k < 100000,"Derived pointer checking in infinite loop");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
              } // End while
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
          } // End of check for derived pointers
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
        } // End of Kcheck for debug info
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
      } // End of if found a safepoint
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
    } // End of forall instructions in block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  } // End of forall blocks
2014
5510e7394f2d 6782232: assert("CreateEx must be first instruction in block" )
kvn
parents: 1
diff changeset
   346
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
}
2030
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   348
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   349
// Verify that graphs and base pointers are still sane.
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   350
void PhaseChaitin::verify( ResourceArea *a, bool verify_ifg ) const {
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   351
#ifdef ASSERT
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   352
  if( VerifyOpto || VerifyRegisterAllocator ) {
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   353
    _cfg.verify();
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   354
    verify_base_ptrs(a);
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   355
    if(verify_ifg)
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   356
      _ifg->verify(this);
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   357
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
#endif
2030
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   359
}
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   360
39d55e4534b4 6791852: assert(b->_nodes[insidx] == n,"got insidx set incorrectly")
kvn
parents: 2014
diff changeset
   361
#endif