hotspot/src/share/vm/ci/ciMethod.cpp
author tschatzl
Fri, 02 Jun 2017 13:48:01 +0200
changeset 46520 de5cb3eed39b
parent 46458 3c12af929e7d
child 46542 73dd19b96b5d
permissions -rw-r--r--
8177044: Remove _scan_top from HeapRegion Summary: Remove the _scan_top member from HeapRegion using a per-gc pre-calculated table of scan limits that also subsumes other checks. Reviewed-by: sangheki, kbarrett, ehelin
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
     2
 * Copyright (c) 1999, 2017, 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: 4892
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4892
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: 4892
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: 6754
diff changeset
    25
#include "precompiled.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    26
#include "ci/ciCallProfile.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    27
#include "ci/ciExceptionHandler.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    28
#include "ci/ciInstanceKlass.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    29
#include "ci/ciMethod.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    30
#include "ci/ciMethodBlocks.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    31
#include "ci/ciMethodData.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    32
#include "ci/ciStreams.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    33
#include "ci/ciSymbol.hpp"
14477
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
    34
#include "ci/ciReplay.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    35
#include "ci/ciUtilities.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    36
#include "classfile/systemDictionary.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    37
#include "compiler/abstractCompiler.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    38
#include "compiler/methodLiveness.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    39
#include "interpreter/interpreter.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    40
#include "interpreter/linkResolver.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    41
#include "interpreter/oopMapCache.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    42
#include "memory/allocation.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    43
#include "memory/resourceArea.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    44
#include "oops/generateOopMap.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    45
#include "oops/oop.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    46
#include "prims/nativeLookup.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    47
#include "runtime/deoptimization.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    48
#include "utilities/bitMap.inline.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    49
#include "utilities/xmlstream.hpp"
29582
9a0bb63adf5a 8073607: add trace events for inlining
iignatyev
parents: 28912
diff changeset
    50
#include "trace/tracing.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    51
#ifdef COMPILER2
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    52
#include "ci/bcEscapeAnalyzer.hpp"
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    53
#include "ci/ciTypeFlow.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
    54
#include "oops/method.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    55
#endif
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    56
#ifdef SHARK
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    57
#include "ci/ciTypeFlow.hpp"
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
    58
#include "oops/method.hpp"
7397
5b173b4ca846 6989984: Use standard include model for Hospot
stefank
parents: 6754
diff changeset
    59
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
// ciMethod
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
//
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
    63
// This class represents a Method* in the HotSpot virtual
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    64
// machine.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
// ciMethod::ciMethod
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
// Loaded method.
27644
f4aa22a934e4 8060147: SIGSEGV in Metadata::mark_on_stack() while marking metadata in ciEnv
vlivanov
parents: 27143
diff changeset
    71
ciMethod::ciMethod(methodHandle h_m, ciInstanceKlass* holder) :
f4aa22a934e4 8060147: SIGSEGV in Metadata::mark_on_stack() while marking metadata in ciEnv
vlivanov
parents: 27143
diff changeset
    72
  ciMetadata(h_m()),
31228
8e427370cdd1 8074551: GWT can be marked non-compilable due to deopt count pollution
vlivanov
parents: 31019
diff changeset
    73
  _holder(holder)
27644
f4aa22a934e4 8060147: SIGSEGV in Metadata::mark_on_stack() while marking metadata in ciEnv
vlivanov
parents: 27143
diff changeset
    74
{
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
  assert(h_m() != NULL, "no null method");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
31790
4a08476437e8 8025692: Log what methods are touched at run-time
minqi
parents: 31228
diff changeset
    77
  if (LogTouchedMethods) {
4a08476437e8 8025692: Log what methods are touched at run-time
minqi
parents: 31228
diff changeset
    78
    h_m()->log_touched(Thread::current());
4a08476437e8 8025692: Log what methods are touched at run-time
minqi
parents: 31228
diff changeset
    79
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
  // These fields are always filled in in loaded methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  _flags = ciFlags(h_m()->access_flags());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  // Easy to compute, so fill them in now.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
  _max_stack          = h_m()->max_stack();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  _max_locals         = h_m()->max_locals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
  _code_size          = h_m()->code_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
  _intrinsic_id       = h_m()->intrinsic_id();
13282
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 10734
diff changeset
    88
  _handler_count      = h_m()->exception_table_length();
24018
77b156916bab 8032410: compiler/uncommontrap/TestStackBangRbp.java times out on Solaris-Sparc V9
roland
parents: 23525
diff changeset
    89
  _size_of_parameters = h_m()->size_of_parameters();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  _uses_monitors      = h_m()->access_flags().has_monitor_bytecodes();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  _balanced_monitors  = !_uses_monitors || h_m()->access_flags().is_monitor_matching();
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
    92
  _is_c1_compilable   = !h_m()->is_not_c1_compilable();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
    93
  _is_c2_compilable   = !h_m()->is_not_c2_compilable();
35071
a0910b1d3e0d 8046936: JEP 270: Reserved Stack Areas for Critical Sections
fparain
parents: 34317
diff changeset
    94
  _has_reserved_stack_access = h_m()->has_reserved_stack_access();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  // Lazy fields, filled in on demand.  Require allocation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  _code               = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
  _exception_handlers = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
  _liveness           = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
  _method_blocks = NULL;
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   100
#if defined(COMPILER2) || defined(SHARK)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  _flow               = NULL;
5928
f6e69b46e9e3 6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents: 5702
diff changeset
   102
  _bcea               = NULL;
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   103
#endif // COMPILER2 || SHARK
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 2534
diff changeset
   105
  ciEnv *env = CURRENT_ENV;
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   106
  if (env->jvmti_can_hotswap_or_post_breakpoint() && can_be_compiled()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
    // 6328518 check hotswap conditions under the right lock.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
    MutexLocker locker(Compile_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
    if (Dependencies::check_evol_method(h_m()) != NULL) {
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   110
      _is_c1_compilable = false;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   111
      _is_c2_compilable = false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
    CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 13728
diff changeset
   117
  if (h_m()->method_holder()->is_linked()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
    _can_be_statically_bound = h_m()->can_be_statically_bound();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
    // Have to use a conservative value in this case.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
    _can_be_statically_bound = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  // Adjust the definition of this condition to be more useful:
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  // %%% take these conditions into account in vtable generation
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  if (!_can_be_statically_bound && h_m()->is_private())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
    _can_be_statically_bound = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  if (_can_be_statically_bound && h_m()->is_abstract())
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
    _can_be_statically_bound = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
  // generating _signature may allow GC and therefore move m.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
  // These fields are always filled in.
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7432
diff changeset
   133
  _name = env->get_symbol(h_m()->name());
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7432
diff changeset
   134
  ciSymbol* sig_symbol = env->get_symbol(h_m()->signature());
10008
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 8676
diff changeset
   135
  constantPoolHandle cpool = h_m()->constants();
d84de97ad847 7056328: JSR 292 invocation sometimes fails in adapters for types not on boot class path
jrose
parents: 8676
diff changeset
   136
  _signature = new (env->arena()) ciSignature(_holder, cpool, sig_symbol);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
  _method_data = NULL;
24442
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24018
diff changeset
   138
  _nmethod_age = h_m()->nmethod_age();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  // Take a snapshot of these values, so they will be commensurate with the MDO.
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   140
  if (ProfileInterpreter || TieredCompilation) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
    int invcnt = h_m()->interpreter_invocation_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
    // if the value overflowed report it as max int
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
    _interpreter_invocation_count = invcnt < 0 ? max_jint : invcnt ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
    _interpreter_throwout_count   = h_m()->interpreter_throwout_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
    _interpreter_invocation_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
    _interpreter_throwout_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   149
  if (_interpreter_invocation_count == 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
    _interpreter_invocation_count = 1;
14477
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
   151
  _instructions_size = -1;
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
   152
#ifdef ASSERT
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
   153
  if (ReplayCompiles) {
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
   154
    ciReplay::initialize(this);
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
   155
  }
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
   156
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
// ciMethod::ciMethod
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
// Unloaded method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
ciMethod::ciMethod(ciInstanceKlass* holder,
10734
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10506
diff changeset
   165
                   ciSymbol*        name,
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10506
diff changeset
   166
                   ciSymbol*        signature,
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10506
diff changeset
   167
                   ciInstanceKlass* accessor) :
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   168
  ciMetadata((Metadata*)NULL),
10734
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10506
diff changeset
   169
  _name(                   name),
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10506
diff changeset
   170
  _holder(                 holder),
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10506
diff changeset
   171
  _intrinsic_id(           vmIntrinsics::_none),
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10506
diff changeset
   172
  _liveness(               NULL),
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10506
diff changeset
   173
  _can_be_statically_bound(false),
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10506
diff changeset
   174
  _method_blocks(          NULL),
31228
8e427370cdd1 8074551: GWT can be marked non-compilable due to deopt count pollution
vlivanov
parents: 31019
diff changeset
   175
  _method_data(            NULL)
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   176
#if defined(COMPILER2) || defined(SHARK)
10734
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10506
diff changeset
   177
  ,
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10506
diff changeset
   178
  _flow(                   NULL),
14477
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
   179
  _bcea(                   NULL),
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
   180
  _instructions_size(-1)
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   181
#endif // COMPILER2 || SHARK
10734
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10506
diff changeset
   182
{
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10506
diff changeset
   183
  // Usually holder and accessor are the same type but in some cases
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10506
diff changeset
   184
  // the holder has the wrong class loader (e.g. invokedynamic call
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10506
diff changeset
   185
  // sites) so we pass the accessor.
065435337883 7092712: JSR 292: unloaded invokedynamic call sites can lead to a crash with signature types not on BCP
twisti
parents: 10506
diff changeset
   186
  _signature = new (CURRENT_ENV->arena()) ciSignature(accessor, constantPoolHandle(), signature);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   187
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   188
489c9b5090e2 Initial load
duke
parents:
diff changeset
   189
489c9b5090e2 Initial load
duke
parents:
diff changeset
   190
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   191
// ciMethod::load_code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
// Load the bytecodes and exception handler table for this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
void ciMethod::load_code() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  assert(is_loaded(), "only loaded methods have code");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   198
  Method* me = get_Method();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
  Arena* arena = CURRENT_THREAD_ENV->arena();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
  // Load the bytecodes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
  _code = (address)arena->Amalloc(code_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
  memcpy(_code, me->code_base(), code_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
38059
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 35071
diff changeset
   205
#if INCLUDE_JVMTI
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  // Revert any breakpoint bytecodes in ci's copy
200
88d83617f912 6498878: client compiler crashes on windows when dealing with breakpoint instructions
kvn
parents: 1
diff changeset
   207
  if (me->number_of_breakpoints() > 0) {
14391
df0a1573d5bd 8000725: NPG: method_holder() and pool_holder() and pool_holder field should be InstanceKlass
coleenp
parents: 13728
diff changeset
   208
    BreakpointInfo* bp = me->method_holder()->breakpoints();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
    for (; bp != NULL; bp = bp->next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
      if (bp->match(me)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
        code_at_put(bp->bci(), bp->orig_bytecode());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  }
38059
86ab3f0a9f87 8148195: Some InstanceKlass and MethodCounters fields can be excluded when JVMTI is not supported
cjplummer
parents: 35071
diff changeset
   215
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
  // And load the exception table.
13282
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 10734
diff changeset
   218
  ExceptionTable exc_table(me);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
  // Allocate one extra spot in our list of exceptions.  This
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
  // last entry will be used to represent the possibility that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
  // an exception escapes the method.  See ciExceptionHandlerStream
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
  // for details.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
  _exception_handlers =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
    (ciExceptionHandler**)arena->Amalloc(sizeof(ciExceptionHandler*)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
                                         * (_handler_count + 1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  if (_handler_count > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
    for (int i=0; i<_handler_count; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
      _exception_handlers[i] = new (arena) ciExceptionHandler(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
                                holder(),
13282
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 10734
diff changeset
   231
            /* start    */      exc_table.start_pc(i),
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 10734
diff changeset
   232
            /* limit    */      exc_table.end_pc(i),
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 10734
diff changeset
   233
            /* goto pc  */      exc_table.handler_pc(i),
9872915dd78d 7178145: Change constMethodOop::_exception_table to optionally inlined u2 table.
jiangli
parents: 10734
diff changeset
   234
            /* cp index */      exc_table.catch_type_index(i));
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  // Put an entry at the end of our list to represent the possibility
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  // of exceptional exit.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  _exception_handlers[_handler_count] =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
    new (arena) ciExceptionHandler(holder(), 0, code_size(), -1, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  if (CIPrintMethodCodes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
    print_codes();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   245
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
// ciMethod::has_linenumber_table
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
// length unknown until decompression
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
bool    ciMethod::has_linenumber_table() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  VM_ENTRY_MARK;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   256
  return get_Method()->has_linenumber_table();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
// ciMethod::compressed_linenumber_table
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
u_char* ciMethod::compressed_linenumber_table() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  VM_ENTRY_MARK;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   265
  return get_Method()->compressed_linenumber_table();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
// ciMethod::line_number_from_bci
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
int ciMethod::line_number_from_bci(int bci) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  VM_ENTRY_MARK;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   274
  return get_Method()->line_number_from_bci(bci);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
// ciMethod::vtable_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
// Get the position of this method's entry in the vtable, if any.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
int ciMethod::vtable_index() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  assert(holder()->is_linked(), "must be linked");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
  VM_ENTRY_MARK;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   286
  return get_Method()->vtable_index();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   290
#ifdef SHARK
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   291
// ------------------------------------------------------------------
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   292
// ciMethod::itable_index
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   293
//
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   294
// Get the position of this method's entry in the itable, if any.
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   295
int ciMethod::itable_index() {
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   296
  check_is_loaded();
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   297
  assert(holder()->is_linked(), "must be linked");
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   298
  VM_ENTRY_MARK;
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17383
diff changeset
   299
  Method* m = get_Method();
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17383
diff changeset
   300
  if (!m->has_itable_index())
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17383
diff changeset
   301
    return Method::nonvirtual_vtable_index;
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17383
diff changeset
   302
  return m->itable_index();
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   303
}
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   304
#endif // SHARK
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   305
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   306
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
// ciMethod::native_entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
// Get the address of this method's native code, if any.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
address ciMethod::native_entry() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
  assert(flags().is_native(), "must be native method");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
  VM_ENTRY_MARK;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   315
  Method* method = get_Method();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  address entry = method->native_function();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  assert(entry != NULL, "must be valid entry point");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  return entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
// ciMethod::interpreter_entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
// Get the entry point for running this method in the interpreter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
address ciMethod::interpreter_entry() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
  VM_ENTRY_MARK;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   329
  methodHandle mh(THREAD, get_Method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  return Interpreter::entry_for_method(mh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
// ciMethod::uses_balanced_monitors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
// Does this method use monitors in a strict stack-disciplined manner?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
bool ciMethod::has_balanced_monitors() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
  if (_balanced_monitors) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
  // Analyze the method to see if monitors are used properly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  VM_ENTRY_MARK;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   344
  methodHandle method(THREAD, get_Method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
  assert(method->has_monitor_bytecodes(), "should have checked this");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  // Check to see if a previous compilation computed the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
  // monitor-matching analysis.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
  if (method->guaranteed_monitor_matching()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
    _balanced_monitors = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
    EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
    GeneratePairingInfo gpi(method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
    gpi.compute_map(CATCH);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
    if (!gpi.monitor_safe()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
    method->set_guaranteed_monitor_matching();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
    _balanced_monitors = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
// ciMethod::get_flow_analysis
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
ciTypeFlow* ciMethod::get_flow_analysis() {
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   372
#if defined(COMPILER2) || defined(SHARK)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  if (_flow == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
    ciEnv* env = CURRENT_ENV;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
    _flow = new (env->arena()) ciTypeFlow(env, this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
    _flow->do_flow();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  return _flow;
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   379
#else // COMPILER2 || SHARK
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  return NULL;
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   382
#endif // COMPILER2 || SHARK
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
// ciMethod::get_osr_flow_analysis
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
ciTypeFlow* ciMethod::get_osr_flow_analysis(int osr_bci) {
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   389
#if defined(COMPILER2) || defined(SHARK)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  // OSR entry points are always place after a call bytecode of some sort
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  assert(osr_bci >= 0, "must supply valid OSR entry point");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  ciEnv* env = CURRENT_ENV;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  ciTypeFlow* flow = new (env->arena()) ciTypeFlow(env, this, osr_bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
  flow->do_flow();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  return flow;
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   396
#else // COMPILER2 || SHARK
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  return NULL;
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   399
#endif // COMPILER2 || SHARK
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
// ------------------------------------------------------------------
3910
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   403
// ciMethod::raw_liveness_at_bci
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
// Which local variables are live at a specific bci?
3910
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   406
MethodLivenessResult ciMethod::raw_liveness_at_bci(int bci) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
  if (_liveness == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
    // Create the liveness analyzer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
    Arena* arena = CURRENT_ENV->arena();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
    _liveness = new (arena) MethodLiveness(arena, this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
    _liveness->compute_liveness();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  }
3910
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   414
  return _liveness->get_liveness_at(bci);
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   415
}
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   416
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   417
// ------------------------------------------------------------------
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   418
// ciMethod::liveness_at_bci
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   419
//
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   420
// Which local variables are live at a specific bci?  When debugging
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   421
// will return true for all locals in some cases to improve debug
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   422
// information.
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   423
MethodLivenessResult ciMethod::liveness_at_bci(int bci) {
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   424
  MethodLivenessResult result = raw_liveness_at_bci(bci);
22893
e3a2b513713a 8035493: JVMTI PopFrame capability must instruct compilers not to prune locals
mgronlun
parents: 22243
diff changeset
   425
  if (CURRENT_ENV->should_retain_local_variables() || DeoptimizeALot || CompileTheWorld) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
    // Keep all locals live for the user's edification and amusement.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
    result.at_put_range(0, result.size(), true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
// ciMethod::live_local_oops_at_bci
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
// find all the live oops in the locals array for a particular bci
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
// Compute what the interpreter believes by using the interpreter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
// oopmap generator. This is used as a double check during osr to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
// guard against conservative result from MethodLiveness making us
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
// think a dead oop is live.  MethodLiveness is conservative in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
// sense that it may consider locals to be live which cannot be live,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
// like in the case where a local could contain an oop or  a primitive
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
// along different paths.  In that case the local must be dead when
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
// those paths merge. Since the interpreter's viewpoint is used when
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
// gc'ing an interpreter frame we need to use its viewpoint  during
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
// OSR when loading the locals.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
38177
b0c9cb06506b 8141501: Problems with BitMap buffer management
stefank
parents: 38144
diff changeset
   446
ResourceBitMap ciMethod::live_local_oops_at_bci(int bci) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
  InterpreterOopMap mask;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   449
  OopMapCache::compute_one_oop_map(get_Method(), bci, &mask);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
  int mask_size = max_locals();
38177
b0c9cb06506b 8141501: Problems with BitMap buffer management
stefank
parents: 38144
diff changeset
   451
  ResourceBitMap result(mask_size);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
  int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
  for (i = 0; i < mask_size ; i++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
    if (mask.is_oop(i)) result.set_bit(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
#ifdef COMPILER1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
// ciMethod::bci_block_start
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
// Marks all bcis where a new basic block starts
38177
b0c9cb06506b 8141501: Problems with BitMap buffer management
stefank
parents: 38144
diff changeset
   465
const BitMap& ciMethod::bci_block_start() {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  if (_liveness == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
    // Create the liveness analyzer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
    Arena* arena = CURRENT_ENV->arena();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
    _liveness = new (arena) MethodLiveness(arena, this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
    _liveness->compute_liveness();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
  return _liveness->get_bci_block_start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
#endif // COMPILER1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
// ciMethod::call_profile_at_bci
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
// Get the ciCallProfile for the invocation of this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
// Also reports receiver types for non-call type checks (if TypeProfileCasts).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
ciCallProfile ciMethod::call_profile_at_bci(int bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  ciCallProfile result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
  if (method_data() != NULL && method_data()->is_mature()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
    ciProfileData* data = method_data()->bci_to_data(bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
    if (data != NULL && data->is_CounterData()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
      // Every profiled call site has a counter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
      int count = data->as_CounterData()->count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
      if (!data->is_ReceiverTypeData()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
        result._receiver_count[0] = 0;  // that's a definite zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
      } else { // ReceiverTypeData is a subclass of CounterData
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
        ciReceiverTypeData* call = (ciReceiverTypeData*)data->as_ReceiverTypeData();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
        // In addition, virtual call sites have receiver type information
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
        int receivers_count_total = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
        int morphism = 0;
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   500
        // Precompute morphism for the possible fixup
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
        for (uint i = 0; i < call->row_limit(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
          ciKlass* receiver = call->receiver(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
          if (receiver == NULL)  continue;
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   504
          morphism++;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   505
        }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   506
        int epsilon = 0;
46326
70de7011f79a 8159734: Consistency check fails with -XX:-ProfileInterpreter
zmajo
parents: 40664
diff changeset
   507
        if (TieredCompilation) {
70de7011f79a 8159734: Consistency check fails with -XX:-ProfileInterpreter
zmajo
parents: 40664
diff changeset
   508
          // For a call, it is assumed that either the type of the receiver(s)
70de7011f79a 8159734: Consistency check fails with -XX:-ProfileInterpreter
zmajo
parents: 40664
diff changeset
   509
          // is recorded or an associated counter is incremented, but not both. With
70de7011f79a 8159734: Consistency check fails with -XX:-ProfileInterpreter
zmajo
parents: 40664
diff changeset
   510
          // tiered compilation, however, both can happen due to the interpreter and
70de7011f79a 8159734: Consistency check fails with -XX:-ProfileInterpreter
zmajo
parents: 40664
diff changeset
   511
          // C1 profiling invocations differently. Address that inconsistency here.
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   512
          if (morphism == 1 && count > 0) {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   513
            epsilon = count;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   514
            count = 0;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   515
          }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   516
        }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   517
        for (uint i = 0; i < call->row_limit(); i++) {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   518
          ciKlass* receiver = call->receiver(i);
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   519
          if (receiver == NULL)  continue;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   520
          int rcount = call->receiver_count(i) + epsilon;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
          if (rcount == 0) rcount = 1; // Should be valid value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
          receivers_count_total += rcount;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
          // Add the receiver to result data.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
          result.add_receiver(receiver, rcount);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
          // If we extend profiling to record methods,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
          // we will set result._method also.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
        // Determine call site's morphism.
46326
70de7011f79a 8159734: Consistency check fails with -XX:-ProfileInterpreter
zmajo
parents: 40664
diff changeset
   529
        // The call site count is 0 with known morphism (only 1 or 2 receivers)
70de7011f79a 8159734: Consistency check fails with -XX:-ProfileInterpreter
zmajo
parents: 40664
diff changeset
   530
        // or < 0 in the case of a type check failure for checkcast, aastore, instanceof.
4754
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   531
        // The call site count is > 0 in the case of a polymorphic virtual call.
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   532
        if (morphism > 0 && morphism == result._limit) {
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   533
           // The morphism <= MorphismLimit.
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   534
           if ((morphism <  ciCallProfile::MorphismLimit) ||
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   535
               (morphism == ciCallProfile::MorphismLimit && count == 0)) {
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   536
#ifdef ASSERT
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   537
             if (count > 0) {
4892
e977b527544a 6923002: assert(false,"this call site should not be polymorphic")
kvn
parents: 4754
diff changeset
   538
               this->print_short_name(tty);
e977b527544a 6923002: assert(false,"this call site should not be polymorphic")
kvn
parents: 4754
diff changeset
   539
               tty->print_cr(" @ bci:%d", bci);
4754
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   540
               this->print_codes();
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   541
               assert(false, "this call site should not be polymorphic");
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   542
             }
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   543
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
             result._morphism = morphism;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
           }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
        // Make the count consistent if this is a call profile. If count is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
        // zero or less, presume that this is a typecheck profile and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
        // do nothing.  Otherwise, increase count to be the sum of all
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
        // receiver's counts.
4754
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   551
        if (count >= 0) {
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   552
          count += receivers_count_total;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
      result._count = count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
// Add new receiver and sort data by receiver's profile count.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
void ciCallProfile::add_receiver(ciKlass* receiver, int receiver_count) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
  // Add new receiver and sort data by receiver's counts when we have space
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
  // for it otherwise replace the less called receiver (less called receiver
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
  // is placed to the last array element which is not used).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
  // First array's element contains most called receiver.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
  int i = _limit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
  for (; i > 0 && receiver_count > _receiver_count[i-1]; i--) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
    _receiver[i] = _receiver[i-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
    _receiver_count[i] = _receiver_count[i-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  _receiver[i] = receiver;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
  _receiver_count[i] = receiver_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  if (_limit < MorphismLimit) _limit++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   578
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   579
void ciMethod::assert_virtual_call_type_ok(int bci) {
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   580
  assert(java_code_at_bci(bci) == Bytecodes::_invokevirtual ||
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31790
diff changeset
   581
         java_code_at_bci(bci) == Bytecodes::_invokeinterface, "unexpected bytecode %s", Bytecodes::name(java_code_at_bci(bci)));
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   582
}
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   583
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   584
void ciMethod::assert_call_type_ok(int bci) {
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   585
  assert(java_code_at_bci(bci) == Bytecodes::_invokestatic ||
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   586
         java_code_at_bci(bci) == Bytecodes::_invokespecial ||
33105
294e48b4f704 8080775: Better argument formatting for assert() and friends
david
parents: 31790
diff changeset
   587
         java_code_at_bci(bci) == Bytecodes::_invokedynamic, "unexpected bytecode %s", Bytecodes::name(java_code_at_bci(bci)));
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   588
}
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   589
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   590
/**
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   591
 * Check whether profiling provides a type for the argument i to the
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   592
 * call at bci bci
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   593
 *
23525
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   594
 * @param [in]bci         bci of the call
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   595
 * @param [in]i           argument number
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   596
 * @param [out]type       profiled type of argument, NULL if none
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   597
 * @param [out]maybe_null true if null was seen for argument
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   598
 * @return                true if profiling exists
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   599
 *
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   600
 */
23525
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   601
bool ciMethod::argument_profiled_type(int bci, int i, ciKlass*& type, bool& maybe_null) {
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   602
  if (MethodData::profile_parameters() && method_data() != NULL && method_data()->is_mature()) {
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   603
    ciProfileData* data = method_data()->bci_to_data(bci);
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   604
    if (data != NULL) {
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   605
      if (data->is_VirtualCallTypeData()) {
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   606
        assert_virtual_call_type_ok(bci);
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   607
        ciVirtualCallTypeData* call = (ciVirtualCallTypeData*)data->as_VirtualCallTypeData();
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   608
        if (i >= call->number_of_arguments()) {
23525
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   609
          return false;
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   610
        }
23525
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   611
        type = call->valid_argument_type(i);
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   612
        maybe_null = call->argument_maybe_null(i);
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   613
        return true;
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   614
      } else if (data->is_CallTypeData()) {
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   615
        assert_call_type_ok(bci);
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   616
        ciCallTypeData* call = (ciCallTypeData*)data->as_CallTypeData();
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   617
        if (i >= call->number_of_arguments()) {
23525
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   618
          return false;
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   619
        }
23525
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   620
        type = call->valid_argument_type(i);
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   621
        maybe_null = call->argument_maybe_null(i);
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   622
        return true;
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   623
      }
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   624
    }
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   625
  }
23525
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   626
  return false;
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   627
}
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   628
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   629
/**
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   630
 * Check whether profiling provides a type for the return value from
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   631
 * the call at bci bci
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   632
 *
23525
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   633
 * @param [in]bci         bci of the call
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   634
 * @param [out]type       profiled type of argument, NULL if none
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   635
 * @param [out]maybe_null true if null was seen for argument
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   636
 * @return                true if profiling exists
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   637
 *
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   638
 */
23525
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   639
bool ciMethod::return_profiled_type(int bci, ciKlass*& type, bool& maybe_null) {
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   640
  if (MethodData::profile_return() && method_data() != NULL && method_data()->is_mature()) {
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   641
    ciProfileData* data = method_data()->bci_to_data(bci);
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   642
    if (data != NULL) {
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   643
      if (data->is_VirtualCallTypeData()) {
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   644
        assert_virtual_call_type_ok(bci);
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   645
        ciVirtualCallTypeData* call = (ciVirtualCallTypeData*)data->as_VirtualCallTypeData();
23525
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   646
        type = call->valid_return_type();
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   647
        maybe_null = call->return_maybe_null();
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   648
        return true;
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   649
      } else if (data->is_CallTypeData()) {
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   650
        assert_call_type_ok(bci);
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   651
        ciCallTypeData* call = (ciCallTypeData*)data->as_CallTypeData();
23525
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   652
        type = call->valid_return_type();
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   653
        maybe_null = call->return_maybe_null();
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   654
        return true;
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   655
      }
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   656
    }
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   657
  }
23525
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   658
  return false;
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   659
}
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   660
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   661
/**
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   662
 * Check whether profiling provides a type for the parameter i
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   663
 *
23525
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   664
 * @param [in]i           parameter number
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   665
 * @param [out]type       profiled type of parameter, NULL if none
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   666
 * @param [out]maybe_null true if null was seen for parameter
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   667
 * @return                true if profiling exists
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   668
 *
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   669
 */
23525
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   670
bool ciMethod::parameter_profiled_type(int i, ciKlass*& type, bool& maybe_null) {
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   671
  if (MethodData::profile_parameters() && method_data() != NULL && method_data()->is_mature()) {
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   672
    ciParametersTypeData* parameters = method_data()->parameters_type_data();
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   673
    if (parameters != NULL && i < parameters->number_of_parameters()) {
23525
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   674
      type = parameters->valid_parameter_type(i);
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   675
      maybe_null = parameters->parameter_maybe_null(i);
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   676
      return true;
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   677
    }
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   678
  }
23525
e3eb08ead679 8031755: Type speculation should be used to optimize explicit null checks
roland
parents: 23194
diff changeset
   679
  return false;
21099
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   680
}
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   681
46e6bbecd9e5 8024070: C2 needs some form of type speculation
roland
parents: 20695
diff changeset
   682
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
// ciMethod::find_monomorphic_target
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
// Given a certain calling environment, find the monomorphic target
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
// for the call.  Return NULL if the call is not monomorphic in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
// its calling environment, or if there are only abstract methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
// The returned method is never abstract.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
// Note: If caller uses a non-null result, it must inform dependencies
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
// via assert_unique_concrete_method or assert_leaf_type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
ciMethod* ciMethod::find_monomorphic_target(ciInstanceKlass* caller,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
                                            ciInstanceKlass* callee_holder,
30223
82ab7b6b4927 8062280: C2: inlining failure due to access checks being too strict
vlivanov
parents: 29582
diff changeset
   694
                                            ciInstanceKlass* actual_recv,
82ab7b6b4927 8062280: C2: inlining failure due to access checks being too strict
vlivanov
parents: 29582
diff changeset
   695
                                            bool check_access) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
  if (actual_recv->is_interface()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
    // %%% We cannot trust interface types, yet.  See bug 6312651.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
30223
82ab7b6b4927 8062280: C2: inlining failure due to access checks being too strict
vlivanov
parents: 29582
diff changeset
   703
  ciMethod* root_m = resolve_invoke(caller, actual_recv, check_access);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
  if (root_m == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
    // Something went wrong looking up the actual receiver method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
  assert(!root_m->is_abstract(), "resolve_invoke promise");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
  // Make certain quick checks even if UseCHA is false.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
  // Is it private or final?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
  if (root_m->can_be_statically_bound()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
    return root_m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
  if (actual_recv->is_leaf_type() && actual_recv == root_m->holder()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
    // Easy case.  There is no other place to put a method, so don't bother
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
    // to go through the VM_ENTRY_MARK and all the rest.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
    return root_m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
  // Array methods (clone, hashCode, etc.) are always statically bound.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
  // If we were to see an array type here, we'd return root_m.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
  // However, this method processes only ciInstanceKlasses.  (See 4962591.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
  // The inline_native_clone intrinsic narrows Object to T[] properly,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
  // so there is no need to do the same job here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
  if (!UseCHA)  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
23194
e60d7409415b 8036100: Default method returns true for a while, and then returns false
vlivanov
parents: 22893
diff changeset
   733
  // Disable CHA for default methods for now
e60d7409415b 8036100: Default method returns true for a while, and then returns false
vlivanov
parents: 22893
diff changeset
   734
  if (root_m->get_Method()->is_default_method()) {
e60d7409415b 8036100: Default method returns true for a while, and then returns false
vlivanov
parents: 22893
diff changeset
   735
    return NULL;
e60d7409415b 8036100: Default method returns true for a while, and then returns false
vlivanov
parents: 22893
diff changeset
   736
  }
e60d7409415b 8036100: Default method returns true for a while, and then returns false
vlivanov
parents: 22893
diff changeset
   737
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
  methodHandle target;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
    MutexLocker locker(Compile_lock);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   741
    Klass* context = actual_recv->get_Klass();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
    target = Dependencies::find_unique_concrete_method(context,
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   743
                                                       root_m->get_Method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
    // %%% Should upgrade this ciMethod API to look for 1 or 2 concrete methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
#ifndef PRODUCT
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   748
  if (TraceDependencies && target() != NULL && target() != root_m->get_Method()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
    tty->print("found a non-root unique target method");
33602
16053580a684 8139163: InstanceKlass::cast passes through NULL
coleenp
parents: 33129
diff changeset
   750
    tty->print_cr("  context = %s", actual_recv->get_Klass()->external_name());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
    tty->print("  method  = ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
    target->print_short_name(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
    tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
#endif //PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
  if (target() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   760
  if (target() == root_m->get_Method()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
    return root_m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
  if (!root_m->is_public() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
      !root_m->is_protected()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
    // If we are going to reason about inheritance, it's easiest
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
    // if the method in question is public, protected, or private.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
    // If the answer is not root_m, it is conservatively correct
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
    // to return NULL, even if the CHA encountered irrelevant
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
    // methods in other packages.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
    // %%% TO DO: Work out logic for package-private methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
    // with the same name but different vtable indexes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  }
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   774
  return CURRENT_THREAD_ENV->get_method(target());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
// ciMethod::resolve_invoke
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
// Given a known receiver klass, find the target for the call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
// Return NULL if the call has no target or the target is abstract.
30223
82ab7b6b4927 8062280: C2: inlining failure due to access checks being too strict
vlivanov
parents: 29582
diff changeset
   782
ciMethod* ciMethod::resolve_invoke(ciKlass* caller, ciKlass* exact_receiver, bool check_access) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
   check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
   VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   786
   Klass* caller_klass = caller->get_Klass();
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   787
   Klass* recv         = exact_receiver->get_Klass();
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   788
   Klass* resolved     = holder()->get_Klass();
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7432
diff changeset
   789
   Symbol* h_name      = name()->get_symbol();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7432
diff changeset
   790
   Symbol* h_signature = signature()->get_symbol();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   792
   LinkInfo link_info(resolved, h_name, h_signature, caller_klass,
38719
133bf85c3f36 8145148: InterfaceMethod CP entry pointing to a class should cause ICCE
coleenp
parents: 38177
diff changeset
   793
                      check_access ? LinkInfo::needs_access_check : LinkInfo::skip_access_check);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
   methodHandle m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
   // Only do exact lookup if receiver klass has been linked.  Otherwise,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
   // the vtable has not been setup, and the LinkResolver will fail.
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   797
   if (recv->is_array_klass()
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
        ||
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   799
       InstanceKlass::cast(recv)->is_linked() && !exact_receiver->is_interface()) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
     if (holder()->is_interface()) {
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   801
       m = LinkResolver::resolve_interface_call_or_null(recv, link_info);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
     } else {
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   803
       m = LinkResolver::resolve_virtual_call_or_null(recv, link_info);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
   if (m.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
     // Return NULL only if there was a problem with lookup (uninitialized class, etc.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
     return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
   ciMethod* result = this;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   813
   if (m() != get_Method()) {
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   814
     result = CURRENT_THREAD_ENV->get_method(m());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
   // Don't return abstract methods because they aren't
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
   // optimizable or interesting.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
   if (result->is_abstract()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
     return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
   } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
     return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
// ciMethod::resolve_vtable_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
// Given a known receiver klass, find the vtable index for the call.
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   830
// Return Method::invalid_vtable_index if the vtable_index is unknown.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
int ciMethod::resolve_vtable_index(ciKlass* caller, ciKlass* receiver) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
   check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   834
   int vtable_index = Method::invalid_vtable_index;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
   // Only do lookup if receiver klass has been linked.  Otherwise,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
   // the vtable has not been setup, and the LinkResolver will fail.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
   if (!receiver->is_interface()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
       && (!receiver->is_instance_klass() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
           receiver->as_instance_klass()->is_linked())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
     VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   842
     Klass* caller_klass = caller->get_Klass();
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   843
     Klass* recv         = receiver->get_Klass();
8076
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7432
diff changeset
   844
     Symbol* h_name = name()->get_symbol();
96d498ec7ae1 6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents: 7432
diff changeset
   845
     Symbol* h_signature = signature()->get_symbol();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
46329
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   847
     LinkInfo link_info(recv, h_name, h_signature, caller_klass);
53ccc37bda19 8155672: Remove instanceKlassHandles and KlassHandles
coleenp
parents: 46327
diff changeset
   848
     vtable_index = LinkResolver::resolve_virtual_vtable_index(recv, link_info);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   849
     if (vtable_index == Method::nonvirtual_vtable_index) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
       // A statically bound method.  Return "no such index".
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   851
       vtable_index = Method::invalid_vtable_index;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
   return vtable_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
// ciMethod::interpreter_call_site_count
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
int ciMethod::interpreter_call_site_count(int bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
  if (method_data() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
    ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
    ciProfileData* data = method_data()->bci_to_data(bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
    if (data != NULL && data->is_CounterData()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
      return scale_count(data->as_CounterData()->count());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
  return -1;  // unknown
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
// ------------------------------------------------------------------
14621
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   872
// ciMethod::get_field_at_bci
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   873
ciField* ciMethod::get_field_at_bci(int bci, bool &will_link) {
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   874
  ciBytecodeStream iter(this);
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   875
  iter.reset_to_bci(bci);
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   876
  iter.next();
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   877
  return iter.get_field(will_link);
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   878
}
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   879
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   880
// ------------------------------------------------------------------
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   881
// ciMethod::get_method_at_bci
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   882
ciMethod* ciMethod::get_method_at_bci(int bci, bool &will_link, ciSignature* *declared_signature) {
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   883
  ciBytecodeStream iter(this);
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   884
  iter.reset_to_bci(bci);
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   885
  iter.next();
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   886
  return iter.get_method(will_link, declared_signature);
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   887
}
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   888
fd9265ab0f67 7172640: C2: instrinsic implementations in LibraryCallKit should use argument() instead of pop()
twisti
parents: 14478
diff changeset
   889
// ------------------------------------------------------------------
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
// Adjust a CounterData count to be commensurate with
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
// interpreter_invocation_count.  If the MDO exists for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
// only 25% of the time the method exists, then the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
// counts in the MDO should be scaled by 4X, so that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
// they can be usefully and stably compared against the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
// invocation counts in methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
int ciMethod::scale_count(int count, float prof_factor) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
  if (count > 0 && method_data() != NULL) {
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   898
    int counter_life;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
    int method_life = interpreter_invocation_count();
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   900
    if (TieredCompilation) {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   901
      // In tiered the MDO's life is measured directly, so just use the snapshotted counters
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   902
      counter_life = MAX2(method_data()->invocation_count(), method_data()->backedge_count());
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   903
    } else {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   904
      int current_mileage = method_data()->current_mileage();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   905
      int creation_mileage = method_data()->creation_mileage();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   906
      counter_life = current_mileage - creation_mileage;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   907
    }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
   908
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
    // counter_life due to backedge_counter could be > method_life
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
    if (counter_life > method_life)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
      counter_life = method_life;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
    if (0 < counter_life && counter_life <= method_life) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
      count = (int)((double)count * prof_factor * method_life / counter_life + 0.5);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
      count = (count > 0) ? count : 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
  return count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
16617
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15479
diff changeset
   920
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15479
diff changeset
   921
// ------------------------------------------------------------------
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15479
diff changeset
   922
// ciMethod::is_special_get_caller_class_method
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15479
diff changeset
   923
//
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15479
diff changeset
   924
bool ciMethod::is_ignored_by_security_stack_walk() const {
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15479
diff changeset
   925
  check_is_loaded();
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15479
diff changeset
   926
  VM_ENTRY_MARK;
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15479
diff changeset
   927
  return get_Method()->is_ignored_by_security_stack_walk();
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15479
diff changeset
   928
}
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15479
diff changeset
   929
6235d2c7549f 7198429: need checked categorization of caller-sensitive methods in the JDK
twisti
parents: 15479
diff changeset
   930
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
// ------------------------------------------------------------------
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   932
// invokedynamic support
5687
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   933
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   934
// ------------------------------------------------------------------
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   935
// ciMethod::is_method_handle_intrinsic
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   936
//
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   937
// Return true if the method is an instance of the JVM-generated
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   938
// signature-polymorphic MethodHandle methods, _invokeBasic, _linkToVirtual, etc.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   939
bool ciMethod::is_method_handle_intrinsic() const {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   940
  vmIntrinsics::ID iid = _intrinsic_id;  // do not check if loaded
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   941
  return (MethodHandles::is_signature_polymorphic(iid) &&
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   942
          MethodHandles::is_signature_polymorphic_intrinsic(iid));
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   943
}
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   944
5687
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   945
// ------------------------------------------------------------------
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   946
// ciMethod::is_compiled_lambda_form
5687
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   947
//
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   948
// Return true if the method is a generated MethodHandle adapter.
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   949
// These are built by Java code.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   950
bool ciMethod::is_compiled_lambda_form() const {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   951
  vmIntrinsics::ID iid = _intrinsic_id;  // do not check if loaded
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   952
  return iid == vmIntrinsics::_compiledLambdaForm;
4581
e89fbd1bcb3d 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 4566
diff changeset
   953
}
e89fbd1bcb3d 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 4566
diff changeset
   954
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   955
// ------------------------------------------------------------------
44738
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 43951
diff changeset
   956
// ciMethod::is_object_initializer
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 43951
diff changeset
   957
//
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 43951
diff changeset
   958
bool ciMethod::is_object_initializer() const {
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 43951
diff changeset
   959
   return name() == ciSymbol::object_initializer_name();
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 43951
diff changeset
   960
}
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 43951
diff changeset
   961
11431bbc9549 8168699: Validate special case invocations
coleenp
parents: 43951
diff changeset
   962
// ------------------------------------------------------------------
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   963
// ciMethod::has_member_arg
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   964
//
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   965
// Return true if the method is a linker intrinsic like _linkToVirtual.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   966
// These are built by the JVM.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   967
bool ciMethod::has_member_arg() const {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   968
  vmIntrinsics::ID iid = _intrinsic_id;  // do not check if loaded
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   969
  return (MethodHandles::is_signature_polymorphic(iid) &&
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
   970
          MethodHandles::has_member_arg(iid));
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   971
}
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   972
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   973
// ------------------------------------------------------------------
7432
f06f1253c317 7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents: 7397
diff changeset
   974
// ciMethod::ensure_method_data
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
//
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   976
// Generate new MethodData* objects at compile time.
7432
f06f1253c317 7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents: 7397
diff changeset
   977
// Return true if allocation was successful or no MDO is required.
f06f1253c317 7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents: 7397
diff changeset
   978
bool ciMethod::ensure_method_data(methodHandle h_m) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
  EXCEPTION_CONTEXT;
20695
4f5a5e95090b 8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents: 20692
diff changeset
   980
  if (is_native() || is_abstract() || h_m()->is_accessor()) {
4f5a5e95090b 8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents: 20692
diff changeset
   981
    return true;
4f5a5e95090b 8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents: 20692
diff changeset
   982
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
  if (h_m()->method_data() == NULL) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   984
    Method::build_interpreter_method_data(h_m, THREAD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
  if (h_m()->method_data() != NULL) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
   990
    _method_data = CURRENT_ENV->get_method_data(h_m()->method_data());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
    _method_data->load_data();
7432
f06f1253c317 7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents: 7397
diff changeset
   992
    return true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
    _method_data = CURRENT_ENV->get_empty_methodData();
7432
f06f1253c317 7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents: 7397
diff changeset
   995
    return false;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
// public, retroactive version
7432
f06f1253c317 7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents: 7397
diff changeset
  1000
bool ciMethod::ensure_method_data() {
f06f1253c317 7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents: 7397
diff changeset
  1001
  bool result = true;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
  if (_method_data == NULL || _method_data->is_empty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
    GUARDED_VM_ENTRY({
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1004
      result = ensure_method_data(get_Method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
    });
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
  }
7432
f06f1253c317 7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents: 7397
diff changeset
  1007
  return result;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
// ciMethod::method_data
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
ciMethodData* ciMethod::method_data() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
  if (_method_data != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
    return _method_data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
  ciEnv* env = CURRENT_ENV;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
  Thread* my_thread = JavaThread::current();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1021
  methodHandle h_m(my_thread, get_Method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
  if (h_m()->method_data() != NULL) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1024
    _method_data = CURRENT_ENV->get_method_data(h_m()->method_data());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
    _method_data->load_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
    _method_data = CURRENT_ENV->get_empty_methodData();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
  return _method_data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
7432
f06f1253c317 7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents: 7397
diff changeset
  1033
// ------------------------------------------------------------------
f06f1253c317 7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents: 7397
diff changeset
  1034
// ciMethod::method_data_or_null
f06f1253c317 7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents: 7397
diff changeset
  1035
// Returns a pointer to ciMethodData if MDO exists on the VM side,
f06f1253c317 7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents: 7397
diff changeset
  1036
// NULL otherwise.
f06f1253c317 7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents: 7397
diff changeset
  1037
ciMethodData* ciMethod::method_data_or_null() {
f06f1253c317 7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents: 7397
diff changeset
  1038
  ciMethodData *md = method_data();
20695
4f5a5e95090b 8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents: 20692
diff changeset
  1039
  if (md->is_empty()) {
4f5a5e95090b 8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents: 20692
diff changeset
  1040
    return NULL;
4f5a5e95090b 8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents: 20692
diff changeset
  1041
  }
7432
f06f1253c317 7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents: 7397
diff changeset
  1042
  return md;
f06f1253c317 7003554: (tiered) assert(is_null_object() || handle() != NULL) failed: cannot embed null pointer
iveresov
parents: 7397
diff changeset
  1043
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
// ------------------------------------------------------------------
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
  1046
// ciMethod::ensure_method_counters
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
  1047
//
20695
4f5a5e95090b 8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents: 20692
diff changeset
  1048
MethodCounters* ciMethod::ensure_method_counters() {
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
  1049
  check_is_loaded();
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
  1050
  VM_ENTRY_MARK;
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
  1051
  methodHandle mh(THREAD, get_Method());
20695
4f5a5e95090b 8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents: 20692
diff changeset
  1052
  MethodCounters* method_counters = mh->get_method_counters(CHECK_NULL);
4f5a5e95090b 8025566: EXCEPTION_ACCESS_VIOLATION in compiled by C1 String.valueOf method
twisti
parents: 20692
diff changeset
  1053
  return method_counters;
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
  1054
}
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
  1055
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
  1056
// ------------------------------------------------------------------
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
// ciMethod::has_option
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
bool ciMethod::has_option(const char* option) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
  VM_ENTRY_MARK;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1062
  methodHandle mh(THREAD, get_Method());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
  return CompilerOracle::has_option_string(mh, option);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
// ------------------------------------------------------------------
26433
27020fde2dbf 8056964: JDK-8055286 changes are incomplete.
kvn
parents: 24442
diff changeset
  1067
// ciMethod::has_option_value
27020fde2dbf 8056964: JDK-8055286 changes are incomplete.
kvn
parents: 24442
diff changeset
  1068
//
33451
0712796e4039 8137167: JEP165: Compiler Control: Implementation task
neliasso
parents: 33129
diff changeset
  1069
bool ciMethod::has_option_value(const char* option, double& value) {
26433
27020fde2dbf 8056964: JDK-8055286 changes are incomplete.
kvn
parents: 24442
diff changeset
  1070
  check_is_loaded();
27020fde2dbf 8056964: JDK-8055286 changes are incomplete.
kvn
parents: 24442
diff changeset
  1071
  VM_ENTRY_MARK;
27020fde2dbf 8056964: JDK-8055286 changes are incomplete.
kvn
parents: 24442
diff changeset
  1072
  methodHandle mh(THREAD, get_Method());
27020fde2dbf 8056964: JDK-8055286 changes are incomplete.
kvn
parents: 24442
diff changeset
  1073
  return CompilerOracle::has_option_value(mh, option, value);
27020fde2dbf 8056964: JDK-8055286 changes are incomplete.
kvn
parents: 24442
diff changeset
  1074
}
27020fde2dbf 8056964: JDK-8055286 changes are incomplete.
kvn
parents: 24442
diff changeset
  1075
// ------------------------------------------------------------------
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
// ciMethod::can_be_compiled
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
// Have previous compilations of this method succeeded?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
bool ciMethod::can_be_compiled() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
  check_is_loaded();
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1081
  ciEnv* env = CURRENT_ENV;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1082
  if (is_c1_compile(env->comp_level())) {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1083
    return _is_c1_compilable;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1084
  }
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1085
  return _is_c2_compilable;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
// ciMethod::set_not_compilable
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
// Tell the VM that this method cannot be compiled at all.
15479
e3c00ec80145 8006613: adding reason to made_not_compilable
vlivanov
parents: 15471
diff changeset
  1092
void ciMethod::set_not_compilable(const char* reason) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
  VM_ENTRY_MARK;
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1095
  ciEnv* env = CURRENT_ENV;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1096
  if (is_c1_compile(env->comp_level())) {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1097
    _is_c1_compilable = false;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1098
  } else {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1099
    _is_c2_compilable = false;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1100
  }
15479
e3c00ec80145 8006613: adding reason to made_not_compilable
vlivanov
parents: 15471
diff changeset
  1101
  get_Method()->set_not_compilable(env->comp_level(), true, reason);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
// ciMethod::can_be_osr_compiled
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
// Have previous compilations of this method succeeded?
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1109
// Implementation note: the VM does not currently keep track
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1110
// of failed OSR compilations per bci.  The entry_bci parameter
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1111
// is currently unused.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1112
bool ciMethod::can_be_osr_compiled(int entry_bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1113
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1114
  VM_ENTRY_MARK;
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1115
  ciEnv* env = CURRENT_ENV;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1116
  return !get_Method()->is_not_osr_compilable(env->comp_level());
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1117
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1118
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1119
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1120
// ciMethod::has_compiled_code
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1121
bool ciMethod::has_compiled_code() {
14477
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1122
  return instructions_size() > 0;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1123
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1124
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1125
int ciMethod::comp_level() {
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1126
  check_is_loaded();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1127
  VM_ENTRY_MARK;
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 35071
diff changeset
  1128
  CompiledMethod* nm = get_Method()->code();
6453
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1129
  if (nm != NULL) return nm->comp_level();
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1130
  return 0;
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1131
}
970dc585ab63 6953144: Tiered compilation
iveresov
parents: 6418
diff changeset
  1132
10014
a5c2141ee857 7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents: 10008
diff changeset
  1133
int ciMethod::highest_osr_comp_level() {
a5c2141ee857 7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents: 10008
diff changeset
  1134
  check_is_loaded();
a5c2141ee857 7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents: 10008
diff changeset
  1135
  VM_ENTRY_MARK;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1136
  return get_Method()->highest_osr_comp_level();
10014
a5c2141ee857 7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents: 10008
diff changeset
  1137
}
a5c2141ee857 7057120: Tiered: Allow C1 to inline methods with loops
iveresov
parents: 10008
diff changeset
  1138
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1139
// ------------------------------------------------------------------
10506
575ad9bccff5 7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents: 10014
diff changeset
  1140
// ciMethod::code_size_for_inlining
575ad9bccff5 7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents: 10014
diff changeset
  1141
//
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
  1142
// Code size for inlining decisions.  This method returns a code
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
  1143
// size of 1 for methods which has the ForceInline annotation.
10506
575ad9bccff5 7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents: 10014
diff changeset
  1144
int ciMethod::code_size_for_inlining() {
575ad9bccff5 7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents: 10014
diff changeset
  1145
  check_is_loaded();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1146
  if (get_Method()->force_inline()) {
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
  1147
    return 1;
10506
575ad9bccff5 7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents: 10014
diff changeset
  1148
  }
575ad9bccff5 7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents: 10014
diff changeset
  1149
  return code_size();
575ad9bccff5 7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents: 10014
diff changeset
  1150
}
575ad9bccff5 7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents: 10014
diff changeset
  1151
575ad9bccff5 7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents: 10014
diff changeset
  1152
// ------------------------------------------------------------------
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1153
// ciMethod::instructions_size
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6187
diff changeset
  1154
//
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6187
diff changeset
  1155
// This is a rough metric for "fat" methods, compared before inlining
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6187
diff changeset
  1156
// with InlineSmallCode.  The CodeBlob::code_size accessor includes
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6187
diff changeset
  1157
// junk like exception handler, stubs, and constant table, which are
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6187
diff changeset
  1158
// not highly relevant to an inlined method.  So we use the more
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6187
diff changeset
  1159
// specific accessor nmethod::insts_size.
14477
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1160
int ciMethod::instructions_size() {
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1161
  if (_instructions_size == -1) {
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1162
    GUARDED_VM_ENTRY(
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 35071
diff changeset
  1163
                     CompiledMethod* code = get_Method()->code();
14477
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1164
                     if (code != NULL && (code->comp_level() == CompLevel_full_optimization)) {
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1165
                       _instructions_size = code->insts_end() - code->verified_entry_point();
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1166
                     } else {
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1167
                       _instructions_size = 0;
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1168
                     }
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1169
                     );
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1170
  }
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1171
  return _instructions_size;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1172
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1173
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1174
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1175
// ciMethod::log_nmethod_identity
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1176
void ciMethod::log_nmethod_identity(xmlStream* log) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1177
  GUARDED_VM_ENTRY(
38133
78b95467b9f1 8151956: Support non-continuous CodeBlobs in HotSpot
rbackman
parents: 35071
diff changeset
  1178
    CompiledMethod* code = get_Method()->code();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1179
    if (code != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1180
      code->log_identity(log);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1181
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1182
  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1183
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1184
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1185
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1186
// ciMethod::is_not_reached
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1187
bool ciMethod::is_not_reached(int bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1188
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1189
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1190
  return Interpreter::is_not_reached(
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1191
               methodHandle(THREAD, get_Method()), bci);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1192
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1193
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1194
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1195
// ciMethod::was_never_executed
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1196
bool ciMethod::was_executed_more_than(int times) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1197
  VM_ENTRY_MARK;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1198
  return get_Method()->was_executed_more_than(times);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1199
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1200
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1201
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1202
// ciMethod::has_unloaded_classes_in_signature
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1203
bool ciMethod::has_unloaded_classes_in_signature() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1204
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1205
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1206
    EXCEPTION_MARK;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1207
    methodHandle m(THREAD, get_Method());
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1208
    bool has_unloaded = Method::has_unloaded_classes_in_signature(m, (JavaThread *)THREAD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1209
    if( HAS_PENDING_EXCEPTION ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1210
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1211
      return true;     // Declare that we may have unloaded classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1212
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1213
    return has_unloaded;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1214
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1215
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1216
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1217
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1218
// ciMethod::is_klass_loaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1219
bool ciMethod::is_klass_loaded(int refinfo_index, bool must_be_resolved) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1220
  VM_ENTRY_MARK;
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1221
  return get_Method()->is_klass_loaded(refinfo_index, must_be_resolved);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1222
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1223
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1224
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1225
// ciMethod::check_call
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1226
bool ciMethod::check_call(int refinfo_index, bool is_static) const {
20017
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17383
diff changeset
  1227
  // This method is used only in C2 from InlineTree::ok_to_inline,
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17383
diff changeset
  1228
  // and is only used under -Xcomp or -XX:CompileTheWorld.
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17383
diff changeset
  1229
  // It appears to fail when applied to an invokeinterface call site.
81eba62e9048 8014013: CallInfo structure no longer accurately reports the result of a LinkResolver operation
drchase
parents: 17383
diff changeset
  1230
  // FIXME: Remove this method and resolve_method_statically; refactor to use the other LinkResolver entry points.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1231
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1232
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1233
    EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1234
    HandleMark hm(THREAD);
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1235
    constantPoolHandle pool (THREAD, get_Method()->constants());
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
  1236
    Bytecodes::Code code = (is_static ? Bytecodes::_invokestatic : Bytecodes::_invokevirtual);
31019
d05fcdd70109 8029567: Clean up linkResolver code
coleenp
parents: 30223
diff changeset
  1237
    methodHandle spec_method = LinkResolver::resolve_method_statically(code, pool, refinfo_index, THREAD);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1238
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1239
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1240
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1241
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1242
      return (spec_method->is_static() == is_static);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1243
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1244
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1245
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1246
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1247
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1248
// ------------------------------------------------------------------
24442
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24018
diff changeset
  1249
// ciMethod::profile_aging
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24018
diff changeset
  1250
//
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24018
diff changeset
  1251
// Should the method be compiled with an age counter?
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24018
diff changeset
  1252
bool ciMethod::profile_aging() const {
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24018
diff changeset
  1253
  return UseCodeAging && (!MethodCounters::is_nmethod_hot(nmethod_age()) &&
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24018
diff changeset
  1254
                          !MethodCounters::is_nmethod_age_unset(nmethod_age()));
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24018
diff changeset
  1255
}
4d4ae31dea26 8032463: VirtualDispatch test timeout with DeoptimizeALot
iveresov
parents: 24018
diff changeset
  1256
// ------------------------------------------------------------------
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1257
// ciMethod::print_codes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1258
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1259
// Print the bytecodes for this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1260
void ciMethod::print_codes_on(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1261
  check_is_loaded();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1262
  GUARDED_VM_ENTRY(get_Method()->print_codes_on(st);)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1263
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1264
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1265
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1266
#define FETCH_FLAG_FROM_VM(flag_accessor) { \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1267
  check_is_loaded(); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1268
  VM_ENTRY_MARK; \
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1269
  return get_Method()->flag_accessor(); \
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1270
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1271
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1272
bool ciMethod::is_empty_method() const {         FETCH_FLAG_FROM_VM(is_empty_method); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1273
bool ciMethod::is_vanilla_constructor() const {  FETCH_FLAG_FROM_VM(is_vanilla_constructor); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1274
bool ciMethod::has_loops      () const {         FETCH_FLAG_FROM_VM(has_loops); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1275
bool ciMethod::has_jsrs       () const {         FETCH_FLAG_FROM_VM(has_jsrs);  }
34169
b0b7187852b7 8140650: Method::is_accessor should cover getters and setters for all types
shade
parents: 33451
diff changeset
  1276
bool ciMethod::is_getter      () const {         FETCH_FLAG_FROM_VM(is_getter); }
b0b7187852b7 8140650: Method::is_accessor should cover getters and setters for all types
shade
parents: 33451
diff changeset
  1277
bool ciMethod::is_setter      () const {         FETCH_FLAG_FROM_VM(is_setter); }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1278
bool ciMethod::is_accessor    () const {         FETCH_FLAG_FROM_VM(is_accessor); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1279
bool ciMethod::is_initializer () const {         FETCH_FLAG_FROM_VM(is_initializer); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1280
17383
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1281
bool ciMethod::is_boxing_method() const {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1282
  if (holder()->is_box_klass()) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1283
    switch (intrinsic_id()) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1284
      case vmIntrinsics::_Boolean_valueOf:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1285
      case vmIntrinsics::_Byte_valueOf:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1286
      case vmIntrinsics::_Character_valueOf:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1287
      case vmIntrinsics::_Short_valueOf:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1288
      case vmIntrinsics::_Integer_valueOf:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1289
      case vmIntrinsics::_Long_valueOf:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1290
      case vmIntrinsics::_Float_valueOf:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1291
      case vmIntrinsics::_Double_valueOf:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1292
        return true;
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1293
      default:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1294
        return false;
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1295
    }
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1296
  }
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1297
  return false;
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1298
}
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1299
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1300
bool ciMethod::is_unboxing_method() const {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1301
  if (holder()->is_box_klass()) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1302
    switch (intrinsic_id()) {
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1303
      case vmIntrinsics::_booleanValue:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1304
      case vmIntrinsics::_byteValue:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1305
      case vmIntrinsics::_charValue:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1306
      case vmIntrinsics::_shortValue:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1307
      case vmIntrinsics::_intValue:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1308
      case vmIntrinsics::_longValue:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1309
      case vmIntrinsics::_floatValue:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1310
      case vmIntrinsics::_doubleValue:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1311
        return true;
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1312
      default:
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1313
        return false;
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1314
    }
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1315
  }
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1316
  return false;
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1317
}
3665c0901a0d 6934604: enable parts of EliminateAutoBox by default
kvn
parents: 17000
diff changeset
  1318
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1319
BCEscapeAnalyzer  *ciMethod::get_bcea() {
5928
f6e69b46e9e3 6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents: 5702
diff changeset
  1320
#ifdef COMPILER2
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1321
  if (_bcea == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1322
    _bcea = new (CURRENT_ENV->arena()) BCEscapeAnalyzer(this, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1323
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1324
  return _bcea;
5928
f6e69b46e9e3 6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents: 5702
diff changeset
  1325
#else // COMPILER2
f6e69b46e9e3 6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents: 5702
diff changeset
  1326
  ShouldNotReachHere();
f6e69b46e9e3 6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents: 5702
diff changeset
  1327
  return NULL;
f6e69b46e9e3 6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents: 5702
diff changeset
  1328
#endif // COMPILER2
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1329
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1330
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1331
ciMethodBlocks  *ciMethod::get_method_blocks() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1332
  Arena *arena = CURRENT_ENV->arena();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1333
  if (_method_blocks == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1334
    _method_blocks = new (arena) ciMethodBlocks(arena, this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1335
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1336
  return _method_blocks;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1337
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1338
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1339
#undef FETCH_FLAG_FROM_VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1340
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21099
diff changeset
  1341
void ciMethod::dump_name_as_ascii(outputStream* st) {
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21099
diff changeset
  1342
  Method* method = get_Method();
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21099
diff changeset
  1343
  st->print("%s %s %s",
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21099
diff changeset
  1344
            method->klass_name()->as_quoted_ascii(),
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21099
diff changeset
  1345
            method->name()->as_quoted_ascii(),
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21099
diff changeset
  1346
            method->signature()->as_quoted_ascii());
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21099
diff changeset
  1347
}
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21099
diff changeset
  1348
14477
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1349
void ciMethod::dump_replay_data(outputStream* st) {
15471
41f75023e6a6 8006410: allocating without ResourceMark when CompileCommand was specified
vlivanov
parents: 14621
diff changeset
  1350
  ResourceMark rm;
14477
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1351
  Method* method = get_Method();
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
  1352
  MethodCounters* mcs = method->method_counters();
22243
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21099
diff changeset
  1353
  st->print("ciMethod ");
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21099
diff changeset
  1354
  dump_name_as_ascii(st);
91944eab7b92 8028468: Add inlining information into ciReplay
kvn
parents: 21099
diff changeset
  1355
  st->print_cr(" %d %d %d %d %d",
17000
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
  1356
               mcs == NULL ? 0 : mcs->invocation_counter()->raw_counter(),
11bf92e571a2 8010862: The Method counter fields used for profiling can be allocated lazily.
jiangli
parents: 16617
diff changeset
  1357
               mcs == NULL ? 0 : mcs->backedge_counter()->raw_counter(),
14477
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1358
               interpreter_invocation_count(),
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1359
               interpreter_throwout_count(),
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1360
               _instructions_size);
95e66ea71f71 6830717: replay of compilations would help with debugging
minqi
parents: 14391
diff changeset
  1361
}
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1362
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1363
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1364
// ciMethod::print_codes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1365
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1366
// Print a range of the bytecodes for this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1367
void ciMethod::print_codes_on(int from, int to, outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1368
  check_is_loaded();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1369
  GUARDED_VM_ENTRY(get_Method()->print_codes_on(from, to, st);)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1370
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1371
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1372
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1373
// ciMethod::print_name
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1374
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1375
// Print the name of this method, including signature and some flags.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1376
void ciMethod::print_name(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1377
  check_is_loaded();
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1378
  GUARDED_VM_ENTRY(get_Method()->print_name(st);)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1379
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1380
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1381
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1382
// ciMethod::print_short_name
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1383
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1384
// Print the name of this method, without signature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1385
void ciMethod::print_short_name(outputStream* st) {
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
  1386
  if (is_loaded()) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1387
    GUARDED_VM_ENTRY(get_Method()->print_short_name(st););
13391
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
  1388
  } else {
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
  1389
    // Fall back if method is not loaded.
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
  1390
    holder()->print_name_on(st);
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
  1391
    st->print("::");
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
  1392
    name()->print_symbol_on(st);
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
  1393
    if (WizardMode)
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
  1394
      signature()->as_symbol()->print_symbol_on(st);
30245956af37 7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents: 13282
diff changeset
  1395
  }
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1396
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1397
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1398
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1399
// ciMethod::print_impl
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1400
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1401
// Implementation of the print method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1402
void ciMethod::print_impl(outputStream* st) {
13728
882756847a04 6964458: Reimplement class meta-data storage to use native memory
coleenp
parents: 13522
diff changeset
  1403
  ciMetadata::print_impl(st);
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1404
  st->print(" name=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1405
  name()->print_symbol_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1406
  st->print(" holder=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1407
  holder()->print_name_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1408
  st->print(" signature=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1409
  signature()->as_symbol()->print_symbol_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1410
  if (is_loaded()) {
13522
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
  1411
    st->print(" loaded=true");
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
  1412
    st->print(" arg_size=%d", arg_size());
5ad4627e792a 7192406: JSR 292: C2 needs exact return type information for invokedynamic and invokehandle call sites
twisti
parents: 13391
diff changeset
  1413
    st->print(" flags=");
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1414
    flags().print_member_flags(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1415
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1416
    st->print(" loaded=false");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1417
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1418
}
29582
9a0bb63adf5a 8073607: add trace events for inlining
iignatyev
parents: 28912
diff changeset
  1419
43947
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1420
// ------------------------------------------------------------------
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1421
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1422
static BasicType erase_to_word_type(BasicType bt) {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1423
  if (is_subword_type(bt)) return T_INT;
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1424
  if (bt == T_ARRAY)       return T_OBJECT;
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1425
  return bt;
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1426
}
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1427
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1428
static bool basic_types_match(ciType* t1, ciType* t2) {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1429
  if (t1 == t2)  return true;
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1430
  return erase_to_word_type(t1->basic_type()) == erase_to_word_type(t2->basic_type());
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1431
}
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1432
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1433
bool ciMethod::is_consistent_info(ciMethod* declared_method, ciMethod* resolved_method) {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1434
  bool invoke_through_mh_intrinsic = declared_method->is_method_handle_intrinsic() &&
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1435
                                  !resolved_method->is_method_handle_intrinsic();
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1436
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1437
  if (!invoke_through_mh_intrinsic) {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1438
    // Method name & descriptor should stay the same.
43951
c23519aaccc1 8174818: bigapps/Weblogic12medrec fails with assert(check_call_consistency(jvms, cg)) failed: inconsistent info
vlivanov
parents: 43947
diff changeset
  1439
    // Signatures may reference unloaded types and thus they may be not strictly equal.
c23519aaccc1 8174818: bigapps/Weblogic12medrec fails with assert(check_call_consistency(jvms, cg)) failed: inconsistent info
vlivanov
parents: 43947
diff changeset
  1440
    ciSymbol* declared_signature = declared_method->signature()->as_symbol();
c23519aaccc1 8174818: bigapps/Weblogic12medrec fails with assert(check_call_consistency(jvms, cg)) failed: inconsistent info
vlivanov
parents: 43947
diff changeset
  1441
    ciSymbol* resolved_signature = resolved_method->signature()->as_symbol();
c23519aaccc1 8174818: bigapps/Weblogic12medrec fails with assert(check_call_consistency(jvms, cg)) failed: inconsistent info
vlivanov
parents: 43947
diff changeset
  1442
43947
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1443
    return (declared_method->name()->equals(resolved_method->name())) &&
43951
c23519aaccc1 8174818: bigapps/Weblogic12medrec fails with assert(check_call_consistency(jvms, cg)) failed: inconsistent info
vlivanov
parents: 43947
diff changeset
  1444
           (declared_signature->equals(resolved_signature));
43947
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1445
  }
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1446
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1447
  ciMethod* linker = declared_method;
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1448
  ciMethod* target = resolved_method;
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1449
  // Linkers have appendix argument which is not passed to callee.
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1450
  int has_appendix = MethodHandles::has_member_arg(linker->intrinsic_id()) ? 1 : 0;
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1451
  if (linker->arg_size() != (target->arg_size() + has_appendix)) {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1452
    return false; // argument slot count mismatch
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1453
  }
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1454
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1455
  ciSignature* linker_sig = linker->signature();
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1456
  ciSignature* target_sig = target->signature();
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1457
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1458
  if (linker_sig->count() + (linker->is_static() ? 0 : 1) !=
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1459
      target_sig->count() + (target->is_static() ? 0 : 1) + has_appendix) {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1460
    return false; // argument count mismatch
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1461
  }
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1462
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1463
  int sbase = 0, rbase = 0;
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1464
  switch (linker->intrinsic_id()) {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1465
    case vmIntrinsics::_linkToVirtual:
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1466
    case vmIntrinsics::_linkToInterface:
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1467
    case vmIntrinsics::_linkToSpecial: {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1468
      if (target->is_static()) {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1469
        return false;
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1470
      }
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1471
      if (linker_sig->type_at(0)->is_primitive_type()) {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1472
        return false;  // receiver should be an oop
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1473
      }
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1474
      sbase = 1; // skip receiver
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1475
      break;
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1476
    }
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1477
    case vmIntrinsics::_linkToStatic: {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1478
      if (!target->is_static()) {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1479
        return false;
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1480
      }
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1481
      break;
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1482
    }
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1483
    case vmIntrinsics::_invokeBasic: {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1484
      if (target->is_static()) {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1485
        if (target_sig->type_at(0)->is_primitive_type()) {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1486
          return false; // receiver should be an oop
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1487
        }
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1488
        rbase = 1; // skip receiver
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1489
      }
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1490
      break;
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1491
    }
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1492
  }
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1493
  assert(target_sig->count() - rbase == linker_sig->count() - sbase - has_appendix, "argument count mismatch");
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1494
  int arg_count = target_sig->count() - rbase;
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1495
  for (int i = 0; i < arg_count; i++) {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1496
    if (!basic_types_match(linker_sig->type_at(sbase + i), target_sig->type_at(rbase + i))) {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1497
      return false;
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1498
    }
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1499
  }
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1500
  // Only check the return type if the symbolic info has non-void return type.
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1501
  // I.e. the return value of the resolved method can be dropped.
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1502
  if (!linker->return_type()->is_void() &&
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1503
      !basic_types_match(linker->return_type(), target->return_type())) {
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1504
    return false;
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1505
  }
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1506
  return true; // no mismatch found
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1507
}
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1508
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1509
// ------------------------------------------------------------------
a52ee13998f3 8174721: C1: Inlining through MH invokers/linkers in unreachable code is unsafe
vlivanov
parents: 40664
diff changeset
  1510
29582
9a0bb63adf5a 8073607: add trace events for inlining
iignatyev
parents: 28912
diff changeset
  1511
#if INCLUDE_TRACE
40664
1ec65b303bb7 8164523: Clean up metadata for event based tracing
egahlin
parents: 39219
diff changeset
  1512
TraceStructCalleeMethod ciMethod::to_trace_struct() const {
1ec65b303bb7 8164523: Clean up metadata for event based tracing
egahlin
parents: 39219
diff changeset
  1513
  TraceStructCalleeMethod result;
1ec65b303bb7 8164523: Clean up metadata for event based tracing
egahlin
parents: 39219
diff changeset
  1514
  result.set_type(holder()->name()->as_utf8());
29582
9a0bb63adf5a 8073607: add trace events for inlining
iignatyev
parents: 28912
diff changeset
  1515
  result.set_name(name()->as_utf8());
40664
1ec65b303bb7 8164523: Clean up metadata for event based tracing
egahlin
parents: 39219
diff changeset
  1516
  result.set_descriptor(signature()->as_symbol()->as_utf8());
29582
9a0bb63adf5a 8073607: add trace events for inlining
iignatyev
parents: 28912
diff changeset
  1517
  return result;
9a0bb63adf5a 8073607: add trace events for inlining
iignatyev
parents: 28912
diff changeset
  1518
}
9a0bb63adf5a 8073607: add trace events for inlining
iignatyev
parents: 28912
diff changeset
  1519
#endif