hotspot/src/share/vm/opto/compile.cpp
author cvarming
Mon, 20 Jun 2016 08:11:22 -0400
changeset 39431 cb1b2538c4b2
parent 39419 cc993a4ab581
child 40040 7644f470d923
permissions -rw-r--r--
8159720: Failure of C2 compilation with tiered prevents some C1 compilations. Summary: If C2 fails to compile a method with tiered compilation, then it should mark the method as not compileable on the C2 tier only. Reviewed-by: twisti, thartmann
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
37248
11a660dbbb8e 8132524: Missing includes to resourceArea.hpp
jprovino
parents: 36316
diff changeset
     2
 * Copyright (c) 1997, 2016, 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: 5353
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 5353
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: 5353
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: 6453
diff changeset
    25
#include "precompiled.hpp"
14626
0cf4eccf130f 8003240: x86: move MacroAssembler into separate file
twisti
parents: 14623
diff changeset
    26
#include "asm/macroAssembler.hpp"
0cf4eccf130f 8003240: x86: move MacroAssembler into separate file
twisti
parents: 14623
diff changeset
    27
#include "asm/macroAssembler.inline.hpp"
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
    28
#include "ci/ciReplay.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    29
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    30
#include "code/exceptionHandlerTable.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    31
#include "code/nmethod.hpp"
25495
aeb87692dfd0 8022968: Some codecache allocation failures don't result in invoking the sweeper
thartmann
parents: 25338
diff changeset
    32
#include "compiler/compileBroker.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    33
#include "compiler/compileLog.hpp"
14626
0cf4eccf130f 8003240: x86: move MacroAssembler into separate file
twisti
parents: 14623
diff changeset
    34
#include "compiler/disassembler.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    35
#include "compiler/oopMap.hpp"
37248
11a660dbbb8e 8132524: Missing includes to resourceArea.hpp
jprovino
parents: 36316
diff changeset
    36
#include "memory/resourceArea.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    37
#include "opto/addnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    38
#include "opto/block.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    39
#include "opto/c2compiler.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    40
#include "opto/callGenerator.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    41
#include "opto/callnode.hpp"
35574
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
    42
#include "opto/castnode.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    43
#include "opto/cfgnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    44
#include "opto/chaitin.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    45
#include "opto/compile.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    46
#include "opto/connode.hpp"
29337
ef2be52deeaf 6912521: System.arraycopy works slower than the simple loop for little lengths
roland
parents: 28912
diff changeset
    47
#include "opto/convertnode.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    48
#include "opto/divnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    49
#include "opto/escape.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    50
#include "opto/idealGraphPrinter.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    51
#include "opto/loopnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    52
#include "opto/machnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    53
#include "opto/macro.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    54
#include "opto/matcher.hpp"
20715
be1135dc1406 8025657: compiler/intrinsics/mathexact/ConstantTest.java fails on assert in lcm.cpp on solaris x64
rbackman
parents: 20073
diff changeset
    55
#include "opto/mathexactnode.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    56
#include "opto/memnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    57
#include "opto/mulnode.hpp"
23528
8f1a7f5e8066 8001532: C2 node files refactoring
morris
parents: 23491
diff changeset
    58
#include "opto/narrowptrnode.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    59
#include "opto/node.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    60
#include "opto/opcodes.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    61
#include "opto/output.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    62
#include "opto/parse.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    63
#include "opto/phaseX.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    64
#include "opto/rootnode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    65
#include "opto/runtime.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    66
#include "opto/stringopts.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    67
#include "opto/type.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    68
#include "opto/vectornode.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    69
#include "runtime/arguments.hpp"
29081
c61eb4914428 8072911: Remove includes of oop.inline.hpp from .hpp files
stefank
parents: 28395
diff changeset
    70
#include "runtime/sharedRuntime.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    71
#include "runtime/signature.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    72
#include "runtime/stubRoutines.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    73
#include "runtime/timer.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6453
diff changeset
    74
#include "utilities/copy.hpp"
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
    76
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
    77
// -------------------- Compile::mach_constant_base_node -----------------------
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
    78
// Constant table base node singleton.
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
    79
MachConstantBaseNode* Compile::mach_constant_base_node() {
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
    80
  if (_mach_constant_base_node == NULL) {
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 24673
diff changeset
    81
    _mach_constant_base_node = new MachConstantBaseNode();
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
    82
    _mach_constant_base_node->add_req(C->root());
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
    83
  }
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
    84
  return _mach_constant_base_node;
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
    85
}
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
    86
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
    87
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
/// Support for intrinsics.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
// Return the index at which m must be inserted (or already exists).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
// The sort order is by the address of the ciMethod, with is_virtual as minor key.
36315
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
    92
class IntrinsicDescPair {
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
    93
 private:
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
    94
  ciMethod* _m;
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
    95
  bool _is_virtual;
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
    96
 public:
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
    97
  IntrinsicDescPair(ciMethod* m, bool is_virtual) : _m(m), _is_virtual(is_virtual) {}
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
    98
  static int compare(IntrinsicDescPair* const& key, CallGenerator* const& elt) {
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
    99
    ciMethod* m= elt->method();
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   100
    ciMethod* key_m = key->_m;
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   101
    if (key_m < m)      return -1;
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   102
    else if (key_m > m) return 1;
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   103
    else {
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   104
      bool is_virtual = elt->is_virtual();
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   105
      bool key_virtual = key->_is_virtual;
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   106
      if (key_virtual < is_virtual)      return -1;
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   107
      else if (key_virtual > is_virtual) return 1;
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   108
      else                               return 0;
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   109
    }
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   110
  }
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   111
};
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   112
int Compile::intrinsic_insertion_index(ciMethod* m, bool is_virtual, bool& found) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
  for (int i = 1; i < _intrinsics->length(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
    CallGenerator* cg1 = _intrinsics->at(i-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
    CallGenerator* cg2 = _intrinsics->at(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
    assert(cg1->method() != cg2->method()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
           ? cg1->method()     < cg2->method()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
           : cg1->is_virtual() < cg2->is_virtual(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
           "compiler intrinsics list must stay sorted");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
#endif
36315
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   123
  IntrinsicDescPair pair(m, is_virtual);
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   124
  return _intrinsics->find_sorted<IntrinsicDescPair*, IntrinsicDescPair::compare>(&pair, found);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
void Compile::register_intrinsic(CallGenerator* cg) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  if (_intrinsics == NULL) {
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   129
    _intrinsics = new (comp_arena())GrowableArray<CallGenerator*>(comp_arena(), 60, 0, NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  int len = _intrinsics->length();
36315
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   132
  bool found = false;
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   133
  int index = intrinsic_insertion_index(cg->method(), cg->is_virtual(), found);
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   134
  assert(!found, "registering twice");
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   135
  _intrinsics->insert_before(index, cg);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
  assert(find_intrinsic(cg->method(), cg->is_virtual()) == cg, "registration worked");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
CallGenerator* Compile::find_intrinsic(ciMethod* m, bool is_virtual) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
  assert(m->is_loaded(), "don't try this on unloaded methods");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  if (_intrinsics != NULL) {
36315
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   142
    bool found = false;
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   143
    int index = intrinsic_insertion_index(m, is_virtual, found);
150a415079ae 8007986: GrowableArray should implement binary search
roland
parents: 35576
diff changeset
   144
     if (found) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
      return _intrinsics->at(index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  // Lazily create intrinsics for intrinsic IDs well-known in the runtime.
3273
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2259
diff changeset
   149
  if (m->intrinsic_id() != vmIntrinsics::_none &&
6acf7084b1d3 6862576: vmIntrinsics needs cleanup in order to support JSR 292 intrinsics
jrose
parents: 2259
diff changeset
   150
      m->intrinsic_id() <= vmIntrinsics::LAST_COMPILER_INLINE) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
    CallGenerator* cg = make_vm_intrinsic(m, is_virtual);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
    if (cg != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
      // Save it for next time:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
      register_intrinsic(cg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
      return cg;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
      gather_intrinsic_statistics(m->intrinsic_id(), is_virtual, _intrinsic_disabled);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
// Compile:: register_library_intrinsics and make_vm_intrinsic are defined
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
// in library_call.cpp.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
// statistics gathering...
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
juint  Compile::_intrinsic_hist_count[vmIntrinsics::ID_LIMIT] = {0};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
jubyte Compile::_intrinsic_hist_flags[vmIntrinsics::ID_LIMIT] = {0};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
bool Compile::gather_intrinsic_statistics(vmIntrinsics::ID id, bool is_virtual, int flags) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
  assert(id > vmIntrinsics::_none && id < vmIntrinsics::ID_LIMIT, "oob");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
  int oflags = _intrinsic_hist_flags[id];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
  assert(flags != 0, "what happened?");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
  if (is_virtual) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
    flags |= _intrinsic_virtual;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  bool changed = (flags != oflags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  if ((flags & _intrinsic_worked) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
    juint count = (_intrinsic_hist_count[id] += 1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
    if (count == 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
      changed = true;           // first time
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
    // increment the overall count also:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
    _intrinsic_hist_count[vmIntrinsics::_none] += 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
  if (changed) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
    if (((oflags ^ flags) & _intrinsic_virtual) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
      // Something changed about the intrinsic's virtuality.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
      if ((flags & _intrinsic_virtual) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
        // This is the first use of this intrinsic as a virtual call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
        if (oflags != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
          // We already saw it as a non-virtual, so note both cases.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
          flags |= _intrinsic_both;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
      } else if ((oflags & _intrinsic_both) == 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
        // This is the first use of this intrinsic as a non-virtual
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
        flags |= _intrinsic_both;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
    _intrinsic_hist_flags[id] = (jubyte) (oflags | flags);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  // update the overall flags also:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  _intrinsic_hist_flags[vmIntrinsics::_none] |= (jubyte) flags;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  return changed;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
static char* format_flags(int flags, char* buf) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
  buf[0] = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
  if ((flags & Compile::_intrinsic_worked) != 0)    strcat(buf, ",worked");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
  if ((flags & Compile::_intrinsic_failed) != 0)    strcat(buf, ",failed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  if ((flags & Compile::_intrinsic_disabled) != 0)  strcat(buf, ",disabled");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  if ((flags & Compile::_intrinsic_virtual) != 0)   strcat(buf, ",virtual");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  if ((flags & Compile::_intrinsic_both) != 0)      strcat(buf, ",nonvirtual");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  if (buf[0] == 0)  strcat(buf, ",");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
  assert(buf[0] == ',', "must be");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
  return &buf[1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
void Compile::print_intrinsic_statistics() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  char flagsbuf[100];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  ttyLocker ttyl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  if (xtty != NULL)  xtty->head("statistics type='intrinsic'");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  tty->print_cr("Compiler intrinsic usage:");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  juint total = _intrinsic_hist_count[vmIntrinsics::_none];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  if (total == 0)  total = 1;  // avoid div0 in case of no successes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
  #define PRINT_STAT_LINE(name, c, f) \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
    tty->print_cr("  %4d (%4.1f%%) %s (%s)", (int)(c), ((c) * 100.0) / total, name, f);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
  for (int index = 1 + (int)vmIntrinsics::_none; index < (int)vmIntrinsics::ID_LIMIT; index++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
    vmIntrinsics::ID id = (vmIntrinsics::ID) index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
    int   flags = _intrinsic_hist_flags[id];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
    juint count = _intrinsic_hist_count[id];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
    if ((flags | count) != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
      PRINT_STAT_LINE(vmIntrinsics::name_at(id), count, format_flags(flags, flagsbuf));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  PRINT_STAT_LINE("total", total, format_flags(_intrinsic_hist_flags[vmIntrinsics::_none], flagsbuf));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  if (xtty != NULL)  xtty->tail("statistics");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
void Compile::print_statistics() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
  { ttyLocker ttyl;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
    if (xtty != NULL)  xtty->head("statistics type='opto'");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
    Parse::print_statistics();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
    PhaseCCP::print_statistics();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
    PhaseRegAlloc::print_statistics();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
    Scheduling::print_statistics();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
    PhasePeephole::print_statistics();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
    PhaseIdealLoop::print_statistics();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
    if (xtty != NULL)  xtty->tail("statistics");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  if (_intrinsic_hist_flags[vmIntrinsics::_none] != 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
    // put this under its own <statistics> element.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
    print_intrinsic_statistics();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
#endif //PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
// Support for bundling info
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
Bundle* Compile::node_bundling(const Node *n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  assert(valid_bundle_info(n), "oob");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  return &_node_bundling_base[n->_idx];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
bool Compile::valid_bundle_info(const Node *n) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  return (_node_bundling_limit > n->_idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   272
void Compile::gvn_replace_by(Node* n, Node* nn) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   273
  for (DUIterator_Last imin, i = n->last_outs(imin); i >= imin; ) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   274
    Node* use = n->last_out(i);
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   275
    bool is_in_table = initial_gvn()->hash_delete(use);
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   276
    uint uses_found = 0;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   277
    for (uint j = 0; j < use->len(); j++) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   278
      if (use->in(j) == n) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   279
        if (j < use->req())
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   280
          use->set_req(j, nn);
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   281
        else
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   282
          use->set_prec(j, nn);
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   283
        uses_found++;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   284
      }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   285
    }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   286
    if (is_in_table) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   287
      // reinsert into table
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   288
      initial_gvn()->hash_find_insert(use);
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   289
    }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   290
    record_for_igvn(use);
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   291
    i -= uses_found;    // we deleted 1 or more copies of this edge
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   292
  }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   293
}
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   294
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   295
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   296
static inline bool not_a_node(const Node* n) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   297
  if (n == NULL)                   return true;
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   298
  if (((intptr_t)n & 1) != 0)      return true;  // uninitialized, etc.
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   299
  if (*(address*)n == badAddress)  return true;  // kill by Node::destruct
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   300
  return false;
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   301
}
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   302
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
// Identify all nodes that are reachable from below, useful.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
// Use breadth-first pass that records state in a Unique_Node_List,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
// recursive traversal is slower.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
void Compile::identify_useful_nodes(Unique_Node_List &useful) {
33158
f4e6c593ba73 8137160: Use Compile::live_nodes instead of Compile::unique() in appropriate places -- followup
zmajo
parents: 33065
diff changeset
   307
  int estimated_worklist_size = live_nodes();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
  useful.map( estimated_worklist_size, NULL );  // preallocate space
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
  // Initialize worklist
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
  if (root() != NULL)     { useful.push(root()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  // If 'top' is cached, declare it useful to preserve cached node
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  if( cached_top_node() ) { useful.push(cached_top_node()); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  // Push all useful nodes onto the list, breadthfirst
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  for( uint next = 0; next < useful.size(); ++next ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
    assert( next < unique(), "Unique useful nodes < total nodes");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
    Node *n  = useful.at(next);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
    uint max = n->len();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
    for( uint i = 0; i < max; ++i ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
      Node *m = n->in(i);
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   322
      if (not_a_node(m))  continue;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
      useful.push(m);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   328
// Update dead_node_list with any missing dead nodes using useful
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   329
// list. Consider all non-useful nodes to be useless i.e., dead nodes.
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   330
void Compile::update_dead_node_list(Unique_Node_List &useful) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   331
  uint max_idx = unique();
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   332
  VectorSet& useful_node_set = useful.member_set();
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   333
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   334
  for (uint node_idx = 0; node_idx < max_idx; node_idx++) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   335
    // If node with index node_idx is not in useful set,
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   336
    // mark it as dead in dead node list.
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   337
    if (! useful_node_set.test(node_idx) ) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   338
      record_dead_node(node_idx);
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   339
    }
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   340
  }
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   341
}
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   342
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   343
void Compile::remove_useless_late_inlines(GrowableArray<CallGenerator*>* inlines, Unique_Node_List &useful) {
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   344
  int shift = 0;
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   345
  for (int i = 0; i < inlines->length(); i++) {
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   346
    CallGenerator* cg = inlines->at(i);
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   347
    CallNode* call = cg->call_node();
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   348
    if (shift > 0) {
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   349
      inlines->at_put(i-shift, cg);
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   350
    }
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   351
    if (!useful.member(call)) {
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   352
      shift++;
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   353
    }
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   354
  }
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   355
  inlines->trunc_to(inlines->length()-shift);
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   356
}
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   357
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
// Disconnect all useless nodes by disconnecting those at the boundary.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
void Compile::remove_useless_nodes(Unique_Node_List &useful) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
  uint next = 0;
10988
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
   361
  while (next < useful.size()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
    Node *n = useful.at(next++);
24946
24b68ccf3fc4 8026796: Make replace_in_map() on parent maps generic
roland
parents: 24923
diff changeset
   363
    if (n->is_SafePoint()) {
24b68ccf3fc4 8026796: Make replace_in_map() on parent maps generic
roland
parents: 24923
diff changeset
   364
      // We're done with a parsing phase. Replaced nodes are not valid
24b68ccf3fc4 8026796: Make replace_in_map() on parent maps generic
roland
parents: 24923
diff changeset
   365
      // beyond that point.
24b68ccf3fc4 8026796: Make replace_in_map() on parent maps generic
roland
parents: 24923
diff changeset
   366
      n->as_SafePoint()->delete_replaced_nodes();
24b68ccf3fc4 8026796: Make replace_in_map() on parent maps generic
roland
parents: 24923
diff changeset
   367
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
    // Use raw traversal of out edges since this code removes out edges
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
    int max = n->outcnt();
10988
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
   370
    for (int j = 0; j < max; ++j) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
      Node* child = n->raw_out(j);
10988
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
   372
      if (! useful.member(child)) {
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
   373
        assert(!child->is_top() || child != top(),
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
   374
               "If top is cached in Compile object it is in useful list");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
        // Only need to remove this out-edge to the useless node
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
        n->raw_del_out(j);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
        --j;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
        --max;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
    if (n->outcnt() == 1 && n->has_special_unique_user()) {
10988
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
   382
      record_for_igvn(n->unique_out());
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
   383
    }
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
   384
  }
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
   385
  // Remove useless macro and predicate opaq nodes
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
   386
  for (int i = C->macro_count()-1; i >= 0; i--) {
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
   387
    Node* n = C->macro_node(i);
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
   388
    if (!useful.member(n)) {
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
   389
      remove_macro_node(n);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  }
35574
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
   392
  // Remove useless CastII nodes with range check dependency
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
   393
  for (int i = range_check_cast_count() - 1; i >= 0; i--) {
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
   394
    Node* cast = range_check_cast_node(i);
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
   395
    if (!useful.member(cast)) {
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
   396
      remove_range_check_cast(cast);
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
   397
    }
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
   398
  }
15618
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
   399
  // Remove useless expensive node
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
   400
  for (int i = C->expensive_count()-1; i >= 0; i--) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
   401
    Node* n = C->expensive_node(i);
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
   402
    if (!useful.member(n)) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
   403
      remove_expensive_node(n);
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
   404
    }
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
   405
  }
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   406
  // clean up the late inline lists
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   407
  remove_useless_late_inlines(&_string_late_inlines, useful);
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
   408
  remove_useless_late_inlines(&_boxing_late_inlines, useful);
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   409
  remove_useless_late_inlines(&_late_inlines, useful);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
  debug_only(verify_graph_edges(true/*check for no_dead_code*/);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
//------------------------------frame_size_in_words-----------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
// frame_slots in units of words
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
int Compile::frame_size_in_words() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
  // shift is 0 in LP32 and 1 in LP64
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
  const int shift = (LogBytesPerWord - LogBytesPerInt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
  int words = _frame_slots >> shift;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
  assert( words << shift == _frame_slots, "frame size must be properly aligned in LP64" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
  return words;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
24018
77b156916bab 8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents: 24002
diff changeset
   423
// To bang the stack of this compiled method we use the stack size
77b156916bab 8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents: 24002
diff changeset
   424
// that the interpreter would need in case of a deoptimization. This
77b156916bab 8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents: 24002
diff changeset
   425
// removes the need to bang the stack in the deoptimization blob which
77b156916bab 8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents: 24002
diff changeset
   426
// in turn simplifies stack overflow handling.
77b156916bab 8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents: 24002
diff changeset
   427
int Compile::bang_size_in_bytes() const {
26576
a9429d24d429 8050147: StoreLoad barrier interferes with stack usages
shade
parents: 26175
diff changeset
   428
  return MAX2(frame_size_in_bytes() + os::extra_bang_size_in_bytes(), _interpreter_frame_size);
24018
77b156916bab 8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents: 24002
diff changeset
   429
}
77b156916bab 8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents: 24002
diff changeset
   430
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
// ============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
//------------------------------CompileWrapper---------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
class CompileWrapper : public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
  Compile *const _compile;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
 public:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
  CompileWrapper(Compile* compile);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
  ~CompileWrapper();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
CompileWrapper::CompileWrapper(Compile* compile) : _compile(compile) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
  // the Compile* pointer is stored in the current ciEnv:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
  ciEnv* env = compile->env();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
  assert(env == ciEnv::current(), "must already be a ciEnv active");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
  assert(env->compiler_data() == NULL, "compile already active?");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
  env->set_compiler_data(compile);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  assert(compile == Compile::current(), "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
  compile->set_type_dict(NULL);
30593
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
   450
  compile->set_clone_map(new Dict(cmpkey, hashkey, _compile->comp_arena()));
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
   451
  compile->clone_map().set_clone_idx(0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  compile->set_type_hwm(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
  compile->set_type_last_size(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  compile->set_last_tf(NULL, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
  compile->set_indexSet_arena(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
  compile->set_indexSet_free_block_list(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
  compile->init_type_arena();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
  Type::Initialize(compile);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
  _compile->set_scratch_buffer_blob(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  _compile->begin_method();
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   461
  _compile->clone_map().set_debug(_compile->has_method() && _compile->directive()->CloneMapDebugOption);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
CompileWrapper::~CompileWrapper() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  _compile->end_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  if (_compile->scratch_buffer_blob() != NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
    BufferBlob::free(_compile->scratch_buffer_blob());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  _compile->env()->set_compiler_data(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
//----------------------------print_compile_messages---------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
void Compile::print_compile_messages() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
  // Check if recompiling
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
  if (_subsume_loads == false && PrintOpto) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
    // Recompiling without allowing machine instructions to subsume loads
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
    tty->print_cr("*********************************************************");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
    tty->print_cr("** Bailout: Recompile without subsuming loads          **");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
    tty->print_cr("*********************************************************");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
  }
211
e2b60448c234 6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents: 1
diff changeset
   481
  if (_do_escape_analysis != DoEscapeAnalysis && PrintOpto) {
e2b60448c234 6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents: 1
diff changeset
   482
    // Recompiling without escape analysis
e2b60448c234 6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents: 1
diff changeset
   483
    tty->print_cr("*********************************************************");
e2b60448c234 6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents: 1
diff changeset
   484
    tty->print_cr("** Bailout: Recompile without escape analysis          **");
e2b60448c234 6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents: 1
diff changeset
   485
    tty->print_cr("*********************************************************");
e2b60448c234 6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents: 1
diff changeset
   486
  }
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
   487
  if (_eliminate_boxing != EliminateAutoBox && PrintOpto) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
   488
    // Recompiling without boxing elimination
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
   489
    tty->print_cr("*********************************************************");
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
   490
    tty->print_cr("** Bailout: Recompile without boxing elimination       **");
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
   491
    tty->print_cr("*********************************************************");
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
   492
  }
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   493
  if (C->directive()->BreakAtCompileOption) {
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 2022
diff changeset
   494
    // Open the debugger when compiling this method.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
    tty->print("### Breaking when compiling: ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
    method()->print_short_name();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
    tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
    BREAKPOINT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
  if( PrintOpto ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
    if (is_osr_compilation()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
      tty->print("[OSR]%3d", _compile_id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
      tty->print("%3d", _compile_id);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
7715
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   512
//-----------------------init_scratch_buffer_blob------------------------------
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   513
// Construct a temporary BufferBlob and cache it for this compile.
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   514
void Compile::init_scratch_buffer_blob(int const_size) {
7715
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   515
  // If there is already a scratch buffer blob allocated and the
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   516
  // constant section is big enough, use it.  Otherwise free the
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   517
  // current and allocate a new one.
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   518
  BufferBlob* blob = scratch_buffer_blob();
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   519
  if ((blob != NULL) && (const_size <= _scratch_const_size)) {
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   520
    // Use the current blob.
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   521
  } else {
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   522
    if (blob != NULL) {
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   523
      BufferBlob::free(blob);
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   524
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
7715
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   526
    ResourceMark rm;
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   527
    _scratch_const_size = const_size;
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   528
    int size = (MAX_inst_size + MAX_stubs_size + _scratch_const_size);
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   529
    blob = BufferBlob::create("Compile::scratch_buffer", size);
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   530
    // Record the buffer blob for next time.
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   531
    set_scratch_buffer_blob(blob);
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   532
    // Have we run out of code space?
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   533
    if (scratch_buffer_blob() == NULL) {
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   534
      // Let CompilerBroker disable further compilations.
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   535
      record_failure("Not enough space for scratch buffer in CodeCache");
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   536
      return;
12998f95a334 7008325: CodeCache exhausted on sparc starting from hs20b04
kvn
parents: 7433
diff changeset
   537
    }
589
a44a1e70a3e4 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 374
diff changeset
   538
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
  // Initialize the relocation buffers
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6180
diff changeset
   541
  relocInfo* locs_buf = (relocInfo*) blob->content_end() - MAX_locs_size;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  set_scratch_locs_memory(locs_buf);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
//-----------------------scratch_emit_size-------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
// Helper function that computes size by emitting code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
uint Compile::scratch_emit_size(const Node* n) {
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   549
  // Start scratch_emit_size section.
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   550
  set_in_scratch_emit_size(true);
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   551
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  // Emit into a trash buffer and count bytes emitted.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  // This is a pretty expensive way to compute a size,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
  // but it works well enough if seldom used.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
  // All common fixed-size instructions are given a size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  // method by the AD file.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  // Note that the scratch buffer blob and locs memory are
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  // allocated at the beginning of the compile task, and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  // may be shared by several calls to scratch_emit_size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
  // The allocation of the scratch buffer blob is particularly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
  // expensive, since it has to grab the code cache lock.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
  BufferBlob* blob = this->scratch_buffer_blob();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
  assert(blob != NULL, "Initialize BufferBlob at start");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  assert(blob->size() > MAX_inst_size, "sanity");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
  relocInfo* locs_buf = scratch_locs_memory();
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6180
diff changeset
   566
  address blob_begin = blob->content_begin();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
  address blob_end   = (address)locs_buf;
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 38131
diff changeset
   568
  assert(blob->contains(blob_end), "sanity");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
  CodeBuffer buf(blob_begin, blob_end - blob_begin);
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   570
  buf.initialize_consts_size(_scratch_const_size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
  buf.initialize_stubs_size(MAX_stubs_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  assert(locs_buf != NULL, "sanity");
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   573
  int lsize = MAX_locs_size / 3;
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   574
  buf.consts()->initialize_shared_locs(&locs_buf[lsize * 0], lsize);
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   575
  buf.insts()->initialize_shared_locs( &locs_buf[lsize * 1], lsize);
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   576
  buf.stubs()->initialize_shared_locs( &locs_buf[lsize * 2], lsize);
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   577
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   578
  // Do the emission.
10252
0981ce1c3eef 7063628: Use cbcond on T4
kvn
parents: 10012
diff changeset
   579
0981ce1c3eef 7063628: Use cbcond on T4
kvn
parents: 10012
diff changeset
   580
  Label fakeL; // Fake label for branch instructions.
10266
2ea344c79e33 7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents: 10252
diff changeset
   581
  Label*   saveL = NULL;
2ea344c79e33 7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents: 10252
diff changeset
   582
  uint save_bnum = 0;
2ea344c79e33 7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents: 10252
diff changeset
   583
  bool is_branch = n->is_MachBranch();
10252
0981ce1c3eef 7063628: Use cbcond on T4
kvn
parents: 10012
diff changeset
   584
  if (is_branch) {
0981ce1c3eef 7063628: Use cbcond on T4
kvn
parents: 10012
diff changeset
   585
    MacroAssembler masm(&buf);
0981ce1c3eef 7063628: Use cbcond on T4
kvn
parents: 10012
diff changeset
   586
    masm.bind(fakeL);
10266
2ea344c79e33 7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents: 10252
diff changeset
   587
    n->as_MachBranch()->save_label(&saveL, &save_bnum);
2ea344c79e33 7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents: 10252
diff changeset
   588
    n->as_MachBranch()->label_set(&fakeL, 0);
10252
0981ce1c3eef 7063628: Use cbcond on T4
kvn
parents: 10012
diff changeset
   589
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
  n->emit(buf, this->regalloc());
32082
2a3323e25de1 8130309: Need to bailout cleanly if creation of stubs fails when codecache is out of space
thartmann
parents: 31228
diff changeset
   591
2a3323e25de1 8130309: Need to bailout cleanly if creation of stubs fails when codecache is out of space
thartmann
parents: 31228
diff changeset
   592
  // Emitting into the scratch buffer should not fail
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32202
diff changeset
   593
  assert (!failing(), "Must not have pending failure. Reason is: %s", failure_reason());
32082
2a3323e25de1 8130309: Need to bailout cleanly if creation of stubs fails when codecache is out of space
thartmann
parents: 31228
diff changeset
   594
10266
2ea344c79e33 7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents: 10252
diff changeset
   595
  if (is_branch) // Restore label.
2ea344c79e33 7079317: Incorrect branch's destination block in PrintoOptoAssembly output
kvn
parents: 10252
diff changeset
   596
    n->as_MachBranch()->label_set(saveL, save_bnum);
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   597
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   598
  // End scratch_emit_size section.
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   599
  set_in_scratch_emit_size(false);
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   600
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6180
diff changeset
   601
  return buf.insts_size();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
// ============================================================================
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
//------------------------------Compile standard-------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
debug_only( int Compile::_debug_idx = 100000; )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
// Compile a method.  entry_bci is -1 for normal compilations and indicates
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
// the continuation bci for on stack replacement.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
   613
Compile::Compile( ciEnv* ci_env, C2Compiler* compiler, ciMethod* target, int osr_bci,
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   614
                  bool subsume_loads, bool do_escape_analysis, bool eliminate_boxing, DirectiveSet* directive)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
                : Phase(Compiler),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
                  _env(ci_env),
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   617
                  _directive(directive),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
                  _log(ci_env->log()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
                  _compile_id(ci_env->compile_id()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
                  _save_argument_registers(false),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
                  _stub_name(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
                  _stub_function(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
                  _stub_entry_point(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
                  _method(target),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
                  _entry_bci(osr_bci),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
                  _initial_gvn(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
                  _for_igvn(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
                  _warm_calls(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
                  _subsume_loads(subsume_loads),
211
e2b60448c234 6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents: 1
diff changeset
   630
                  _do_escape_analysis(do_escape_analysis),
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
   631
                  _eliminate_boxing(eliminate_boxing),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
                  _failure_reason(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
                  _code_buffer("Compile::Fill_buffer"),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
                  _orig_pc_slot(0),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
                  _orig_pc_slot_offset_in_bytes(0),
4906
90640ad2d401 6926782: CodeBuffer size too small after 6921352
twisti
parents: 4643
diff changeset
   636
                  _has_method_handle_invokes(false),
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   637
                  _mach_constant_base_node(NULL),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
                  _node_bundling_limit(0),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
                  _node_bundling_base(NULL),
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
   640
                  _java_calls(0),
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
   641
                  _inner_loops(0),
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   642
                  _scratch_const_size(-1),
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   643
                  _in_scratch_emit_size(false),
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   644
                  _dead_node_list(comp_arena()),
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   645
                  _dead_node_count(0),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
#ifndef PRODUCT
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   647
                  _trace_opto_output(directive->TraceOptoOutputOption),
22854
2787e48d6df9 8029025: PPC64 (part 203): opto: Move static _in_dump_cnt to Compile object.
goetz
parents: 22851
diff changeset
   648
                  _in_dump_cnt(0),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
                  _printer(IdealGraphPrinter::printer()),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
#endif
14828
bb9dffedf46c 8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents: 14626
diff changeset
   651
                  _congraph(NULL),
25946
1572c9f03fb9 8046598: Scalable Native memory tracking development
zgu
parents: 25716
diff changeset
   652
                  _comp_arena(mtCompiler),
1572c9f03fb9 8046598: Scalable Native memory tracking development
zgu
parents: 25716
diff changeset
   653
                  _node_arena(mtCompiler),
1572c9f03fb9 8046598: Scalable Native memory tracking development
zgu
parents: 25716
diff changeset
   654
                  _old_arena(mtCompiler),
1572c9f03fb9 8046598: Scalable Native memory tracking development
zgu
parents: 25716
diff changeset
   655
                  _Compile_types(mtCompiler),
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
   656
                  _replay_inline_data(NULL),
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   657
                  _late_inlines(comp_arena(), 2, 0, NULL),
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   658
                  _string_late_inlines(comp_arena(), 2, 0, NULL),
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
   659
                  _boxing_late_inlines(comp_arena(), 2, 0, NULL),
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   660
                  _late_inlines_pos(0),
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   661
                  _number_of_mh_late_inlines(0),
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   662
                  _inlining_progress(false),
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   663
                  _inlining_incrementally(false),
14828
bb9dffedf46c 8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents: 14626
diff changeset
   664
                  _print_inlining_list(NULL),
23846
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
   665
                  _print_inlining_stream(NULL),
21089
e1986ff6fe2e 8024069: replace_in_map() should operate on parent maps
roland
parents: 20715
diff changeset
   666
                  _print_inlining_idx(0),
24673
2ec56802b829 8043638: Multiple compilation attempts break LogCompulation, lead to confusing PrintInlining output
roland
parents: 24442
diff changeset
   667
                  _print_inlining_output(NULL),
27707
f7d26e5b8b5d 8058148: MaxNodeLimit and LiveNodeCountInliningCutoff
vlivanov
parents: 27706
diff changeset
   668
                  _interpreter_frame_size(0),
35071
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34503
diff changeset
   669
                  _max_node_limit(MaxNodeLimit),
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34503
diff changeset
   670
                  _has_reserved_stack_access(target->has_reserved_stack_access()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
  C = this;
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   672
#ifndef PRODUCT
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   673
  if (_printer != NULL) {
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   674
    _printer->set_compile(this);
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   675
  }
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   676
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
  CompileWrapper cw(this);
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
   678
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
   679
  if (CITimeVerbose) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
    tty->print(" ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
    target->holder()->name()->print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
    tty->print(".");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
    target->print_short_name();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
    tty->print("  ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
  }
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
   686
  TraceTime t1("Total compilation time", &_t_totalCompilation, CITime, CITimeVerbose);
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
   687
  TraceTime t2(NULL, &_t_methodCompilation, CITime, false);
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
   688
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
   689
#ifndef PRODUCT
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   690
  bool print_opto_assembly = directive->PrintOptoAssemblyOption;
347
df859fcca515 6667042: PrintAssembly option does not work without special plugin
jrose
parents: 238
diff changeset
   691
  if (!print_opto_assembly) {
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   692
    bool print_assembly = directive->PrintAssemblyOption;
347
df859fcca515 6667042: PrintAssembly option does not work without special plugin
jrose
parents: 238
diff changeset
   693
    if (print_assembly && !Disassembler::can_decode()) {
df859fcca515 6667042: PrintAssembly option does not work without special plugin
jrose
parents: 238
diff changeset
   694
      tty->print_cr("PrintAssembly request changed to PrintOptoAssembly");
df859fcca515 6667042: PrintAssembly option does not work without special plugin
jrose
parents: 238
diff changeset
   695
      print_opto_assembly = true;
df859fcca515 6667042: PrintAssembly option does not work without special plugin
jrose
parents: 238
diff changeset
   696
    }
df859fcca515 6667042: PrintAssembly option does not work without special plugin
jrose
parents: 238
diff changeset
   697
  }
df859fcca515 6667042: PrintAssembly option does not work without special plugin
jrose
parents: 238
diff changeset
   698
  set_print_assembly(print_opto_assembly);
1399
9648dfd4ce09 6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents: 1137
diff changeset
   699
  set_parsed_irreducible_loop(false);
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
   700
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   701
  if (directive->ReplayInlineOption) {
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
   702
    _replay_inline_data = ciReplay::load_inline_data(method(), entry_bci(), ci_env->comp_level());
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
   703
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
#endif
34174
4db2fb26dc49 8140424: don't prefix developer and notproduct flag variables with CONST_ in product builds
twisti
parents: 34164
diff changeset
   705
  set_print_inlining(directive->PrintInliningOption || PrintOptoInlining);
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   706
  set_print_intrinsics(directive->PrintIntrinsicsOption);
24342
34e1384b02db 8039298: assert(base == NULL || t_adr->isa_rawptr() || !phase->type(base)->higher_equal(TypePtr::NULL_PTR))
kvn
parents: 24018
diff changeset
   707
  set_has_irreducible_loop(true); // conservative until build_loop_tree() reset it
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
   709
  if (ProfileTraps RTM_OPT_ONLY( || UseRTMLocking )) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
    // Make sure the method being compiled gets its own MDO,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
    // so we can at least track the decompile_count().
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
   712
    // Need MDO to record RTM code generation state.
7432
f06f1253c317 7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents: 7397
diff changeset
   713
    method()->ensure_method_data();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
  Init(::AliasLevel);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
  print_compile_messages();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
22800
fbb2ab3f06ec 8032490: Remove -XX:+-UseOldInlining
shade
parents: 22799
diff changeset
   721
  _ilt = InlineTree::build_inline_tree_root();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
  // Even if NO memory addresses are used, MergeMem nodes must have at least 1 slice
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
  assert(num_alias_types() >= AliasIdxRaw, "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
#define MINIMUM_NODE_HASH  1023
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
  // Node list that Iterative GVN will start with
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
  Unique_Node_List for_igvn(comp_arena());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  set_for_igvn(&for_igvn);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
  // GVN that will be run immediately on new nodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
  uint estimated_size = method()->code_size()*4+64;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
  estimated_size = (estimated_size < MINIMUM_NODE_HASH ? MINIMUM_NODE_HASH : estimated_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
  PhaseGVN gvn(node_arena(), estimated_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
  set_initial_gvn(&gvn);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
23846
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
   737
  print_inlining_init();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
  { // Scope for timing the parser
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
   739
    TracePhase tp("parse", &timers[_t_parser]);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
    // Put top into the hash table ASAP.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
    initial_gvn()->transform_no_reclaim(top());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
    // Set up tf(), start(), and find a CallGenerator.
9176
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   745
    CallGenerator* cg = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
    if (is_osr_compilation()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
      const TypeTuple *domain = StartOSRNode::osr_domain();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
      const TypeTuple *range = TypeTuple::make_range(method()->signature());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
      init_tf(TypeFunc::make(domain, range));
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 24673
diff changeset
   750
      StartNode* s = new StartOSRNode(root(), domain);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
      initial_gvn()->set_type_bottom(s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
      init_start(s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
      cg = CallGenerator::for_osr(method(), entry_bci());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
      // Normal case.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
      init_tf(TypeFunc::make(method()));
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 24673
diff changeset
   757
      StartNode* s = new StartNode(root(), tf()->domain());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
      initial_gvn()->set_type_bottom(s);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
      init_start(s);
9176
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   760
      if (method()->intrinsic_id() == vmIntrinsics::_Reference_get && UseG1GC) {
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   761
        // With java.lang.ref.reference.get() we must go through the
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   762
        // intrinsic when G1 is enabled - even when get() is the root
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   763
        // method of the compile - so that, if necessary, the value in
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   764
        // the referent field of the reference object gets recorded by
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   765
        // the pre-barrier code.
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   766
        // Specifically, if G1 is enabled, the value in the referent
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   767
        // field is recorded by the G1 SATB pre barrier. This will
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   768
        // result in the referent being marked live and the reference
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   769
        // object removed from the list of discovered references during
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   770
        // reference processing.
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   771
        cg = find_intrinsic(method(), false);
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   772
      }
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   773
      if (cg == NULL) {
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   774
        float past_uses = method()->interpreter_invocation_count();
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   775
        float expected_uses = past_uses;
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   776
        cg = CallGenerator::for_inline(method(), expected_uses);
42d9d1010f38 7009266: G1: assert(obj->is_oop_or_null(true )) failed: Error
johnc
parents: 9175
diff changeset
   777
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
    if (failing())  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
    if (cg == NULL) {
39431
cb1b2538c4b2 8159720: Failure of C2 compilation with tiered prevents some C1 compilations.
cvarming
parents: 39419
diff changeset
   781
      record_method_not_compilable("cannot parse method");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
    JVMState* jvms = build_start_state(start(), tf());
24946
24b68ccf3fc4 8026796: Make replace_in_map() on parent maps generic
roland
parents: 24923
diff changeset
   785
    if ((jvms = cg->generate(jvms)) == NULL) {
28395
fbe08d791778 8055530: assert(_exits.control()->is_top() || !_gvn.type(ret_phi)->empty()) failed: return value must be well defined
roland
parents: 27707
diff changeset
   786
      if (!failure_reason_is(C2Compiler::retry_class_loading_during_parsing())) {
fbe08d791778 8055530: assert(_exits.control()->is_top() || !_gvn.type(ret_phi)->empty()) failed: return value must be well defined
roland
parents: 27707
diff changeset
   787
        record_method_not_compilable("method parse failed");
fbe08d791778 8055530: assert(_exits.control()->is_top() || !_gvn.type(ret_phi)->empty()) failed: return value must be well defined
roland
parents: 27707
diff changeset
   788
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
    GraphKit kit(jvms);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
    if (!kit.stopped()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
      // Accept return values, and transfer control we know not where.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
      // This is done by a special, unique ReturnNode bound to root.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
      return_values(kit.jvms());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
    if (kit.has_exceptions()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
      // Any exceptions that escape from this call must be rethrown
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
      // to whatever caller is dynamically above us on the stack.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
      // This is done by a special, unique RethrowNode bound to root.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
      rethrow_exceptions(kit.transfer_exceptions_into_jvms());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   806
    assert(IncrementalInline || (_late_inlines.length() == 0 && !has_mh_late_inlines()), "incremental inlining is off");
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   807
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   808
    if (_late_inlines.length() == 0 && !has_mh_late_inlines() && !failing() && has_stringbuilder()) {
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   809
      inline_string_calls(true);
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   810
    }
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   811
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   812
    if (failing())  return;
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
   813
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
   814
    print_method(PHASE_BEFORE_REMOVEUSELESS, 3);
1399
9648dfd4ce09 6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents: 1137
diff changeset
   815
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
    // Remove clutter produced by parsing.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
    if (!failing()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
      ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
      PhaseRemoveUseless pru(initial_gvn(), &for_igvn);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
  // Note:  Large methods are capped off in do_one_bytecode().
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
  if (failing())  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
  // After parsing, node notes are no longer automagic.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
  // They must be propagated by register_new_node_with_optimizer(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
  // clone(), or the like.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
  set_default_node_notes(NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
  for (;;) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
    int successes = Inline_Warm();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
    if (failing())  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
    if (successes == 0)  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
  // Drain the list.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
  Finish_Warm();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
#ifndef PRODUCT
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   840
  if (_printer && _printer->should_print(1)) {
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   841
    _printer->print_inlining();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
  if (failing())  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
  NOT_PRODUCT( verify_graph_edges(); )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
  // Now optimize
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
  Optimize();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
  if (failing())  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
  NOT_PRODUCT( verify_graph_edges(); )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
  if (PrintIdeal) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
    ttyLocker ttyl;  // keep the following output all in one block
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
    // This output goes directly to the tty, not the compiler log.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
    // To enable tools to match it up with the compilation activity,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
    // be sure to tag this tty output with the compile ID.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
    if (xtty != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
      xtty->head("ideal compile_id='%d'%s", compile_id(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
                 is_osr_compilation()    ? " compile_kind='osr'" :
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
                 "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
    root()->dump(9999);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
    if (xtty != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
      xtty->tail("ideal");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
21526
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
   871
  NOT_PRODUCT( verify_barriers(); )
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
   872
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
   873
  // Dump compilation data to replay it.
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   874
  if (directive->DumpReplayOption) {
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
   875
    env()->dump_replay_data(_compile_id);
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
   876
  }
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   877
  if (directive->DumpInlineOption && (ilt() != NULL)) {
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
   878
    env()->dump_inline_data(_compile_id);
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
   879
  }
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
   880
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
  // Now that we know the size of all the monitors we can add a fixed slot
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
  // for the original deopt pc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
  _orig_pc_slot =  fixed_slots();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
  int next_slot = _orig_pc_slot + (sizeof(address) / VMRegImpl::stack_slot_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
  set_fixed_slots(next_slot);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
22856
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 22854
diff changeset
   888
  // Compute when to use implicit null checks. Used by matching trap based
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 22854
diff changeset
   889
  // nodes and NullCheck optimization.
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 22854
diff changeset
   890
  set_allowed_deopt_reasons();
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 22854
diff changeset
   891
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
  // Now generate code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
  Code_Gen();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
  if (failing())  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
  // Check if we want to skip execution of all compiled code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
    if (OptoNoExecute) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
      record_method_not_compilable("+OptoNoExecute");  // Flag as failed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
#endif
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
   904
    TracePhase tp("install_code", &timers[_t_registerMethod]);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
    if (is_osr_compilation()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
      _code_offsets.set_value(CodeOffsets::Verified_Entry, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
      _code_offsets.set_value(CodeOffsets::OSR_Entry, _first_block_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
      _code_offsets.set_value(CodeOffsets::Verified_Entry, _first_block_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
      _code_offsets.set_value(CodeOffsets::OSR_Entry, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
    env()->register_method(_method, _entry_bci,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
                           &_code_offsets,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
                           _orig_pc_slot_offset_in_bytes,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
                           code_buffer(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
                           frame_size_in_words(), _oop_map_set,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
                           &_handler_table, &_inc_table,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
                           compiler,
13883
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13728
diff changeset
   921
                           has_unsafe_access(),
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
   922
                           SharedRuntime::is_wide_vector(max_vector_size()),
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
   923
                           rtm_state()
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
                           );
13964
01a2b863cc61 7177003: C1: LogCompilation support
vlivanov
parents: 13895
diff changeset
   925
01a2b863cc61 7177003: C1: LogCompilation support
vlivanov
parents: 13895
diff changeset
   926
    if (log() != NULL) // Print code cache state into compiler log
01a2b863cc61 7177003: C1: LogCompilation support
vlivanov
parents: 13895
diff changeset
   927
      log()->code_cache_state();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
//------------------------------Compile----------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
// Compile a runtime stub
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
Compile::Compile( ciEnv* ci_env,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
                  TypeFunc_generator generator,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
                  address stub_function,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
                  const char *stub_name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
                  int is_fancy_jump,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
                  bool pass_tls,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
                  bool save_arg_registers,
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   940
                  bool return_pc,
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   941
                  DirectiveSet* directive)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
  : Phase(Compiler),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
    _env(ci_env),
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
   944
    _directive(directive),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
    _log(ci_env->log()),
15946
f688e7528dc6 8005772: Stubs report compile id -1 in phase events
neliasso
parents: 15874
diff changeset
   946
    _compile_id(0),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
    _save_argument_registers(save_arg_registers),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
    _method(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
    _stub_name(stub_name),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
    _stub_function(stub_function),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
    _stub_entry_point(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
    _entry_bci(InvocationEntryBci),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
    _initial_gvn(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
    _for_igvn(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
    _warm_calls(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
    _orig_pc_slot(0),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
    _orig_pc_slot_offset_in_bytes(0),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
    _subsume_loads(true),
211
e2b60448c234 6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents: 1
diff changeset
   959
    _do_escape_analysis(false),
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
   960
    _eliminate_boxing(false),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
    _failure_reason(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
    _code_buffer("Compile::Fill_buffer"),
4906
90640ad2d401 6926782: CodeBuffer size too small after 6921352
twisti
parents: 4643
diff changeset
   963
    _has_method_handle_invokes(false),
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
   964
    _mach_constant_base_node(NULL),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
    _node_bundling_limit(0),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
    _node_bundling_base(NULL),
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
   967
    _java_calls(0),
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
   968
    _inner_loops(0),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
    _trace_opto_output(TraceOptoOutput),
22854
2787e48d6df9 8029025: PPC64 (part 203): opto: Move static _in_dump_cnt to Compile object.
goetz
parents: 22851
diff changeset
   971
    _in_dump_cnt(0),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
    _printer(NULL),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
#endif
25946
1572c9f03fb9 8046598: Scalable Native memory tracking development
zgu
parents: 25716
diff changeset
   974
    _comp_arena(mtCompiler),
1572c9f03fb9 8046598: Scalable Native memory tracking development
zgu
parents: 25716
diff changeset
   975
    _node_arena(mtCompiler),
1572c9f03fb9 8046598: Scalable Native memory tracking development
zgu
parents: 25716
diff changeset
   976
    _old_arena(mtCompiler),
1572c9f03fb9 8046598: Scalable Native memory tracking development
zgu
parents: 25716
diff changeset
   977
    _Compile_types(mtCompiler),
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   978
    _dead_node_list(comp_arena()),
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
   979
    _dead_node_count(0),
14828
bb9dffedf46c 8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents: 14626
diff changeset
   980
    _congraph(NULL),
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
   981
    _replay_inline_data(NULL),
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   982
    _number_of_mh_late_inlines(0),
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   983
    _inlining_progress(false),
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
   984
    _inlining_incrementally(false),
14828
bb9dffedf46c 8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents: 14626
diff changeset
   985
    _print_inlining_list(NULL),
23846
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
   986
    _print_inlining_stream(NULL),
21089
e1986ff6fe2e 8024069: replace_in_map() should operate on parent maps
roland
parents: 20715
diff changeset
   987
    _print_inlining_idx(0),
24673
2ec56802b829 8043638: Multiple compilation attempts break LogCompulation, lead to confusing PrintInlining output
roland
parents: 24442
diff changeset
   988
    _print_inlining_output(NULL),
24018
77b156916bab 8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents: 24002
diff changeset
   989
    _allowed_reasons(0),
27707
f7d26e5b8b5d 8058148: MaxNodeLimit and LiveNodeCountInliningCutoff
vlivanov
parents: 27706
diff changeset
   990
    _interpreter_frame_size(0),
f7d26e5b8b5d 8058148: MaxNodeLimit and LiveNodeCountInliningCutoff
vlivanov
parents: 27706
diff changeset
   991
    _max_node_limit(MaxNodeLimit) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
  C = this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
   994
  TraceTime t1(NULL, &_t_totalCompilation, CITime, false);
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
   995
  TraceTime t2(NULL, &_t_stubCompilation, CITime, false);
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
   996
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
  set_print_assembly(PrintFrameConverterAssembly);
1399
9648dfd4ce09 6384206: Phis which are later unneeded are impairing our ability to inline based on static types
never
parents: 1137
diff changeset
   999
  set_parsed_irreducible_loop(false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
#endif
24342
34e1384b02db 8039298: assert(base == NULL || t_adr->isa_rawptr() || !phase->type(base)->higher_equal(TypePtr::NULL_PTR))
kvn
parents: 24018
diff changeset
  1001
  set_has_irreducible_loop(false); // no loops
34e1384b02db 8039298: assert(base == NULL || t_adr->isa_rawptr() || !phase->type(base)->higher_equal(TypePtr::NULL_PTR))
kvn
parents: 24018
diff changeset
  1002
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
  CompileWrapper cw(this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
  Init(/*AliasLevel=*/ 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
  init_tf((*generator)());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
    // The following is a dummy for the sake of GraphKit::gen_stub
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
    Unique_Node_List for_igvn(comp_arena());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
    set_for_igvn(&for_igvn);  // not used, but some GraphKit guys push on this
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
    PhaseGVN gvn(Thread::current()->resource_area(),255);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
    set_initial_gvn(&gvn);    // not significant, but GraphKit guys use it pervasively
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
    gvn.transform_no_reclaim(top());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
    GraphKit kit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
    kit.gen_stub(stub_function, stub_name, is_fancy_jump, pass_tls, return_pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
  NOT_PRODUCT( verify_graph_edges(); )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
  Code_Gen();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
  if (failing())  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
  // Entry point will be accessed using compile->stub_entry_point();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
  if (code_buffer() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
    Matcher::soft_match_failure();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
    if (PrintAssembly && (WizardMode || Verbose))
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
      tty->print_cr("### Stub::%s", stub_name);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
    if (!failing()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
      assert(_fixed_slots == 0, "no fixed slots used for runtime stubs");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
      // Make the NMethod
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
      // For now we mark the frame as never safe for profile stackwalking
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
      RuntimeStub *rs = RuntimeStub::new_runtime_stub(stub_name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
                                                      code_buffer(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
                                                      CodeOffsets::frame_never_safe,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
                                                      // _code_offsets.value(CodeOffsets::Frame_Complete),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
                                                      frame_size_in_words(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
                                                      _oop_map_set,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
                                                      save_arg_registers);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
      assert(rs != NULL && rs->is_runtime_stub(), "sanity check");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
      _stub_entry_point = rs->entry_point();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
//------------------------------Init-------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
// Prepare for a single compilation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
void Compile::Init(int aliaslevel) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
  _unique  = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
  _regalloc = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
  _tf      = NULL;  // filled in later
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
  _top     = NULL;  // cached later
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
  _matcher = NULL;  // filled in later
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
  _cfg     = NULL;  // filled in later
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
  set_24_bit_selection_and_mode(Use24BitFP, false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
  _node_note_array = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
  _default_node_notes = NULL;
25913
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  1065
  DEBUG_ONLY( _modified_nodes = NULL; ) // Used in Optimize()
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
  _immutable_memory = NULL; // filled in at first inquiry
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
  // Globally visible Nodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
  // First set TOP to NULL to give safe behavior during creation of RootNode
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
  set_cached_top_node(NULL);
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 24673
diff changeset
  1072
  set_root(new RootNode());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
  // Now that you have a Root to point to, create the real TOP
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 24673
diff changeset
  1074
  set_cached_top_node( new ConNode(Type::TOP) );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
  set_recent_alloc(NULL, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
  // Create Debug Information Recorder to record scopes, oopmaps, etc.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  1078
  env()->set_oop_recorder(new OopRecorder(env()->arena()));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
  env()->set_debug_info(new DebugInformationRecorder(env()->oop_recorder()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
  env()->set_dependencies(new Dependencies(env()));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
  _fixed_slots = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
  set_has_split_ifs(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
  set_has_loops(has_method() && method()->has_loops()); // first approximation
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  1085
  set_has_stringbuilder(false);
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1086
  set_has_boxed_value(false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
  _trap_can_recompile = false;  // no traps emitted yet
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
  _major_progress = true; // start out assuming good things will happen
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
  set_has_unsafe_access(false);
13883
6979b9850feb 7196199: java/text/Bidi/Bug6665028.java failed: Bidi run count incorrect
kvn
parents: 13728
diff changeset
  1090
  set_max_vector_size(0);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
  Copy::zero_to_bytes(_trap_hist, sizeof(_trap_hist));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
  set_decompile_count(0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
  1094
  set_do_freq_based_layout(_directive->BlockLayoutByFrequencyOption);
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1095
  set_num_loop_opts(LoopOptsCount);
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1096
  set_do_inlining(Inline);
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1097
  set_max_inline_size(MaxInlineSize);
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1098
  set_freq_inline_size(FreqInlineSize);
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1099
  set_do_scheduling(OptoScheduling);
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1100
  set_do_count_invocations(false);
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1101
  set_do_method_data_update(false);
30593
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  1102
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  1103
  set_do_vector_loop(false);
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  1104
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  1105
  if (AllowVectorizeOnDemand) {
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
  1106
    if (has_method() && (_directive->VectorizeOption || _directive->VectorizeDebugOption)) {
30593
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  1107
      set_do_vector_loop(true);
33469
30f4811eded0 8139340: SuperWord enhancement to support vector conditional move (CMovVD) on Intel AVX cpu
iveresov
parents: 33451
diff changeset
  1108
      NOT_PRODUCT(if (do_vector_loop() && Verbose) {tty->print("Compile::Init: do vectorized loops (SIMD like) for method %s\n",  method()->name()->as_quoted_ascii());})
30593
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  1109
    } else if (has_method() && method()->name() != 0 &&
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  1110
               method()->intrinsic_id() == vmIntrinsics::_forEachRemaining) {
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  1111
      set_do_vector_loop(true);
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  1112
    }
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  1113
  }
33469
30f4811eded0 8139340: SuperWord enhancement to support vector conditional move (CMovVD) on Intel AVX cpu
iveresov
parents: 33451
diff changeset
  1114
  set_use_cmove(UseCMoveUnconditionally /* || do_vector_loop()*/); //TODO: consider do_vector_loop() mandate use_cmove unconditionally
30f4811eded0 8139340: SuperWord enhancement to support vector conditional move (CMovVD) on Intel AVX cpu
iveresov
parents: 33451
diff changeset
  1115
  NOT_PRODUCT(if (use_cmove() && Verbose && has_method()) {tty->print("Compile::Init: use CMove without profitability tests for method %s\n",  method()->name()->as_quoted_ascii());})
30593
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  1116
24442
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24424
diff changeset
  1117
  set_age_code(has_method() && method()->profile_aging());
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  1118
  set_rtm_state(NoRTM); // No RTM lock eliding by default
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
  1119
  _max_node_limit = _directive->MaxNodeLimitOption;
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
  1120
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  1121
#if INCLUDE_RTM_OPT
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  1122
  if (UseRTMLocking && has_method() && (method()->method_data_or_null() != NULL)) {
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  1123
    int rtm_state = method()->method_data()->rtm_state();
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  1124
    if (method_has_option("NoRTMLockEliding") || ((rtm_state & NoRTM) != 0)) {
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  1125
      // Don't generate RTM lock eliding code.
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  1126
      set_rtm_state(NoRTM);
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  1127
    } else if (method_has_option("UseRTMLockEliding") || ((rtm_state & UseRTM) != 0) || !UseRTMDeopt) {
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  1128
      // Generate RTM lock eliding code without abort ratio calculation code.
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  1129
      set_rtm_state(UseRTM);
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  1130
    } else if (UseRTMDeopt) {
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  1131
      // Generate RTM lock eliding code and include abort ratio calculation
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  1132
      // code if UseRTMDeopt is on.
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  1133
      set_rtm_state(ProfileRTM);
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  1134
    }
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  1135
  }
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  1136
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1137
  if (debug_info()->recording_non_safepoints()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1138
    set_node_note_array(new(comp_arena()) GrowableArray<Node_Notes*>
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
                        (comp_arena(), 8, 0, NULL));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1140
    set_default_node_notes(Node_Notes::make(this));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1141
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1142
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1143
  // // -- Initialize types before each compile --
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1144
  // // Update cached type information
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1145
  // if( _method && _method->constants() )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1146
  //   Type::update_loaded_types(_method, _method->constants());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1147
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1148
  // Init alias_type map.
211
e2b60448c234 6667610: (Escape Analysis) retry compilation without EA if it fails
kvn
parents: 1
diff changeset
  1149
  if (!_do_escape_analysis && aliaslevel == 3)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1150
    aliaslevel = 2;  // No unique types without escape analysis
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1151
  _AliasLevel = aliaslevel;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1152
  const int grow_ats = 16;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
  _max_alias_types = grow_ats;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1154
  _alias_types   = NEW_ARENA_ARRAY(comp_arena(), AliasType*, grow_ats);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1155
  AliasType* ats = NEW_ARENA_ARRAY(comp_arena(), AliasType,  grow_ats);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1156
  Copy::zero_to_bytes(ats, sizeof(AliasType)*grow_ats);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1157
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1158
    for (int i = 0; i < grow_ats; i++)  _alias_types[i] = &ats[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1159
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1160
  // Initialize the first few types.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1161
  _alias_types[AliasIdxTop]->Init(AliasIdxTop, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1162
  _alias_types[AliasIdxBot]->Init(AliasIdxBot, TypePtr::BOTTOM);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1163
  _alias_types[AliasIdxRaw]->Init(AliasIdxRaw, TypeRawPtr::BOTTOM);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1164
  _num_alias_types = AliasIdxRaw+1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1165
  // Zero out the alias type cache.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1166
  Copy::zero_to_bytes(_alias_cache, sizeof(_alias_cache));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1167
  // A NULL adr_type hits in the cache right away.  Preload the right answer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1168
  probe_alias_cache(NULL)->_index = AliasIdxTop;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1169
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1170
  _intrinsics = NULL;
6180
53c1bf468c81 6973963: SEGV in ciBlock::start_bci() with EA
kvn
parents: 5914
diff changeset
  1171
  _macro_nodes = new(comp_arena()) GrowableArray<Node*>(comp_arena(), 8,  0, NULL);
53c1bf468c81 6973963: SEGV in ciBlock::start_bci() with EA
kvn
parents: 5914
diff changeset
  1172
  _predicate_opaqs = new(comp_arena()) GrowableArray<Node*>(comp_arena(), 8,  0, NULL);
15618
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  1173
  _expensive_nodes = new(comp_arena()) GrowableArray<Node*>(comp_arena(), 8,  0, NULL);
35574
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  1174
  _range_check_casts = new(comp_arena()) GrowableArray<Node*>(comp_arena(), 8,  0, NULL);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
  register_library_intrinsics();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1178
//---------------------------init_start----------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
// Install the StartNode on this compile object.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
void Compile::init_start(StartNode* s) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
  if (failing())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
    return; // already failing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
  assert(s == start(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
27016
58e6c6d54017 8059331: Print additional information for the assert in Compile::start()
anoll
parents: 26919
diff changeset
  1186
/**
58e6c6d54017 8059331: Print additional information for the assert in Compile::start()
anoll
parents: 26919
diff changeset
  1187
 * Return the 'StartNode'. We must not have a pending failure, since the ideal graph
58e6c6d54017 8059331: Print additional information for the assert in Compile::start()
anoll
parents: 26919
diff changeset
  1188
 * can be in an inconsistent state, i.e., we can get segmentation faults when traversing
58e6c6d54017 8059331: Print additional information for the assert in Compile::start()
anoll
parents: 26919
diff changeset
  1189
 * the ideal graph.
58e6c6d54017 8059331: Print additional information for the assert in Compile::start()
anoll
parents: 26919
diff changeset
  1190
 */
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1191
StartNode* Compile::start() const {
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32202
diff changeset
  1192
  assert (!failing(), "Must not have pending failure. Reason is: %s", failure_reason());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
  for (DUIterator_Fast imax, i = root()->fast_outs(imax); i < imax; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
    Node* start = root()->fast_out(i);
27016
58e6c6d54017 8059331: Print additional information for the assert in Compile::start()
anoll
parents: 26919
diff changeset
  1195
    if (start->is_Start()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
      return start->as_Start();
27016
58e6c6d54017 8059331: Print additional information for the assert in Compile::start()
anoll
parents: 26919
diff changeset
  1197
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1198
  }
24342
34e1384b02db 8039298: assert(base == NULL || t_adr->isa_rawptr() || !phase->type(base)->higher_equal(TypePtr::NULL_PTR))
kvn
parents: 24018
diff changeset
  1199
  fatal("Did not find Start node!");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
//-------------------------------immutable_memory-------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
// Access immutable memory
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
Node* Compile::immutable_memory() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
  if (_immutable_memory != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1207
    return _immutable_memory;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1208
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
  StartNode* s = start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
  for (DUIterator_Fast imax, i = s->fast_outs(imax); true; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
    Node *p = s->fast_out(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
    if (p != s && p->as_Proj()->_con == TypeFunc::Memory) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
      _immutable_memory = p;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
      return _immutable_memory;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1221
//----------------------set_cached_top_node------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
// Install the cached top node, and make sure Node::is_top works correctly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
void Compile::set_cached_top_node(Node* tn) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
  if (tn != NULL)  verify_top(tn);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
  Node* old_top = _top;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
  _top = tn;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1227
  // Calling Node::setup_is_top allows the nodes the chance to adjust
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1228
  // their _out arrays.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1229
  if (_top != NULL)     _top->setup_is_top();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1230
  if (old_top != NULL)  old_top->setup_is_top();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
  assert(_top == NULL || top()->is_top(), "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1234
#ifdef ASSERT
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1235
uint Compile::count_live_nodes_by_graph_walk() {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1236
  Unique_Node_List useful(comp_arena());
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1237
  // Get useful node list by walking the graph.
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1238
  identify_useful_nodes(useful);
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1239
  return useful.size();
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1240
}
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1241
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1242
void Compile::print_missing_nodes() {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1243
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1244
  // Return if CompileLog is NULL and PrintIdealNodeCount is false.
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1245
  if ((_log == NULL) && (! PrintIdealNodeCount)) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1246
    return;
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1247
  }
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1248
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1249
  // This is an expensive function. It is executed only when the user
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1250
  // specifies VerifyIdealNodeCount option or otherwise knows the
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1251
  // additional work that needs to be done to identify reachable nodes
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1252
  // by walking the flow graph and find the missing ones using
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1253
  // _dead_node_list.
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1254
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1255
  Unique_Node_List useful(comp_arena());
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1256
  // Get useful node list by walking the graph.
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1257
  identify_useful_nodes(useful);
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1258
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1259
  uint l_nodes = C->live_nodes();
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1260
  uint l_nodes_by_walk = useful.size();
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1261
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1262
  if (l_nodes != l_nodes_by_walk) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1263
    if (_log != NULL) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1264
      _log->begin_head("mismatched_nodes count='%d'", abs((int) (l_nodes - l_nodes_by_walk)));
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1265
      _log->stamp();
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1266
      _log->end_head();
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1267
    }
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1268
    VectorSet& useful_member_set = useful.member_set();
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1269
    int last_idx = l_nodes_by_walk;
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1270
    for (int i = 0; i < last_idx; i++) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1271
      if (useful_member_set.test(i)) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1272
        if (_dead_node_list.test(i)) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1273
          if (_log != NULL) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1274
            _log->elem("mismatched_node_info node_idx='%d' type='both live and dead'", i);
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1275
          }
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1276
          if (PrintIdealNodeCount) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1277
            // Print the log message to tty
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1278
              tty->print_cr("mismatched_node idx='%d' both live and dead'", i);
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1279
              useful.at(i)->dump();
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1280
          }
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1281
        }
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1282
      }
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1283
      else if (! _dead_node_list.test(i)) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1284
        if (_log != NULL) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1285
          _log->elem("mismatched_node_info node_idx='%d' type='neither live nor dead'", i);
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1286
        }
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1287
        if (PrintIdealNodeCount) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1288
          // Print the log message to tty
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1289
          tty->print_cr("mismatched_node idx='%d' type='neither live nor dead'", i);
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1290
        }
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1291
      }
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1292
    }
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1293
    if (_log != NULL) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1294
      _log->tail("mismatched_nodes");
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1295
    }
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1296
  }
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1297
}
25913
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  1298
void Compile::record_modified_node(Node* n) {
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  1299
  if (_modified_nodes != NULL && !_inlining_incrementally &&
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  1300
      n->outcnt() != 0 && !n->is_Con()) {
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  1301
    _modified_nodes->push(n);
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  1302
  }
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  1303
}
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  1304
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  1305
void Compile::remove_modified_node(Node* n) {
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  1306
  if (_modified_nodes != NULL) {
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  1307
    _modified_nodes->remove(n);
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  1308
  }
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  1309
}
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1310
#endif
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  1311
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1312
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1313
void Compile::verify_top(Node* tn) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1314
  if (tn != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1315
    assert(tn->is_Con(), "top node must be a constant");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1316
    assert(((ConNode*)tn)->type() == Type::TOP, "top node must have correct type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1317
    assert(tn->in(0) != NULL, "must have live top node");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1318
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1320
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
///-------------------Managing Per-Node Debug & Profile Info-------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1325
void Compile::grow_node_notes(GrowableArray<Node_Notes*>* arr, int grow_by) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1326
  guarantee(arr != NULL, "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1327
  int num_blocks = arr->length();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1328
  if (grow_by < num_blocks)  grow_by = num_blocks;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
  int num_notes = grow_by * _node_notes_block_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
  Node_Notes* notes = NEW_ARENA_ARRAY(node_arena(), Node_Notes, num_notes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
  Copy::zero_to_bytes(notes, num_notes * sizeof(Node_Notes));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
  while (num_notes > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
    arr->append(notes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
    notes     += _node_notes_block_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
    num_notes -= _node_notes_block_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
  assert(num_notes == 0, "exact multiple, please");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1338
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1339
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
bool Compile::copy_node_notes_to(Node* dest, Node* source) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1341
  if (source == NULL || dest == NULL)  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1342
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1343
  if (dest->is_Con())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1344
    return false;               // Do not push debug info onto constants.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1345
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1346
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1347
  // Leave a bread crumb trail pointing to the original node:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1348
  if (dest != NULL && dest != source && dest->debug_orig() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1349
    dest->set_debug_orig(source);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1350
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1351
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1352
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1353
  if (node_note_array() == NULL)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1354
    return false;               // Not collecting any notes now.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1355
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1356
  // This is a copy onto a pre-existing node, which may already have notes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1357
  // If both nodes have notes, do not overwrite any pre-existing notes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1358
  Node_Notes* source_notes = node_notes_at(source->_idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1359
  if (source_notes == NULL || source_notes->is_clear())  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1360
  Node_Notes* dest_notes   = node_notes_at(dest->_idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1361
  if (dest_notes == NULL || dest_notes->is_clear()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
    return set_node_notes_at(dest->_idx, source_notes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
  Node_Notes merged_notes = (*source_notes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
  // The order of operations here ensures that dest notes will win...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
  merged_notes.update_from(dest_notes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
  return set_node_notes_at(dest->_idx, &merged_notes);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1369
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
//--------------------------allow_range_check_smearing-------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
// Gating condition for coalescing similar range checks.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
// Sometimes we try 'speculatively' replacing a series of a range checks by a
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
// single covering check that is at least as strong as any of them.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
// If the optimization succeeds, the simplified (strengthened) range check
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
// will always succeed.  If it fails, we will deopt, and then give up
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1378
// on the optimization.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
bool Compile::allow_range_check_smearing() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
  // If this method has already thrown a range-check,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
  // assume it was because we already tried range smearing
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
  // and it failed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
  uint already_trapped = trap_count(Deoptimization::Reason_range_check);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
  return !already_trapped;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1385
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1386
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1387
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1388
//------------------------------flatten_alias_type-----------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1389
const TypePtr *Compile::flatten_alias_type( const TypePtr *tj ) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1390
  int offset = tj->offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1391
  TypePtr::PTR ptr = tj->ptr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1392
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1393
  // Known instance (scalarizable allocation) alias only with itself.
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1394
  bool is_known_inst = tj->isa_oopptr() != NULL &&
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1395
                       tj->is_oopptr()->is_known_instance();
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1396
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
  // Process weird unsafe references.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
  if (offset == Type::OffsetBot && (tj->isa_instptr() /*|| tj->isa_klassptr()*/)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
    assert(InlineUnsafeOps, "indeterminate pointers come only from unsafe ops");
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1400
    assert(!is_known_inst, "scalarizable allocation should not have unsafe references");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
    tj = TypeOopPtr::BOTTOM;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1402
    ptr = tj->ptr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1403
    offset = tj->offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
  // Array pointers need some flattening
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
  const TypeAryPtr *ta = tj->isa_aryptr();
19770
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 19717
diff changeset
  1408
  if (ta && ta->is_stable()) {
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 19717
diff changeset
  1409
    // Erase stability property for alias analysis.
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 19717
diff changeset
  1410
    tj = ta = ta->cast_to_stable(false);
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 19717
diff changeset
  1411
  }
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1412
  if( ta && is_known_inst ) {
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1413
    if ( offset != Type::OffsetBot &&
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1414
         offset > arrayOopDesc::length_offset_in_bytes() ) {
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1415
      offset = Type::OffsetBot; // Flatten constant access into array body only
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1416
      tj = ta = TypeAryPtr::make(ptr, ta->ary(), ta->klass(), true, offset, ta->instance_id());
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1417
    }
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1418
  } else if( ta && _AliasLevel >= 2 ) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1419
    // For arrays indexed by constant indices, we flatten the alias
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1420
    // space to include all of the array body.  Only the header, klass
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1421
    // and array length can be accessed un-aliased.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1422
    if( offset != Type::OffsetBot ) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  1423
      if( ta->const_oop() ) { // MethodData* or Method*
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1424
        offset = Type::OffsetBot;   // Flatten constant access into array body
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1425
        tj = ta = TypeAryPtr::make(ptr,ta->const_oop(),ta->ary(),ta->klass(),false,offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1426
      } else if( offset == arrayOopDesc::length_offset_in_bytes() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1427
        // range is OK as-is.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1428
        tj = ta = TypeAryPtr::RANGE;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1429
      } else if( offset == oopDesc::klass_offset_in_bytes() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1430
        tj = TypeInstPtr::KLASS; // all klass loads look alike
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1431
        ta = TypeAryPtr::RANGE; // generic ignored junk
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1432
        ptr = TypePtr::BotPTR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1433
      } else if( offset == oopDesc::mark_offset_in_bytes() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1434
        tj = TypeInstPtr::MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1435
        ta = TypeAryPtr::RANGE; // generic ignored junk
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1436
        ptr = TypePtr::BotPTR;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1437
      } else {                  // Random constant offset into array body
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1438
        offset = Type::OffsetBot;   // Flatten constant access into array body
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1439
        tj = ta = TypeAryPtr::make(ptr,ta->ary(),ta->klass(),false,offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1440
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1441
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1442
    // Arrays of fixed size alias with arrays of unknown size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1443
    if (ta->size() != TypeInt::POS) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1444
      const TypeAry *tary = TypeAry::make(ta->elem(), TypeInt::POS);
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1445
      tj = ta = TypeAryPtr::make(ptr,ta->const_oop(),tary,ta->klass(),false,offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1446
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1447
    // Arrays of known objects become arrays of unknown objects.
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 347
diff changeset
  1448
    if (ta->elem()->isa_narrowoop() && ta->elem() != TypeNarrowOop::BOTTOM) {
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 347
diff changeset
  1449
      const TypeAry *tary = TypeAry::make(TypeNarrowOop::BOTTOM, ta->size());
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1450
      tj = ta = TypeAryPtr::make(ptr,ta->const_oop(),tary,NULL,false,offset);
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 347
diff changeset
  1451
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1452
    if (ta->elem()->isa_oopptr() && ta->elem() != TypeInstPtr::BOTTOM) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1453
      const TypeAry *tary = TypeAry::make(TypeInstPtr::BOTTOM, ta->size());
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1454
      tj = ta = TypeAryPtr::make(ptr,ta->const_oop(),tary,NULL,false,offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1455
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1456
    // Arrays of bytes and of booleans both use 'bastore' and 'baload' so
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1457
    // cannot be distinguished by bytecode alone.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1458
    if (ta->elem() == TypeInt::BOOL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1459
      const TypeAry *tary = TypeAry::make(TypeInt::BYTE, ta->size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1460
      ciKlass* aklass = ciTypeArrayKlass::make(T_BYTE);
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1461
      tj = ta = TypeAryPtr::make(ptr,ta->const_oop(),tary,aklass,false,offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1462
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1463
    // During the 2nd round of IterGVN, NotNull castings are removed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1464
    // Make sure the Bottom and NotNull variants alias the same.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1465
    // Also, make sure exact and non-exact variants alias the same.
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  1466
    if (ptr == TypePtr::NotNull || ta->klass_is_exact() || ta->speculative() != NULL) {
10012
31d52b0abd0b 7047954: VM crashes with assert(is_Mem()) failed
kvn
parents: 9182
diff changeset
  1467
      tj = ta = TypeAryPtr::make(TypePtr::BotPTR,ta->ary(),ta->klass(),false,offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1468
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1469
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1470
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1471
  // Oop pointers need some flattening
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1472
  const TypeInstPtr *to = tj->isa_instptr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1473
  if( to && _AliasLevel >= 2 && to != TypeOopPtr::BOTTOM ) {
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1474
    ciInstanceKlass *k = to->klass()->as_instance_klass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1475
    if( ptr == TypePtr::Constant ) {
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1476
      if (to->klass() != ciEnv::current()->Class_klass() ||
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1477
          offset < k->size_helper() * wordSize) {
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1478
        // No constant oop pointers (such as Strings); they alias with
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1479
        // unknown strings.
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1480
        assert(!is_known_inst, "not scalarizable allocation");
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1481
        tj = to = TypeInstPtr::make(TypePtr::BotPTR,to->klass(),false,0,offset);
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1482
      }
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1483
    } else if( is_known_inst ) {
589
a44a1e70a3e4 6695810: null oop passed to encode_heap_oop_not_null
kvn
parents: 374
diff changeset
  1484
      tj = to; // Keep NotNull and klass_is_exact for instance type
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1485
    } else if( ptr == TypePtr::NotNull || to->klass_is_exact() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1486
      // During the 2nd round of IterGVN, NotNull castings are removed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1487
      // Make sure the Bottom and NotNull variants alias the same.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1488
      // Also, make sure exact and non-exact variants alias the same.
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1489
      tj = to = TypeInstPtr::make(TypePtr::BotPTR,to->klass(),false,0,offset);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1490
    }
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  1491
    if (to->speculative() != NULL) {
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  1492
      tj = to = TypeInstPtr::make(to->ptr(),to->klass(),to->klass_is_exact(),to->const_oop(),to->offset(), to->instance_id());
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  1493
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1494
    // Canonicalize the holder of this field
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 347
diff changeset
  1495
    if (offset >= 0 && offset < instanceOopDesc::base_offset_in_bytes()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1496
      // First handle header references such as a LoadKlassNode, even if the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1497
      // object's klass is unloaded at compile time (4965979).
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1498
      if (!is_known_inst) { // Do it only for non-instance types
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1499
        tj = to = TypeInstPtr::make(TypePtr::BotPTR, env()->Object_klass(), false, NULL, offset);
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1500
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1501
    } else if (offset < 0 || offset >= k->size_helper() * wordSize) {
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1502
      // Static fields are in the space above the normal instance
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1503
      // fields in the java.lang.Class instance.
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1504
      if (to->klass() != ciEnv::current()->Class_klass()) {
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1505
        to = NULL;
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1506
        tj = TypeOopPtr::BOTTOM;
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1507
        offset = tj->offset();
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1508
      }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1509
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1510
      ciInstanceKlass *canonical_holder = k->get_canonical_holder(offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1511
      if (!k->equals(canonical_holder) || tj->offset() != offset) {
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1512
        if( is_known_inst ) {
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1513
          tj = to = TypeInstPtr::make(to->ptr(), canonical_holder, true, NULL, offset, to->instance_id());
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1514
        } else {
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1515
          tj = to = TypeInstPtr::make(to->ptr(), canonical_holder, false, NULL, offset);
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1516
        }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1517
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1518
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1519
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1520
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1521
  // Klass pointers to object array klasses need some flattening
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1522
  const TypeKlassPtr *tk = tj->isa_klassptr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1523
  if( tk ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1524
    // If we are referencing a field within a Klass, we need
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1525
    // to assume the worst case of an Object.  Both exact and
11428
7496cc6cc1a9 7121073: secondary_super_cache memory slice has incorrect bounds in flatten_alias_type
never
parents: 11191
diff changeset
  1526
    // inexact types must flatten to the same alias class so
7496cc6cc1a9 7121073: secondary_super_cache memory slice has incorrect bounds in flatten_alias_type
never
parents: 11191
diff changeset
  1527
    // use NotNull as the PTR.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1528
    if ( offset == Type::OffsetBot || (offset >= 0 && (size_t)offset < sizeof(Klass)) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1529
11428
7496cc6cc1a9 7121073: secondary_super_cache memory slice has incorrect bounds in flatten_alias_type
never
parents: 11191
diff changeset
  1530
      tj = tk = TypeKlassPtr::make(TypePtr::NotNull,
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1531
                                   TypeKlassPtr::OBJECT->klass(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1532
                                   offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1533
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1534
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1535
    ciKlass* klass = tk->klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1536
    if( klass->is_obj_array_klass() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1537
      ciKlass* k = TypeAryPtr::OOPS->klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1538
      if( !k || !k->is_loaded() )                  // Only fails for some -Xcomp runs
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1539
        k = TypeInstPtr::BOTTOM->klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1540
      tj = tk = TypeKlassPtr::make( TypePtr::NotNull, k, offset );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1541
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1542
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1543
    // Check for precise loads from the primary supertype array and force them
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1544
    // to the supertype cache alias index.  Check for generic array loads from
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1545
    // the primary supertype array and also force them to the supertype cache
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1546
    // alias index.  Since the same load can reach both, we need to merge
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1547
    // these 2 disparate memories into the same alias class.  Since the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1548
    // primary supertype array is read-only, there's no chance of confusion
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1549
    // where we bypass an array load and an array store.
11430
718fc06da49a 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 11428
diff changeset
  1550
    int primary_supers_offset = in_bytes(Klass::primary_supers_offset());
11428
7496cc6cc1a9 7121073: secondary_super_cache memory slice has incorrect bounds in flatten_alias_type
never
parents: 11191
diff changeset
  1551
    if (offset == Type::OffsetBot ||
7496cc6cc1a9 7121073: secondary_super_cache memory slice has incorrect bounds in flatten_alias_type
never
parents: 11191
diff changeset
  1552
        (offset >= primary_supers_offset &&
7496cc6cc1a9 7121073: secondary_super_cache memory slice has incorrect bounds in flatten_alias_type
never
parents: 11191
diff changeset
  1553
         offset < (int)(primary_supers_offset + Klass::primary_super_limit() * wordSize)) ||
11430
718fc06da49a 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 11428
diff changeset
  1554
        offset == (int)in_bytes(Klass::secondary_super_cache_offset())) {
718fc06da49a 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 11428
diff changeset
  1555
      offset = in_bytes(Klass::secondary_super_cache_offset());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1556
      tj = tk = TypeKlassPtr::make( TypePtr::NotNull, tk->klass(), offset );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1557
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1558
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1559
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1560
  // Flatten all Raw pointers together.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1561
  if (tj->base() == Type::RawPtr)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1562
    tj = TypeRawPtr::BOTTOM;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1563
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1564
  if (tj->base() == Type::AnyPtr)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1565
    tj = TypePtr::BOTTOM;      // An error, which the caller must check for.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1566
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1567
  // Flatten all to bottom for now
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1568
  switch( _AliasLevel ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1569
  case 0:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1570
    tj = TypePtr::BOTTOM;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1571
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1572
  case 1:                       // Flatten to: oop, static, field or array
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1573
    switch (tj->base()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1574
    //case Type::AryPtr: tj = TypeAryPtr::RANGE;    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1575
    case Type::RawPtr:   tj = TypeRawPtr::BOTTOM;   break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1576
    case Type::AryPtr:   // do not distinguish arrays at all
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1577
    case Type::InstPtr:  tj = TypeInstPtr::BOTTOM;  break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1578
    case Type::KlassPtr: tj = TypeKlassPtr::OBJECT; break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1579
    case Type::AnyPtr:   tj = TypePtr::BOTTOM;      break;  // caller checks it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1580
    default: ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1581
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1582
    break;
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 2022
diff changeset
  1583
  case 2:                       // No collapsing at level 2; keep all splits
98f9cef66a34 6810672: Comment typos
twisti
parents: 2022
diff changeset
  1584
  case 3:                       // No collapsing at level 3; keep all splits
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1585
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1586
  default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1587
    Unimplemented();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1588
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1589
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1590
  offset = tj->offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1591
  assert( offset != Type::OffsetTop, "Offset has fallen from constant" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1592
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1593
  assert( (offset != Type::OffsetBot && tj->base() != Type::AryPtr) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1594
          (offset == Type::OffsetBot && tj->base() == Type::AryPtr) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1595
          (offset == Type::OffsetBot && tj == TypeOopPtr::BOTTOM) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1596
          (offset == Type::OffsetBot && tj == TypePtr::BOTTOM) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1597
          (offset == oopDesc::mark_offset_in_bytes() && tj->base() == Type::AryPtr) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1598
          (offset == oopDesc::klass_offset_in_bytes() && tj->base() == Type::AryPtr) ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1599
          (offset == arrayOopDesc::length_offset_in_bytes() && tj->base() == Type::AryPtr)  ,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1600
          "For oops, klasses, raw offset must be constant; for arrays the offset is never known" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1601
  assert( tj->ptr() != TypePtr::TopPTR &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1602
          tj->ptr() != TypePtr::AnyNull &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1603
          tj->ptr() != TypePtr::Null, "No imprecise addresses" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1604
//    assert( tj->ptr() != TypePtr::Constant ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1605
//            tj->base() == Type::RawPtr ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1606
//            tj->base() == Type::KlassPtr, "No constant oop addresses" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1607
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1608
  return tj;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1609
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1610
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1611
void Compile::AliasType::Init(int i, const TypePtr* at) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1612
  _index = i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1613
  _adr_type = at;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1614
  _field = NULL;
19770
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 19717
diff changeset
  1615
  _element = NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1616
  _is_rewritable = true; // default
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1617
  const TypeOopPtr *atoop = (at != NULL) ? at->isa_oopptr() : NULL;
769
78e5090c7a20 6716441: error in meet with +DoEscapeAnalysis
kvn
parents: 768
diff changeset
  1618
  if (atoop != NULL && atoop->is_known_instance()) {
78e5090c7a20 6716441: error in meet with +DoEscapeAnalysis
kvn
parents: 768
diff changeset
  1619
    const TypeOopPtr *gt = atoop->cast_to_instance_id(TypeOopPtr::InstanceBot);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1620
    _general_index = Compile::current()->get_alias_index(gt);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1621
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1622
    _general_index = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1623
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1624
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1625
38131
7bb27ec1a3d8 8134918: C2: Type speculation produces mismatched unsafe accesses
vlivanov
parents: 37248
diff changeset
  1626
BasicType Compile::AliasType::basic_type() const {
7bb27ec1a3d8 8134918: C2: Type speculation produces mismatched unsafe accesses
vlivanov
parents: 37248
diff changeset
  1627
  if (element() != NULL) {
7bb27ec1a3d8 8134918: C2: Type speculation produces mismatched unsafe accesses
vlivanov
parents: 37248
diff changeset
  1628
    const Type* element = adr_type()->is_aryptr()->elem();
7bb27ec1a3d8 8134918: C2: Type speculation produces mismatched unsafe accesses
vlivanov
parents: 37248
diff changeset
  1629
    return element->isa_narrowoop() ? T_OBJECT : element->array_element_basic_type();
7bb27ec1a3d8 8134918: C2: Type speculation produces mismatched unsafe accesses
vlivanov
parents: 37248
diff changeset
  1630
  } if (field() != NULL) {
7bb27ec1a3d8 8134918: C2: Type speculation produces mismatched unsafe accesses
vlivanov
parents: 37248
diff changeset
  1631
    return field()->layout_type();
7bb27ec1a3d8 8134918: C2: Type speculation produces mismatched unsafe accesses
vlivanov
parents: 37248
diff changeset
  1632
  } else {
7bb27ec1a3d8 8134918: C2: Type speculation produces mismatched unsafe accesses
vlivanov
parents: 37248
diff changeset
  1633
    return T_ILLEGAL; // unknown
7bb27ec1a3d8 8134918: C2: Type speculation produces mismatched unsafe accesses
vlivanov
parents: 37248
diff changeset
  1634
  }
7bb27ec1a3d8 8134918: C2: Type speculation produces mismatched unsafe accesses
vlivanov
parents: 37248
diff changeset
  1635
}
7bb27ec1a3d8 8134918: C2: Type speculation produces mismatched unsafe accesses
vlivanov
parents: 37248
diff changeset
  1636
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1637
//---------------------------------print_on------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1638
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1639
void Compile::AliasType::print_on(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1640
  if (index() < 10)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1641
        st->print("@ <%d> ", index());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1642
  else  st->print("@ <%d>",  index());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1643
  st->print(is_rewritable() ? "   " : " RO");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1644
  int offset = adr_type()->offset();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1645
  if (offset == Type::OffsetBot)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1646
        st->print(" +any");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1647
  else  st->print(" +%-3d", offset);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1648
  st->print(" in ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1649
  adr_type()->dump_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1650
  const TypeOopPtr* tjp = adr_type()->isa_oopptr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1651
  if (field() != NULL && tjp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1652
    if (tjp->klass()  != field()->holder() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1653
        tjp->offset() != field()->offset_in_bytes()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1654
      st->print(" != ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1655
      field()->print();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1656
      st->print(" ***");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1657
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1658
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1659
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1660
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1661
void print_alias_types() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1662
  Compile* C = Compile::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1663
  tty->print_cr("--- Alias types, AliasIdxBot .. %d", C->num_alias_types()-1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1664
  for (int idx = Compile::AliasIdxBot; idx < C->num_alias_types(); idx++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1665
    C->alias_type(idx)->print_on(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1666
    tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1667
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1668
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1669
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1670
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1671
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1672
//----------------------------probe_alias_cache--------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1673
Compile::AliasCacheEntry* Compile::probe_alias_cache(const TypePtr* adr_type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1674
  intptr_t key = (intptr_t) adr_type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1675
  key ^= key >> logAliasCacheSize;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1676
  return &_alias_cache[key & right_n_bits(logAliasCacheSize)];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1677
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1678
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1679
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1680
//-----------------------------grow_alias_types--------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1681
void Compile::grow_alias_types() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1682
  const int old_ats  = _max_alias_types; // how many before?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1683
  const int new_ats  = old_ats;          // how many more?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1684
  const int grow_ats = old_ats+new_ats;  // how many now?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1685
  _max_alias_types = grow_ats;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1686
  _alias_types =  REALLOC_ARENA_ARRAY(comp_arena(), AliasType*, _alias_types, old_ats, grow_ats);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1687
  AliasType* ats =    NEW_ARENA_ARRAY(comp_arena(), AliasType, new_ats);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1688
  Copy::zero_to_bytes(ats, sizeof(AliasType)*new_ats);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1689
  for (int i = 0; i < new_ats; i++)  _alias_types[old_ats+i] = &ats[i];
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1690
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1691
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1692
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1693
//--------------------------------find_alias_type------------------------------
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1694
Compile::AliasType* Compile::find_alias_type(const TypePtr* adr_type, bool no_create, ciField* original_field) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1695
  if (_AliasLevel == 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1696
    return alias_type(AliasIdxBot);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1697
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1698
  AliasCacheEntry* ace = probe_alias_cache(adr_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1699
  if (ace->_adr_type == adr_type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1700
    return alias_type(ace->_index);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1701
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1702
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1703
  // Handle special cases.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1704
  if (adr_type == NULL)             return alias_type(AliasIdxTop);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1705
  if (adr_type == TypePtr::BOTTOM)  return alias_type(AliasIdxBot);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1706
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1707
  // Do it the slow way.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1708
  const TypePtr* flat = flatten_alias_type(adr_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1709
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1710
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1711
  assert(flat == flatten_alias_type(flat), "idempotent");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1712
  assert(flat != TypePtr::BOTTOM,     "cannot alias-analyze an untyped ptr");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1713
  if (flat->isa_oopptr() && !flat->isa_klassptr()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1714
    const TypeOopPtr* foop = flat->is_oopptr();
955
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1715
    // Scalarizable allocations have exact klass always.
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1716
    bool exact = !foop->klass_is_exact() || foop->is_known_instance();
723d7b577fba 6723160: Nightly failure: Error: meet not symmetric
kvn
parents: 953
diff changeset
  1717
    const TypePtr* xoop = foop->cast_to_exactness(exact)->is_ptr();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1718
    assert(foop == flatten_alias_type(xoop), "exactness must not affect alias type");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1719
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1720
  assert(flat == flatten_alias_type(flat), "exact bit doesn't matter");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1721
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1722
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1723
  int idx = AliasIdxTop;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1724
  for (int i = 0; i < num_alias_types(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1725
    if (alias_type(i)->adr_type() == flat) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1726
      idx = i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1727
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1728
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1729
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1730
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1731
  if (idx == AliasIdxTop) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1732
    if (no_create)  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1733
    // Grow the array if necessary.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1734
    if (_num_alias_types == _max_alias_types)  grow_alias_types();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1735
    // Add a new alias type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1736
    idx = _num_alias_types++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1737
    _alias_types[idx]->Init(idx, flat);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1738
    if (flat == TypeInstPtr::KLASS)  alias_type(idx)->set_rewritable(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1739
    if (flat == TypeAryPtr::RANGE)   alias_type(idx)->set_rewritable(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1740
    if (flat->isa_instptr()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1741
      if (flat->offset() == java_lang_Class::klass_offset_in_bytes()
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1742
          && flat->is_instptr()->klass() == env()->Class_klass())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1743
        alias_type(idx)->set_rewritable(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1744
    }
19770
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 19717
diff changeset
  1745
    if (flat->isa_aryptr()) {
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 19717
diff changeset
  1746
#ifdef ASSERT
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 19717
diff changeset
  1747
      const int header_size_min  = arrayOopDesc::base_offset_in_bytes(T_BYTE);
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 19717
diff changeset
  1748
      // (T_BYTE has the weakest alignment and size restrictions...)
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 19717
diff changeset
  1749
      assert(flat->offset() < header_size_min, "array body reference must be OffsetBot");
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 19717
diff changeset
  1750
#endif
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 19717
diff changeset
  1751
      if (flat->offset() == TypePtr::OffsetBot) {
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 19717
diff changeset
  1752
        alias_type(idx)->set_element(flat->is_aryptr()->elem());
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 19717
diff changeset
  1753
      }
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 19717
diff changeset
  1754
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1755
    if (flat->isa_klassptr()) {
11430
718fc06da49a 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 11428
diff changeset
  1756
      if (flat->offset() == in_bytes(Klass::super_check_offset_offset()))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1757
        alias_type(idx)->set_rewritable(false);
11430
718fc06da49a 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 11428
diff changeset
  1758
      if (flat->offset() == in_bytes(Klass::modifier_flags_offset()))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1759
        alias_type(idx)->set_rewritable(false);
11430
718fc06da49a 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 11428
diff changeset
  1760
      if (flat->offset() == in_bytes(Klass::access_flags_offset()))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1761
        alias_type(idx)->set_rewritable(false);
11430
718fc06da49a 7118863: Move sizeof(klassOopDesc) into the *Klass::*_offset_in_bytes() functions
stefank
parents: 11428
diff changeset
  1762
      if (flat->offset() == in_bytes(Klass::java_mirror_offset()))
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1763
        alias_type(idx)->set_rewritable(false);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1764
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1765
    // %%% (We would like to finalize JavaThread::threadObj_offset(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1766
    // but the base pointer type is not distinctive enough to identify
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1767
    // references into JavaThread.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1768
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1769
    // Check for final fields.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1770
    const TypeInstPtr* tinst = flat->isa_instptr();
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 347
diff changeset
  1771
    if (tinst && tinst->offset() >= instanceOopDesc::base_offset_in_bytes()) {
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1772
      ciField* field;
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1773
      if (tinst->const_oop() != NULL &&
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1774
          tinst->klass() == ciEnv::current()->Class_klass() &&
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1775
          tinst->offset() >= (tinst->klass()->as_instance_klass()->size_helper() * wordSize)) {
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1776
        // static field
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1777
        ciInstanceKlass* k = tinst->const_oop()->as_instance()->java_lang_Class_klass()->as_instance_klass();
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1778
        field = k->get_field_by_offset(tinst->offset(), true);
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1779
      } else {
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1780
        ciInstanceKlass *k = tinst->klass()->as_instance_klass();
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1781
        field = k->get_field_by_offset(tinst->offset(), false);
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1782
      }
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1783
      assert(field == NULL ||
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1784
             original_field == NULL ||
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1785
             (field->holder() == original_field->holder() &&
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1786
              field->offset() == original_field->offset() &&
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1787
              field->is_static() == original_field->is_static()), "wrong field?");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1788
      // Set field() and is_rewritable() attributes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1789
      if (field != NULL)  alias_type(idx)->set_field(field);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1790
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1791
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1792
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1793
  // Fill the cache for next time.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1794
  ace->_adr_type = adr_type;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1795
  ace->_index    = idx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1796
  assert(alias_type(adr_type) == alias_type(idx),  "type must be installed");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1797
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1798
  // Might as well try to fill the cache for the flattened version, too.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1799
  AliasCacheEntry* face = probe_alias_cache(flat);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1800
  if (face->_adr_type == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1801
    face->_adr_type = flat;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1802
    face->_index    = idx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1803
    assert(alias_type(flat) == alias_type(idx), "flat type must work too");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1804
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1805
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1806
  return alias_type(idx);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1807
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1808
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1809
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1810
Compile::AliasType* Compile::alias_type(ciField* field) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1811
  const TypeOopPtr* t;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1812
  if (field->is_static())
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1813
    t = TypeInstPtr::make(field->holder()->java_mirror());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1814
  else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1815
    t = TypeOopPtr::make_from_klass_raw(field->holder());
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1816
  AliasType* atp = alias_type(t->add_offset(field->offset_in_bytes()), field);
19770
7cb9f982ea81 8001107: @Stable annotation for constant folding of lazily evaluated variables
vlivanov
parents: 19717
diff changeset
  1817
  assert((field->is_final() || field->is_stable()) == !atp->is_rewritable(), "must get the rewritable bits correct");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1818
  return atp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1819
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1820
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1821
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1822
//------------------------------have_alias_type--------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1823
bool Compile::have_alias_type(const TypePtr* adr_type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1824
  AliasCacheEntry* ace = probe_alias_cache(adr_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1825
  if (ace->_adr_type == adr_type) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1826
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1827
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1828
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1829
  // Handle special cases.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1830
  if (adr_type == NULL)             return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1831
  if (adr_type == TypePtr::BOTTOM)  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1832
8725
8c1e3dd5fe1b 7017732: move static fields into Class to prepare for perm gen removal
never
parents: 8107
diff changeset
  1833
  return find_alias_type(adr_type, true, NULL) != NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1834
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1835
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1836
//-----------------------------must_alias--------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1837
// True if all values of the given address type are in the given alias category.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1838
bool Compile::must_alias(const TypePtr* adr_type, int alias_idx) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1839
  if (alias_idx == AliasIdxBot)         return true;  // the universal category
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1840
  if (adr_type == NULL)                 return true;  // NULL serves as TypePtr::TOP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1841
  if (alias_idx == AliasIdxTop)         return false; // the empty category
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1842
  if (adr_type->base() == Type::AnyPtr) return false; // TypePtr::BOTTOM or its twins
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1843
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1844
  // the only remaining possible overlap is identity
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1845
  int adr_idx = get_alias_index(adr_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1846
  assert(adr_idx != AliasIdxBot && adr_idx != AliasIdxTop, "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1847
  assert(adr_idx == alias_idx ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1848
         (alias_type(alias_idx)->adr_type() != TypeOopPtr::BOTTOM
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1849
          && adr_type                       != TypeOopPtr::BOTTOM),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1850
         "should not be testing for overlap with an unsafe pointer");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1851
  return adr_idx == alias_idx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1852
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1853
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1854
//------------------------------can_alias--------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1855
// True if any values of the given address type are in the given alias category.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1856
bool Compile::can_alias(const TypePtr* adr_type, int alias_idx) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1857
  if (alias_idx == AliasIdxTop)         return false; // the empty category
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1858
  if (adr_type == NULL)                 return false; // NULL serves as TypePtr::TOP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1859
  if (alias_idx == AliasIdxBot)         return true;  // the universal category
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1860
  if (adr_type->base() == Type::AnyPtr) return true;  // TypePtr::BOTTOM or its twins
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1861
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1862
  // the only remaining possible overlap is identity
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1863
  int adr_idx = get_alias_index(adr_type);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1864
  assert(adr_idx != AliasIdxBot && adr_idx != AliasIdxTop, "");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1865
  return adr_idx == alias_idx;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1866
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1867
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1868
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1869
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1870
//---------------------------pop_warm_call-------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1871
WarmCallInfo* Compile::pop_warm_call() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1872
  WarmCallInfo* wci = _warm_calls;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1873
  if (wci != NULL)  _warm_calls = wci->remove_from(wci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1874
  return wci;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1875
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1876
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1877
//----------------------------Inline_Warm--------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1878
int Compile::Inline_Warm() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1879
  // If there is room, try to inline some more warm call sites.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1880
  // %%% Do a graph index compaction pass when we think we're out of space?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1881
  if (!InlineWarmCalls)  return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1882
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1883
  int calls_made_hot = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1884
  int room_to_grow   = NodeCountInliningCutoff - unique();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1885
  int amount_to_grow = MIN2(room_to_grow, (int)NodeCountInliningStep);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1886
  int amount_grown   = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1887
  WarmCallInfo* call;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1888
  while (amount_to_grow > 0 && (call = pop_warm_call()) != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1889
    int est_size = (int)call->size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1890
    if (est_size > (room_to_grow - amount_grown)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1891
      // This one won't fit anyway.  Get rid of it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1892
      call->make_cold();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1893
      continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1894
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1895
    call->make_hot();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1896
    calls_made_hot++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1897
    amount_grown   += est_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1898
    amount_to_grow -= est_size;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1899
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1900
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1901
  if (calls_made_hot > 0)  set_major_progress();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1902
  return calls_made_hot;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1903
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1904
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1905
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1906
//----------------------------Finish_Warm--------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1907
void Compile::Finish_Warm() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1908
  if (!InlineWarmCalls)  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1909
  if (failing())  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1910
  if (warm_calls() == NULL)  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1911
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1912
  // Clean up loose ends, if we are out of space for inlining.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1913
  WarmCallInfo* call;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1914
  while ((call = pop_warm_call()) != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1915
    call->make_cold();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1916
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1917
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1918
4643
61c659c91c57 6894779: Loop Predication for Loop Optimizer in C2
cfang
parents: 4470
diff changeset
  1919
//---------------------cleanup_loop_predicates-----------------------
61c659c91c57 6894779: Loop Predication for Loop Optimizer in C2
cfang
parents: 4470
diff changeset
  1920
// Remove the opaque nodes that protect the predicates so that all unused
61c659c91c57 6894779: Loop Predication for Loop Optimizer in C2
cfang
parents: 4470
diff changeset
  1921
// checks and uncommon_traps will be eliminated from the ideal graph
61c659c91c57 6894779: Loop Predication for Loop Optimizer in C2
cfang
parents: 4470
diff changeset
  1922
void Compile::cleanup_loop_predicates(PhaseIterGVN &igvn) {
61c659c91c57 6894779: Loop Predication for Loop Optimizer in C2
cfang
parents: 4470
diff changeset
  1923
  if (predicate_count()==0) return;
61c659c91c57 6894779: Loop Predication for Loop Optimizer in C2
cfang
parents: 4470
diff changeset
  1924
  for (int i = predicate_count(); i > 0; i--) {
61c659c91c57 6894779: Loop Predication for Loop Optimizer in C2
cfang
parents: 4470
diff changeset
  1925
    Node * n = predicate_opaque1_node(i-1);
61c659c91c57 6894779: Loop Predication for Loop Optimizer in C2
cfang
parents: 4470
diff changeset
  1926
    assert(n->Opcode() == Op_Opaque1, "must be");
61c659c91c57 6894779: Loop Predication for Loop Optimizer in C2
cfang
parents: 4470
diff changeset
  1927
    igvn.replace_node(n, n->in(1));
61c659c91c57 6894779: Loop Predication for Loop Optimizer in C2
cfang
parents: 4470
diff changeset
  1928
  }
61c659c91c57 6894779: Loop Predication for Loop Optimizer in C2
cfang
parents: 4470
diff changeset
  1929
  assert(predicate_count()==0, "should be clean!");
61c659c91c57 6894779: Loop Predication for Loop Optimizer in C2
cfang
parents: 4470
diff changeset
  1930
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1931
35574
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  1932
void Compile::add_range_check_cast(Node* n) {
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  1933
  assert(n->isa_CastII()->has_range_check(), "CastII should have range check dependency");
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  1934
  assert(!_range_check_casts->contains(n), "duplicate entry in range check casts");
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  1935
  _range_check_casts->append(n);
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  1936
}
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  1937
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  1938
// Remove all range check dependent CastIINodes.
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  1939
void Compile::remove_range_check_casts(PhaseIterGVN &igvn) {
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  1940
  for (int i = range_check_cast_count(); i > 0; i--) {
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  1941
    Node* cast = range_check_cast_node(i-1);
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  1942
    assert(cast->isa_CastII()->has_range_check(), "CastII should have range check dependency");
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  1943
    igvn.replace_node(cast, cast->in(1));
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  1944
  }
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  1945
  assert(range_check_cast_count() == 0, "should be empty");
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  1946
}
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  1947
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1948
// StringOpts and late inlining of string methods
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1949
void Compile::inline_string_calls(bool parse_time) {
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1950
  {
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1951
    // remove useless nodes to make the usage analysis simpler
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1952
    ResourceMark rm;
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1953
    PhaseRemoveUseless pru(initial_gvn(), for_igvn());
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1954
  }
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1955
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1956
  {
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1957
    ResourceMark rm;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  1958
    print_method(PHASE_BEFORE_STRINGOPTS, 3);
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1959
    PhaseStringOpts pso(initial_gvn(), for_igvn());
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  1960
    print_method(PHASE_AFTER_STRINGOPTS, 3);
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1961
  }
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1962
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1963
  // now inline anything that we skipped the first time around
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1964
  if (!parse_time) {
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1965
    _late_inlines_pos = _late_inlines.length();
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1966
  }
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1967
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1968
  while (_string_late_inlines.length() > 0) {
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1969
    CallGenerator* cg = _string_late_inlines.pop();
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1970
    cg->do_late_inline();
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1971
    if (failing())  return;
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1972
  }
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1973
  _string_late_inlines.trunc_to(0);
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1974
}
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  1975
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1976
// Late inlining of boxing methods
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1977
void Compile::inline_boxing_calls(PhaseIterGVN& igvn) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1978
  if (_boxing_late_inlines.length() > 0) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1979
    assert(has_boxed_value(), "inconsistent");
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1980
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1981
    PhaseGVN* gvn = initial_gvn();
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1982
    set_inlining_incrementally(true);
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1983
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1984
    assert( igvn._worklist.size() == 0, "should be done with igvn" );
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1985
    for_igvn()->clear();
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1986
    gvn->replace_with(&igvn);
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1987
24946
24b68ccf3fc4 8026796: Make replace_in_map() on parent maps generic
roland
parents: 24923
diff changeset
  1988
    _late_inlines_pos = _late_inlines.length();
24b68ccf3fc4 8026796: Make replace_in_map() on parent maps generic
roland
parents: 24923
diff changeset
  1989
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1990
    while (_boxing_late_inlines.length() > 0) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1991
      CallGenerator* cg = _boxing_late_inlines.pop();
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1992
      cg->do_late_inline();
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1993
      if (failing())  return;
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1994
    }
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1995
    _boxing_late_inlines.trunc_to(0);
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1996
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1997
    {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1998
      ResourceMark rm;
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  1999
      PhaseRemoveUseless pru(gvn, for_igvn());
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2000
    }
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2001
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2002
    igvn = PhaseIterGVN(gvn);
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2003
    igvn.optimize();
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2004
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2005
    set_inlining_progress(false);
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2006
    set_inlining_incrementally(false);
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2007
  }
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2008
}
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2009
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2010
void Compile::inline_incrementally_one(PhaseIterGVN& igvn) {
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2011
  assert(IncrementalInline, "incremental inlining should be on");
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2012
  PhaseGVN* gvn = initial_gvn();
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2013
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2014
  set_inlining_progress(false);
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2015
  for_igvn()->clear();
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2016
  gvn->replace_with(&igvn);
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2017
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2018
  {
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2019
    TracePhase tp("incrementalInline_inline", &timers[_t_incrInline_inline]);
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2020
    int i = 0;
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2021
    for (; i <_late_inlines.length() && !inlining_progress(); i++) {
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2022
      CallGenerator* cg = _late_inlines.at(i);
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2023
      _late_inlines_pos = i+1;
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2024
      cg->do_late_inline();
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2025
      if (failing())  return;
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2026
    }
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2027
    int j = 0;
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2028
    for (; i < _late_inlines.length(); i++, j++) {
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2029
      _late_inlines.at_put(j, _late_inlines.at(i));
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2030
    }
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2031
    _late_inlines.trunc_to(j);
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2032
  }
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2033
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2034
  {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2035
    TracePhase tp("incrementalInline_pru", &timers[_t_incrInline_pru]);
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2036
    ResourceMark rm;
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2037
    PhaseRemoveUseless pru(gvn, for_igvn());
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2038
  }
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2039
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2040
  {
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2041
    TracePhase tp("incrementalInline_igvn", &timers[_t_incrInline_igvn]);
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2042
    igvn = PhaseIterGVN(gvn);
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2043
  }
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2044
}
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2045
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2046
// Perform incremental inlining until bound on number of live nodes is reached
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2047
void Compile::inline_incrementally(PhaseIterGVN& igvn) {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2048
  TracePhase tp("incrementalInline", &timers[_t_incrInline]);
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2049
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2050
  PhaseGVN* gvn = initial_gvn();
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2051
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2052
  set_inlining_incrementally(true);
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2053
  set_inlining_progress(true);
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2054
  uint low_live_nodes = 0;
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2055
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2056
  while(inlining_progress() && _late_inlines.length() > 0) {
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2057
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2058
    if (live_nodes() > (uint)LiveNodeCountInliningCutoff) {
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2059
      if (low_live_nodes < (uint)LiveNodeCountInliningCutoff * 8 / 10) {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2060
        TracePhase tp("incrementalInline_ideal", &timers[_t_incrInline_ideal]);
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2061
        // PhaseIdealLoop is expensive so we only try it once we are
24946
24b68ccf3fc4 8026796: Make replace_in_map() on parent maps generic
roland
parents: 24923
diff changeset
  2062
        // out of live nodes and we only try it again if the previous
24b68ccf3fc4 8026796: Make replace_in_map() on parent maps generic
roland
parents: 24923
diff changeset
  2063
        // helped got the number of nodes down significantly
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2064
        PhaseIdealLoop ideal_loop( igvn, false, true );
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2065
        if (failing())  return;
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2066
        low_live_nodes = live_nodes();
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2067
        _major_progress = true;
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2068
      }
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2069
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2070
      if (live_nodes() > (uint)LiveNodeCountInliningCutoff) {
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2071
        break;
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2072
      }
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2073
    }
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2074
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2075
    inline_incrementally_one(igvn);
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2076
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2077
    if (failing())  return;
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2078
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2079
    {
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2080
      TracePhase tp("incrementalInline_igvn", &timers[_t_incrInline_igvn]);
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2081
      igvn.optimize();
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2082
    }
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2083
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2084
    if (failing())  return;
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2085
  }
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2086
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2087
  assert( igvn._worklist.size() == 0, "should be done with igvn" );
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2088
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2089
  if (_string_late_inlines.length() > 0) {
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2090
    assert(has_stringbuilder(), "inconsistent");
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2091
    for_igvn()->clear();
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2092
    initial_gvn()->replace_with(&igvn);
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2093
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2094
    inline_string_calls(false);
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2095
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2096
    if (failing())  return;
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2097
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2098
    {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2099
      TracePhase tp("incrementalInline_pru", &timers[_t_incrInline_pru]);
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2100
      ResourceMark rm;
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2101
      PhaseRemoveUseless pru(initial_gvn(), for_igvn());
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2102
    }
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2103
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2104
    {
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2105
      TracePhase tp("incrementalInline_igvn", &timers[_t_incrInline_igvn]);
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2106
      igvn = PhaseIterGVN(gvn);
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2107
      igvn.optimize();
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2108
    }
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2109
  }
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2110
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2111
  set_inlining_incrementally(false);
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2112
}
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2114
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2115
//------------------------------Optimize---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2116
// Given a graph, optimize it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2117
void Compile::Optimize() {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2118
  TracePhase tp("optimizer", &timers[_t_optimizer]);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2119
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2120
#ifndef PRODUCT
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33198
diff changeset
  2121
  if (_directive->BreakAtCompileOption) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2122
    BREAKPOINT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2123
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2124
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2125
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2126
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2127
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2128
  int          loop_opts_cnt;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2129
23846
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  2130
  print_inlining_reinit();
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  2131
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2132
  NOT_PRODUCT( verify_graph_edges(); )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2133
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  2134
  print_method(PHASE_AFTER_PARSING);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2135
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2136
 {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2137
  // Iterative Global Value Numbering, including ideal transforms
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2138
  // Initialize IterGVN with types and values from parse-time GVN
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2139
  PhaseIterGVN igvn(initial_gvn());
25913
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  2140
#ifdef ASSERT
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  2141
  _modified_nodes = new (comp_arena()) Unique_Node_List(comp_arena());
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  2142
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2143
  {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2144
    TracePhase tp("iterGVN", &timers[_t_iterGVN]);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2145
    igvn.optimize();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2146
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2147
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  2148
  print_method(PHASE_ITER_GVN1, 2);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2149
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2150
  if (failing())  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2151
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2152
  inline_incrementally(igvn);
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2153
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  2154
  print_method(PHASE_INCREMENTAL_INLINE, 2);
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2155
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2156
  if (failing())  return;
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  2157
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2158
  if (eliminate_boxing()) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2159
    // Inline valueOf() methods now.
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2160
    inline_boxing_calls(igvn);
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2161
24946
24b68ccf3fc4 8026796: Make replace_in_map() on parent maps generic
roland
parents: 24923
diff changeset
  2162
    if (AlwaysIncrementalInline) {
24b68ccf3fc4 8026796: Make replace_in_map() on parent maps generic
roland
parents: 24923
diff changeset
  2163
      inline_incrementally(igvn);
24b68ccf3fc4 8026796: Make replace_in_map() on parent maps generic
roland
parents: 24923
diff changeset
  2164
    }
24b68ccf3fc4 8026796: Make replace_in_map() on parent maps generic
roland
parents: 24923
diff changeset
  2165
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  2166
    print_method(PHASE_INCREMENTAL_BOXING_INLINE, 2);
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2167
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2168
    if (failing())  return;
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2169
  }
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  2170
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  2171
  // Remove the speculative part of types and clean up the graph from
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  2172
  // the extra CastPP nodes whose only purpose is to carry them. Do
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  2173
  // that early so that optimizations are not disrupted by the extra
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  2174
  // CastPP nodes.
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  2175
  remove_speculative_types(igvn);
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  2176
15618
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  2177
  // No more new expensive nodes will be added to the list from here
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  2178
  // so keep only the actual candidates for optimizations.
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  2179
  cleanup_expensive_nodes(igvn);
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  2180
34503
57d1a0e76091 8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents: 34211
diff changeset
  2181
  if (!failing() && RenumberLiveNodes && live_nodes() + NodeLimitFudgeFactor < unique()) {
57d1a0e76091 8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents: 34211
diff changeset
  2182
    Compile::TracePhase tp("", &timers[_t_renumberLive]);
57d1a0e76091 8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents: 34211
diff changeset
  2183
    initial_gvn()->replace_with(&igvn);
57d1a0e76091 8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents: 34211
diff changeset
  2184
    for_igvn()->clear();
57d1a0e76091 8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents: 34211
diff changeset
  2185
    Unique_Node_List new_worklist(C->comp_arena());
57d1a0e76091 8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents: 34211
diff changeset
  2186
    {
57d1a0e76091 8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents: 34211
diff changeset
  2187
      ResourceMark rm;
57d1a0e76091 8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents: 34211
diff changeset
  2188
      PhaseRenumberLive prl = PhaseRenumberLive(initial_gvn(), for_igvn(), &new_worklist);
57d1a0e76091 8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents: 34211
diff changeset
  2189
    }
57d1a0e76091 8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents: 34211
diff changeset
  2190
    set_for_igvn(&new_worklist);
57d1a0e76091 8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents: 34211
diff changeset
  2191
    igvn = PhaseIterGVN(initial_gvn());
57d1a0e76091 8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents: 34211
diff changeset
  2192
    igvn.optimize();
57d1a0e76091 8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents: 34211
diff changeset
  2193
  }
57d1a0e76091 8129847: Compiling methods generated by Nashorn triggers high memory usage in C2
zmajo
parents: 34211
diff changeset
  2194
5914
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5889
diff changeset
  2195
  // Perform escape analysis
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5889
diff changeset
  2196
  if (_do_escape_analysis && ConnectionGraph::has_candidates(this)) {
10988
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
  2197
    if (has_loops()) {
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
  2198
      // Cleanup graph (remove dead nodes).
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2199
      TracePhase tp("idealLoop", &timers[_t_idealLoop]);
10988
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
  2200
      PhaseIdealLoop ideal_loop( igvn, false, true );
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  2201
      if (major_progress()) print_method(PHASE_PHASEIDEAL_BEFORE_EA, 2);
10988
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
  2202
      if (failing())  return;
a3b2bd43ef4f 7107042: assert(no_dead_loop) failed: dead loop detected
kvn
parents: 10508
diff changeset
  2203
    }
5914
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5889
diff changeset
  2204
    ConnectionGraph::do_analysis(this, &igvn);
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5889
diff changeset
  2205
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5889
diff changeset
  2206
    if (failing())  return;
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5889
diff changeset
  2207
11191
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 11190
diff changeset
  2208
    // Optimize out fields loads from scalar replaceable allocations.
5914
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5889
diff changeset
  2209
    igvn.optimize();
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  2210
    print_method(PHASE_ITER_GVN_AFTER_EA, 2);
5914
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5889
diff changeset
  2211
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5889
diff changeset
  2212
    if (failing())  return;
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5889
diff changeset
  2213
11191
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 11190
diff changeset
  2214
    if (congraph() != NULL && macro_count() > 0) {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2215
      TracePhase tp("macroEliminate", &timers[_t_macroEliminate]);
11191
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 11190
diff changeset
  2216
      PhaseMacroExpand mexp(igvn);
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 11190
diff changeset
  2217
      mexp.eliminate_macro_nodes();
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 11190
diff changeset
  2218
      igvn.set_delay_transform(false);
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 11190
diff changeset
  2219
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 11190
diff changeset
  2220
      igvn.optimize();
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  2221
      print_method(PHASE_ITER_GVN_AFTER_ELIMINATION, 2);
11191
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 11190
diff changeset
  2222
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 11190
diff changeset
  2223
      if (failing())  return;
d54ab5dcba83 6890673: Eliminate allocations immediately after EA
kvn
parents: 11190
diff changeset
  2224
    }
5914
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5889
diff changeset
  2225
  }
8363e7e6915a 6966411: escape.cpp:450 assert(base->Opcode() == Op_ConP
kvn
parents: 5889
diff changeset
  2226
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2227
  // Loop transforms on the ideal graph.  Range Check Elimination,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2228
  // peeling, unrolling, etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2229
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2230
  // Set loop opts counter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2231
  loop_opts_cnt = num_loop_opts();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2232
  if((loop_opts_cnt > 0) && (has_loops() || has_split_ifs())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2233
    {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2234
      TracePhase tp("idealLoop", &timers[_t_idealLoop]);
9101
ff58f9a8e31c 7004535: Clone loop predicate during loop unswitch
kvn
parents: 8868
diff changeset
  2235
      PhaseIdealLoop ideal_loop( igvn, true );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2236
      loop_opts_cnt--;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  2237
      if (major_progress()) print_method(PHASE_PHASEIDEALLOOP1, 2);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2238
      if (failing())  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2239
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2240
    // Loop opts pass if partial peeling occurred in previous pass
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2241
    if(PartialPeelLoop && major_progress() && (loop_opts_cnt > 0)) {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2242
      TracePhase tp("idealLoop", &timers[_t_idealLoop]);
9101
ff58f9a8e31c 7004535: Clone loop predicate during loop unswitch
kvn
parents: 8868
diff changeset
  2243
      PhaseIdealLoop ideal_loop( igvn, false );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2244
      loop_opts_cnt--;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  2245
      if (major_progress()) print_method(PHASE_PHASEIDEALLOOP2, 2);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2246
      if (failing())  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2247
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2248
    // Loop opts pass for loop-unrolling before CCP
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2249
    if(major_progress() && (loop_opts_cnt > 0)) {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2250
      TracePhase tp("idealLoop", &timers[_t_idealLoop]);
9101
ff58f9a8e31c 7004535: Clone loop predicate during loop unswitch
kvn
parents: 8868
diff changeset
  2251
      PhaseIdealLoop ideal_loop( igvn, false );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2252
      loop_opts_cnt--;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  2253
      if (major_progress()) print_method(PHASE_PHASEIDEALLOOP3, 2);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2254
    }
3676
3bac3e882cd3 6862956: PhaseIdealLoop should have a CFG verification mode
never
parents: 3276
diff changeset
  2255
    if (!failing()) {
3bac3e882cd3 6862956: PhaseIdealLoop should have a CFG verification mode
never
parents: 3276
diff changeset
  2256
      // Verify that last round of loop opts produced a valid graph
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2257
      TracePhase tp("idealLoopVerify", &timers[_t_idealLoopVerify]);
3676
3bac3e882cd3 6862956: PhaseIdealLoop should have a CFG verification mode
never
parents: 3276
diff changeset
  2258
      PhaseIdealLoop::verify(igvn);
3bac3e882cd3 6862956: PhaseIdealLoop should have a CFG verification mode
never
parents: 3276
diff changeset
  2259
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2260
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2261
  if (failing())  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2262
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2263
  // Conditional Constant Propagation;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2264
  PhaseCCP ccp( &igvn );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2265
  assert( true, "Break here to ccp.dump_nodes_and_types(_root,999,1)");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2266
  {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2267
    TracePhase tp("ccp", &timers[_t_ccp]);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2268
    ccp.do_transform();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2269
  }
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  2270
  print_method(PHASE_CPP1, 2);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2271
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2272
  assert( true, "Break here to ccp.dump_old2new_map()");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2273
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2274
  // Iterative Global Value Numbering, including ideal transforms
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2275
  {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2276
    TracePhase tp("iterGVN2", &timers[_t_iterGVN2]);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2277
    igvn = ccp;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2278
    igvn.optimize();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2279
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2280
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  2281
  print_method(PHASE_ITER_GVN2, 2);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2282
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2283
  if (failing())  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2284
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2285
  // Loop transforms on the ideal graph.  Range Check Elimination,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2286
  // peeling, unrolling, etc.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2287
  if(loop_opts_cnt > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2288
    debug_only( int cnt = 0; );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2289
    while(major_progress() && (loop_opts_cnt > 0)) {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2290
      TracePhase tp("idealLoop", &timers[_t_idealLoop]);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2291
      assert( cnt++ < 40, "infinite cycle in loop optimization" );
9101
ff58f9a8e31c 7004535: Clone loop predicate during loop unswitch
kvn
parents: 8868
diff changeset
  2292
      PhaseIdealLoop ideal_loop( igvn, true);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2293
      loop_opts_cnt--;
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  2294
      if (major_progress()) print_method(PHASE_PHASEIDEALLOOP_ITERATIONS, 2);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2295
      if (failing())  return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2296
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2297
  }
33160
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 33158
diff changeset
  2298
  // Ensure that major progress is now clear
c59f1676d27e 8136421: JEP 243: Java-Level JVM Compiler Interface
twisti
parents: 33158
diff changeset
  2299
  C->clear_major_progress();
3676
3bac3e882cd3 6862956: PhaseIdealLoop should have a CFG verification mode
never
parents: 3276
diff changeset
  2300
3bac3e882cd3 6862956: PhaseIdealLoop should have a CFG verification mode
never
parents: 3276
diff changeset
  2301
  {
3bac3e882cd3 6862956: PhaseIdealLoop should have a CFG verification mode
never
parents: 3276
diff changeset
  2302
    // Verify that all previous optimizations produced a valid graph
3bac3e882cd3 6862956: PhaseIdealLoop should have a CFG verification mode
never
parents: 3276
diff changeset
  2303
    // at least to this point, even if no loop optimizations were done.
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2304
    TracePhase tp("idealLoopVerify", &timers[_t_idealLoopVerify]);
3676
3bac3e882cd3 6862956: PhaseIdealLoop should have a CFG verification mode
never
parents: 3276
diff changeset
  2305
    PhaseIdealLoop::verify(igvn);
3bac3e882cd3 6862956: PhaseIdealLoop should have a CFG verification mode
never
parents: 3276
diff changeset
  2306
  }
3bac3e882cd3 6862956: PhaseIdealLoop should have a CFG verification mode
never
parents: 3276
diff changeset
  2307
35574
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  2308
  if (range_check_cast_count() > 0) {
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  2309
    // No more loop optimizations. Remove all range check dependent CastIINodes.
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  2310
    C->remove_range_check_casts(igvn);
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  2311
    igvn.optimize();
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  2312
  }
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  2313
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2314
  {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2315
    TracePhase tp("macroExpand", &timers[_t_macroExpand]);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2316
    PhaseMacroExpand  mex(igvn);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2317
    if (mex.expand_macro_nodes()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2318
      assert(failing(), "must bail out w/ explicit message");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2319
      return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2320
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2321
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2322
25913
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  2323
  DEBUG_ONLY( _modified_nodes = NULL; )
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2324
 } // (End scope of igvn; run destructor if necessary for asserts.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2325
35545
a8f29dfd62b2 8139771: Eliminating CastPP nodes at Phis when they all come from a unique input may cause crash
roland
parents: 35071
diff changeset
  2326
 process_print_inlining();
a8f29dfd62b2 8139771: Eliminating CastPP nodes at Phis when they all come from a unique input may cause crash
roland
parents: 35071
diff changeset
  2327
 // A method with only infinite loops has no edges entering loops from root
a8f29dfd62b2 8139771: Eliminating CastPP nodes at Phis when they all come from a unique input may cause crash
roland
parents: 35071
diff changeset
  2328
 {
a8f29dfd62b2 8139771: Eliminating CastPP nodes at Phis when they all come from a unique input may cause crash
roland
parents: 35071
diff changeset
  2329
   TracePhase tp("graphReshape", &timers[_t_graphReshaping]);
a8f29dfd62b2 8139771: Eliminating CastPP nodes at Phis when they all come from a unique input may cause crash
roland
parents: 35071
diff changeset
  2330
   if (final_graph_reshaping()) {
a8f29dfd62b2 8139771: Eliminating CastPP nodes at Phis when they all come from a unique input may cause crash
roland
parents: 35071
diff changeset
  2331
     assert(failing(), "must bail out w/ explicit message");
a8f29dfd62b2 8139771: Eliminating CastPP nodes at Phis when they all come from a unique input may cause crash
roland
parents: 35071
diff changeset
  2332
     return;
a8f29dfd62b2 8139771: Eliminating CastPP nodes at Phis when they all come from a unique input may cause crash
roland
parents: 35071
diff changeset
  2333
   }
a8f29dfd62b2 8139771: Eliminating CastPP nodes at Phis when they all come from a unique input may cause crash
roland
parents: 35071
diff changeset
  2334
 }
a8f29dfd62b2 8139771: Eliminating CastPP nodes at Phis when they all come from a unique input may cause crash
roland
parents: 35071
diff changeset
  2335
a8f29dfd62b2 8139771: Eliminating CastPP nodes at Phis when they all come from a unique input may cause crash
roland
parents: 35071
diff changeset
  2336
 print_method(PHASE_OPTIMIZE_FINISHED, 2);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2337
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2338
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2339
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2340
//------------------------------Code_Gen---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2341
// Given a graph, generate code for it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2342
void Compile::Code_Gen() {
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2343
  if (failing()) {
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2344
    return;
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2345
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2346
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2347
  // Perform instruction selection.  You might think we could reclaim Matcher
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2348
  // memory PDQ, but actually the Matcher is used in generating spill code.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2349
  // Internals of the Matcher (including some VectorSets) must remain live
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2350
  // for awhile - thus I cannot reclaim Matcher memory lest a VectorSet usage
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2351
  // set a bit in reclaimed memory.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2352
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2353
  // In debug mode can dump m._nodes.dump() for mapping of ideal to machine
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2354
  // nodes.  Mapping is only valid at the root of each matched subtree.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2355
  NOT_PRODUCT( verify_graph_edges(); )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2356
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2357
  Matcher matcher;
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2358
  _matcher = &matcher;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2359
  {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2360
    TracePhase tp("matcher", &timers[_t_matcher]);
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2361
    matcher.match();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2362
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2363
  // In debug mode can dump m._nodes.dump() for mapping of ideal to machine
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2364
  // nodes.  Mapping is only valid at the root of each matched subtree.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2365
  NOT_PRODUCT( verify_graph_edges(); )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2366
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2367
  // If you have too many nodes, or if matching has failed, bail out
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2368
  check_node_count(0, "out of nodes matching instructions");
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2369
  if (failing()) {
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2370
    return;
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2371
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2372
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2373
  // Build a proper-looking CFG
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2374
  PhaseCFG cfg(node_arena(), root(), matcher);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2375
  _cfg = &cfg;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2376
  {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2377
    TracePhase tp("scheduler", &timers[_t_scheduler]);
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2378
    bool success = cfg.do_global_code_motion();
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2379
    if (!success) {
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2380
      return;
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2381
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2382
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  2383
    print_method(PHASE_GLOBAL_CODE_MOTION, 2);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2384
    NOT_PRODUCT( verify_graph_edges(); )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2385
    debug_only( cfg.verify(); )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2386
  }
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2387
33065
55892792936f 8134802: LCM register pressure scheduling
mcberg
parents: 32202
diff changeset
  2388
  PhaseChaitin regalloc(unique(), cfg, matcher, false);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2389
  _regalloc = &regalloc;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2390
  {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2391
    TracePhase tp("regalloc", &timers[_t_registerAllocation]);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2392
    // Perform register allocation.  After Chaitin, use-def chains are
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2393
    // no longer accurate (at spill code) and so must be ignored.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2394
    // Node->LRG->reg mappings are still accurate.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2395
    _regalloc->Register_Allocate();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2396
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2397
    // Bail out if the allocator builds too many nodes
17013
22a05c7f3314 8011621: live_ranges_in_separate_class.patch
neliasso
parents: 16670
diff changeset
  2398
    if (failing()) {
22a05c7f3314 8011621: live_ranges_in_separate_class.patch
neliasso
parents: 16670
diff changeset
  2399
      return;
22a05c7f3314 8011621: live_ranges_in_separate_class.patch
neliasso
parents: 16670
diff changeset
  2400
    }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2401
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2402
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2403
  // Prior to register allocation we kept empty basic blocks in case the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2404
  // the allocator needed a place to spill.  After register allocation we
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2405
  // are not adding any new instructions.  If any basic block is empty, we
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2406
  // can now safely remove it.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2407
  {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2408
    TracePhase tp("blockOrdering", &timers[_t_blockOrdering]);
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2409
    cfg.remove_empty_blocks();
1498
346bf226078e 6743900: frequency based block layout
rasbold
parents: 1497
diff changeset
  2410
    if (do_freq_based_layout()) {
346bf226078e 6743900: frequency based block layout
rasbold
parents: 1497
diff changeset
  2411
      PhaseBlockLayout layout(cfg);
346bf226078e 6743900: frequency based block layout
rasbold
parents: 1497
diff changeset
  2412
    } else {
346bf226078e 6743900: frequency based block layout
rasbold
parents: 1497
diff changeset
  2413
      cfg.set_loop_alignment();
346bf226078e 6743900: frequency based block layout
rasbold
parents: 1497
diff changeset
  2414
    }
346bf226078e 6743900: frequency based block layout
rasbold
parents: 1497
diff changeset
  2415
    cfg.fixup_flow();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2416
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2417
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2418
  // Apply peephole optimizations
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2419
  if( OptoPeephole ) {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2420
    TracePhase tp("peephole", &timers[_t_peephole]);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2421
    PhasePeephole peep( _regalloc, cfg);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2422
    peep.do_transform();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2423
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2424
22844
90f76a40ed8a 8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents: 22838
diff changeset
  2425
  // Do late expand if CPU requires this.
90f76a40ed8a 8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents: 22838
diff changeset
  2426
  if (Matcher::require_postalloc_expand) {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2427
    TracePhase tp("postalloc_expand", &timers[_t_postalloc_expand]);
22844
90f76a40ed8a 8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents: 22838
diff changeset
  2428
    cfg.postalloc_expand(_regalloc);
90f76a40ed8a 8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents: 22838
diff changeset
  2429
  }
90f76a40ed8a 8003854: PPC64 (part 115): Introduce PostallocExpand that expands nodes after register allocation
goetz
parents: 22838
diff changeset
  2430
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2431
  // Convert Nodes to instruction bits in a buffer
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2432
  {
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  2433
    TraceTime tp("output", &timers[_t_output], CITime);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2434
    Output();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2435
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2436
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  2437
  print_method(PHASE_FINAL_CODE);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2438
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2439
  // He's dead, Jim.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2440
  _cfg     = (PhaseCFG*)0xdeadbeef;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2441
  _regalloc = (PhaseChaitin*)0xdeadbeef;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2442
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2443
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2444
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2445
//------------------------------dump_asm---------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2446
// Dump formatted assembly
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2447
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2448
void Compile::dump_asm(int *pcs, uint pc_limit) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2449
  bool cut_short = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2450
  tty->print_cr("#");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2451
  tty->print("#  ");  _tf->dump();  tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2452
  tty->print_cr("#");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2453
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2454
  // For all blocks
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2455
  int pc = 0x0;                 // Program counter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2456
  char starts_bundle = ' ';
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2457
  _regalloc->dump_frame();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2458
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2459
  Node *n = NULL;
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2460
  for (uint i = 0; i < _cfg->number_of_blocks(); i++) {
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2461
    if (VMThread::should_terminate()) {
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2462
      cut_short = true;
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2463
      break;
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2464
    }
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2465
    Block* block = _cfg->get_block(i);
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2466
    if (block->is_connector() && !Verbose) {
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2467
      continue;
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2468
    }
19717
7819ffdaf0ff 8023691: Create interface for nodes in class Block
adlertz
parents: 19330
diff changeset
  2469
    n = block->head();
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2470
    if (pcs && n->_idx < pc_limit) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2471
      tty->print("%3.3x   ", pcs[n->_idx]);
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2472
    } else {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2473
      tty->print("      ");
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2474
    }
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2475
    block->dump_head(_cfg);
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2476
    if (block->is_connector()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2477
      tty->print_cr("        # Empty connector block");
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2478
    } else if (block->num_preds() == 2 && block->pred(1)->is_CatchProj() && block->pred(1)->as_CatchProj()->_con == CatchProjNode::fall_through_index) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2479
      tty->print_cr("        # Block is sole successor of call");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2480
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2481
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2482
    // For all instructions
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2483
    Node *delay = NULL;
19717
7819ffdaf0ff 8023691: Create interface for nodes in class Block
adlertz
parents: 19330
diff changeset
  2484
    for (uint j = 0; j < block->number_of_nodes(); j++) {
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2485
      if (VMThread::should_terminate()) {
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2486
        cut_short = true;
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2487
        break;
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2488
      }
19717
7819ffdaf0ff 8023691: Create interface for nodes in class Block
adlertz
parents: 19330
diff changeset
  2489
      n = block->get_node(j);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2490
      if (valid_bundle_info(n)) {
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2491
        Bundle* bundle = node_bundling(n);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2492
        if (bundle->used_in_unconditional_delay()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2493
          delay = n;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2494
          continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2495
        }
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2496
        if (bundle->starts_bundle()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2497
          starts_bundle = '+';
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2498
        }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2499
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2500
19330
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2501
      if (WizardMode) {
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2502
        n->dump();
49d6711171e6 8023003: Cleanup the public interface to PhaseCFG
adlertz
parents: 19279
diff changeset
  2503
      }
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 347
diff changeset
  2504
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2505
      if( !n->is_Region() &&    // Dont print in the Assembly
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2506
          !n->is_Phi() &&       // a few noisely useless nodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2507
          !n->is_Proj() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2508
          !n->is_MachTemp() &&
4470
1e6edcab3109 6895383: JCK test throws NPE for method compiled with Escape Analysis
kvn
parents: 4450
diff changeset
  2509
          !n->is_SafePointScalarObject() &&
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2510
          !n->is_Catch() &&     // Would be nice to print exception table targets
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2511
          !n->is_MergeMem() &&  // Not very interesting
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2512
          !n->is_top() &&       // Debug info table constants
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2513
          !(n->is_Con() && !n->is_Mach())// Debug info table constants
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2514
          ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2515
        if (pcs && n->_idx < pc_limit)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2516
          tty->print("%3.3x", pcs[n->_idx]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2517
        else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2518
          tty->print("   ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2519
        tty->print(" %c ", starts_bundle);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2520
        starts_bundle = ' ';
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2521
        tty->print("\t");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2522
        n->format(_regalloc, tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2523
        tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2524
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2525
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2526
      // If we have an instruction with a delay slot, and have seen a delay,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2527
      // then back up and print it
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2528
      if (valid_bundle_info(n) && node_bundling(n)->use_unconditional_delay()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2529
        assert(delay != NULL, "no unconditional delay instruction");
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 347
diff changeset
  2530
        if (WizardMode) delay->dump();
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 347
diff changeset
  2531
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2532
        if (node_bundling(delay)->starts_bundle())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2533
          starts_bundle = '+';
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2534
        if (pcs && n->_idx < pc_limit)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2535
          tty->print("%3.3x", pcs[n->_idx]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2536
        else
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2537
          tty->print("   ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2538
        tty->print(" %c ", starts_bundle);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2539
        starts_bundle = ' ';
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2540
        tty->print("\t");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2541
        delay->format(_regalloc, tty);
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24342
diff changeset
  2542
        tty->cr();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2543
        delay = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2544
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2545
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2546
      // Dump the exception table as well
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2547
      if( n->is_Catch() && (Verbose || WizardMode) ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2548
        // Print the exception table for this offset
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2549
        _handler_table.print_subtable_for(pc);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2550
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2551
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2552
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2553
    if (pcs && n->_idx < pc_limit)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2554
      tty->print_cr("%3.3x", pcs[n->_idx]);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2555
    else
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24342
diff changeset
  2556
      tty->cr();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2557
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2558
    assert(cut_short || delay == NULL, "no unconditional delay branch");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2559
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2560
  } // End of per-block dump
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24342
diff changeset
  2561
  tty->cr();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2562
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2563
  if (cut_short)  tty->print_cr("*** disassembly is cut short ***");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2564
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2565
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2566
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2567
//------------------------------Final_Reshape_Counts---------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2568
// This class defines counters to help identify when a method
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2569
// may/must be executed using hardware with only 24-bit precision.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2570
struct Final_Reshape_Counts : public StackObj {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2571
  int  _call_count;             // count non-inlined 'common' calls
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2572
  int  _float_count;            // count float ops requiring 24-bit precision
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2573
  int  _double_count;           // count double ops requiring more precision
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2574
  int  _java_call_count;        // count non-inlined 'java' calls
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  2575
  int  _inner_loop_count;       // count loops which need alignment
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2576
  VectorSet _visited;           // Visitation flags
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2577
  Node_List _tests;             // Set of IfNodes & PCTableNodes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2578
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2579
  Final_Reshape_Counts() :
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  2580
    _call_count(0), _float_count(0), _double_count(0),
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  2581
    _java_call_count(0), _inner_loop_count(0),
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2582
    _visited( Thread::current()->resource_area() ) { }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2583
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2584
  void inc_call_count  () { _call_count  ++; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2585
  void inc_float_count () { _float_count ++; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2586
  void inc_double_count() { _double_count++; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2587
  void inc_java_call_count() { _java_call_count++; }
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  2588
  void inc_inner_loop_count() { _inner_loop_count++; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2589
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2590
  int  get_call_count  () const { return _call_count  ; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2591
  int  get_float_count () const { return _float_count ; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2592
  int  get_double_count() const { return _double_count; }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2593
  int  get_java_call_count() const { return _java_call_count; }
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  2594
  int  get_inner_loop_count() const { return _inner_loop_count; }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2595
};
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2596
16670
4af09aff4237 8003310: Enable -Wunused-function when compiling with gcc
mikael
parents: 15946
diff changeset
  2597
#ifdef ASSERT
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2598
static bool oop_offset_is_sane(const TypeInstPtr* tp) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2599
  ciInstanceKlass *k = tp->klass()->as_instance_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2600
  // Make sure the offset goes inside the instance layout.
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 347
diff changeset
  2601
  return k->contains_field_offset(tp->offset());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2602
  // Note that OffsetBot and OffsetTop are very negative.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2603
}
16670
4af09aff4237 8003310: Enable -Wunused-function when compiling with gcc
mikael
parents: 15946
diff changeset
  2604
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2605
9175
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2606
// Eliminate trivially redundant StoreCMs and accumulate their
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2607
// precedence edges.
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  2608
void Compile::eliminate_redundant_card_marks(Node* n) {
9175
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2609
  assert(n->Opcode() == Op_StoreCM, "expected StoreCM");
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2610
  if (n->in(MemNode::Address)->outcnt() > 1) {
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2611
    // There are multiple users of the same address so it might be
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2612
    // possible to eliminate some of the StoreCMs
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2613
    Node* mem = n->in(MemNode::Memory);
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2614
    Node* adr = n->in(MemNode::Address);
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2615
    Node* val = n->in(MemNode::ValueIn);
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2616
    Node* prev = n;
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2617
    bool done = false;
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2618
    // Walk the chain of StoreCMs eliminating ones that match.  As
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2619
    // long as it's a chain of single users then the optimization is
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2620
    // safe.  Eliminating partially redundant StoreCMs would require
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2621
    // cloning copies down the other paths.
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2622
    while (mem->Opcode() == Op_StoreCM && mem->outcnt() == 1 && !done) {
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2623
      if (adr == mem->in(MemNode::Address) &&
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2624
          val == mem->in(MemNode::ValueIn)) {
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2625
        // redundant StoreCM
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2626
        if (mem->req() > MemNode::OopStore) {
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2627
          // Hasn't been processed by this code yet.
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2628
          n->add_prec(mem->in(MemNode::OopStore));
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2629
        } else {
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2630
          // Already converted to precedence edge
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2631
          for (uint i = mem->req(); i < mem->len(); i++) {
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2632
            // Accumulate any precedence edges
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2633
            if (mem->in(i) != NULL) {
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2634
              n->add_prec(mem->in(i));
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2635
            }
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2636
          }
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2637
          // Everything above this point has been processed.
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2638
          done = true;
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2639
        }
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2640
        // Eliminate the previous StoreCM
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2641
        prev->set_req(MemNode::Memory, mem->in(MemNode::Memory));
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2642
        assert(mem->outcnt() == 0, "should be dead");
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  2643
        mem->disconnect_inputs(NULL, this);
9175
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2644
      } else {
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2645
        prev = mem;
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2646
      }
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2647
      mem = prev->in(MemNode::Memory);
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2648
    }
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2649
  }
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2650
}
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2651
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2652
//------------------------------final_graph_reshaping_impl----------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2653
// Implement items 1-5 from final_graph_reshaping below.
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  2654
void Compile::final_graph_reshaping_impl( Node *n, Final_Reshape_Counts &frc) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2655
594
9f4474e5dbaf 6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents: 590
diff changeset
  2656
  if ( n->outcnt() == 0 ) return; // dead node
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2657
  uint nop = n->Opcode();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2658
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2659
  // Check for 2-input instruction with "last use" on right input.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2660
  // Swap to left input.  Implements item (2).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2661
  if( n->req() == 3 &&          // two-input instruction
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2662
      n->in(1)->outcnt() > 1 && // left use is NOT a last use
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2663
      (!n->in(1)->is_Phi() || n->in(1)->in(2) != n) && // it is not data loop
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2664
      n->in(2)->outcnt() == 1 &&// right use IS a last use
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2665
      !n->in(2)->is_Con() ) {   // right use is not a constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2666
    // Check for commutative opcode
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2667
    switch( nop ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2668
    case Op_AddI:  case Op_AddF:  case Op_AddD:  case Op_AddL:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2669
    case Op_MaxI:  case Op_MinI:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2670
    case Op_MulI:  case Op_MulF:  case Op_MulD:  case Op_MulL:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2671
    case Op_AndL:  case Op_XorL:  case Op_OrL:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2672
    case Op_AndI:  case Op_XorI:  case Op_OrI: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2673
      // Move "last use" input to left by swapping inputs
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2674
      n->swap_edges(1, 2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2675
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2676
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2677
    default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2678
      break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2679
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2680
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2681
5889
13152be884e5 6959430: Make sure raw loads have control edge
kvn
parents: 5702
diff changeset
  2682
#ifdef ASSERT
13152be884e5 6959430: Make sure raw loads have control edge
kvn
parents: 5702
diff changeset
  2683
  if( n->is_Mem() ) {
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  2684
    int alias_idx = get_alias_index(n->as_Mem()->adr_type());
5889
13152be884e5 6959430: Make sure raw loads have control edge
kvn
parents: 5702
diff changeset
  2685
    assert( n->in(0) != NULL || alias_idx != Compile::AliasIdxRaw ||
13152be884e5 6959430: Make sure raw loads have control edge
kvn
parents: 5702
diff changeset
  2686
            // oop will be recorded in oop map if load crosses safepoint
13152be884e5 6959430: Make sure raw loads have control edge
kvn
parents: 5702
diff changeset
  2687
            n->is_Load() && (n->as_Load()->bottom_type()->isa_oopptr() ||
13152be884e5 6959430: Make sure raw loads have control edge
kvn
parents: 5702
diff changeset
  2688
                             LoadNode::is_immutable_value(n->in(MemNode::Address))),
13152be884e5 6959430: Make sure raw loads have control edge
kvn
parents: 5702
diff changeset
  2689
            "raw memory operations should have control edge");
13152be884e5 6959430: Make sure raw loads have control edge
kvn
parents: 5702
diff changeset
  2690
  }
13152be884e5 6959430: Make sure raw loads have control edge
kvn
parents: 5702
diff changeset
  2691
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2692
  // Count FPU ops and common calls, implements item (3)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2693
  switch( nop ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2694
  // Count all float operations that may use FPU
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2695
  case Op_AddF:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2696
  case Op_SubF:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2697
  case Op_MulF:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2698
  case Op_DivF:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2699
  case Op_NegF:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2700
  case Op_ModF:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2701
  case Op_ConvI2F:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2702
  case Op_ConF:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2703
  case Op_CmpF:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2704
  case Op_CmpF3:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2705
  // case Op_ConvL2F: // longs are split into 32-bit halves
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  2706
    frc.inc_float_count();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2707
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2708
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2709
  case Op_ConvF2D:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2710
  case Op_ConvD2F:
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  2711
    frc.inc_float_count();
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  2712
    frc.inc_double_count();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2713
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2714
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2715
  // Count all double operations that may use FPU
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2716
  case Op_AddD:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2717
  case Op_SubD:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2718
  case Op_MulD:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2719
  case Op_DivD:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2720
  case Op_NegD:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2721
  case Op_ModD:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2722
  case Op_ConvI2D:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2723
  case Op_ConvD2I:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2724
  // case Op_ConvL2D: // handled by leaf call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2725
  // case Op_ConvD2L: // handled by leaf call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2726
  case Op_ConD:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2727
  case Op_CmpD:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2728
  case Op_CmpD3:
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  2729
    frc.inc_double_count();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2730
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2731
  case Op_Opaque1:              // Remove Opaque Nodes before matching
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2732
  case Op_Opaque2:              // Remove Opaque Nodes before matching
23491
f690330b10b9 8031320: Use Intel RTM instructions for locks
kvn
parents: 22916
diff changeset
  2733
  case Op_Opaque3:
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  2734
    n->subsume_by(n->in(1), this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2735
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2736
  case Op_CallStaticJava:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2737
  case Op_CallJava:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2738
  case Op_CallDynamicJava:
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  2739
    frc.inc_java_call_count(); // Count java call site;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2740
  case Op_CallRuntime:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2741
  case Op_CallLeaf:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2742
  case Op_CallLeafNoFP: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2743
    assert( n->is_Call(), "" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2744
    CallNode *call = n->as_Call();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2745
    // Count call sites where the FP mode bit would have to be flipped.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2746
    // Do not count uncommon runtime calls:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2747
    // uncommon_trap, _complete_monitor_locking, _complete_monitor_unlocking,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2748
    // _new_Java, _new_typeArray, _new_objArray, _rethrow_Java, ...
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2749
    if( !call->is_CallStaticJava() || !call->as_CallStaticJava()->_name ) {
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  2750
      frc.inc_call_count();   // Count the call site
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2751
    } else {                  // See if uncommon argument is shared
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2752
      Node *n = call->in(TypeFunc::Parms);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2753
      int nop = n->Opcode();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2754
      // Clone shared simple arguments to uncommon calls, item (1).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2755
      if( n->outcnt() > 1 &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2756
          !n->is_Proj() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2757
          nop != Op_CreateEx &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2758
          nop != Op_CheckCastPP &&
1135
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  2759
          nop != Op_DecodeN &&
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  2760
          nop != Op_DecodeNKlass &&
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2761
          !n->is_Mem() ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2762
        Node *x = n->clone();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2763
        call->set_req( TypeFunc::Parms, x );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2764
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2765
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2766
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2767
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2768
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2769
  case Op_StoreD:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2770
  case Op_LoadD:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2771
  case Op_LoadD_unaligned:
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  2772
    frc.inc_double_count();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2773
    goto handle_mem;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2774
  case Op_StoreF:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2775
  case Op_LoadF:
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  2776
    frc.inc_float_count();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2777
    goto handle_mem;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2778
9175
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2779
  case Op_StoreCM:
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2780
    {
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2781
      // Convert OopStore dependence into precedence edge
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2782
      Node* prec = n->in(MemNode::OopStore);
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2783
      n->del_req(MemNode::OopStore);
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2784
      n->add_prec(prec);
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2785
      eliminate_redundant_card_marks(n);
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2786
    }
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2787
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2788
    // fall through
80221fe09772 7032963: StoreCM shouldn't participate in store elimination
never
parents: 8725
diff changeset
  2789
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2790
  case Op_StoreB:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2791
  case Op_StoreC:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2792
  case Op_StorePConditional:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2793
  case Op_StoreI:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2794
  case Op_StoreL:
1500
bea9a90f3e8f 6462850: generate biased locking code in C2 ideal graph
kvn
parents: 1498
diff changeset
  2795
  case Op_StoreIConditional:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2796
  case Op_StoreLConditional:
39419
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38286
diff changeset
  2797
  case Op_CompareAndSwapB:
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38286
diff changeset
  2798
  case Op_CompareAndSwapS:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2799
  case Op_CompareAndSwapI:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2800
  case Op_CompareAndSwapL:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2801
  case Op_CompareAndSwapP:
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 347
diff changeset
  2802
  case Op_CompareAndSwapN:
39419
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38286
diff changeset
  2803
  case Op_WeakCompareAndSwapB:
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38286
diff changeset
  2804
  case Op_WeakCompareAndSwapS:
36316
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 36315
diff changeset
  2805
  case Op_WeakCompareAndSwapI:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 36315
diff changeset
  2806
  case Op_WeakCompareAndSwapL:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 36315
diff changeset
  2807
  case Op_WeakCompareAndSwapP:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 36315
diff changeset
  2808
  case Op_WeakCompareAndSwapN:
39419
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38286
diff changeset
  2809
  case Op_CompareAndExchangeB:
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38286
diff changeset
  2810
  case Op_CompareAndExchangeS:
36316
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 36315
diff changeset
  2811
  case Op_CompareAndExchangeI:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 36315
diff changeset
  2812
  case Op_CompareAndExchangeL:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 36315
diff changeset
  2813
  case Op_CompareAndExchangeP:
7a83de7aabca 8148146: Integrate new internal Unsafe entry points, and basic intrinsic support for VarHandles
shade
parents: 36315
diff changeset
  2814
  case Op_CompareAndExchangeN:
39419
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38286
diff changeset
  2815
  case Op_GetAndAddS:
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38286
diff changeset
  2816
  case Op_GetAndAddB:
13886
8d82c4dfa722 7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents: 13883
diff changeset
  2817
  case Op_GetAndAddI:
8d82c4dfa722 7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents: 13883
diff changeset
  2818
  case Op_GetAndAddL:
39419
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38286
diff changeset
  2819
  case Op_GetAndSetS:
cc993a4ab581 8157726: VarHandles/Unsafe should support sub-word atomic ops
shade
parents: 38286
diff changeset
  2820
  case Op_GetAndSetB:
13886
8d82c4dfa722 7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents: 13883
diff changeset
  2821
  case Op_GetAndSetI:
8d82c4dfa722 7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents: 13883
diff changeset
  2822
  case Op_GetAndSetL:
8d82c4dfa722 7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents: 13883
diff changeset
  2823
  case Op_GetAndSetP:
8d82c4dfa722 7023898: Intrinsify AtomicLongFieldUpdater.getAndIncrement()
roland
parents: 13883
diff changeset
  2824
  case Op_GetAndSetN:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2825
  case Op_StoreP:
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 347
diff changeset
  2826
  case Op_StoreN:
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  2827
  case Op_StoreNKlass:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2828
  case Op_LoadB:
2150
0d91d17158cc 6797305: Add LoadUB and LoadUI opcode class
twisti
parents: 2131
diff changeset
  2829
  case Op_LoadUB:
2022
28ce8115a91d 6796746: rename LoadC (char) opcode class to LoadUS (unsigned short)
twisti
parents: 1679
diff changeset
  2830
  case Op_LoadUS:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2831
  case Op_LoadI:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2832
  case Op_LoadKlass:
590
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 589
diff changeset
  2833
  case Op_LoadNKlass:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2834
  case Op_LoadL:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2835
  case Op_LoadL_unaligned:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2836
  case Op_LoadPLocked:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2837
  case Op_LoadP:
360
21d113ecbf6a 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes
coleenp
parents: 347
diff changeset
  2838
  case Op_LoadN:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2839
  case Op_LoadRange:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2840
  case Op_LoadS: {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2841
  handle_mem:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2842
#ifdef ASSERT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2843
    if( VerifyOptoOopOffsets ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2844
      assert( n->is_Mem(), "" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2845
      MemNode *mem  = (MemNode*)n;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2846
      // Check to see if address types have grounded out somehow.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2847
      const TypeInstPtr *tp = mem->in(MemNode::Address)->bottom_type()->isa_instptr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2848
      assert( !tp || oop_offset_is_sane(tp), "" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2849
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2850
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2851
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2852
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2853
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2854
  case Op_AddP: {               // Assert sane base pointers
608
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2855
    Node *addp = n->in(AddPNode::Address);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2856
    assert( !addp->is_AddP() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2857
            addp->in(AddPNode::Base)->is_top() || // Top OK for allocation
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2858
            addp->in(AddPNode::Base) == n->in(AddPNode::Base),
38140
7816bbb2e84a 8154836: VM crash due to "Base pointers must match"
mdoerr
parents: 38133
diff changeset
  2859
            "Base pointers must match (addp %u)", addp->_idx );
608
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2860
#ifdef _LP64
19979
ebe1dbb6e1aa 8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents: 19717
diff changeset
  2861
    if ((UseCompressedOops || UseCompressedClassPointers) &&
608
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2862
        addp->Opcode() == Op_ConP &&
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2863
        addp == n->in(AddPNode::Base) &&
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2864
        n->in(AddPNode::Offset)->is_Con()) {
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2865
      // Use addressing with narrow klass to load with offset on x86.
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2866
      // On sparc loading 32-bits constant and decoding it have less
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2867
      // instructions (4) then load 64-bits constant (7).
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2868
      // Do this transformation here since IGVN will convert ConN back to ConP.
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2869
      const Type* t = addp->bottom_type();
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  2870
      if (t->isa_oopptr() || t->isa_klassptr()) {
608
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2871
        Node* nn = NULL;
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2872
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  2873
        int op = t->isa_oopptr() ? Op_ConN : Op_ConNKlass;
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  2874
608
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2875
        // Look for existing ConN node of the same exact type.
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  2876
        Node* r  = root();
608
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2877
        uint cnt = r->outcnt();
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2878
        for (uint i = 0; i < cnt; i++) {
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2879
          Node* m = r->raw_out(i);
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  2880
          if (m!= NULL && m->Opcode() == op &&
767
64fb1fd7186d 6710487: More than half of JDI Regression tests hang with COOPs in -Xcomp mode
kvn
parents: 608
diff changeset
  2881
              m->bottom_type()->make_ptr() == t) {
608
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2882
            nn = m;
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2883
            break;
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2884
          }
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2885
        }
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2886
        if (nn != NULL) {
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2887
          // Decode a narrow oop to match address
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2888
          // [R12 + narrow_oop_reg<<3 + offset]
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  2889
          if (t->isa_oopptr()) {
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 24673
diff changeset
  2890
            nn = new DecodeNNode(nn, t);
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  2891
          } else {
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 24673
diff changeset
  2892
            nn = new DecodeNKlassNode(nn, t);
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  2893
          }
38140
7816bbb2e84a 8154836: VM crash due to "Base pointers must match"
mdoerr
parents: 38133
diff changeset
  2894
          // Check for succeeding AddP which uses the same Base.
7816bbb2e84a 8154836: VM crash due to "Base pointers must match"
mdoerr
parents: 38133
diff changeset
  2895
          // Otherwise we will run into the assertion above when visiting that guy.
7816bbb2e84a 8154836: VM crash due to "Base pointers must match"
mdoerr
parents: 38133
diff changeset
  2896
          for (uint i = 0; i < n->outcnt(); ++i) {
7816bbb2e84a 8154836: VM crash due to "Base pointers must match"
mdoerr
parents: 38133
diff changeset
  2897
            Node *out_i = n->raw_out(i);
7816bbb2e84a 8154836: VM crash due to "Base pointers must match"
mdoerr
parents: 38133
diff changeset
  2898
            if (out_i && out_i->is_AddP() && out_i->in(AddPNode::Base) == addp) {
7816bbb2e84a 8154836: VM crash due to "Base pointers must match"
mdoerr
parents: 38133
diff changeset
  2899
              out_i->set_req(AddPNode::Base, nn);
7816bbb2e84a 8154836: VM crash due to "Base pointers must match"
mdoerr
parents: 38133
diff changeset
  2900
#ifdef ASSERT
7816bbb2e84a 8154836: VM crash due to "Base pointers must match"
mdoerr
parents: 38133
diff changeset
  2901
              for (uint j = 0; j < out_i->outcnt(); ++j) {
7816bbb2e84a 8154836: VM crash due to "Base pointers must match"
mdoerr
parents: 38133
diff changeset
  2902
                Node *out_j = out_i->raw_out(j);
7816bbb2e84a 8154836: VM crash due to "Base pointers must match"
mdoerr
parents: 38133
diff changeset
  2903
                assert(out_j == NULL || !out_j->is_AddP() || out_j->in(AddPNode::Base) != addp,
7816bbb2e84a 8154836: VM crash due to "Base pointers must match"
mdoerr
parents: 38133
diff changeset
  2904
                       "more than 2 AddP nodes in a chain (out_j %u)", out_j->_idx);
7816bbb2e84a 8154836: VM crash due to "Base pointers must match"
mdoerr
parents: 38133
diff changeset
  2905
              }
7816bbb2e84a 8154836: VM crash due to "Base pointers must match"
mdoerr
parents: 38133
diff changeset
  2906
#endif
7816bbb2e84a 8154836: VM crash due to "Base pointers must match"
mdoerr
parents: 38133
diff changeset
  2907
            }
7816bbb2e84a 8154836: VM crash due to "Base pointers must match"
mdoerr
parents: 38133
diff changeset
  2908
          }
608
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2909
          n->set_req(AddPNode::Base, nn);
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2910
          n->set_req(AddPNode::Address, nn);
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2911
          if (addp->outcnt() == 0) {
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  2912
            addp->disconnect_inputs(NULL, this);
608
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2913
          }
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2914
        }
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2915
      }
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2916
    }
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 594
diff changeset
  2917
#endif
38286
0ddb6f84e138 8154826: AArch64: take advantage better of base + shifted offset addressing mode
roland
parents: 38236
diff changeset
  2918
    // platform dependent reshaping of the address expression
0ddb6f84e138 8154826: AArch64: take advantage better of base + shifted offset addressing mode
roland
parents: 38236
diff changeset
  2919
    reshape_address(n->as_AddP());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2920
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2921
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  2922
30300
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2923
  case Op_CastPP: {
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2924
    // Remove CastPP nodes to gain more freedom during scheduling but
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2925
    // keep the dependency they encode as control or precedence edges
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2926
    // (if control is set already) on memory operations. Some CastPP
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2927
    // nodes don't have a control (don't carry a dependency): skip
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2928
    // those.
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2929
    if (n->in(0) != NULL) {
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2930
      ResourceMark rm;
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2931
      Unique_Node_List wq;
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2932
      wq.push(n);
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2933
      for (uint next = 0; next < wq.size(); ++next) {
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2934
        Node *m = wq.at(next);
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2935
        for (DUIterator_Fast imax, i = m->fast_outs(imax); i < imax; i++) {
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2936
          Node* use = m->fast_out(i);
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2937
          if (use->is_Mem() || use->is_EncodeNarrowPtr()) {
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2938
            use->ensure_control_or_add_prec(n->in(0));
35545
a8f29dfd62b2 8139771: Eliminating CastPP nodes at Phis when they all come from a unique input may cause crash
roland
parents: 35071
diff changeset
  2939
          } else {
30300
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2940
            switch(use->Opcode()) {
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2941
            case Op_AddP:
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2942
            case Op_DecodeN:
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2943
            case Op_DecodeNKlass:
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2944
            case Op_CheckCastPP:
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2945
            case Op_CastPP:
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2946
              wq.push(use);
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2947
              break;
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2948
            }
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2949
          }
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2950
        }
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2951
      }
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2952
    }
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2953
    const bool is_LP64 = LP64_ONLY(true) NOT_LP64(false);
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2954
    if (is_LP64 && n->in(1)->is_DecodeN() && Matcher::gen_narrow_oop_implicit_null_checks()) {
1400
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2955
      Node* in1 = n->in(1);
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2956
      const Type* t = n->bottom_type();
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2957
      Node* new_in1 = in1->clone();
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2958
      new_in1->as_DecodeN()->set_type(t);
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2959
5698
091095915ee6 6954029: Improve implicit null check generation with compressed oops
kvn
parents: 5353
diff changeset
  2960
      if (!Matcher::narrow_oop_use_complex_address()) {
1400
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2961
        //
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2962
        // x86, ARM and friends can handle 2 adds in addressing mode
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2963
        // and Matcher can fold a DecodeN node into address by using
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2964
        // a narrow oop directly and do implicit NULL check in address:
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2965
        //
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2966
        // [R12 + narrow_oop_reg<<3 + offset]
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2967
        // NullCheck narrow_oop_reg
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2968
        //
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2969
        // On other platforms (Sparc) we have to keep new DecodeN node and
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2970
        // use it to do implicit NULL check in address:
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2971
        //
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2972
        // decode_not_null narrow_oop_reg, base_reg
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2973
        // [base_reg + offset]
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2974
        // NullCheck base_reg
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2975
        //
2131
98f9cef66a34 6810672: Comment typos
twisti
parents: 2022
diff changeset
  2976
        // Pin the new DecodeN node to non-null path on these platform (Sparc)
1400
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2977
        // to keep the information to which NULL check the new DecodeN node
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2978
        // corresponds to use it as value in implicit_null_check().
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2979
        //
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2980
        new_in1->set_req(0, n->in(0));
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2981
      }
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2982
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  2983
      n->subsume_by(new_in1, this);
1400
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2984
      if (in1->outcnt() == 0) {
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  2985
        in1->disconnect_inputs(NULL, this);
1400
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2986
      }
30300
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2987
    } else {
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2988
      n->subsume_by(n->in(1), this);
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2989
      if (n->outcnt() == 0) {
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2990
        n->disconnect_inputs(NULL, this);
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2991
      }
1400
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2992
    }
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  2993
    break;
30300
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2994
  }
4b12a5b40064 8069191: moving predicate out of loops may cause array accesses to bypass null check
roland
parents: 30211
diff changeset
  2995
#ifdef _LP64
590
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 589
diff changeset
  2996
  case Op_CmpP:
594
9f4474e5dbaf 6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents: 590
diff changeset
  2997
    // Do this transformation here to preserve CmpPNode::sub() and
9f4474e5dbaf 6705887: Compressed Oops: generate x64 addressing and implicit null checks with narrow oops
kvn
parents: 590
diff changeset
  2998
    // other TypePtr related Ideal optimizations (for example, ptr nullness).
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  2999
    if (n->in(1)->is_DecodeNarrowPtr() || n->in(2)->is_DecodeNarrowPtr()) {
1135
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3000
      Node* in1 = n->in(1);
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3001
      Node* in2 = n->in(2);
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3002
      if (!in1->is_DecodeNarrowPtr()) {
1135
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3003
        in2 = in1;
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3004
        in1 = n->in(2);
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3005
      }
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3006
      assert(in1->is_DecodeNarrowPtr(), "sanity");
1135
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3007
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3008
      Node* new_in2 = NULL;
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3009
      if (in2->is_DecodeNarrowPtr()) {
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3010
        assert(in2->Opcode() == in1->Opcode(), "must be same node type");
1135
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3011
        new_in2 = in2->in(1);
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3012
      } else if (in2->Opcode() == Op_ConP) {
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3013
        const Type* t = in2->bottom_type();
5698
091095915ee6 6954029: Improve implicit null check generation with compressed oops
kvn
parents: 5353
diff changeset
  3014
        if (t == TypePtr::NULL_PTR) {
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3015
          assert(in1->is_DecodeN(), "compare klass to null?");
5698
091095915ee6 6954029: Improve implicit null check generation with compressed oops
kvn
parents: 5353
diff changeset
  3016
          // Don't convert CmpP null check into CmpN if compressed
091095915ee6 6954029: Improve implicit null check generation with compressed oops
kvn
parents: 5353
diff changeset
  3017
          // oops implicit null check is not generated.
091095915ee6 6954029: Improve implicit null check generation with compressed oops
kvn
parents: 5353
diff changeset
  3018
          // This will allow to generate normal oop implicit null check.
091095915ee6 6954029: Improve implicit null check generation with compressed oops
kvn
parents: 5353
diff changeset
  3019
          if (Matcher::gen_narrow_oop_implicit_null_checks())
25930
eae8b7490d2c 8054033: Remove unused references to Compile*
thartmann
parents: 25914
diff changeset
  3020
            new_in2 = ConNode::make(TypeNarrowOop::NULL_PTR);
1400
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3021
          //
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3022
          // This transformation together with CastPP transformation above
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3023
          // will generated code for implicit NULL checks for compressed oops.
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3024
          //
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3025
          // The original code after Optimize()
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3026
          //
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3027
          //    LoadN memory, narrow_oop_reg
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3028
          //    decode narrow_oop_reg, base_reg
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3029
          //    CmpP base_reg, NULL
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3030
          //    CastPP base_reg // NotNull
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3031
          //    Load [base_reg + offset], val_reg
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3032
          //
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3033
          // after these transformations will be
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3034
          //
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3035
          //    LoadN memory, narrow_oop_reg
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3036
          //    CmpN narrow_oop_reg, NULL
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3037
          //    decode_not_null narrow_oop_reg, base_reg
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3038
          //    Load [base_reg + offset], val_reg
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3039
          //
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3040
          // and the uncommon path (== NULL) will use narrow_oop_reg directly
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3041
          // since narrow oops can be used in debug info now (see the code in
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3042
          // final_graph_reshaping_walk()).
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3043
          //
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3044
          // At the end the code will be matched to
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3045
          // on x86:
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3046
          //
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3047
          //    Load_narrow_oop memory, narrow_oop_reg
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3048
          //    Load [R12 + narrow_oop_reg<<3 + offset], val_reg
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3049
          //    NullCheck narrow_oop_reg
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3050
          //
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3051
          // and on sparc:
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3052
          //
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3053
          //    Load_narrow_oop memory, narrow_oop_reg
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3054
          //    decode_not_null narrow_oop_reg, base_reg
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3055
          //    Load [base_reg + offset], val_reg
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3056
          //    NullCheck base_reg
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3057
          //
590
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 589
diff changeset
  3058
        } else if (t->isa_oopptr()) {
25930
eae8b7490d2c 8054033: Remove unused references to Compile*
thartmann
parents: 25914
diff changeset
  3059
          new_in2 = ConNode::make(t->make_narrowoop());
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3060
        } else if (t->isa_klassptr()) {
25930
eae8b7490d2c 8054033: Remove unused references to Compile*
thartmann
parents: 25914
diff changeset
  3061
          new_in2 = ConNode::make(t->make_narrowklass());
590
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 589
diff changeset
  3062
        }
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 589
diff changeset
  3063
      }
1135
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3064
      if (new_in2 != NULL) {
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 24673
diff changeset
  3065
        Node* cmpN = new CmpNNode(in1->in(1), new_in2);
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3066
        n->subsume_by(cmpN, this);
1135
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3067
        if (in1->outcnt() == 0) {
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3068
          in1->disconnect_inputs(NULL, this);
1135
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3069
        }
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3070
        if (in2->outcnt() == 0) {
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3071
          in2->disconnect_inputs(NULL, this);
1135
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3072
        }
590
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 589
diff changeset
  3073
      }
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 589
diff changeset
  3074
    }
1055
f4fb9fb08038 6731641: assert(m->adr_type() == mach->adr_type(),"matcher should not change adr type")
kvn
parents: 961
diff changeset
  3075
    break;
1400
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3076
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3077
  case Op_DecodeN:
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3078
  case Op_DecodeNKlass:
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3079
    assert(!n->in(1)->is_EncodeNarrowPtr(), "should be optimized out");
5698
091095915ee6 6954029: Improve implicit null check generation with compressed oops
kvn
parents: 5353
diff changeset
  3080
    // DecodeN could be pinned when it can't be fold into
1679
07b65f7cd0aa 6787050: assert(n->in(0) == 0L,"no control") with UseCompressedOops on sparcv9
kvn
parents: 1677
diff changeset
  3081
    // an address expression, see the code for Op_CastPP above.
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3082
    assert(n->in(0) == NULL || (UseCompressedOops && !Matcher::narrow_oop_use_complex_address()), "no control");
1400
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3083
    break;
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3084
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3085
  case Op_EncodeP:
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3086
  case Op_EncodePKlass: {
1400
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3087
    Node* in1 = n->in(1);
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3088
    if (in1->is_DecodeNarrowPtr()) {
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3089
      n->subsume_by(in1->in(1), this);
1400
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3090
    } else if (in1->Opcode() == Op_ConP) {
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3091
      const Type* t = in1->bottom_type();
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3092
      if (t == TypePtr::NULL_PTR) {
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3093
        assert(t->isa_oopptr(), "null klass?");
25930
eae8b7490d2c 8054033: Remove unused references to Compile*
thartmann
parents: 25914
diff changeset
  3094
        n->subsume_by(ConNode::make(TypeNarrowOop::NULL_PTR), this);
1400
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3095
      } else if (t->isa_oopptr()) {
25930
eae8b7490d2c 8054033: Remove unused references to Compile*
thartmann
parents: 25914
diff changeset
  3096
        n->subsume_by(ConNode::make(t->make_narrowoop()), this);
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3097
      } else if (t->isa_klassptr()) {
25930
eae8b7490d2c 8054033: Remove unused references to Compile*
thartmann
parents: 25914
diff changeset
  3098
        n->subsume_by(ConNode::make(t->make_narrowklass()), this);
1400
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3099
      }
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3100
    }
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3101
    if (in1->outcnt() == 0) {
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3102
      in1->disconnect_inputs(NULL, this);
1400
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3103
    }
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3104
    break;
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3105
  }
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3106
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3107
  case Op_Proj: {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3108
    if (OptimizeStringConcat) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3109
      ProjNode* p = n->as_Proj();
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3110
      if (p->_is_io_use) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3111
        // Separate projections were used for the exception path which
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3112
        // are normally removed by a late inline.  If it wasn't inlined
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3113
        // then they will hang around and should just be replaced with
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3114
        // the original one.
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3115
        Node* proj = NULL;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3116
        // Replace with just one
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3117
        for (SimpleDUIterator i(p->in(0)); i.has_next(); i.next()) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3118
          Node *use = i.get();
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3119
          if (use->is_Proj() && p != use && use->as_Proj()->_con == p->_con) {
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3120
            proj = use;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3121
            break;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3122
          }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3123
        }
11435
3fde349bcbcf 7123954: Some CTW test crash with SIGSEGV
kvn
parents: 11430
diff changeset
  3124
        assert(proj != NULL, "must be found");
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3125
        p->subsume_by(proj, this);
4450
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3126
      }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3127
    }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3128
    break;
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3129
  }
6d700b859b3e 6892658: C2 should optimize some stringbuilder patterns
never
parents: 3684
diff changeset
  3130
1400
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3131
  case Op_Phi:
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3132
    if (n->as_Phi()->bottom_type()->isa_narrowoop() || n->as_Phi()->bottom_type()->isa_narrowklass()) {
1400
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3133
      // The EncodeP optimization may create Phi with the same edges
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3134
      // for all paths. It is not handled well by Register Allocator.
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3135
      Node* unique_in = n->in(1);
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3136
      assert(unique_in != NULL, "");
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3137
      uint cnt = n->req();
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3138
      for (uint i = 2; i < cnt; i++) {
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3139
        Node* m = n->in(i);
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3140
        assert(m != NULL, "");
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3141
        if (unique_in != m)
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3142
          unique_in = NULL;
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3143
      }
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3144
      if (unique_in != NULL) {
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3145
        n->subsume_by(unique_in, this);
1400
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3146
      }
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3147
    }
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3148
    break;
afd034bb8c2e 6747051: Improve code and implicit null check generation for compressed oops
kvn
parents: 1399
diff changeset
  3149
590
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 589
diff changeset
  3150
#endif
2954744d7bba 6703890: Compressed Oops: add LoadNKlass node to generate narrow oops (32-bits) compare instructions
kvn
parents: 589
diff changeset
  3151
35574
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  3152
#ifdef ASSERT
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  3153
  case Op_CastII:
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  3154
    // Verify that all range check dependent CastII nodes were removed.
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  3155
    if (n->isa_CastII()->has_range_check()) {
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  3156
      n->dump(3);
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  3157
      assert(false, "Range check dependent CastII node was not removed");
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  3158
    }
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  3159
    break;
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  3160
#endif
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  3161
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3162
  case Op_ModI:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3163
    if (UseDivMod) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3164
      // Check if a%b and a/b both exist
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3165
      Node* d = n->find_similar(Op_DivI);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3166
      if (d) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3167
        // Replace them with a fused divmod if supported
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3168
        if (Matcher::has_match_rule(Op_DivModI)) {
25930
eae8b7490d2c 8054033: Remove unused references to Compile*
thartmann
parents: 25914
diff changeset
  3169
          DivModINode* divmod = DivModINode::make(n);
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3170
          d->subsume_by(divmod->div_proj(), this);
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3171
          n->subsume_by(divmod->mod_proj(), this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3172
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3173
          // replace a%b with a-((a/b)*b)
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 24673
diff changeset
  3174
          Node* mult = new MulINode(d, d->in(2));
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 24673
diff changeset
  3175
          Node* sub  = new SubINode(d->in(1), mult);
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3176
          n->subsume_by(sub, this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3177
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3178
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3179
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3180
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3181
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3182
  case Op_ModL:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3183
    if (UseDivMod) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3184
      // Check if a%b and a/b both exist
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3185
      Node* d = n->find_similar(Op_DivL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3186
      if (d) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3187
        // Replace them with a fused divmod if supported
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3188
        if (Matcher::has_match_rule(Op_DivModL)) {
25930
eae8b7490d2c 8054033: Remove unused references to Compile*
thartmann
parents: 25914
diff changeset
  3189
          DivModLNode* divmod = DivModLNode::make(n);
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3190
          d->subsume_by(divmod->div_proj(), this);
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3191
          n->subsume_by(divmod->mod_proj(), this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3192
        } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3193
          // replace a%b with a-((a/b)*b)
24923
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 24673
diff changeset
  3194
          Node* mult = new MulLNode(d, d->in(2));
9631f7d691dc 8034812: remove IDX_INIT macro hack in Node class
thartmann
parents: 24673
diff changeset
  3195
          Node* sub  = new SubLNode(d->in(1), mult);
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3196
          n->subsume_by(sub, this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3197
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3198
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3199
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3200
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3201
13104
657b387034fb 7119644: Increase superword's vector size up to 256 bits
kvn
parents: 12957
diff changeset
  3202
  case Op_LoadVector:
657b387034fb 7119644: Increase superword's vector size up to 256 bits
kvn
parents: 12957
diff changeset
  3203
  case Op_StoreVector:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3204
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3205
30211
442fbbb31f75 8074981: Integer/FP scalar reduction optimization
kvn
parents: 29341
diff changeset
  3206
  case Op_AddReductionVI:
442fbbb31f75 8074981: Integer/FP scalar reduction optimization
kvn
parents: 29341
diff changeset
  3207
  case Op_AddReductionVL:
442fbbb31f75 8074981: Integer/FP scalar reduction optimization
kvn
parents: 29341
diff changeset
  3208
  case Op_AddReductionVF:
442fbbb31f75 8074981: Integer/FP scalar reduction optimization
kvn
parents: 29341
diff changeset
  3209
  case Op_AddReductionVD:
442fbbb31f75 8074981: Integer/FP scalar reduction optimization
kvn
parents: 29341
diff changeset
  3210
  case Op_MulReductionVI:
30624
2e1803c8a26d 8076276: Add support for AVX512
kvn
parents: 30593
diff changeset
  3211
  case Op_MulReductionVL:
30211
442fbbb31f75 8074981: Integer/FP scalar reduction optimization
kvn
parents: 29341
diff changeset
  3212
  case Op_MulReductionVF:
442fbbb31f75 8074981: Integer/FP scalar reduction optimization
kvn
parents: 29341
diff changeset
  3213
  case Op_MulReductionVD:
442fbbb31f75 8074981: Integer/FP scalar reduction optimization
kvn
parents: 29341
diff changeset
  3214
    break;
442fbbb31f75 8074981: Integer/FP scalar reduction optimization
kvn
parents: 29341
diff changeset
  3215
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3216
  case Op_PackB:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3217
  case Op_PackS:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3218
  case Op_PackI:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3219
  case Op_PackF:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3220
  case Op_PackL:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3221
  case Op_PackD:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3222
    if (n->req()-1 > 2) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3223
      // Replace many operand PackNodes with a binary tree for matching
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3224
      PackNode* p = (PackNode*) n;
25930
eae8b7490d2c 8054033: Remove unused references to Compile*
thartmann
parents: 25914
diff changeset
  3225
      Node* btp = p->binary_tree_pack(1, n->req());
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3226
      n->subsume_by(btp, this);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3227
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3228
    break;
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3229
  case Op_Loop:
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3230
  case Op_CountedLoop:
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3231
    if (n->as_Loop()->is_inner_loop()) {
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3232
      frc.inc_inner_loop_count();
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3233
    }
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3234
    break;
8868
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3235
  case Op_LShiftI:
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3236
  case Op_RShiftI:
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3237
  case Op_URShiftI:
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3238
  case Op_LShiftL:
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3239
  case Op_RShiftL:
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3240
  case Op_URShiftL:
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3241
    if (Matcher::need_masked_shift_count) {
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3242
      // The cpu's shift instructions don't restrict the count to the
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3243
      // lower 5/6 bits. We need to do the masking ourselves.
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3244
      Node* in2 = n->in(2);
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3245
      juint mask = (n->bottom_type() == TypeInt::INT) ? (BitsPerInt - 1) : (BitsPerLong - 1);
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3246
      const TypeInt* t = in2->find_int_type();
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3247
      if (t != NULL && t->is_con()) {
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3248
        juint shift = t->get_con();
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3249
        if (shift > mask) { // Unsigned cmp
25930
eae8b7490d2c 8054033: Remove unused references to Compile*
thartmann
parents: 25914
diff changeset
  3250
          n->set_req(2, ConNode::make(TypeInt::make(shift & mask)));
8868
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3251
        }
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3252
      } else {
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3253
        if (t == NULL || t->_lo < 0 || t->_hi > (int)mask) {
25930
eae8b7490d2c 8054033: Remove unused references to Compile*
thartmann
parents: 25914
diff changeset
  3254
          Node* shift = new AndINode(in2, ConNode::make(TypeInt::make(mask)));
8868
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3255
          n->set_req(2, shift);
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3256
        }
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3257
      }
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3258
      if (in2->outcnt() == 0) { // Remove dead node
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3259
        in2->disconnect_inputs(NULL, this);
8868
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3260
      }
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3261
    }
1bae515b806b 7029017: Additional architecture support for c2 compiler
roland
parents: 8725
diff changeset
  3262
    break;
15874
57f16a8b609f 8009460: C2compiler crash in machnode::in_regmask(unsigned int)
roland
parents: 15871
diff changeset
  3263
  case Op_MemBarStoreStore:
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17013
diff changeset
  3264
  case Op_MemBarRelease:
15874
57f16a8b609f 8009460: C2compiler crash in machnode::in_regmask(unsigned int)
roland
parents: 15871
diff changeset
  3265
    // Break the link with AllocateNode: it is no longer useful and
57f16a8b609f 8009460: C2compiler crash in machnode::in_regmask(unsigned int)
roland
parents: 15871
diff changeset
  3266
    // confuses register allocation.
57f16a8b609f 8009460: C2compiler crash in machnode::in_regmask(unsigned int)
roland
parents: 15871
diff changeset
  3267
    if (n->req() > MemBarNode::Precedent) {
57f16a8b609f 8009460: C2compiler crash in machnode::in_regmask(unsigned int)
roland
parents: 15871
diff changeset
  3268
      n->set_req(MemBarNode::Precedent, top());
57f16a8b609f 8009460: C2compiler crash in machnode::in_regmask(unsigned int)
roland
parents: 15871
diff changeset
  3269
    }
57f16a8b609f 8009460: C2compiler crash in machnode::in_regmask(unsigned int)
roland
parents: 15871
diff changeset
  3270
    break;
34164
a9e6034d7707 8137168: Replace IfNode with a new RangeCheckNode for range checks
roland
parents: 33469
diff changeset
  3271
  case Op_RangeCheck: {
a9e6034d7707 8137168: Replace IfNode with a new RangeCheckNode for range checks
roland
parents: 33469
diff changeset
  3272
    RangeCheckNode* rc = n->as_RangeCheck();
a9e6034d7707 8137168: Replace IfNode with a new RangeCheckNode for range checks
roland
parents: 33469
diff changeset
  3273
    Node* iff = new IfNode(rc->in(0), rc->in(1), rc->_prob, rc->_fcnt);
a9e6034d7707 8137168: Replace IfNode with a new RangeCheckNode for range checks
roland
parents: 33469
diff changeset
  3274
    n->subsume_by(iff, this);
a9e6034d7707 8137168: Replace IfNode with a new RangeCheckNode for range checks
roland
parents: 33469
diff changeset
  3275
    frc._tests.push(iff);
a9e6034d7707 8137168: Replace IfNode with a new RangeCheckNode for range checks
roland
parents: 33469
diff changeset
  3276
    break;
a9e6034d7707 8137168: Replace IfNode with a new RangeCheckNode for range checks
roland
parents: 33469
diff changeset
  3277
  }
38236
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3278
  case Op_ConvI2L: {
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3279
    if (!Matcher::convi2l_type_required) {
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3280
      // Code generation on some platforms doesn't need accurate
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3281
      // ConvI2L types. Widening the type can help remove redundant
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3282
      // address computations.
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3283
      n->as_Type()->set_type(TypeLong::INT);
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3284
      ResourceMark rm;
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3285
      Node_List wq;
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3286
      wq.push(n);
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3287
      for (uint next = 0; next < wq.size(); next++) {
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3288
        Node *m = wq.at(next);
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3289
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3290
        for(;;) {
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3291
          // Loop over all nodes with identical inputs edges as m
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3292
          Node* k = m->find_similar(m->Opcode());
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3293
          if (k == NULL) {
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3294
            break;
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3295
          }
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3296
          // Push their uses so we get a chance to remove node made
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3297
          // redundant
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3298
          for (DUIterator_Fast imax, i = k->fast_outs(imax); i < imax; i++) {
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3299
            Node* u = k->fast_out(i);
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3300
            assert(!wq.contains(u), "shouldn't process one node several times");
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3301
            if (u->Opcode() == Op_LShiftL ||
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3302
                u->Opcode() == Op_AddL ||
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3303
                u->Opcode() == Op_SubL ||
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3304
                u->Opcode() == Op_AddP) {
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3305
              wq.push(u);
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3306
            }
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3307
          }
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3308
          // Replace all nodes with identical edges as m with m
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3309
          k->subsume_by(m, this);
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3310
        }
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3311
      }
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3312
    }
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3313
    break;
510f77046e00 8154943: AArch64: redundant address computation instructions with vectorization
roland
parents: 38140
diff changeset
  3314
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3315
  default:
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3316
    assert( !n->is_Call(), "" );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3317
    assert( !n->is_Mem(), "" );
28912
27fac2f8fdbe 8063137: Never-taken branches should be pruned when GWT LambdaForms are shared
vlivanov
parents: 28395
diff changeset
  3318
    assert( nop != Op_ProfileBoolean, "should be eliminated during IGVN");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3319
    break;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3320
  }
374
585c671c9c0e 6663848: assert(i < Max(),"oob") in C2 with -Xcomp
never
parents: 360
diff changeset
  3321
585c671c9c0e 6663848: assert(i < Max(),"oob") in C2 with -Xcomp
never
parents: 360
diff changeset
  3322
  // Collect CFG split points
34164
a9e6034d7707 8137168: Replace IfNode with a new RangeCheckNode for range checks
roland
parents: 33469
diff changeset
  3323
  if (n->is_MultiBranch() && !n->is_RangeCheck()) {
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3324
    frc._tests.push(n);
34164
a9e6034d7707 8137168: Replace IfNode with a new RangeCheckNode for range checks
roland
parents: 33469
diff changeset
  3325
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3326
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3327
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3328
//------------------------------final_graph_reshaping_walk---------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3329
// Replacing Opaque nodes with their input in final_graph_reshaping_impl(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3330
// requires that the walk visits a node's inputs before visiting the node.
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3331
void Compile::final_graph_reshaping_walk( Node_Stack &nstack, Node *root, Final_Reshape_Counts &frc ) {
1135
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3332
  ResourceArea *area = Thread::current()->resource_area();
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3333
  Unique_Node_List sfpt(area);
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3334
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3335
  frc._visited.set(root->_idx); // first, mark node as visited
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3336
  uint cnt = root->req();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3337
  Node *n = root;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3338
  uint  i = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3339
  while (true) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3340
    if (i < cnt) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3341
      // Place all non-visited non-null inputs onto stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3342
      Node* m = n->in(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3343
      ++i;
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3344
      if (m != NULL && !frc._visited.test_set(m->_idx)) {
24018
77b156916bab 8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents: 24002
diff changeset
  3345
        if (m->is_SafePoint() && m->as_SafePoint()->jvms() != NULL) {
77b156916bab 8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents: 24002
diff changeset
  3346
          // compute worst case interpreter size in case of a deoptimization
77b156916bab 8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents: 24002
diff changeset
  3347
          update_interpreter_frame_size(m->as_SafePoint()->jvms()->interpreter_frame_size());
77b156916bab 8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents: 24002
diff changeset
  3348
1135
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3349
          sfpt.push(m);
24018
77b156916bab 8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents: 24002
diff changeset
  3350
        }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3351
        cnt = m->req();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3352
        nstack.push(n, i); // put on stack parent and next input's index
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3353
        n = m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3354
        i = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3355
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3356
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3357
      // Now do post-visit work
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3358
      final_graph_reshaping_impl( n, frc );
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3359
      if (nstack.is_empty())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3360
        break;             // finished
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3361
      n = nstack.node();   // Get node from stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3362
      cnt = n->req();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3363
      i = nstack.index();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3364
      nstack.pop();        // Shift to the next node on stack
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3365
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3366
  }
1135
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3367
5698
091095915ee6 6954029: Improve implicit null check generation with compressed oops
kvn
parents: 5353
diff changeset
  3368
  // Skip next transformation if compressed oops are not used.
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3369
  if ((UseCompressedOops && !Matcher::gen_narrow_oop_implicit_null_checks()) ||
19979
ebe1dbb6e1aa 8015107: NPG: Use consistent naming for metaspace concepts
ehelin
parents: 19717
diff changeset
  3370
      (!UseCompressedOops && !UseCompressedClassPointers))
5698
091095915ee6 6954029: Improve implicit null check generation with compressed oops
kvn
parents: 5353
diff changeset
  3371
    return;
091095915ee6 6954029: Improve implicit null check generation with compressed oops
kvn
parents: 5353
diff changeset
  3372
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3373
  // Go over safepoints nodes to skip DecodeN/DecodeNKlass nodes for debug edges.
1135
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3374
  // It could be done for an uncommon traps or any safepoints/calls
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3375
  // if the DecodeN/DecodeNKlass node is referenced only in a debug info.
1135
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3376
  while (sfpt.size() > 0) {
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3377
    n = sfpt.pop();
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3378
    JVMState *jvms = n->as_SafePoint()->jvms();
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3379
    assert(jvms != NULL, "sanity");
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3380
    int start = jvms->debug_start();
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3381
    int end   = n->req();
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3382
    bool is_uncommon = (n->is_CallStaticJava() &&
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3383
                        n->as_CallStaticJava()->uncommon_trap_request() != 0);
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3384
    for (int j = start; j < end; j++) {
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3385
      Node* in = n->in(j);
13969
d2a189b83b87 7054512: Compress class pointers after perm gen removal
roland
parents: 13964
diff changeset
  3386
      if (in->is_DecodeNarrowPtr()) {
1135
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3387
        bool safe_to_skip = true;
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3388
        if (!is_uncommon ) {
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3389
          // Is it safe to skip?
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3390
          for (uint i = 0; i < in->outcnt(); i++) {
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3391
            Node* u = in->raw_out(i);
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3392
            if (!u->is_SafePoint() ||
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3393
                 u->is_Call() && u->as_Call()->has_non_debug_use(n)) {
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3394
              safe_to_skip = false;
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3395
            }
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3396
          }
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3397
        }
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3398
        if (safe_to_skip) {
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3399
          n->set_req(j, in->in(1));
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3400
        }
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3401
        if (in->outcnt() == 0) {
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3402
          in->disconnect_inputs(NULL, this);
1135
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3403
        }
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3404
      }
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3405
    }
9487203e5789 6706829: Compressed Oops: add debug info for narrow oops
kvn
parents: 1055
diff changeset
  3406
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3407
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3408
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3409
//------------------------------final_graph_reshaping--------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3410
// Final Graph Reshaping.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3411
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3412
// (1) Clone simple inputs to uncommon calls, so they can be scheduled late
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3413
//     and not commoned up and forced early.  Must come after regular
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3414
//     optimizations to avoid GVN undoing the cloning.  Clone constant
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3415
//     inputs to Loop Phis; these will be split by the allocator anyways.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3416
//     Remove Opaque nodes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3417
// (2) Move last-uses by commutative operations to the left input to encourage
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3418
//     Intel update-in-place two-address operations and better register usage
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3419
//     on RISCs.  Must come after regular optimizations to avoid GVN Ideal
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3420
//     calls canonicalizing them back.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3421
// (3) Count the number of double-precision FP ops, single-precision FP ops
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3422
//     and call sites.  On Intel, we can get correct rounding either by
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3423
//     forcing singles to memory (requires extra stores and loads after each
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3424
//     FP bytecode) or we can set a rounding mode bit (requires setting and
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3425
//     clearing the mode bit around call sites).  The mode bit is only used
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3426
//     if the relative frequency of single FP ops to calls is low enough.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3427
//     This is a key transform for SPEC mpeg_audio.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3428
// (4) Detect infinite loops; blobs of code reachable from above but not
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3429
//     below.  Several of the Code_Gen algorithms fail on such code shapes,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3430
//     so we simply bail out.  Happens a lot in ZKM.jar, but also happens
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3431
//     from time to time in other codes (such as -Xcomp finalizer loops, etc).
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3432
//     Detection is by looking for IfNodes where only 1 projection is
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3433
//     reachable from below or CatchNodes missing some targets.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3434
// (5) Assert for insane oop offsets in debug mode.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3435
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3436
bool Compile::final_graph_reshaping() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3437
  // an infinite loop may have been eliminated by the optimizer,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3438
  // in which case the graph will be empty.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3439
  if (root()->req() == 1) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3440
    record_method_not_compilable("trivial infinite loop");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3441
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3442
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3443
15618
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  3444
  // Expensive nodes have their control input set to prevent the GVN
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  3445
  // from freely commoning them. There's no GVN beyond this point so
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  3446
  // no need to keep the control input. We want the expensive nodes to
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  3447
  // be freely moved to the least frequent code path by gcm.
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  3448
  assert(OptimizeExpensiveOps || expensive_count() == 0, "optimization off but list non empty?");
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  3449
  for (int i = 0; i < expensive_count(); i++) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  3450
    _expensive_nodes->at(i)->set_req(0, NULL);
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  3451
  }
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  3452
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3453
  Final_Reshape_Counts frc;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3454
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3455
  // Visit everybody reachable!
33158
f4e6c593ba73 8137160: Use Compile::live_nodes instead of Compile::unique() in appropriate places -- followup
zmajo
parents: 33065
diff changeset
  3456
  // Allocate stack of size C->live_nodes()/2 to avoid frequent realloc
32202
7e7ad8b06f5b 8011858: Use Compile::live_nodes() instead of Compile::unique() in appropriate places
kvn
parents: 32082
diff changeset
  3457
  Node_Stack nstack(live_nodes() >> 1);
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3458
  final_graph_reshaping_walk(nstack, root(), frc);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3459
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3460
  // Check for unreachable (from below) code (i.e., infinite loops).
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3461
  for( uint i = 0; i < frc._tests.size(); i++ ) {
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3462
    MultiBranchNode *n = frc._tests[i]->as_MultiBranch();
374
585c671c9c0e 6663848: assert(i < Max(),"oob") in C2 with -Xcomp
never
parents: 360
diff changeset
  3463
    // Get number of CFG targets.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3464
    // Note that PCTables include exception targets after calls.
374
585c671c9c0e 6663848: assert(i < Max(),"oob") in C2 with -Xcomp
never
parents: 360
diff changeset
  3465
    uint required_outcnt = n->required_outcnt();
585c671c9c0e 6663848: assert(i < Max(),"oob") in C2 with -Xcomp
never
parents: 360
diff changeset
  3466
    if (n->outcnt() != required_outcnt) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3467
      // Check for a few special cases.  Rethrow Nodes never take the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3468
      // 'fall-thru' path, so expected kids is 1 less.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3469
      if (n->is_PCTable() && n->in(0) && n->in(0)->in(0)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3470
        if (n->in(0)->in(0)->is_Call()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3471
          CallNode *call = n->in(0)->in(0)->as_Call();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3472
          if (call->entry_point() == OptoRuntime::rethrow_stub()) {
374
585c671c9c0e 6663848: assert(i < Max(),"oob") in C2 with -Xcomp
never
parents: 360
diff changeset
  3473
            required_outcnt--;      // Rethrow always has 1 less kid
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3474
          } else if (call->req() > TypeFunc::Parms &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3475
                     call->is_CallDynamicJava()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3476
            // Check for null receiver. In such case, the optimizer has
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3477
            // detected that the virtual call will always result in a null
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3478
            // pointer exception. The fall-through projection of this CatchNode
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3479
            // will not be populated.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3480
            Node *arg0 = call->in(TypeFunc::Parms);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3481
            if (arg0->is_Type() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3482
                arg0->as_Type()->type()->higher_equal(TypePtr::NULL_PTR)) {
374
585c671c9c0e 6663848: assert(i < Max(),"oob") in C2 with -Xcomp
never
parents: 360
diff changeset
  3483
              required_outcnt--;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3484
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3485
          } else if (call->entry_point() == OptoRuntime::new_array_Java() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3486
                     call->req() > TypeFunc::Parms+1 &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3487
                     call->is_CallStaticJava()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3488
            // Check for negative array length. In such case, the optimizer has
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3489
            // detected that the allocation attempt will always result in an
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3490
            // exception. There is no fall-through projection of this CatchNode .
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3491
            Node *arg1 = call->in(TypeFunc::Parms+1);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3492
            if (arg1->is_Type() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3493
                arg1->as_Type()->type()->join(TypeInt::POS)->empty()) {
374
585c671c9c0e 6663848: assert(i < Max(),"oob") in C2 with -Xcomp
never
parents: 360
diff changeset
  3494
              required_outcnt--;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3495
            }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3496
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3497
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3498
      }
374
585c671c9c0e 6663848: assert(i < Max(),"oob") in C2 with -Xcomp
never
parents: 360
diff changeset
  3499
      // Recheck with a better notion of 'required_outcnt'
585c671c9c0e 6663848: assert(i < Max(),"oob") in C2 with -Xcomp
never
parents: 360
diff changeset
  3500
      if (n->outcnt() != required_outcnt) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3501
        record_method_not_compilable("malformed control flow");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3502
        return true;            // Not all targets reachable!
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3503
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3504
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3505
    // Check that I actually visited all kids.  Unreached kids
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3506
    // must be infinite loops.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3507
    for (DUIterator_Fast jmax, j = n->fast_outs(jmax); j < jmax; j++)
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3508
      if (!frc._visited.test(n->fast_out(j)->_idx)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3509
        record_method_not_compilable("infinite loop");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3510
        return true;            // Found unvisited kid; must be unreach
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3511
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3512
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3513
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3514
  // If original bytecodes contained a mixture of floats and doubles
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3515
  // check if the optimizer has made it homogenous, item (3).
3684
0b6d63791583 6873777: FPU control word optimization still performed with SSE
never
parents: 3676
diff changeset
  3516
  if( Use24BitFPMode && Use24BitFP && UseSSE == 0 &&
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3517
      frc.get_float_count() > 32 &&
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3518
      frc.get_double_count() == 0 &&
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3519
      (10 * frc.get_call_count() < frc.get_float_count()) ) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3520
    set_24_bit_selection_and_mode( false,  true );
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3521
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3522
3276
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3523
  set_java_calls(frc.get_java_call_count());
bda7d4532054 6860599: nodes limit could be reached during Output phase
kvn
parents: 3273
diff changeset
  3524
  set_inner_loops(frc.get_inner_loop_count());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3525
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3526
  // No infinite loops, no reason to bail out.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3527
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3528
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3529
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3530
//-----------------------------too_many_traps----------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3531
// Report if there are too many traps at the current method and bci.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3532
// Return true if there was a trap, and/or PerMethodTrapLimit is exceeded.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3533
bool Compile::too_many_traps(ciMethod* method,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3534
                             int bci,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3535
                             Deoptimization::DeoptReason reason) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3536
  ciMethodData* md = method->method_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3537
  if (md->is_empty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3538
    // Assume the trap has not occurred, or that it occurred only
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3539
    // because of a transient condition during start-up in the interpreter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3540
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3541
  }
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22911
diff changeset
  3542
  ciMethod* m = Deoptimization::reason_is_speculate(reason) ? this->method() : NULL;
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22911
diff changeset
  3543
  if (md->has_trap_at(bci, m, reason) != 0) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3544
    // Assume PerBytecodeTrapLimit==0, for a more conservative heuristic.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3545
    // Also, if there are multiple reasons, or if there is no per-BCI record,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3546
    // assume the worst.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3547
    if (log())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3548
      log()->elem("observe trap='%s' count='%d'",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3549
                  Deoptimization::trap_reason_name(reason),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3550
                  md->trap_count(reason));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3551
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3552
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3553
    // Ignore method/bci and see if there have been too many globally.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3554
    return too_many_traps(reason, md);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3555
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3556
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3557
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3558
// Less-accurate variant which does not require a method and bci.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3559
bool Compile::too_many_traps(Deoptimization::DeoptReason reason,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3560
                             ciMethodData* logmd) {
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22911
diff changeset
  3561
  if (trap_count(reason) >= Deoptimization::per_method_trap_limit(reason)) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3562
    // Too many traps globally.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3563
    // Note that we use cumulative trap_count, not just md->trap_count.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3564
    if (log()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3565
      int mcount = (logmd == NULL)? -1: (int)logmd->trap_count(reason);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3566
      log()->elem("observe trap='%s' count='0' mcount='%d' ccount='%d'",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3567
                  Deoptimization::trap_reason_name(reason),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3568
                  mcount, trap_count(reason));
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3569
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3570
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3571
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3572
    // The coast is clear.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3573
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3574
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3575
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3576
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3577
//--------------------------too_many_recompiles--------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3578
// Report if there are too many recompiles at the current method and bci.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3579
// Consults PerBytecodeRecompilationCutoff and PerMethodRecompilationCutoff.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3580
// Is not eager to return true, since this will cause the compiler to use
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3581
// Action_none for a trap point, to avoid too many recompilations.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3582
bool Compile::too_many_recompiles(ciMethod* method,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3583
                                  int bci,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3584
                                  Deoptimization::DeoptReason reason) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3585
  ciMethodData* md = method->method_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3586
  if (md->is_empty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3587
    // Assume the trap has not occurred, or that it occurred only
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3588
    // because of a transient condition during start-up in the interpreter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3589
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3590
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3591
  // Pick a cutoff point well within PerBytecodeRecompilationCutoff.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3592
  uint bc_cutoff = (uint) PerBytecodeRecompilationCutoff / 8;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3593
  uint m_cutoff  = (uint) PerMethodRecompilationCutoff / 2 + 1;  // not zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3594
  Deoptimization::DeoptReason per_bc_reason
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3595
    = Deoptimization::reason_recorded_per_bytecode_if_any(reason);
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22911
diff changeset
  3596
  ciMethod* m = Deoptimization::reason_is_speculate(reason) ? this->method() : NULL;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3597
  if ((per_bc_reason == Deoptimization::Reason_none
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22911
diff changeset
  3598
       || md->has_trap_at(bci, m, reason) != 0)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3599
      // The trap frequency measure we care about is the recompile count:
22916
582da2ed4dfa 8031752: Failed speculative optimizations should be reattempted when root of compilation is different
roland
parents: 22911
diff changeset
  3600
      && md->trap_recompiled_at(bci, m)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3601
      && md->overflow_recompile_count() >= bc_cutoff) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3602
    // Do not emit a trap here if it has already caused recompilations.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3603
    // Also, if there are multiple reasons, or if there is no per-BCI record,
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3604
    // assume the worst.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3605
    if (log())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3606
      log()->elem("observe trap='%s recompiled' count='%d' recompiles2='%d'",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3607
                  Deoptimization::trap_reason_name(reason),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3608
                  md->trap_count(reason),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3609
                  md->overflow_recompile_count());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3610
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3611
  } else if (trap_count(reason) != 0
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3612
             && decompile_count() >= m_cutoff) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3613
    // Too many recompiles globally, and we have seen this sort of trap.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3614
    // Use cumulative decompile_count, not just md->decompile_count.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3615
    if (log())
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3616
      log()->elem("observe trap='%s' count='%d' mcount='%d' decompiles='%d' mdecompiles='%d'",
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3617
                  Deoptimization::trap_reason_name(reason),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3618
                  md->trap_count(reason), trap_count(reason),
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3619
                  md->decompile_count(), decompile_count());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3620
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3621
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3622
    // The coast is clear.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3623
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3624
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3625
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3626
22856
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 22854
diff changeset
  3627
// Compute when not to trap. Used by matching trap based nodes and
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 22854
diff changeset
  3628
// NullCheck optimization.
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 22854
diff changeset
  3629
void Compile::set_allowed_deopt_reasons() {
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 22854
diff changeset
  3630
  _allowed_reasons = 0;
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 22854
diff changeset
  3631
  if (is_method_compilation()) {
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 22854
diff changeset
  3632
    for (int rs = (int)Deoptimization::Reason_none+1; rs < Compile::trapHistLength; rs++) {
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 22854
diff changeset
  3633
      assert(rs < BitsPerInt, "recode bit map");
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 22854
diff changeset
  3634
      if (!too_many_traps((Deoptimization::DeoptReason) rs)) {
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 22854
diff changeset
  3635
        _allowed_reasons |= nth_bit(rs);
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 22854
diff changeset
  3636
      }
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 22854
diff changeset
  3637
    }
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 22854
diff changeset
  3638
  }
03ad2cf18166 8029015: PPC64 (part 216): opto: trap based null and range checks
goetz
parents: 22854
diff changeset
  3639
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3640
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3641
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3642
//------------------------------verify_graph_edges---------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3643
// Walk the Graph and verify that there is a one-to-one correspondence
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3644
// between Use-Def edges and Def-Use edges in the graph.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3645
void Compile::verify_graph_edges(bool no_dead_code) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3646
  if (VerifyGraphEdges) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3647
    ResourceArea *area = Thread::current()->resource_area();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3648
    Unique_Node_List visited(area);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3649
    // Call recursive graph walk to check edges
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3650
    _root->verify_edges(visited);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3651
    if (no_dead_code) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3652
      // Now make sure that no visited node is used by an unvisited node.
25338
8afcbcb8271a 8008321: compile.cpp verify_graph_edges uses bool as int
thartmann
parents: 24946
diff changeset
  3653
      bool dead_nodes = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3654
      Unique_Node_List checked(area);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3655
      while (visited.size() > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3656
        Node* n = visited.pop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3657
        checked.push(n);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3658
        for (uint i = 0; i < n->outcnt(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3659
          Node* use = n->raw_out(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3660
          if (checked.member(use))  continue;  // already checked
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3661
          if (visited.member(use))  continue;  // already in the graph
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3662
          if (use->is_Con())        continue;  // a dead ConNode is OK
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3663
          // At this point, we have found a dead node which is DU-reachable.
25338
8afcbcb8271a 8008321: compile.cpp verify_graph_edges uses bool as int
thartmann
parents: 24946
diff changeset
  3664
          if (!dead_nodes) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3665
            tty->print_cr("*** Dead nodes reachable via DU edges:");
25338
8afcbcb8271a 8008321: compile.cpp verify_graph_edges uses bool as int
thartmann
parents: 24946
diff changeset
  3666
            dead_nodes = true;
8afcbcb8271a 8008321: compile.cpp verify_graph_edges uses bool as int
thartmann
parents: 24946
diff changeset
  3667
          }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3668
          use->dump(2);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3669
          tty->print_cr("---");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3670
          checked.push(use);  // No repeats; pretend it is now checked.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3671
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3672
      }
25338
8afcbcb8271a 8008321: compile.cpp verify_graph_edges uses bool as int
thartmann
parents: 24946
diff changeset
  3673
      assert(!dead_nodes, "using nodes must be reachable from root");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3674
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3675
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3676
}
21526
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3677
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3678
// Verify GC barriers consistency
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3679
// Currently supported:
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3680
// - G1 pre-barriers (see GraphKit::g1_write_barrier_pre())
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3681
void Compile::verify_barriers() {
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3682
  if (UseG1GC) {
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3683
    // Verify G1 pre-barriers
34148
6efbc7ffd767 8143014: Access PtrQueue member offsets through derived classes
kbarrett
parents: 33626
diff changeset
  3684
    const int marking_offset = in_bytes(JavaThread::satb_mark_queue_offset() + SATBMarkQueue::byte_offset_of_active());
21526
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3685
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3686
    ResourceArea *area = Thread::current()->resource_area();
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3687
    Unique_Node_List visited(area);
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3688
    Node_List worklist(area);
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3689
    // We're going to walk control flow backwards starting from the Root
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3690
    worklist.push(_root);
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3691
    while (worklist.size() > 0) {
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3692
      Node* x = worklist.pop();
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3693
      if (x == NULL || x == top()) continue;
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3694
      if (visited.member(x)) {
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3695
        continue;
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3696
      } else {
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3697
        visited.push(x);
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3698
      }
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3699
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3700
      if (x->is_Region()) {
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3701
        for (uint i = 1; i < x->req(); i++) {
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3702
          worklist.push(x->in(i));
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3703
        }
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3704
      } else {
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3705
        worklist.push(x->in(0));
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3706
        // We are looking for the pattern:
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3707
        //                            /->ThreadLocal
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3708
        // If->Bool->CmpI->LoadB->AddP->ConL(marking_offset)
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3709
        //              \->ConI(0)
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3710
        // We want to verify that the If and the LoadB have the same control
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3711
        // See GraphKit::g1_write_barrier_pre()
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3712
        if (x->is_If()) {
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3713
          IfNode *iff = x->as_If();
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3714
          if (iff->in(1)->is_Bool() && iff->in(1)->in(1)->is_Cmp()) {
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3715
            CmpNode *cmp = iff->in(1)->in(1)->as_Cmp();
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3716
            if (cmp->Opcode() == Op_CmpI && cmp->in(2)->is_Con() && cmp->in(2)->bottom_type()->is_int()->get_con() == 0
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3717
                && cmp->in(1)->is_Load()) {
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3718
              LoadNode* load = cmp->in(1)->as_Load();
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3719
              if (load->Opcode() == Op_LoadB && load->in(2)->is_AddP() && load->in(2)->in(2)->Opcode() == Op_ThreadLocal
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3720
                  && load->in(2)->in(3)->is_Con()
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3721
                  && load->in(2)->in(3)->bottom_type()->is_intptr_t()->get_con() == marking_offset) {
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3722
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3723
                Node* if_ctrl = iff->in(0);
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3724
                Node* load_ctrl = load->in(0);
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3725
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3726
                if (if_ctrl != load_ctrl) {
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3727
                  // Skip possible CProj->NeverBranch in infinite loops
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3728
                  if ((if_ctrl->is_Proj() && if_ctrl->Opcode() == Op_CProj)
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3729
                      && (if_ctrl->in(0)->is_MultiBranch() && if_ctrl->in(0)->Opcode() == Op_NeverBranch)) {
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3730
                    if_ctrl = if_ctrl->in(0)->in(0);
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3731
                  }
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3732
                }
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3733
                assert(load_ctrl != NULL && if_ctrl == load_ctrl, "controls must match");
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3734
              }
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3735
            }
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3736
          }
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3737
        }
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3738
      }
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3739
    }
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3740
  }
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3741
}
03b4acedb351 8017065: C2 allows safepoint checks to leak into G1 pre-barriers
iveresov
parents: 21099
diff changeset
  3742
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3743
#endif
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3744
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3745
// The Compile object keeps track of failure reasons separately from the ciEnv.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3746
// This is required because there is not quite a 1-1 relation between the
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3747
// ciEnv and its compilation task and the Compile object.  Note that one
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3748
// ciEnv might use two Compile objects, if C2Compiler::compile_method decides
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3749
// to backtrack and retry without subsuming loads.  Other than this backtracking
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3750
// behavior, the Compile's failure reason is quietly copied up to the ciEnv
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3751
// by the logic in C2Compiler.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3752
void Compile::record_failure(const char* reason) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3753
  if (log() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3754
    log()->elem("failure reason='%s' phase='compile'", reason);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3755
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3756
  if (_failure_reason == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3757
    // Record the first failure reason.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3758
    _failure_reason = reason;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3759
  }
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  3760
768
d0bebc7eefc2 6718676: putback for 6604014 is incomplete
never
parents: 767
diff changeset
  3761
  if (!C->failure_reason_is(C2Compiler::retry_no_subsuming_loads())) {
18025
b7bcf7497f93 8005849: JEP 167: Event-Based JVM Tracing
sla
parents: 17383
diff changeset
  3762
    C->print_method(PHASE_FAILURE);
768
d0bebc7eefc2 6718676: putback for 6604014 is incomplete
never
parents: 767
diff changeset
  3763
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3764
  _root = NULL;  // flush the graph, too
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3765
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3766
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  3767
Compile::TracePhase::TracePhase(const char* name, elapsedTimer* accumulator)
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  3768
  : TraceTime(name, accumulator, CITime, CITimeVerbose),
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  3769
    _phase_name(name), _dolog(CITimeVerbose)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3770
{
26913
9ad70cd32368 8058968: Compiler time traces should be improved
shade
parents: 26796
diff changeset
  3771
  if (_dolog) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3772
    C = Compile::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3773
    _log = C->log();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3774
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3775
    C = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3776
    _log = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3777
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3778
  if (_log != NULL) {
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3779
    _log->begin_head("phase name='%s' nodes='%d' live='%d'", _phase_name, C->unique(), C->live_nodes());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3780
    _log->stamp();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3781
    _log->end_head();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3782
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3783
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3784
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3785
Compile::TracePhase::~TracePhase() {
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3786
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3787
  C = Compile::current();
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3788
  if (_dolog) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3789
    _log = C->log();
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3790
  } else {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3791
    _log = NULL;
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3792
  }
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3793
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3794
#ifdef ASSERT
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3795
  if (PrintIdealNodeCount) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3796
    tty->print_cr("phase name='%s' nodes='%d' live='%d' live_graph_walk='%d'",
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3797
                  _phase_name, C->unique(), C->live_nodes(), C->count_live_nodes_by_graph_walk());
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3798
  }
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3799
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3800
  if (VerifyIdealNodeCount) {
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3801
    Compile::current()->print_missing_nodes();
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3802
  }
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3803
#endif
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3804
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3805
  if (_log != NULL) {
14623
70c4c1be0a14 7092905: C2: Keep track of the number of dead nodes
bharadwaj
parents: 14126
diff changeset
  3806
    _log->done("phase name='%s' nodes='%d' live='%d'", _phase_name, C->unique(), C->live_nodes());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3807
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  3808
}
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3809
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3810
//=============================================================================
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3811
// Two Constant's are equal when the type and the value are equal.
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3812
bool Compile::Constant::operator==(const Constant& other) {
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3813
  if (type()          != other.type()         )  return false;
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3814
  if (can_be_reused() != other.can_be_reused())  return false;
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3815
  // For floating point values we compare the bit pattern.
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3816
  switch (type()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3817
  case T_FLOAT:   return (_v._value.i == other._v._value.i);
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3818
  case T_LONG:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3819
  case T_DOUBLE:  return (_v._value.j == other._v._value.j);
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3820
  case T_OBJECT:
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3821
  case T_ADDRESS: return (_v._value.l == other._v._value.l);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3822
  case T_VOID:    return (_v._value.l == other._v._value.l);  // jump-table entries
14126
afb8a3a86f1f 8000623: tools/javac/Diagnostics/6769027/T6769027.java crashes in PSPromotionManager::copy_to_survivor_space
kvn
parents: 13970
diff changeset
  3823
  case T_METADATA: return (_v._metadata == other._v._metadata);
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3824
  default: ShouldNotReachHere();
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3825
  }
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3826
  return false;
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3827
}
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3828
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3829
static int type_to_size_in_bytes(BasicType t) {
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3830
  switch (t) {
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3831
  case T_LONG:    return sizeof(jlong  );
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3832
  case T_FLOAT:   return sizeof(jfloat );
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3833
  case T_DOUBLE:  return sizeof(jdouble);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3834
  case T_METADATA: return sizeof(Metadata*);
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3835
    // We use T_VOID as marker for jump-table entries (labels) which
11190
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3836
    // need an internal word relocation.
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3837
  case T_VOID:
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3838
  case T_ADDRESS:
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3839
  case T_OBJECT:  return sizeof(jobject);
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3840
  }
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3841
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3842
  ShouldNotReachHere();
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3843
  return -1;
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3844
}
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3845
11190
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3846
int Compile::ConstantTable::qsort_comparator(Constant* a, Constant* b) {
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3847
  // sort descending
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3848
  if (a->freq() > b->freq())  return -1;
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3849
  if (a->freq() < b->freq())  return  1;
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3850
  return 0;
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3851
}
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3852
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3853
void Compile::ConstantTable::calculate_offsets_and_size() {
11190
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3854
  // First, sort the array by frequencies.
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3855
  _constants.sort(qsort_comparator);
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3856
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3857
#ifdef ASSERT
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3858
  // Make sure all jump-table entries were sorted to the end of the
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3859
  // array (they have a negative frequency).
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3860
  bool found_void = false;
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3861
  for (int i = 0; i < _constants.length(); i++) {
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3862
    Constant con = _constants.at(i);
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3863
    if (con.type() == T_VOID)
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3864
      found_void = true;  // jump-tables
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3865
    else
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3866
      assert(!found_void, "wrong sorting");
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3867
  }
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3868
#endif
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3869
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3870
  int offset = 0;
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3871
  for (int i = 0; i < _constants.length(); i++) {
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3872
    Constant* con = _constants.adr_at(i);
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3873
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3874
    // Align offset for type.
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3875
    int typesize = type_to_size_in_bytes(con->type());
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3876
    offset = align_size_up(offset, typesize);
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3877
    con->set_offset(offset);   // set constant's offset
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3878
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3879
    if (con->type() == T_VOID) {
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3880
      MachConstantNode* n = (MachConstantNode*) con->get_jobject();
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3881
      offset = offset + typesize * n->outcnt();  // expand jump-table
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3882
    } else {
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3883
      offset = offset + typesize;
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3884
    }
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3885
  }
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3886
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3887
  // Align size up to the next section start (which is insts; see
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3888
  // CodeBuffer::align_at_start).
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3889
  assert(_size == -1, "already set?");
11190
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3890
  _size = align_size_up(offset, CodeEntryAlignment);
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3891
}
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3892
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3893
void Compile::ConstantTable::emit(CodeBuffer& cb) {
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3894
  MacroAssembler _masm(&cb);
11190
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3895
  for (int i = 0; i < _constants.length(); i++) {
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3896
    Constant con = _constants.at(i);
33589
7cbd1b2c139b 8139040: Fix initializations before ShouldNotReachHere() etc. and enable -Wuninitialized on linux.
goetz
parents: 33198
diff changeset
  3897
    address constant_addr = NULL;
11190
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3898
    switch (con.type()) {
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3899
    case T_LONG:   constant_addr = _masm.long_constant(  con.get_jlong()  ); break;
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3900
    case T_FLOAT:  constant_addr = _masm.float_constant( con.get_jfloat() ); break;
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3901
    case T_DOUBLE: constant_addr = _masm.double_constant(con.get_jdouble()); break;
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3902
    case T_OBJECT: {
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3903
      jobject obj = con.get_jobject();
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3904
      int oop_index = _masm.oop_recorder()->find_index(obj);
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3905
      constant_addr = _masm.address_constant((address) obj, oop_Relocation::spec(oop_index));
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3906
      break;
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3907
    }
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3908
    case T_ADDRESS: {
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3909
      address addr = (address) con.get_jobject();
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3910
      constant_addr = _masm.address_constant(addr);
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3911
      break;
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3912
    }
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3913
    // We use T_VOID as marker for jump-table entries (labels) which
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3914
    // need an internal word relocation.
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3915
    case T_VOID: {
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3916
      MachConstantNode* n = (MachConstantNode*) con.get_jobject();
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3917
      // Fill the jump-table with a dummy word.  The real value is
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3918
      // filled in later in fill_jump_table.
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3919
      address dummy = (address) n;
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3920
      constant_addr = _masm.address_constant(dummy);
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3921
      // Expand jump-table
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3922
      for (uint i = 1; i < n->outcnt(); i++) {
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3923
        address temp_addr = _masm.address_constant(dummy + i);
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3924
        assert(temp_addr, "consts section too small");
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3925
      }
11190
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3926
      break;
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3927
    }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3928
    case T_METADATA: {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3929
      Metadata* obj = con.get_metadata();
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3930
      int metadata_index = _masm.oop_recorder()->find_index(obj);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3931
      constant_addr = _masm.address_constant((address) obj, metadata_Relocation::spec(metadata_index));
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3932
      break;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3933
    }
11190
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3934
    default: ShouldNotReachHere();
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3935
    }
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3936
    assert(constant_addr, "consts section too small");
24424
2658d7834c6e 8037816: Fix for 8036122 breaks build with Xcode5/clang
drchase
parents: 24342
diff changeset
  3937
    assert((constant_addr - _masm.code()->consts()->start()) == con.offset(),
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32202
diff changeset
  3938
            "must be: %d == %d", (int) (constant_addr - _masm.code()->consts()->start()), (int)(con.offset()));
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3939
  }
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3940
}
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3941
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3942
int Compile::ConstantTable::find_offset(Constant& con) const {
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3943
  int idx = _constants.find(con);
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3944
  assert(idx != -1, "constant must be in constant table");
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3945
  int offset = _constants.at(idx).offset();
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3946
  assert(offset != -1, "constant table not emitted yet?");
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3947
  return offset;
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3948
}
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3949
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3950
void Compile::ConstantTable::add(Constant& con) {
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3951
  if (con.can_be_reused()) {
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3952
    int idx = _constants.find(con);
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3953
    if (idx != -1 && _constants.at(idx).can_be_reused()) {
11190
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3954
      _constants.adr_at(idx)->inc_freq(con.freq());  // increase the frequency by the current value
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3955
      return;
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3956
    }
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3957
  }
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3958
  (void) _constants.append(con);
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3959
}
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3960
11190
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3961
Compile::Constant Compile::ConstantTable::add(MachConstantNode* n, BasicType type, jvalue value) {
19279
4be3c2e6663c 8022284: Hide internal data structure in PhaseCFG
adlertz
parents: 18025
diff changeset
  3962
  Block* b = Compile::current()->cfg()->get_block_for_node(n);
11190
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3963
  Constant con(type, value, b->_freq);
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3964
  add(con);
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3965
  return con;
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3966
}
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3967
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3968
Compile::Constant Compile::ConstantTable::add(Metadata* metadata) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3969
  Constant con(metadata);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3970
  add(con);
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3971
  return con;
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3972
}
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3973
11190
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3974
Compile::Constant Compile::ConstantTable::add(MachConstantNode* n, MachOper* oper) {
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3975
  jvalue value;
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3976
  BasicType type = oper->type()->basic_type();
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3977
  switch (type) {
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3978
  case T_LONG:    value.j = oper->constantL(); break;
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3979
  case T_FLOAT:   value.f = oper->constantF(); break;
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3980
  case T_DOUBLE:  value.d = oper->constantD(); break;
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3981
  case T_OBJECT:
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3982
  case T_ADDRESS: value.l = (jobject) oper->constant(); break;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13490
diff changeset
  3983
  case T_METADATA: return add((Metadata*)oper->constant()); break;
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32202
diff changeset
  3984
  default: guarantee(false, "unhandled type: %s", type2name(type));
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3985
  }
11190
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3986
  return add(n, type, value);
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3987
}
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3988
11190
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3989
Compile::Constant Compile::ConstantTable::add_jump_table(MachConstantNode* n) {
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3990
  jvalue value;
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3991
  // We can use the node pointer here to identify the right jump-table
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3992
  // as this method is called from Compile::Fill_buffer right before
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3993
  // the MachNodes are emitted and the jump-table is filled (means the
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3994
  // MachNode pointers do not change anymore).
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3995
  value.l = (jobject) n;
11190
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3996
  Constant con(T_VOID, value, next_jump_table_freq(), false);  // Labels of a jump-table cannot be reused.
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  3997
  add(con);
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3998
  return con;
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  3999
}
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4000
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4001
void Compile::ConstantTable::fill_jump_table(CodeBuffer& cb, MachConstantNode* n, GrowableArray<Label*> labels) const {
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4002
  // If called from Compile::scratch_emit_size do nothing.
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4003
  if (Compile::current()->in_scratch_emit_size())  return;
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4004
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4005
  assert(labels.is_nonempty(), "must be");
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32202
diff changeset
  4006
  assert((uint) labels.length() == n->outcnt(), "must be equal: %d == %d", labels.length(), n->outcnt());
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4007
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4008
  // Since MachConstantNode::constant_offset() also contains
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4009
  // table_base_offset() we need to subtract the table_base_offset()
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4010
  // to get the plain offset into the constant table.
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4011
  int offset = n->constant_offset() - table_base_offset();
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4012
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4013
  MacroAssembler _masm(&cb);
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4014
  address* jump_table_base = (address*) (_masm.code()->consts()->start() + offset);
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4015
11190
d561d41f241a 7003454: order constants in constant table by number of references in code
twisti
parents: 10988
diff changeset
  4016
  for (uint i = 0; i < n->outcnt(); i++) {
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4017
    address* constant_addr = &jump_table_base[i];
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32202
diff changeset
  4018
    assert(*constant_addr == (((address) n) + i), "all jump-table entries must contain adjusted node pointer: " INTPTR_FORMAT " == " INTPTR_FORMAT, p2i(*constant_addr), p2i(((address) n) + i));
7433
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4019
    *constant_addr = cb.consts()->target(*labels.at(i), (address) constant_addr);
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4020
    cb.consts()->relocate((address) constant_addr, relocInfo::internal_word_type);
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4021
  }
b418028612ad 6961690: load oops from constant table on SPARC
twisti
parents: 7432
diff changeset
  4022
}
14828
bb9dffedf46c 8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents: 14626
diff changeset
  4023
26166
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4024
//----------------------------static_subtype_check-----------------------------
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4025
// Shortcut important common cases when superklass is exact:
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4026
// (0) superklass is java.lang.Object (can occur in reflective code)
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4027
// (1) subklass is already limited to a subtype of superklass => always ok
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4028
// (2) subklass does not overlap with superklass => always fail
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4029
// (3) superklass has NO subtypes and we can check with a simple compare.
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4030
int Compile::static_subtype_check(ciKlass* superk, ciKlass* subk) {
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4031
  if (StressReflectiveCode) {
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4032
    return SSC_full_test;       // Let caller generate the general case.
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4033
  }
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4034
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4035
  if (superk == env()->Object_klass()) {
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4036
    return SSC_always_true;     // (0) this test cannot fail
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4037
  }
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4038
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4039
  ciType* superelem = superk;
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4040
  if (superelem->is_array_klass())
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4041
    superelem = superelem->as_array_klass()->base_element_type();
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4042
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4043
  if (!subk->is_interface()) {  // cannot trust static interface types yet
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4044
    if (subk->is_subtype_of(superk)) {
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4045
      return SSC_always_true;   // (1) false path dead; no dynamic test needed
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4046
    }
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4047
    if (!(superelem->is_klass() && superelem->as_klass()->is_interface()) &&
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4048
        !superk->is_subtype_of(subk)) {
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4049
      return SSC_always_false;
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4050
    }
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4051
  }
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4052
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4053
  // If casting to an instance klass, it must have no subtypes
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4054
  if (superk->is_interface()) {
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4055
    // Cannot trust interfaces yet.
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4056
    // %%% S.B. superk->nof_implementors() == 1
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4057
  } else if (superelem->is_instance_klass()) {
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4058
    ciInstanceKlass* ik = superelem->as_instance_klass();
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4059
    if (!ik->has_subklass() && !ik->is_interface()) {
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4060
      if (!ik->is_final()) {
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4061
        // Add a dependency if there is a chance of a later subclass.
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4062
        dependencies()->assert_leaf_type(ik);
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4063
      }
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4064
      return SSC_easy_test;     // (3) caller can do a simple ptr comparison
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4065
    }
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4066
  } else {
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4067
    // A primitive array type has no subtypes.
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4068
    return SSC_easy_test;       // (3) caller can do a simple ptr comparison
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4069
  }
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4070
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4071
  return SSC_full_test;
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4072
}
4b49fd58bbd9 7173584: Implement arraycopy as a macro node
roland
parents: 25930
diff changeset
  4073
35574
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4074
Node* Compile::conv_I2X_index(PhaseGVN* phase, Node* idx, const TypeInt* sizetype, Node* ctrl) {
29337
ef2be52deeaf 6912521: System.arraycopy works slower than the simple loop for little lengths
roland
parents: 28912
diff changeset
  4075
#ifdef _LP64
ef2be52deeaf 6912521: System.arraycopy works slower than the simple loop for little lengths
roland
parents: 28912
diff changeset
  4076
  // The scaled index operand to AddP must be a clean 64-bit value.
ef2be52deeaf 6912521: System.arraycopy works slower than the simple loop for little lengths
roland
parents: 28912
diff changeset
  4077
  // Java allows a 32-bit int to be incremented to a negative
ef2be52deeaf 6912521: System.arraycopy works slower than the simple loop for little lengths
roland
parents: 28912
diff changeset
  4078
  // value, which appears in a 64-bit register as a large
ef2be52deeaf 6912521: System.arraycopy works slower than the simple loop for little lengths
roland
parents: 28912
diff changeset
  4079
  // positive number.  Using that large positive number as an
ef2be52deeaf 6912521: System.arraycopy works slower than the simple loop for little lengths
roland
parents: 28912
diff changeset
  4080
  // operand in pointer arithmetic has bad consequences.
ef2be52deeaf 6912521: System.arraycopy works slower than the simple loop for little lengths
roland
parents: 28912
diff changeset
  4081
  // On the other hand, 32-bit overflow is rare, and the possibility
ef2be52deeaf 6912521: System.arraycopy works slower than the simple loop for little lengths
roland
parents: 28912
diff changeset
  4082
  // can often be excluded, if we annotate the ConvI2L node with
ef2be52deeaf 6912521: System.arraycopy works slower than the simple loop for little lengths
roland
parents: 28912
diff changeset
  4083
  // a type assertion that its value is known to be a small positive
ef2be52deeaf 6912521: System.arraycopy works slower than the simple loop for little lengths
roland
parents: 28912
diff changeset
  4084
  // number.  (The prior range check has ensured this.)
ef2be52deeaf 6912521: System.arraycopy works slower than the simple loop for little lengths
roland
parents: 28912
diff changeset
  4085
  // This assertion is used by ConvI2LNode::Ideal.
ef2be52deeaf 6912521: System.arraycopy works slower than the simple loop for little lengths
roland
parents: 28912
diff changeset
  4086
  int index_max = max_jint - 1;  // array size is max_jint, index is one less
35574
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4087
  if (sizetype != NULL) index_max = sizetype->_hi - 1;
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4088
  const TypeInt* iidxtype = TypeInt::make(0, index_max, Type::WidenMax);
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4089
  idx = constrained_convI2L(phase, idx, iidxtype, ctrl);
29337
ef2be52deeaf 6912521: System.arraycopy works slower than the simple loop for little lengths
roland
parents: 28912
diff changeset
  4090
#endif
ef2be52deeaf 6912521: System.arraycopy works slower than the simple loop for little lengths
roland
parents: 28912
diff changeset
  4091
  return idx;
ef2be52deeaf 6912521: System.arraycopy works slower than the simple loop for little lengths
roland
parents: 28912
diff changeset
  4092
}
ef2be52deeaf 6912521: System.arraycopy works slower than the simple loop for little lengths
roland
parents: 28912
diff changeset
  4093
35574
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4094
// Convert integer value to a narrowed long type dependent on ctrl (for example, a range check)
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4095
Node* Compile::constrained_convI2L(PhaseGVN* phase, Node* value, const TypeInt* itype, Node* ctrl) {
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4096
  if (ctrl != NULL) {
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4097
    // Express control dependency by a CastII node with a narrow type.
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4098
    value = new CastIINode(value, itype, false, true /* range check dependency */);
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4099
    // Make the CastII node dependent on the control input to prevent the narrowed ConvI2L
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4100
    // node from floating above the range check during loop optimizations. Otherwise, the
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4101
    // ConvI2L node may be eliminated independently of the range check, causing the data path
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4102
    // to become TOP while the control path is still there (although it's unreachable).
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4103
    value->set_req(0, ctrl);
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4104
    // Save CastII node to remove it after loop optimizations.
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4105
    phase->C->add_range_check_cast(value);
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4106
    value = phase->transform(value);
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4107
  }
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4108
  const TypeLong* ltype = TypeLong::make(itype->_lo, itype->_hi, itype->_widen);
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4109
  return phase->transform(new ConvI2LNode(value, ltype));
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4110
}
2b25eb88c8d6 6675699: need comprehensive fix for unconstrained ConvI2L with narrowed type
thartmann
parents: 35545
diff changeset
  4111
23846
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4112
// The message about the current inlining is accumulated in
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4113
// _print_inlining_stream and transfered into the _print_inlining_list
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4114
// once we know whether inlining succeeds or not. For regular
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4115
// inlining, messages are appended to the buffer pointed by
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4116
// _print_inlining_idx in the _print_inlining_list. For late inlining,
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4117
// a new buffer is added after _print_inlining_idx in the list. This
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4118
// way we can update the inlining message for late inlining call site
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4119
// when the inlining is attempted again.
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4120
void Compile::print_inlining_init() {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4121
  if (print_inlining() || print_intrinsics()) {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4122
    _print_inlining_stream = new stringStream();
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4123
    _print_inlining_list = new (comp_arena())GrowableArray<PrintInliningBuffer>(comp_arena(), 1, 1, PrintInliningBuffer());
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4124
  }
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4125
}
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4126
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4127
void Compile::print_inlining_reinit() {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4128
  if (print_inlining() || print_intrinsics()) {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4129
    // Re allocate buffer when we change ResourceMark
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4130
    _print_inlining_stream = new stringStream();
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4131
  }
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4132
}
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4133
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4134
void Compile::print_inlining_reset() {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4135
  _print_inlining_stream->reset();
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4136
}
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4137
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4138
void Compile::print_inlining_commit() {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4139
  assert(print_inlining() || print_intrinsics(), "PrintInlining off?");
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4140
  // Transfer the message from _print_inlining_stream to the current
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4141
  // _print_inlining_list buffer and clear _print_inlining_stream.
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4142
  _print_inlining_list->at(_print_inlining_idx).ss()->write(_print_inlining_stream->as_string(), _print_inlining_stream->size());
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4143
  print_inlining_reset();
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4144
}
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4145
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4146
void Compile::print_inlining_push() {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4147
  // Add new buffer to the _print_inlining_list at current position
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4148
  _print_inlining_idx++;
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4149
  _print_inlining_list->insert_before(_print_inlining_idx, PrintInliningBuffer());
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4150
}
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4151
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4152
Compile::PrintInliningBuffer& Compile::print_inlining_current() {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4153
  return _print_inlining_list->at(_print_inlining_idx);
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4154
}
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4155
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4156
void Compile::print_inlining_update(CallGenerator* cg) {
20073
bfc95277d42b 8022585: VM crashes when ran with -XX:+PrintInlining
kvn
parents: 19995
diff changeset
  4157
  if (print_inlining() || print_intrinsics()) {
23846
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4158
    if (!cg->is_late_inline()) {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4159
      if (print_inlining_current().cg() != NULL) {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4160
        print_inlining_push();
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4161
      }
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4162
      print_inlining_commit();
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4163
    } else {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4164
      if (print_inlining_current().cg() != cg &&
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4165
          (print_inlining_current().cg() != NULL ||
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4166
           print_inlining_current().ss()->size() != 0)) {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4167
        print_inlining_push();
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4168
      }
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4169
      print_inlining_commit();
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4170
      print_inlining_current().set_cg(cg);
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4171
    }
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4172
  }
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4173
}
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4174
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4175
void Compile::print_inlining_move_to(CallGenerator* cg) {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4176
  // We resume inlining at a late inlining call site. Locate the
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4177
  // corresponding inlining buffer so that we can update it.
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4178
  if (print_inlining()) {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4179
    for (int i = 0; i < _print_inlining_list->length(); i++) {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4180
      if (_print_inlining_list->adr_at(i)->cg() == cg) {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4181
        _print_inlining_idx = i;
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4182
        return;
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4183
      }
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4184
    }
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4185
    ShouldNotReachHere();
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4186
  }
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4187
}
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4188
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4189
void Compile::print_inlining_update_delayed(CallGenerator* cg) {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4190
  if (print_inlining()) {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4191
    assert(_print_inlining_stream->size() > 0, "missing inlining msg");
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4192
    assert(print_inlining_current().cg() == cg, "wrong entry");
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4193
    // replace message with new message
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4194
    _print_inlining_list->at_put(_print_inlining_idx, PrintInliningBuffer());
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4195
    print_inlining_commit();
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4196
    print_inlining_current().set_cg(cg);
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4197
  }
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4198
}
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4199
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4200
void Compile::print_inlining_assert_ready() {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4201
  assert(!_print_inlining || _print_inlining_stream->size() == 0, "loosing data");
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4202
}
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4203
24673
2ec56802b829 8043638: Multiple compilation attempts break LogCompulation, lead to confusing PrintInlining output
roland
parents: 24442
diff changeset
  4204
void Compile::process_print_inlining() {
23846
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4205
  bool do_print_inlining = print_inlining() || print_intrinsics();
24002
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4206
  if (do_print_inlining || log() != NULL) {
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  4207
    // Print inlining message for candidates that we couldn't inline
23846
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4208
    // for lack of space
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  4209
    for (int i = 0; i < _late_inlines.length(); i++) {
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  4210
      CallGenerator* cg = _late_inlines.at(i);
23846
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4211
      if (!cg->is_mh_late_inline()) {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4212
        const char* msg = "live nodes > LiveNodeCountInliningCutoff";
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4213
        if (do_print_inlining) {
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4214
          cg->print_inlining_late(msg);
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4215
        }
24002
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4216
        log_late_inline_failure(cg, msg);
15113
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  4217
      }
823590505eb4 8005071: Incremental inlining for JSR 292
roland
parents: 14828
diff changeset
  4218
    }
23846
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4219
  }
490ace57944d 8007988: PrintInlining output is inconsistent with incremental inlining
roland
parents: 23528
diff changeset
  4220
  if (do_print_inlining) {
24673
2ec56802b829 8043638: Multiple compilation attempts break LogCompulation, lead to confusing PrintInlining output
roland
parents: 24442
diff changeset
  4221
    ResourceMark rm;
2ec56802b829 8043638: Multiple compilation attempts break LogCompulation, lead to confusing PrintInlining output
roland
parents: 24442
diff changeset
  4222
    stringStream ss;
14828
bb9dffedf46c 8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents: 14626
diff changeset
  4223
    for (int i = 0; i < _print_inlining_list->length(); i++) {
24673
2ec56802b829 8043638: Multiple compilation attempts break LogCompulation, lead to confusing PrintInlining output
roland
parents: 24442
diff changeset
  4224
      ss.print("%s", _print_inlining_list->adr_at(i)->ss()->as_string());
14828
bb9dffedf46c 8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents: 14626
diff changeset
  4225
    }
24673
2ec56802b829 8043638: Multiple compilation attempts break LogCompulation, lead to confusing PrintInlining output
roland
parents: 24442
diff changeset
  4226
    size_t end = ss.size();
2ec56802b829 8043638: Multiple compilation attempts break LogCompulation, lead to confusing PrintInlining output
roland
parents: 24442
diff changeset
  4227
    _print_inlining_output = NEW_ARENA_ARRAY(comp_arena(), char, end+1);
2ec56802b829 8043638: Multiple compilation attempts break LogCompulation, lead to confusing PrintInlining output
roland
parents: 24442
diff changeset
  4228
    strncpy(_print_inlining_output, ss.base(), end+1);
2ec56802b829 8043638: Multiple compilation attempts break LogCompulation, lead to confusing PrintInlining output
roland
parents: 24442
diff changeset
  4229
    _print_inlining_output[end] = 0;
2ec56802b829 8043638: Multiple compilation attempts break LogCompulation, lead to confusing PrintInlining output
roland
parents: 24442
diff changeset
  4230
  }
2ec56802b829 8043638: Multiple compilation attempts break LogCompulation, lead to confusing PrintInlining output
roland
parents: 24442
diff changeset
  4231
}
2ec56802b829 8043638: Multiple compilation attempts break LogCompulation, lead to confusing PrintInlining output
roland
parents: 24442
diff changeset
  4232
2ec56802b829 8043638: Multiple compilation attempts break LogCompulation, lead to confusing PrintInlining output
roland
parents: 24442
diff changeset
  4233
void Compile::dump_print_inlining() {
2ec56802b829 8043638: Multiple compilation attempts break LogCompulation, lead to confusing PrintInlining output
roland
parents: 24442
diff changeset
  4234
  if (_print_inlining_output != NULL) {
2ec56802b829 8043638: Multiple compilation attempts break LogCompulation, lead to confusing PrintInlining output
roland
parents: 24442
diff changeset
  4235
    tty->print_raw(_print_inlining_output);
14828
bb9dffedf46c 8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents: 14626
diff changeset
  4236
  }
bb9dffedf46c 8005031: Some cleanup in c2 to prepare for incremental inlining support
roland
parents: 14626
diff changeset
  4237
}
15618
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4238
24002
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4239
void Compile::log_late_inline(CallGenerator* cg) {
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4240
  if (log() != NULL) {
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4241
    log()->head("late_inline method='%d'  inline_id='" JLONG_FORMAT "'", log()->identify(cg->method()),
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4242
                cg->unique_id());
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4243
    JVMState* p = cg->call_node()->jvms();
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4244
    while (p != NULL) {
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4245
      log()->elem("jvms bci='%d' method='%d'", p->bci(), log()->identify(p->method()));
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4246
      p = p->caller();
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4247
    }
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4248
    log()->tail("late_inline");
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4249
  }
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4250
}
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4251
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4252
void Compile::log_late_inline_failure(CallGenerator* cg, const char* msg) {
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4253
  log_late_inline(cg);
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4254
  if (log() != NULL) {
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4255
    log()->inline_fail(msg);
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4256
  }
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4257
}
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4258
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4259
void Compile::log_inline_id(CallGenerator* cg) {
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4260
  if (log() != NULL) {
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4261
    // The LogCompilation tool needs a unique way to identify late
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4262
    // inline call sites. This id must be unique for this call site in
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4263
    // this compilation. Try to have it unique across compilations as
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4264
    // well because it can be convenient when grepping through the log
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4265
    // file.
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4266
    // Distinguish OSR compilations from others in case CICountOSR is
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4267
    // on.
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4268
    jlong id = ((jlong)unique()) + (((jlong)compile_id()) << 33) + (CICountOSR && is_osr_compilation() ? ((jlong)1) << 32 : 0);
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4269
    cg->set_unique_id(id);
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4270
    log()->elem("inline_id id='" JLONG_FORMAT "'", id);
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4271
  }
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4272
}
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4273
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4274
void Compile::log_inline_failure(const char* msg) {
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4275
  if (C->log() != NULL) {
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4276
    C->log()->inline_fail(msg);
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4277
  }
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4278
}
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4279
4e6a72032a99 8005079: fix LogCompilation for incremental inlining
roland
parents: 24001
diff changeset
  4280
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
  4281
// Dump inlining replay data to the stream.
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
  4282
// Don't change thread state and acquire any locks.
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
  4283
void Compile::dump_inline_data(outputStream* out) {
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
  4284
  InlineTree* inl_tree = ilt();
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
  4285
  if (inl_tree != NULL) {
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
  4286
    out->print(" inline %d", inl_tree->count());
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
  4287
    inl_tree->dump_replay_data(out);
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
  4288
  }
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
  4289
}
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21527
diff changeset
  4290
15618
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4291
int Compile::cmp_expensive_nodes(Node* n1, Node* n2) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4292
  if (n1->Opcode() < n2->Opcode())      return -1;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4293
  else if (n1->Opcode() > n2->Opcode()) return 1;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4294
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 32202
diff changeset
  4295
  assert(n1->req() == n2->req(), "can't compare %s nodes: n1->req() = %d, n2->req() = %d", NodeClassNames[n1->Opcode()], n1->req(), n2->req());
15618
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4296
  for (uint i = 1; i < n1->req(); i++) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4297
    if (n1->in(i) < n2->in(i))      return -1;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4298
    else if (n1->in(i) > n2->in(i)) return 1;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4299
  }
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4300
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4301
  return 0;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4302
}
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4303
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4304
int Compile::cmp_expensive_nodes(Node** n1p, Node** n2p) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4305
  Node* n1 = *n1p;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4306
  Node* n2 = *n2p;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4307
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4308
  return cmp_expensive_nodes(n1, n2);
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4309
}
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4310
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4311
void Compile::sort_expensive_nodes() {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4312
  if (!expensive_nodes_sorted()) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4313
    _expensive_nodes->sort(cmp_expensive_nodes);
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4314
  }
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4315
}
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4316
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4317
bool Compile::expensive_nodes_sorted() const {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4318
  for (int i = 1; i < _expensive_nodes->length(); i++) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4319
    if (cmp_expensive_nodes(_expensive_nodes->adr_at(i), _expensive_nodes->adr_at(i-1)) < 0) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4320
      return false;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4321
    }
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4322
  }
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4323
  return true;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4324
}
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4325
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4326
bool Compile::should_optimize_expensive_nodes(PhaseIterGVN &igvn) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4327
  if (_expensive_nodes->length() == 0) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4328
    return false;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4329
  }
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4330
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4331
  assert(OptimizeExpensiveOps, "optimization off?");
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4332
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4333
  // Take this opportunity to remove dead nodes from the list
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4334
  int j = 0;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4335
  for (int i = 0; i < _expensive_nodes->length(); i++) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4336
    Node* n = _expensive_nodes->at(i);
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4337
    if (!n->is_unreachable(igvn)) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4338
      assert(n->is_expensive(), "should be expensive");
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4339
      _expensive_nodes->at_put(j, n);
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4340
      j++;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4341
    }
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4342
  }
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4343
  _expensive_nodes->trunc_to(j);
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4344
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4345
  // Then sort the list so that similar nodes are next to each other
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4346
  // and check for at least two nodes of identical kind with same data
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4347
  // inputs.
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4348
  sort_expensive_nodes();
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4349
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4350
  for (int i = 0; i < _expensive_nodes->length()-1; i++) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4351
    if (cmp_expensive_nodes(_expensive_nodes->adr_at(i), _expensive_nodes->adr_at(i+1)) == 0) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4352
      return true;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4353
    }
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4354
  }
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4355
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4356
  return false;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4357
}
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4358
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4359
void Compile::cleanup_expensive_nodes(PhaseIterGVN &igvn) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4360
  if (_expensive_nodes->length() == 0) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4361
    return;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4362
  }
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4363
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4364
  assert(OptimizeExpensiveOps, "optimization off?");
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4365
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4366
  // Sort to bring similar nodes next to each other and clear the
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4367
  // control input of nodes for which there's only a single copy.
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4368
  sort_expensive_nodes();
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4369
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4370
  int j = 0;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4371
  int identical = 0;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4372
  int i = 0;
25913
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  4373
  bool modified = false;
15618
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4374
  for (; i < _expensive_nodes->length()-1; i++) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4375
    assert(j <= i, "can't write beyond current index");
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4376
    if (_expensive_nodes->at(i)->Opcode() == _expensive_nodes->at(i+1)->Opcode()) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4377
      identical++;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4378
      _expensive_nodes->at_put(j++, _expensive_nodes->at(i));
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4379
      continue;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4380
    }
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4381
    if (identical > 0) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4382
      _expensive_nodes->at_put(j++, _expensive_nodes->at(i));
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4383
      identical = 0;
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4384
    } else {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4385
      Node* n = _expensive_nodes->at(i);
25913
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  4386
      igvn.replace_input_of(n, 0, NULL);
15618
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4387
      igvn.hash_insert(n);
25913
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  4388
      modified = true;
15618
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4389
    }
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4390
  }
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4391
  if (identical > 0) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4392
    _expensive_nodes->at_put(j++, _expensive_nodes->at(i));
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4393
  } else if (_expensive_nodes->length() >= 1) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4394
    Node* n = _expensive_nodes->at(i);
25913
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  4395
    igvn.replace_input_of(n, 0, NULL);
15618
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4396
    igvn.hash_insert(n);
25913
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  4397
    modified = true;
15618
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4398
  }
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4399
  _expensive_nodes->trunc_to(j);
25913
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  4400
  if (modified) {
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  4401
    igvn.optimize();
81dbc151e91c 8040213: C2 does not put all modified nodes on IGVN worklist
thartmann
parents: 25495
diff changeset
  4402
  }
15618
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4403
}
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4404
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4405
void Compile::add_expensive_node(Node * n) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4406
  assert(!_expensive_nodes->contains(n), "duplicate entry in expensive list");
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4407
  assert(n->is_expensive(), "expensive nodes with non-null control here only");
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4408
  assert(!n->is_CFG() && !n->is_Mem(), "no cfg or memory nodes here");
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4409
  if (OptimizeExpensiveOps) {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4410
    _expensive_nodes->append(n);
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4411
  } else {
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4412
    // Clear control input and let IGVN optimize expensive nodes if
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4413
    // OptimizeExpensiveOps is off.
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4414
    n->set_req(0, NULL);
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4415
  }
3eb521896836 7197327: 40% regression on 8 b41 comp 8 b40 on specjvm2008.mpegaudio on oob
roland
parents: 15211
diff changeset
  4416
}
15871
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4417
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4418
/**
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4419
 * Remove the speculative part of types and clean up the graph
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4420
 */
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4421
void Compile::remove_speculative_types(PhaseIterGVN &igvn) {
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4422
  if (UseTypeSpeculation) {
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4423
    Unique_Node_List worklist;
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4424
    worklist.push(root());
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4425
    int modified = 0;
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4426
    // Go over all type nodes that carry a speculative type, drop the
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4427
    // speculative part of the type and enqueue the node for an igvn
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4428
    // which may optimize it out.
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4429
    for (uint next = 0; next < worklist.size(); ++next) {
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4430
      Node *n  = worklist.at(next);
22799
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4431
      if (n->is_Type()) {
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4432
        TypeNode* tn = n->as_Type();
22799
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4433
        const Type* t = tn->type();
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4434
        const Type* t_no_spec = t->remove_speculative();
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4435
        if (t_no_spec != t) {
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4436
          bool in_hash = igvn.hash_delete(n);
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4437
          assert(in_hash, "node should be in igvn hash table");
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4438
          tn->set_type(t_no_spec);
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4439
          igvn.hash_insert(n);
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4440
          igvn._worklist.push(n); // give it a chance to go away
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4441
          modified++;
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4442
        }
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4443
      }
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4444
      uint max = n->len();
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4445
      for( uint i = 0; i < max; ++i ) {
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4446
        Node *m = n->in(i);
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4447
        if (not_a_node(m))  continue;
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4448
        worklist.push(m);
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4449
      }
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4450
    }
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4451
    // Drop the speculative part of all types in the igvn's type table
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4452
    igvn.remove_speculative_types();
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4453
    if (modified > 0) {
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4454
      igvn.optimize();
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4455
    }
22799
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4456
#ifdef ASSERT
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4457
    // Verify that after the IGVN is over no speculative type has resurfaced
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4458
    worklist.clear();
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4459
    worklist.push(root());
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4460
    for (uint next = 0; next < worklist.size(); ++next) {
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4461
      Node *n  = worklist.at(next);
24001
d0eea05381dd 8036898: assert(t != NULL) failed: must set before get
anoll
parents: 23846
diff changeset
  4462
      const Type* t = igvn.type_or_null(n);
d0eea05381dd 8036898: assert(t != NULL) failed: must set before get
anoll
parents: 23846
diff changeset
  4463
      assert((t == NULL) || (t == t->remove_speculative()), "no more speculative types");
22799
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4464
      if (n->is_Type()) {
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4465
        t = n->as_Type()->type();
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4466
        assert(t == t->remove_speculative(), "no more speculative types");
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4467
      }
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4468
      uint max = n->len();
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4469
      for( uint i = 0; i < max; ++i ) {
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4470
        Node *m = n->in(i);
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4471
        if (not_a_node(m))  continue;
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4472
        worklist.push(m);
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4473
      }
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4474
    }
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4475
    igvn.check_no_speculative_types();
83e58bac7980 8027422: assert(_gvn.type(obj)->higher_equal(tjp)) failed: cast_up is no longer needed
roland
parents: 22243
diff changeset
  4476
#endif
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4477
  }
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4478
}
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 21096
diff changeset
  4479
15871
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4480
// Auxiliary method to support randomized stressing/fuzzing.
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4481
//
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4482
// This method can be called the arbitrary number of times, with current count
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4483
// as the argument. The logic allows selecting a single candidate from the
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4484
// running list of candidates as follows:
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4485
//    int count = 0;
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4486
//    Cand* selected = null;
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4487
//    while(cand = cand->next()) {
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4488
//      if (randomized_select(++count)) {
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4489
//        selected = cand;
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4490
//      }
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4491
//    }
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4492
//
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4493
// Including count equalizes the chances any candidate is "selected".
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4494
// This is useful when we don't have the complete list of candidates to choose
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4495
// from uniformly. In this case, we need to adjust the randomicity of the
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4496
// selection, or else we will end up biasing the selection towards the latter
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4497
// candidates.
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4498
//
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4499
// Quick back-envelope calculation shows that for the list of n candidates
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4500
// the equal probability for the candidate to persist as "best" can be
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4501
// achieved by replacing it with "next" k-th candidate with the probability
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4502
// of 1/k. It can be easily shown that by the end of the run, the
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4503
// probability for any candidate is converged to 1/n, thus giving the
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4504
// uniform distribution among all the candidates.
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4505
//
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4506
// We don't care about the domain size as long as (RANDOMIZED_DOMAIN / count) is large.
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4507
#define RANDOMIZED_DOMAIN_POW 29
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4508
#define RANDOMIZED_DOMAIN (1 << RANDOMIZED_DOMAIN_POW)
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4509
#define RANDOMIZED_DOMAIN_MASK ((1 << (RANDOMIZED_DOMAIN_POW + 1)) - 1)
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4510
bool Compile::randomized_select(int count) {
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4511
  assert(count > 0, "only positive");
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4512
  return (os::random() & RANDOMIZED_DOMAIN_MASK) < (RANDOMIZED_DOMAIN / count);
b04dd94da4e6 8009120: Fuzz instruction scheduling in HotSpot compilers
shade
parents: 15618
diff changeset
  4513
}
30593
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4514
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4515
CloneMap&     Compile::clone_map()                 { return _clone_map; }
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4516
void          Compile::set_clone_map(Dict* d)      { _clone_map._dict = d; }
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4517
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4518
void NodeCloneInfo::dump() const {
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4519
  tty->print(" {%d:%d} ", idx(), gen());
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4520
}
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4521
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4522
void CloneMap::clone(Node* old, Node* nnn, int gen) {
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4523
  uint64_t val = value(old->_idx);
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4524
  NodeCloneInfo cio(val);
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4525
  assert(val != 0, "old node should be in the map");
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4526
  NodeCloneInfo cin(cio.idx(), gen + cio.gen());
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4527
  insert(nnn->_idx, cin.get());
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4528
#ifndef PRODUCT
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4529
  if (is_debug()) {
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4530
    tty->print_cr("CloneMap::clone inserted node %d info {%d:%d} into CloneMap", nnn->_idx, cin.idx(), cin.gen());
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4531
  }
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4532
#endif
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4533
}
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4534
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4535
void CloneMap::verify_insert_and_clone(Node* old, Node* nnn, int gen) {
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4536
  NodeCloneInfo cio(value(old->_idx));
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4537
  if (cio.get() == 0) {
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4538
    cio.set(old->_idx, 0);
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4539
    insert(old->_idx, cio.get());
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4540
#ifndef PRODUCT
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4541
    if (is_debug()) {
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4542
      tty->print_cr("CloneMap::verify_insert_and_clone inserted node %d info {%d:%d} into CloneMap", old->_idx, cio.idx(), cio.gen());
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4543
    }
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4544
#endif
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4545
  }
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4546
  clone(old, nnn, gen);
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4547
}
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4548
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4549
int CloneMap::max_gen() const {
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4550
  int g = 0;
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4551
  DictI di(_dict);
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4552
  for(; di.test(); ++di) {
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4553
    int t = gen(di._key);
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4554
    if (g < t) {
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4555
      g = t;
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4556
#ifndef PRODUCT
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4557
      if (is_debug()) {
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4558
        tty->print_cr("CloneMap::max_gen() update max=%d from %d", g, _2_node_idx_t(di._key));
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4559
      }
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4560
#endif
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4561
    }
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4562
  }
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4563
  return g;
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4564
}
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4565
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4566
void CloneMap::dump(node_idx_t key) const {
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4567
  uint64_t val = value(key);
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4568
  if (val != 0) {
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4569
    NodeCloneInfo ni(val);
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4570
    ni.dump();
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4571
  }
69f942690128 8076284: Improve vectorization of parallel streams
kvn
parents: 30300
diff changeset
  4572
}