hotspot/src/share/vm/ci/ciMethod.cpp
author twisti
Fri, 21 May 2010 02:59:24 -0700
changeset 5687 b862d1f189bd
parent 4892 e977b527544a
child 5702 201c5cde25bb
permissions -rw-r--r--
6930772: JSR 292 needs to support SPARC C1 Summary: C1 for SPARC needs to support JSR 292. Reviewed-by: never, jrose
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
4581
e89fbd1bcb3d 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 4566
diff changeset
     2
 * Copyright 1999-2010 Sun Microsystems, Inc.  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
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    19
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    20
 * CA 95054 USA or visit www.sun.com if you need additional information or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    21
 * have any questions.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
489c9b5090e2 Initial load
duke
parents:
diff changeset
    25
#include "incls/_precompiled.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    26
#include "incls/_ciMethod.cpp.incl"
489c9b5090e2 Initial load
duke
parents:
diff changeset
    27
489c9b5090e2 Initial load
duke
parents:
diff changeset
    28
// ciMethod
489c9b5090e2 Initial load
duke
parents:
diff changeset
    29
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    30
// This class represents a methodOop in the HotSpot virtual
489c9b5090e2 Initial load
duke
parents:
diff changeset
    31
// machine.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    32
489c9b5090e2 Initial load
duke
parents:
diff changeset
    33
489c9b5090e2 Initial load
duke
parents:
diff changeset
    34
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
    35
// ciMethod::ciMethod
489c9b5090e2 Initial load
duke
parents:
diff changeset
    36
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
    37
// Loaded method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    38
ciMethod::ciMethod(methodHandle h_m) : ciObject(h_m) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    39
  assert(h_m() != NULL, "no null method");
489c9b5090e2 Initial load
duke
parents:
diff changeset
    40
489c9b5090e2 Initial load
duke
parents:
diff changeset
    41
  // These fields are always filled in in loaded methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    42
  _flags = ciFlags(h_m()->access_flags());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    43
489c9b5090e2 Initial load
duke
parents:
diff changeset
    44
  // Easy to compute, so fill them in now.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    45
  _max_stack          = h_m()->max_stack();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    46
  _max_locals         = h_m()->max_locals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    47
  _code_size          = h_m()->code_size();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    48
  _intrinsic_id       = h_m()->intrinsic_id();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    49
  _handler_count      = h_m()->exception_table()->length() / 4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    50
  _uses_monitors      = h_m()->access_flags().has_monitor_bytecodes();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    51
  _balanced_monitors  = !_uses_monitors || h_m()->access_flags().is_monitor_matching();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    52
  _is_compilable      = !h_m()->is_not_compilable();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    53
  // Lazy fields, filled in on demand.  Require allocation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    54
  _code               = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    55
  _exception_handlers = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    56
  _liveness           = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    57
  _bcea = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    58
  _method_blocks = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
#ifdef COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
    60
  _flow               = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    61
#endif // COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
    62
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 2534
diff changeset
    63
  ciEnv *env = CURRENT_ENV;
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 2534
diff changeset
    64
  if (env->jvmti_can_hotswap_or_post_breakpoint() && _is_compilable) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    65
    // 6328518 check hotswap conditions under the right lock.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    66
    MutexLocker locker(Compile_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    67
    if (Dependencies::check_evol_method(h_m()) != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    68
      _is_compilable = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    69
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    70
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    71
    CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
489c9b5090e2 Initial load
duke
parents:
diff changeset
    72
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    73
489c9b5090e2 Initial load
duke
parents:
diff changeset
    74
  if (instanceKlass::cast(h_m()->method_holder())->is_linked()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    75
    _can_be_statically_bound = h_m()->can_be_statically_bound();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    76
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    77
    // Have to use a conservative value in this case.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    78
    _can_be_statically_bound = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    79
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
    80
489c9b5090e2 Initial load
duke
parents:
diff changeset
    81
  // Adjust the definition of this condition to be more useful:
489c9b5090e2 Initial load
duke
parents:
diff changeset
    82
  // %%% take these conditions into account in vtable generation
489c9b5090e2 Initial load
duke
parents:
diff changeset
    83
  if (!_can_be_statically_bound && h_m()->is_private())
489c9b5090e2 Initial load
duke
parents:
diff changeset
    84
    _can_be_statically_bound = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    85
  if (_can_be_statically_bound && h_m()->is_abstract())
489c9b5090e2 Initial load
duke
parents:
diff changeset
    86
    _can_be_statically_bound = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    87
489c9b5090e2 Initial load
duke
parents:
diff changeset
    88
  // generating _signature may allow GC and therefore move m.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    89
  // These fields are always filled in.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    90
  _name = env->get_object(h_m()->name())->as_symbol();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    91
  _holder = env->get_object(h_m()->method_holder())->as_instance_klass();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    92
  ciSymbol* sig_symbol = env->get_object(h_m()->signature())->as_symbol();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    93
  _signature = new (env->arena()) ciSignature(_holder, sig_symbol);
489c9b5090e2 Initial load
duke
parents:
diff changeset
    94
  _method_data = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
    95
  // Take a snapshot of these values, so they will be commensurate with the MDO.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    96
  if (ProfileInterpreter) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
    97
    int invcnt = h_m()->interpreter_invocation_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
    98
    // if the value overflowed report it as max int
489c9b5090e2 Initial load
duke
parents:
diff changeset
    99
    _interpreter_invocation_count = invcnt < 0 ? max_jint : invcnt ;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   100
    _interpreter_throwout_count   = h_m()->interpreter_throwout_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   101
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   102
    _interpreter_invocation_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   103
    _interpreter_throwout_count = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   104
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   105
  if (_interpreter_invocation_count == 0)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   106
    _interpreter_invocation_count = 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   107
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   108
489c9b5090e2 Initial load
duke
parents:
diff changeset
   109
489c9b5090e2 Initial load
duke
parents:
diff changeset
   110
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   111
// ciMethod::ciMethod
489c9b5090e2 Initial load
duke
parents:
diff changeset
   112
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   113
// Unloaded method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   114
ciMethod::ciMethod(ciInstanceKlass* holder,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   115
                   ciSymbol* name,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   116
                   ciSymbol* signature) : ciObject(ciMethodKlass::make()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   117
  // These fields are always filled in.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   118
  _name = name;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   119
  _holder = holder;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   120
  _signature = new (CURRENT_ENV->arena()) ciSignature(_holder, signature);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   121
  _intrinsic_id = vmIntrinsics::_none;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   122
  _liveness = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   123
  _can_be_statically_bound = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   124
  _bcea = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  _method_blocks = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   126
  _method_data = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
#ifdef COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   128
  _flow = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   129
#endif // COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   130
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   131
489c9b5090e2 Initial load
duke
parents:
diff changeset
   132
489c9b5090e2 Initial load
duke
parents:
diff changeset
   133
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   134
// ciMethod::load_code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   135
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   136
// Load the bytecodes and exception handler table for this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   137
void ciMethod::load_code() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   138
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   139
  assert(is_loaded(), "only loaded methods have code");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   140
489c9b5090e2 Initial load
duke
parents:
diff changeset
   141
  methodOop me = get_methodOop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   142
  Arena* arena = CURRENT_THREAD_ENV->arena();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   143
489c9b5090e2 Initial load
duke
parents:
diff changeset
   144
  // Load the bytecodes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   145
  _code = (address)arena->Amalloc(code_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   146
  memcpy(_code, me->code_base(), code_size());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   147
489c9b5090e2 Initial load
duke
parents:
diff changeset
   148
  // 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
   149
  if (me->number_of_breakpoints() > 0) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   150
    BreakpointInfo* bp = instanceKlass::cast(me->method_holder())->breakpoints();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   151
    for (; bp != NULL; bp = bp->next()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   152
      if (bp->match(me)) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   153
        code_at_put(bp->bci(), bp->orig_bytecode());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   154
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   155
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   156
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   157
489c9b5090e2 Initial load
duke
parents:
diff changeset
   158
  // And load the exception table.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   159
  typeArrayOop exc_table = me->exception_table();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   160
489c9b5090e2 Initial load
duke
parents:
diff changeset
   161
  // Allocate one extra spot in our list of exceptions.  This
489c9b5090e2 Initial load
duke
parents:
diff changeset
   162
  // last entry will be used to represent the possibility that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   163
  // an exception escapes the method.  See ciExceptionHandlerStream
489c9b5090e2 Initial load
duke
parents:
diff changeset
   164
  // for details.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   165
  _exception_handlers =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   166
    (ciExceptionHandler**)arena->Amalloc(sizeof(ciExceptionHandler*)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   167
                                         * (_handler_count + 1));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   168
  if (_handler_count > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   169
    for (int i=0; i<_handler_count; i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   170
      int base = i*4;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   171
      _exception_handlers[i] = new (arena) ciExceptionHandler(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   172
                                holder(),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   173
            /* start    */      exc_table->int_at(base),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   174
            /* limit    */      exc_table->int_at(base+1),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   175
            /* goto pc  */      exc_table->int_at(base+2),
489c9b5090e2 Initial load
duke
parents:
diff changeset
   176
            /* cp index */      exc_table->int_at(base+3));
489c9b5090e2 Initial load
duke
parents:
diff changeset
   177
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   178
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   179
489c9b5090e2 Initial load
duke
parents:
diff changeset
   180
  // Put an entry at the end of our list to represent the possibility
489c9b5090e2 Initial load
duke
parents:
diff changeset
   181
  // of exceptional exit.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   182
  _exception_handlers[_handler_count] =
489c9b5090e2 Initial load
duke
parents:
diff changeset
   183
    new (arena) ciExceptionHandler(holder(), 0, code_size(), -1, 0);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   184
489c9b5090e2 Initial load
duke
parents:
diff changeset
   185
  if (CIPrintMethodCodes) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   186
    print_codes();
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
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   192
// ciMethod::has_linenumber_table
489c9b5090e2 Initial load
duke
parents:
diff changeset
   193
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   194
// length unknown until decompression
489c9b5090e2 Initial load
duke
parents:
diff changeset
   195
bool    ciMethod::has_linenumber_table() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   196
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   197
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   198
  return get_methodOop()->has_linenumber_table();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   199
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   200
489c9b5090e2 Initial load
duke
parents:
diff changeset
   201
489c9b5090e2 Initial load
duke
parents:
diff changeset
   202
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   203
// ciMethod::compressed_linenumber_table
489c9b5090e2 Initial load
duke
parents:
diff changeset
   204
u_char* ciMethod::compressed_linenumber_table() const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   205
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   206
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   207
  return get_methodOop()->compressed_linenumber_table();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   208
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   209
489c9b5090e2 Initial load
duke
parents:
diff changeset
   210
489c9b5090e2 Initial load
duke
parents:
diff changeset
   211
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   212
// ciMethod::line_number_from_bci
489c9b5090e2 Initial load
duke
parents:
diff changeset
   213
int ciMethod::line_number_from_bci(int bci) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   214
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   215
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   216
  return get_methodOop()->line_number_from_bci(bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   217
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   218
489c9b5090e2 Initial load
duke
parents:
diff changeset
   219
489c9b5090e2 Initial load
duke
parents:
diff changeset
   220
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   221
// ciMethod::vtable_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   222
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   223
// Get the position of this method's entry in the vtable, if any.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   224
int ciMethod::vtable_index() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   225
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   226
  assert(holder()->is_linked(), "must be linked");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   227
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   228
  return get_methodOop()->vtable_index();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   229
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   230
489c9b5090e2 Initial load
duke
parents:
diff changeset
   231
489c9b5090e2 Initial load
duke
parents:
diff changeset
   232
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   233
// ciMethod::native_entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   234
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   235
// Get the address of this method's native code, if any.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   236
address ciMethod::native_entry() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   237
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   238
  assert(flags().is_native(), "must be native method");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   239
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   240
  methodOop method = get_methodOop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   241
  address entry = method->native_function();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   242
  assert(entry != NULL, "must be valid entry point");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   243
  return entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   244
}
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
// ciMethod::interpreter_entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
// Get the entry point for running this method in the interpreter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
address ciMethod::interpreter_entry() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  return Interpreter::entry_for_method(mh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
}
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
// ciMethod::uses_balanced_monitors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
// Does this method use monitors in a strict stack-disciplined manner?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
bool ciMethod::has_balanced_monitors() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
  if (_balanced_monitors) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  // Analyze the method to see if monitors are used properly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  methodHandle method(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
  assert(method->has_monitor_bytecodes(), "should have checked this");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
  // Check to see if a previous compilation computed the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
  // monitor-matching analysis.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
  if (method->guaranteed_monitor_matching()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
    _balanced_monitors = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
    return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
    EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
    GeneratePairingInfo gpi(method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
    gpi.compute_map(CATCH);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
    if (!gpi.monitor_safe()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
    method->set_guaranteed_monitor_matching();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
    _balanced_monitors = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   290
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   291
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   292
489c9b5090e2 Initial load
duke
parents:
diff changeset
   293
489c9b5090e2 Initial load
duke
parents:
diff changeset
   294
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
// ciMethod::get_flow_analysis
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
ciTypeFlow* ciMethod::get_flow_analysis() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
#ifdef COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
  if (_flow == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
    ciEnv* env = CURRENT_ENV;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
    _flow = new (env->arena()) ciTypeFlow(env, this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
    _flow->do_flow();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  return _flow;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
#else // COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
#endif // COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
489c9b5090e2 Initial load
duke
parents:
diff changeset
   311
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
// ciMethod::get_osr_flow_analysis
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
ciTypeFlow* ciMethod::get_osr_flow_analysis(int osr_bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
#ifdef COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
  // OSR entry points are always place after a call bytecode of some sort
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  assert(osr_bci >= 0, "must supply valid OSR entry point");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  ciEnv* env = CURRENT_ENV;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   318
  ciTypeFlow* flow = new (env->arena()) ciTypeFlow(env, this, osr_bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  flow->do_flow();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  return flow;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   321
#else // COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
#endif // COMPILER2
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
// ------------------------------------------------------------------
3910
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   328
// ciMethod::raw_liveness_at_bci
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
// 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
   331
MethodLivenessResult ciMethod::raw_liveness_at_bci(int bci) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  if (_liveness == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
    // Create the liveness analyzer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   335
    Arena* arena = CURRENT_ENV->arena();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
    _liveness = new (arena) MethodLiveness(arena, this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
    _liveness->compute_liveness();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   338
  }
3910
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   339
  return _liveness->get_liveness_at(bci);
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   340
}
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   341
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   342
// ------------------------------------------------------------------
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   343
// ciMethod::liveness_at_bci
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   344
//
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   345
// 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
   346
// 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
   347
// information.
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   348
MethodLivenessResult ciMethod::liveness_at_bci(int bci) {
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   349
  MethodLivenessResult result = raw_liveness_at_bci(bci);
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 2534
diff changeset
   350
  if (CURRENT_ENV->jvmti_can_access_local_variables() || DeoptimizeALot || CompileTheWorld) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
    // Keep all locals live for the user's edification and amusement.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
    result.at_put_range(0, result.size(), true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
// ciMethod::live_local_oops_at_bci
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
// find all the live oops in the locals array for a particular bci
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
// Compute what the interpreter believes by using the interpreter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
// oopmap generator. This is used as a double check during osr to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
// guard against conservative result from MethodLiveness making us
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
// think a dead oop is live.  MethodLiveness is conservative in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
// sense that it may consider locals to be live which cannot be live,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
// like in the case where a local could contain an oop or  a primitive
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
// along different paths.  In that case the local must be dead when
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
// those paths merge. Since the interpreter's viewpoint is used when
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
// gc'ing an interpreter frame we need to use its viewpoint  during
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
// OSR when loading the locals.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
BitMap ciMethod::live_local_oops_at_bci(int bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
  InterpreterOopMap mask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
  OopMapCache::compute_one_oop_map(get_methodOop(), bci, &mask);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
  int mask_size = max_locals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
  BitMap result(mask_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
  result.clear();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
  int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
  for (i = 0; i < mask_size ; i++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
    if (mask.is_oop(i)) result.set_bit(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  return result;
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
#ifdef COMPILER1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
// ciMethod::bci_block_start
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
// Marks all bcis where a new basic block starts
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
const BitMap ciMethod::bci_block_start() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  if (_liveness == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
    // Create the liveness analyzer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
    Arena* arena = CURRENT_ENV->arena();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
    _liveness = new (arena) MethodLiveness(arena, this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
    _liveness->compute_liveness();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
  return _liveness->get_bci_block_start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
#endif // COMPILER1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
// ciMethod::call_profile_at_bci
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
// Get the ciCallProfile for the invocation of this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
// Also reports receiver types for non-call type checks (if TypeProfileCasts).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
ciCallProfile ciMethod::call_profile_at_bci(int bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
  ciCallProfile result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
  if (method_data() != NULL && method_data()->is_mature()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
    ciProfileData* data = method_data()->bci_to_data(bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
    if (data != NULL && data->is_CounterData()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
      // Every profiled call site has a counter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
      int count = data->as_CounterData()->count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
      if (!data->is_ReceiverTypeData()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
        result._receiver_count[0] = 0;  // that's a definite zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
      } else { // ReceiverTypeData is a subclass of CounterData
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
        ciReceiverTypeData* call = (ciReceiverTypeData*)data->as_ReceiverTypeData();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
        // In addition, virtual call sites have receiver type information
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
        int receivers_count_total = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
        int morphism = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
        for (uint i = 0; i < call->row_limit(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
          ciKlass* receiver = call->receiver(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
          if (receiver == NULL)  continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
          morphism += 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
          int rcount = call->receiver_count(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
          if (rcount == 0) rcount = 1; // Should be valid value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
          receivers_count_total += rcount;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
          // Add the receiver to result data.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
          result.add_receiver(receiver, rcount);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
          // If we extend profiling to record methods,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
          // we will set result._method also.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
        // Determine call site's morphism.
4754
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   439
        // The call site count is 0 with known morphism (onlt 1 or 2 receivers)
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   440
        // or < 0 in the case of a type check failured for checkcast, aastore, instanceof.
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   441
        // 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
   442
        if (morphism > 0 && morphism == result._limit) {
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   443
           // The morphism <= MorphismLimit.
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   444
           if ((morphism <  ciCallProfile::MorphismLimit) ||
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   445
               (morphism == ciCallProfile::MorphismLimit && count == 0)) {
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   446
#ifdef ASSERT
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   447
             if (count > 0) {
4892
e977b527544a 6923002: assert(false,"this call site should not be polymorphic")
kvn
parents: 4754
diff changeset
   448
               this->print_short_name(tty);
e977b527544a 6923002: assert(false,"this call site should not be polymorphic")
kvn
parents: 4754
diff changeset
   449
               tty->print_cr(" @ bci:%d", bci);
4754
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   450
               this->print_codes();
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   451
               assert(false, "this call site should not be polymorphic");
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   452
             }
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   453
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
             result._morphism = morphism;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
           }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
        // Make the count consistent if this is a call profile. If count is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
        // zero or less, presume that this is a typecheck profile and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
        // do nothing.  Otherwise, increase count to be the sum of all
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
        // receiver's counts.
4754
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   461
        if (count >= 0) {
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   462
          count += receivers_count_total;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
      result._count = count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
// Add new receiver and sort data by receiver's profile count.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
void ciCallProfile::add_receiver(ciKlass* receiver, int receiver_count) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
  // Add new receiver and sort data by receiver's counts when we have space
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
  // for it otherwise replace the less called receiver (less called receiver
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
  // is placed to the last array element which is not used).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
  // First array's element contains most called receiver.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
  int i = _limit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
  for (; i > 0 && receiver_count > _receiver_count[i-1]; i--) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
    _receiver[i] = _receiver[i-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
    _receiver_count[i] = _receiver_count[i-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
  _receiver[i] = receiver;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
  _receiver_count[i] = receiver_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
  if (_limit < MorphismLimit) _limit++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
// ciMethod::find_monomorphic_target
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
// Given a certain calling environment, find the monomorphic target
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
// for the call.  Return NULL if the call is not monomorphic in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
// its calling environment, or if there are only abstract methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
// The returned method is never abstract.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
// Note: If caller uses a non-null result, it must inform dependencies
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
// via assert_unique_concrete_method or assert_leaf_type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
ciMethod* ciMethod::find_monomorphic_target(ciInstanceKlass* caller,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
                                            ciInstanceKlass* callee_holder,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
                                            ciInstanceKlass* actual_recv) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  if (actual_recv->is_interface()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
    // %%% We cannot trust interface types, yet.  See bug 6312651.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  ciMethod* root_m = resolve_invoke(caller, actual_recv);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
  if (root_m == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
    // Something went wrong looking up the actual receiver method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
  assert(!root_m->is_abstract(), "resolve_invoke promise");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  // Make certain quick checks even if UseCHA is false.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  // Is it private or final?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  if (root_m->can_be_statically_bound()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
    return root_m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  if (actual_recv->is_leaf_type() && actual_recv == root_m->holder()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
    // Easy case.  There is no other place to put a method, so don't bother
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
    // to go through the VM_ENTRY_MARK and all the rest.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
    return root_m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
  // Array methods (clone, hashCode, etc.) are always statically bound.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  // If we were to see an array type here, we'd return root_m.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
  // However, this method processes only ciInstanceKlasses.  (See 4962591.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  // The inline_native_clone intrinsic narrows Object to T[] properly,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  // so there is no need to do the same job here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  if (!UseCHA)  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
  methodHandle target;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
    MutexLocker locker(Compile_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
    klassOop context = actual_recv->get_klassOop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
    target = Dependencies::find_unique_concrete_method(context,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
                                                       root_m->get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
    // %%% Should upgrade this ciMethod API to look for 1 or 2 concrete methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
  if (TraceDependencies && target() != NULL && target() != root_m->get_methodOop()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
    tty->print("found a non-root unique target method");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
    tty->print_cr("  context = %s", instanceKlass::cast(actual_recv->get_klassOop())->external_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
    tty->print("  method  = ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
    target->print_short_name(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
    tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
#endif //PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
  if (target() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
  if (target() == root_m->get_methodOop()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
    return root_m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
  if (!root_m->is_public() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
      !root_m->is_protected()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
    // If we are going to reason about inheritance, it's easiest
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
    // if the method in question is public, protected, or private.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
    // If the answer is not root_m, it is conservatively correct
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
    // to return NULL, even if the CHA encountered irrelevant
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
    // methods in other packages.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
    // %%% TO DO: Work out logic for package-private methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
    // with the same name but different vtable indexes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  return CURRENT_THREAD_ENV->get_object(target())->as_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
// ciMethod::resolve_invoke
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
// Given a known receiver klass, find the target for the call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
// Return NULL if the call has no target or the target is abstract.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
ciMethod* ciMethod::resolve_invoke(ciKlass* caller, ciKlass* exact_receiver) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
   check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
   VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
   KlassHandle caller_klass (THREAD, caller->get_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
   KlassHandle h_recv       (THREAD, exact_receiver->get_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
   KlassHandle h_resolved   (THREAD, holder()->get_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
   symbolHandle h_name      (THREAD, name()->get_symbolOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
   symbolHandle h_signature (THREAD, signature()->get_symbolOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
   methodHandle m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
   // Only do exact lookup if receiver klass has been linked.  Otherwise,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
   // the vtable has not been setup, and the LinkResolver will fail.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
   if (h_recv->oop_is_javaArray()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
        ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
       instanceKlass::cast(h_recv())->is_linked() && !exact_receiver->is_interface()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
     if (holder()->is_interface()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
       m = LinkResolver::resolve_interface_call_or_null(h_recv, h_resolved, h_name, h_signature, caller_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
     } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
       m = LinkResolver::resolve_virtual_call_or_null(h_recv, h_resolved, h_name, h_signature, caller_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
   if (m.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
     // Return NULL only if there was a problem with lookup (uninitialized class, etc.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
     return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
   ciMethod* result = this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
   if (m() != get_methodOop()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
     result = CURRENT_THREAD_ENV->get_object(m())->as_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
   // Don't return abstract methods because they aren't
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
   // optimizable or interesting.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
   if (result->is_abstract()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
     return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
   } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
     return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
// ciMethod::resolve_vtable_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
// Given a known receiver klass, find the vtable index for the call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
// Return methodOopDesc::invalid_vtable_index if the vtable_index is unknown.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
int ciMethod::resolve_vtable_index(ciKlass* caller, ciKlass* receiver) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
   check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
   int vtable_index = methodOopDesc::invalid_vtable_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
   // Only do lookup if receiver klass has been linked.  Otherwise,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
   // the vtable has not been setup, and the LinkResolver will fail.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
   if (!receiver->is_interface()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
       && (!receiver->is_instance_klass() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
           receiver->as_instance_klass()->is_linked())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
     VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
     KlassHandle caller_klass (THREAD, caller->get_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
     KlassHandle h_recv       (THREAD, receiver->get_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
     symbolHandle h_name      (THREAD, name()->get_symbolOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
     symbolHandle h_signature (THREAD, signature()->get_symbolOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
     vtable_index = LinkResolver::resolve_virtual_vtable_index(h_recv, h_recv, h_name, h_signature, caller_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
     if (vtable_index == methodOopDesc::nonvirtual_vtable_index) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
       // A statically bound method.  Return "no such index".
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
       vtable_index = methodOopDesc::invalid_vtable_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
   return vtable_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
// ciMethod::interpreter_call_site_count
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
int ciMethod::interpreter_call_site_count(int bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
  if (method_data() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
    ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
    ciProfileData* data = method_data()->bci_to_data(bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
    if (data != NULL && data->is_CounterData()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
      return scale_count(data->as_CounterData()->count());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
  return -1;  // unknown
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
// Adjust a CounterData count to be commensurate with
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
// interpreter_invocation_count.  If the MDO exists for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
// only 25% of the time the method exists, then the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
// counts in the MDO should be scaled by 4X, so that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
// they can be usefully and stably compared against the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
// invocation counts in methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
int ciMethod::scale_count(int count, float prof_factor) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
  if (count > 0 && method_data() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
    int current_mileage = method_data()->current_mileage();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
    int creation_mileage = method_data()->creation_mileage();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
    int counter_life = current_mileage - creation_mileage;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
    int method_life = interpreter_invocation_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
    // counter_life due to backedge_counter could be > method_life
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
    if (counter_life > method_life)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
      counter_life = method_life;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
    if (0 < counter_life && counter_life <= method_life) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
      count = (int)((double)count * prof_factor * method_life / counter_life + 0.5);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
      count = (count > 0) ? count : 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
  return count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
// ------------------------------------------------------------------
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   692
// invokedynamic support
5687
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   693
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   694
// ------------------------------------------------------------------
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   695
// ciMethod::is_method_handle_invoke
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   696
//
5687
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   697
// Return true if the method is a MethodHandle target.
4566
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 3910
diff changeset
   698
bool ciMethod::is_method_handle_invoke() const {
5687
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   699
  bool flag = (holder()->name() == ciSymbol::java_dyn_MethodHandle() &&
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   700
               methodOopDesc::is_method_handle_invoke_name(name()->sid()));
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   701
#ifdef ASSERT
5687
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   702
  if (is_loaded()) {
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   703
    bool flag2 = ((flags().as_int() & JVM_MH_INVOKE_BITS) == JVM_MH_INVOKE_BITS);
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   704
    {
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   705
      VM_ENTRY_MARK;
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   706
      bool flag3 = get_methodOop()->is_method_handle_invoke();
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   707
      assert(flag2 == flag3, "consistent");
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   708
      assert(flag  == flag3, "consistent");
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   709
    }
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   710
  }
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   711
#endif //ASSERT
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   712
  return flag;
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   713
}
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   714
5687
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   715
// ------------------------------------------------------------------
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   716
// ciMethod::is_method_handle_adapter
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   717
//
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   718
// Return true if the method is a generated MethodHandle adapter.
4581
e89fbd1bcb3d 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 4566
diff changeset
   719
bool ciMethod::is_method_handle_adapter() const {
e89fbd1bcb3d 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 4566
diff changeset
   720
  check_is_loaded();
e89fbd1bcb3d 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 4566
diff changeset
   721
  VM_ENTRY_MARK;
e89fbd1bcb3d 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 4566
diff changeset
   722
  return get_methodOop()->is_method_handle_adapter();
e89fbd1bcb3d 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 4566
diff changeset
   723
}
e89fbd1bcb3d 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 4566
diff changeset
   724
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   725
ciInstance* ciMethod::method_handle_type() {
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   726
  check_is_loaded();
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   727
  VM_ENTRY_MARK;
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   728
  oop mtype = get_methodOop()->method_handle_type();
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   729
  return CURRENT_THREAD_ENV->get_object(mtype)->as_instance();
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   730
}
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   731
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   732
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   733
// ------------------------------------------------------------------
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
// ciMethod::build_method_data
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
// Generate new methodDataOop objects at compile time.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
void ciMethod::build_method_data(methodHandle h_m) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
  EXCEPTION_CONTEXT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  if (is_native() || is_abstract() || h_m()->is_accessor()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
  if (h_m()->method_data() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
    methodOopDesc::build_interpreter_method_data(h_m, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
  if (h_m()->method_data() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
    _method_data = CURRENT_ENV->get_object(h_m()->method_data())->as_method_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
    _method_data->load_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
    _method_data = CURRENT_ENV->get_empty_methodData();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
// public, retroactive version
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
void ciMethod::build_method_data() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
  if (_method_data == NULL || _method_data->is_empty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
    GUARDED_VM_ENTRY({
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
      build_method_data(get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
    });
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
// ciMethod::method_data
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
ciMethodData* ciMethod::method_data() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
  if (_method_data != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
    return _method_data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
  ciEnv* env = CURRENT_ENV;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  Thread* my_thread = JavaThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
  methodHandle h_m(my_thread, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
  if (Tier1UpdateMethodData && is_tier1_compile(env->comp_level())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
    build_method_data(h_m);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
  if (h_m()->method_data() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
    _method_data = CURRENT_ENV->get_object(h_m()->method_data())->as_method_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
    _method_data->load_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
    _method_data = CURRENT_ENV->get_empty_methodData();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
  return _method_data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
// ciMethod::will_link
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
// Will this method link in a specific calling context?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
bool ciMethod::will_link(ciKlass* accessing_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
                         ciKlass* declared_method_holder,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
                         Bytecodes::Code bc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
  if (!is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
    // Method lookup failed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
  // The link checks have been front-loaded into the get_method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
  // call.  This method (ciMethod::will_link()) will be removed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
  // in the future.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
// ciMethod::should_exclude
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
// Should this method be excluded from compilation?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
bool ciMethod::should_exclude() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
  bool ignore;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
  return CompilerOracle::should_exclude(mh, ignore);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
// ciMethod::should_inline
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
// Should this method be inlined during compilation?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
bool ciMethod::should_inline() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
  return CompilerOracle::should_inline(mh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
// ciMethod::should_not_inline
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
// Should this method be disallowed from inlining during compilation?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
bool ciMethod::should_not_inline() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  return CompilerOracle::should_not_inline(mh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
// ciMethod::should_print_assembly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
// Should the compiler print the generated code for this method?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
bool ciMethod::should_print_assembly() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
  return CompilerOracle::should_print(mh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
// ciMethod::break_at_execute
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
// Should the compiler insert a breakpoint into the generated code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
// method?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
bool ciMethod::break_at_execute() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
  return CompilerOracle::should_break_at(mh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
// ciMethod::has_option
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
bool ciMethod::has_option(const char* option) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
  return CompilerOracle::has_option_string(mh, option);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
// ciMethod::can_be_compiled
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
// Have previous compilations of this method succeeded?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
bool ciMethod::can_be_compiled() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
  return _is_compilable;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
// ciMethod::set_not_compilable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
// Tell the VM that this method cannot be compiled at all.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
void ciMethod::set_not_compilable() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
  _is_compilable = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
  get_methodOop()->set_not_compilable();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
// ciMethod::can_be_osr_compiled
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
// Have previous compilations of this method succeeded?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
// Implementation note: the VM does not currently keep track
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
// of failed OSR compilations per bci.  The entry_bci parameter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
// is currently unused.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
bool ciMethod::can_be_osr_compiled(int entry_bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
  return !get_methodOop()->access_flags().is_not_osr_compilable();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
// ciMethod::has_compiled_code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
bool ciMethod::has_compiled_code() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
  return get_methodOop()->code() != NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
// ciMethod::instructions_size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
// This is a rough metric for "fat" methods, compared
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
// before inlining with InlineSmallCode.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
// The CodeBlob::instructions_size accessor includes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
// junk like exception handler, stubs, and constant table,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
// which are not highly relevant to an inlined method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
// So we use the more specific accessor nmethod::code_size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
int ciMethod::instructions_size() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
  GUARDED_VM_ENTRY(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
    nmethod* code = get_methodOop()->code();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
    // if there's no compiled code or the code was produced by the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
    // tier1 profiler return 0 for the code size.  This should
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
    // probably be based on the compilation level of the nmethod but
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
    // that currently isn't properly recorded.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
    if (code == NULL ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
        (TieredCompilation && code->compiler() != NULL && code->compiler()->is_c1())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
      return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
    }
608
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 200
diff changeset
   937
    return code->code_end() - code->verified_entry_point();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
// ciMethod::log_nmethod_identity
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
void ciMethod::log_nmethod_identity(xmlStream* log) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
  GUARDED_VM_ENTRY(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
    nmethod* code = get_methodOop()->code();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
    if (code != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
      code->log_identity(log);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
// ciMethod::is_not_reached
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
bool ciMethod::is_not_reached(int bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
  return Interpreter::is_not_reached(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
               methodHandle(THREAD, get_methodOop()), bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
// ciMethod::was_never_executed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
bool ciMethod::was_executed_more_than(int times) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
  return get_methodOop()->was_executed_more_than(times);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
// ciMethod::has_unloaded_classes_in_signature
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
bool ciMethod::has_unloaded_classes_in_signature() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
    EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
    methodHandle m(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
    bool has_unloaded = methodOopDesc::has_unloaded_classes_in_signature(m, (JavaThread *)THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
    if( HAS_PENDING_EXCEPTION ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
      return true;     // Declare that we may have unloaded classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
    return has_unloaded;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
// ciMethod::is_klass_loaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
bool ciMethod::is_klass_loaded(int refinfo_index, bool must_be_resolved) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
  return get_methodOop()->is_klass_loaded(refinfo_index, must_be_resolved);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
// ciMethod::check_call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
bool ciMethod::check_call(int refinfo_index, bool is_static) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
    EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
    HandleMark hm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
    constantPoolHandle pool (THREAD, get_methodOop()->constants());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
    methodHandle spec_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
    KlassHandle  spec_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
    LinkResolver::resolve_method(spec_method, spec_klass, pool, refinfo_index, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
      return (spec_method->is_static() == is_static);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
// ciMethod::print_codes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
// Print the bytecodes for this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
void ciMethod::print_codes_on(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
  GUARDED_VM_ENTRY(get_methodOop()->print_codes_on(st);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
#define FETCH_FLAG_FROM_VM(flag_accessor) { \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
  check_is_loaded(); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
  VM_ENTRY_MARK; \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
  return get_methodOop()->flag_accessor(); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
bool ciMethod::is_empty_method() const {         FETCH_FLAG_FROM_VM(is_empty_method); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
bool ciMethod::is_vanilla_constructor() const {  FETCH_FLAG_FROM_VM(is_vanilla_constructor); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
bool ciMethod::has_loops      () const {         FETCH_FLAG_FROM_VM(has_loops); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
bool ciMethod::has_jsrs       () const {         FETCH_FLAG_FROM_VM(has_jsrs);  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
bool ciMethod::is_accessor    () const {         FETCH_FLAG_FROM_VM(is_accessor); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
bool ciMethod::is_initializer () const {         FETCH_FLAG_FROM_VM(is_initializer); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
BCEscapeAnalyzer  *ciMethod::get_bcea() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
  if (_bcea == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
    _bcea = new (CURRENT_ENV->arena()) BCEscapeAnalyzer(this, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
  return _bcea;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
ciMethodBlocks  *ciMethod::get_method_blocks() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
  Arena *arena = CURRENT_ENV->arena();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
  if (_method_blocks == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
    _method_blocks = new (arena) ciMethodBlocks(arena, this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
  return _method_blocks;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
#undef FETCH_FLAG_FROM_VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
// ciMethod::print_codes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
// Print a range of the bytecodes for this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
void ciMethod::print_codes_on(int from, int to, outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
  GUARDED_VM_ENTRY(get_methodOop()->print_codes_on(from, to, st);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
// ciMethod::print_name
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
// Print the name of this method, including signature and some flags.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
void ciMethod::print_name(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
  GUARDED_VM_ENTRY(get_methodOop()->print_name(st);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
// ciMethod::print_short_name
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
// Print the name of this method, without signature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
void ciMethod::print_short_name(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
  GUARDED_VM_ENTRY(get_methodOop()->print_short_name(st);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
// ciMethod::print_impl
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
// Implementation of the print method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
void ciMethod::print_impl(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
  ciObject::print_impl(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
  st->print(" name=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
  name()->print_symbol_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
  st->print(" holder=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
  holder()->print_name_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
  st->print(" signature=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
  signature()->as_symbol()->print_symbol_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
  if (is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
    st->print(" loaded=true flags=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
    flags().print_member_flags(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
    st->print(" loaded=false");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
}