hotspot/src/share/vm/ci/ciMethod.cpp
author kvn
Fri, 08 May 2009 10:44:20 -0700
changeset 2867 69187054225f
parent 2534 08dac9ce0cd7
child 3910 67050ceda719
permissions -rw-r--r--
6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits Summary: Cache Jvmti and DTrace flags used by Compiler. Reviewed-by: never
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
     2
 * Copyright 1999-2009 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
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   328
// ciMethod::liveness_at_bci
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?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
MethodLivenessResult ciMethod::liveness_at_bci(int bci) {
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
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
  MethodLivenessResult result = _liveness->get_liveness_at(bci);
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 2534
diff changeset
   340
  if (CURRENT_ENV->jvmti_can_access_local_variables() || DeoptimizeALot || CompileTheWorld) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
    // Keep all locals live for the user's edification and amusement.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   342
    result.at_put_range(0, result.size(), true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   345
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
// ciMethod::live_local_oops_at_bci
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
// find all the live oops in the locals array for a particular bci
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
// Compute what the interpreter believes by using the interpreter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
// oopmap generator. This is used as a double check during osr to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
// guard against conservative result from MethodLiveness making us
489c9b5090e2 Initial load
duke
parents:
diff changeset
   353
// think a dead oop is live.  MethodLiveness is conservative in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   354
// sense that it may consider locals to be live which cannot be live,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   355
// like in the case where a local could contain an oop or  a primitive
489c9b5090e2 Initial load
duke
parents:
diff changeset
   356
// along different paths.  In that case the local must be dead when
489c9b5090e2 Initial load
duke
parents:
diff changeset
   357
// those paths merge. Since the interpreter's viewpoint is used when
489c9b5090e2 Initial load
duke
parents:
diff changeset
   358
// gc'ing an interpreter frame we need to use its viewpoint  during
489c9b5090e2 Initial load
duke
parents:
diff changeset
   359
// OSR when loading the locals.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   360
489c9b5090e2 Initial load
duke
parents:
diff changeset
   361
BitMap ciMethod::live_local_oops_at_bci(int bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   362
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   363
  InterpreterOopMap mask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   364
  OopMapCache::compute_one_oop_map(get_methodOop(), bci, &mask);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
  int mask_size = max_locals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
  BitMap result(mask_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  result.clear();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
  for (i = 0; i < mask_size ; i++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
    if (mask.is_oop(i)) result.set_bit(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
#ifdef COMPILER1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
// ciMethod::bci_block_start
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
// Marks all bcis where a new basic block starts
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
const BitMap ciMethod::bci_block_start() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
  if (_liveness == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
    // Create the liveness analyzer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
    Arena* arena = CURRENT_ENV->arena();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
    _liveness = new (arena) MethodLiveness(arena, this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
    _liveness->compute_liveness();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  return _liveness->get_bci_block_start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
#endif // COMPILER1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
// ciMethod::call_profile_at_bci
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
// Get the ciCallProfile for the invocation of this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
// Also reports receiver types for non-call type checks (if TypeProfileCasts).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
ciCallProfile ciMethod::call_profile_at_bci(int bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
  ciCallProfile result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
  if (method_data() != NULL && method_data()->is_mature()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
    ciProfileData* data = method_data()->bci_to_data(bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
    if (data != NULL && data->is_CounterData()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
      // Every profiled call site has a counter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
      int count = data->as_CounterData()->count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
      if (!data->is_ReceiverTypeData()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
        result._receiver_count[0] = 0;  // that's a definite zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
      } else { // ReceiverTypeData is a subclass of CounterData
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
        ciReceiverTypeData* call = (ciReceiverTypeData*)data->as_ReceiverTypeData();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
        // In addition, virtual call sites have receiver type information
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
        int receivers_count_total = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
        int morphism = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
        for (uint i = 0; i < call->row_limit(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
          ciKlass* receiver = call->receiver(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
          if (receiver == NULL)  continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
          morphism += 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
          int rcount = call->receiver_count(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
          if (rcount == 0) rcount = 1; // Should be valid value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
          receivers_count_total += rcount;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
          // Add the receiver to result data.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
          result.add_receiver(receiver, rcount);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
          // If we extend profiling to record methods,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
          // we will set result._method also.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
        // Determine call site's morphism.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
        // The call site count could be == (receivers_count_total + 1)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
        // not only in the case of a polymorphic call but also in the case
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
        // when a method data snapshot is taken after the site count was updated
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
        // but before receivers counters were updated.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
        if (morphism == result._limit) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
           // There were no array klasses and morphism <= MorphismLimit.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
           if (morphism <  ciCallProfile::MorphismLimit ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
               morphism == ciCallProfile::MorphismLimit &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
               (receivers_count_total+1) >= count) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
             result._morphism = morphism;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
           }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
        // Make the count consistent if this is a call profile. If count is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
        // zero or less, presume that this is a typecheck profile and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
        // do nothing.  Otherwise, increase count to be the sum of all
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
        // receiver's counts.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
        if (count > 0) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
          if (count < receivers_count_total) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
            count = receivers_count_total;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
          }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
      result._count = count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   453
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   454
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   455
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   456
489c9b5090e2 Initial load
duke
parents:
diff changeset
   457
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   458
// Add new receiver and sort data by receiver's profile count.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   459
void ciCallProfile::add_receiver(ciKlass* receiver, int receiver_count) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   460
  // Add new receiver and sort data by receiver's counts when we have space
489c9b5090e2 Initial load
duke
parents:
diff changeset
   461
  // for it otherwise replace the less called receiver (less called receiver
489c9b5090e2 Initial load
duke
parents:
diff changeset
   462
  // is placed to the last array element which is not used).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   463
  // First array's element contains most called receiver.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   464
  int i = _limit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   465
  for (; i > 0 && receiver_count > _receiver_count[i-1]; i--) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   466
    _receiver[i] = _receiver[i-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   467
    _receiver_count[i] = _receiver_count[i-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
  _receiver[i] = receiver;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
  _receiver_count[i] = receiver_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
  if (_limit < MorphismLimit) _limit++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   475
// ciMethod::find_monomorphic_target
489c9b5090e2 Initial load
duke
parents:
diff changeset
   476
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
// Given a certain calling environment, find the monomorphic target
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
// for the call.  Return NULL if the call is not monomorphic in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
// its calling environment, or if there are only abstract methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
// The returned method is never abstract.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
// Note: If caller uses a non-null result, it must inform dependencies
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
// via assert_unique_concrete_method or assert_leaf_type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
ciMethod* ciMethod::find_monomorphic_target(ciInstanceKlass* caller,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
                                            ciInstanceKlass* callee_holder,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
                                            ciInstanceKlass* actual_recv) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  if (actual_recv->is_interface()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
    // %%% We cannot trust interface types, yet.  See bug 6312651.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
  ciMethod* root_m = resolve_invoke(caller, actual_recv);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
  if (root_m == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
    // Something went wrong looking up the actual receiver method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  assert(!root_m->is_abstract(), "resolve_invoke promise");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
  // Make certain quick checks even if UseCHA is false.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
  // Is it private or final?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
  if (root_m->can_be_statically_bound()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
    return root_m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
  if (actual_recv->is_leaf_type() && actual_recv == root_m->holder()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
    // Easy case.  There is no other place to put a method, so don't bother
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
    // to go through the VM_ENTRY_MARK and all the rest.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
    return root_m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
  // Array methods (clone, hashCode, etc.) are always statically bound.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  // If we were to see an array type here, we'd return root_m.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
  // However, this method processes only ciInstanceKlasses.  (See 4962591.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  // The inline_native_clone intrinsic narrows Object to T[] properly,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
  // so there is no need to do the same job here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  if (!UseCHA)  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
  methodHandle target;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
    MutexLocker locker(Compile_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
    klassOop context = actual_recv->get_klassOop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
    target = Dependencies::find_unique_concrete_method(context,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
                                                       root_m->get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
    // %%% Should upgrade this ciMethod API to look for 1 or 2 concrete methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  if (TraceDependencies && target() != NULL && target() != root_m->get_methodOop()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
    tty->print("found a non-root unique target method");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
    tty->print_cr("  context = %s", instanceKlass::cast(actual_recv->get_klassOop())->external_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
    tty->print("  method  = ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
    target->print_short_name(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
    tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
#endif //PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  if (target() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
  if (target() == root_m->get_methodOop()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
    return root_m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
  if (!root_m->is_public() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
      !root_m->is_protected()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
    // If we are going to reason about inheritance, it's easiest
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
    // if the method in question is public, protected, or private.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
    // If the answer is not root_m, it is conservatively correct
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
    // to return NULL, even if the CHA encountered irrelevant
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
    // methods in other packages.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
    // %%% TO DO: Work out logic for package-private methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
    // with the same name but different vtable indexes.
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
  return CURRENT_THREAD_ENV->get_object(target())->as_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
// ciMethod::resolve_invoke
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
// Given a known receiver klass, find the target for the call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
// Return NULL if the call has no target or the target is abstract.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
ciMethod* ciMethod::resolve_invoke(ciKlass* caller, ciKlass* exact_receiver) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
   check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
   VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
   KlassHandle caller_klass (THREAD, caller->get_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
   KlassHandle h_recv       (THREAD, exact_receiver->get_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
   KlassHandle h_resolved   (THREAD, holder()->get_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
   symbolHandle h_name      (THREAD, name()->get_symbolOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
   symbolHandle h_signature (THREAD, signature()->get_symbolOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
   methodHandle m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
   // Only do exact lookup if receiver klass has been linked.  Otherwise,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
   // the vtable has not been setup, and the LinkResolver will fail.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
   if (h_recv->oop_is_javaArray()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
        ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
       instanceKlass::cast(h_recv())->is_linked() && !exact_receiver->is_interface()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
     if (holder()->is_interface()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
       m = LinkResolver::resolve_interface_call_or_null(h_recv, h_resolved, h_name, h_signature, caller_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
     } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
       m = LinkResolver::resolve_virtual_call_or_null(h_recv, h_resolved, h_name, h_signature, caller_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
   if (m.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
     // Return NULL only if there was a problem with lookup (uninitialized class, etc.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
     return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
   ciMethod* result = this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
   if (m() != get_methodOop()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
     result = CURRENT_THREAD_ENV->get_object(m())->as_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
   // Don't return abstract methods because they aren't
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
   // optimizable or interesting.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
   if (result->is_abstract()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
     return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
   } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
     return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
// ciMethod::resolve_vtable_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
// Given a known receiver klass, find the vtable index for the call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
// Return methodOopDesc::invalid_vtable_index if the vtable_index is unknown.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
int ciMethod::resolve_vtable_index(ciKlass* caller, ciKlass* receiver) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
   check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
   int vtable_index = methodOopDesc::invalid_vtable_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
   // Only do lookup if receiver klass has been linked.  Otherwise,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
   // the vtable has not been setup, and the LinkResolver will fail.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
   if (!receiver->is_interface()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
       && (!receiver->is_instance_klass() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
           receiver->as_instance_klass()->is_linked())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
     VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
     KlassHandle caller_klass (THREAD, caller->get_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
     KlassHandle h_recv       (THREAD, receiver->get_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
     symbolHandle h_name      (THREAD, name()->get_symbolOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
     symbolHandle h_signature (THREAD, signature()->get_symbolOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
     vtable_index = LinkResolver::resolve_virtual_vtable_index(h_recv, h_recv, h_name, h_signature, caller_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
     if (vtable_index == methodOopDesc::nonvirtual_vtable_index) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
       // A statically bound method.  Return "no such index".
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
       vtable_index = methodOopDesc::invalid_vtable_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   634
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   635
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   636
489c9b5090e2 Initial load
duke
parents:
diff changeset
   637
   return vtable_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
// ciMethod::interpreter_call_site_count
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
int ciMethod::interpreter_call_site_count(int bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
  if (method_data() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
    ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
    ciProfileData* data = method_data()->bci_to_data(bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
    if (data != NULL && data->is_CounterData()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
      return scale_count(data->as_CounterData()->count());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
  return -1;  // unknown
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
// Adjust a CounterData count to be commensurate with
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
// interpreter_invocation_count.  If the MDO exists for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
// only 25% of the time the method exists, then the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
// counts in the MDO should be scaled by 4X, so that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
// they can be usefully and stably compared against the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
// invocation counts in methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
int ciMethod::scale_count(int count, float prof_factor) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
  if (count > 0 && method_data() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
    int current_mileage = method_data()->current_mileage();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
    int creation_mileage = method_data()->creation_mileage();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
    int counter_life = current_mileage - creation_mileage;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
    int method_life = interpreter_invocation_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
    // counter_life due to backedge_counter could be > method_life
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
    if (counter_life > method_life)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
      counter_life = method_life;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
    if (0 < counter_life && counter_life <= method_life) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
      count = (int)((double)count * prof_factor * method_life / counter_life + 0.5);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
      count = (count > 0) ? count : 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
  return count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
// ------------------------------------------------------------------
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   678
// invokedynamic support
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   679
//
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   680
bool ciMethod::is_method_handle_invoke() {
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   681
  check_is_loaded();
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   682
  bool flag = ((flags().as_int() & JVM_MH_INVOKE_BITS) == JVM_MH_INVOKE_BITS);
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   683
#ifdef ASSERT
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   684
  {
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   685
    VM_ENTRY_MARK;
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   686
    bool flag2 = get_methodOop()->is_method_handle_invoke();
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   687
    assert(flag == flag2, "consistent");
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   688
  }
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   689
#endif //ASSERT
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   690
  return flag;
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   691
}
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   692
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   693
ciInstance* ciMethod::method_handle_type() {
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   694
  check_is_loaded();
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   695
  VM_ENTRY_MARK;
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   696
  oop mtype = get_methodOop()->method_handle_type();
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   697
  return CURRENT_THREAD_ENV->get_object(mtype)->as_instance();
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   698
}
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   699
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   700
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   701
// ------------------------------------------------------------------
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
// ciMethod::build_method_data
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
// Generate new methodDataOop objects at compile time.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
void ciMethod::build_method_data(methodHandle h_m) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   706
  EXCEPTION_CONTEXT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   707
  if (is_native() || is_abstract() || h_m()->is_accessor()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   708
  if (h_m()->method_data() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   709
    methodOopDesc::build_interpreter_method_data(h_m, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   710
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   711
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   712
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   713
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   714
  if (h_m()->method_data() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   715
    _method_data = CURRENT_ENV->get_object(h_m()->method_data())->as_method_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   716
    _method_data->load_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   717
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   718
    _method_data = CURRENT_ENV->get_empty_methodData();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   719
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   720
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   721
489c9b5090e2 Initial load
duke
parents:
diff changeset
   722
// public, retroactive version
489c9b5090e2 Initial load
duke
parents:
diff changeset
   723
void ciMethod::build_method_data() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   724
  if (_method_data == NULL || _method_data->is_empty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   725
    GUARDED_VM_ENTRY({
489c9b5090e2 Initial load
duke
parents:
diff changeset
   726
      build_method_data(get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   727
    });
489c9b5090e2 Initial load
duke
parents:
diff changeset
   728
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   729
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   730
489c9b5090e2 Initial load
duke
parents:
diff changeset
   731
489c9b5090e2 Initial load
duke
parents:
diff changeset
   732
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   733
// ciMethod::method_data
489c9b5090e2 Initial load
duke
parents:
diff changeset
   734
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   735
ciMethodData* ciMethod::method_data() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   736
  if (_method_data != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   737
    return _method_data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   738
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
  ciEnv* env = CURRENT_ENV;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
  Thread* my_thread = JavaThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
  methodHandle h_m(my_thread, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
  if (Tier1UpdateMethodData && is_tier1_compile(env->comp_level())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
    build_method_data(h_m);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
  if (h_m()->method_data() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
    _method_data = CURRENT_ENV->get_object(h_m()->method_data())->as_method_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
    _method_data->load_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
    _method_data = CURRENT_ENV->get_empty_methodData();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
  return _method_data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
489c9b5090e2 Initial load
duke
parents:
diff changeset
   756
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   757
489c9b5090e2 Initial load
duke
parents:
diff changeset
   758
489c9b5090e2 Initial load
duke
parents:
diff changeset
   759
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
// ciMethod::will_link
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
// Will this method link in a specific calling context?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
bool ciMethod::will_link(ciKlass* accessing_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
                         ciKlass* declared_method_holder,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
                         Bytecodes::Code bc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
  if (!is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
    // Method lookup failed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
  // The link checks have been front-loaded into the get_method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
  // call.  This method (ciMethod::will_link()) will be removed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  // in the future.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
// ciMethod::should_exclude
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
// Should this method be excluded from compilation?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
bool ciMethod::should_exclude() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
  bool ignore;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
  return CompilerOracle::should_exclude(mh, ignore);
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
// ciMethod::should_inline
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
// Should this method be inlined during compilation?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
bool ciMethod::should_inline() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
  return CompilerOracle::should_inline(mh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
// ciMethod::should_not_inline
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
// Should this method be disallowed from inlining during compilation?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
bool ciMethod::should_not_inline() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
  return CompilerOracle::should_not_inline(mh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
// ciMethod::should_print_assembly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
// Should the compiler print the generated code for this method?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
bool ciMethod::should_print_assembly() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
  return CompilerOracle::should_print(mh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
// ciMethod::break_at_execute
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
// Should the compiler insert a breakpoint into the generated code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
// method?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
bool ciMethod::break_at_execute() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
  return CompilerOracle::should_break_at(mh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
// ciMethod::has_option
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
bool ciMethod::has_option(const char* option) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
  return CompilerOracle::has_option_string(mh, option);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
// ciMethod::can_be_compiled
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
// Have previous compilations of this method succeeded?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
bool ciMethod::can_be_compiled() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
  return _is_compilable;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
// ciMethod::set_not_compilable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
// Tell the VM that this method cannot be compiled at all.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
void ciMethod::set_not_compilable() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
  _is_compilable = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
  get_methodOop()->set_not_compilable();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
// ciMethod::can_be_osr_compiled
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
// Have previous compilations of this method succeeded?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
// Implementation note: the VM does not currently keep track
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
// of failed OSR compilations per bci.  The entry_bci parameter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
// is currently unused.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
bool ciMethod::can_be_osr_compiled(int entry_bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
  return !get_methodOop()->access_flags().is_not_osr_compilable();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
// ciMethod::has_compiled_code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
bool ciMethod::has_compiled_code() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
  return get_methodOop()->code() != NULL;
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::instructions_size
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
// This is a rough metric for "fat" methods, compared
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
// before inlining with InlineSmallCode.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
// The CodeBlob::instructions_size accessor includes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
// junk like exception handler, stubs, and constant table,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
// which are not highly relevant to an inlined method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
// So we use the more specific accessor nmethod::code_size.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
int ciMethod::instructions_size() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
  GUARDED_VM_ENTRY(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
    nmethod* code = get_methodOop()->code();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
    // if there's no compiled code or the code was produced by the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
    // tier1 profiler return 0 for the code size.  This should
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
    // probably be based on the compilation level of the nmethod but
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
    // that currently isn't properly recorded.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
    if (code == NULL ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
        (TieredCompilation && code->compiler() != NULL && code->compiler()->is_c1())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
      return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
    }
608
fe8c5fbbc54e 6709093: Compressed Oops: reduce size of compiled methods
kvn
parents: 200
diff changeset
   905
    return code->code_end() - code->verified_entry_point();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
// ciMethod::log_nmethod_identity
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
void ciMethod::log_nmethod_identity(xmlStream* log) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
  GUARDED_VM_ENTRY(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
    nmethod* code = get_methodOop()->code();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
    if (code != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
      code->log_identity(log);
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
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
// ciMethod::is_not_reached
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
bool ciMethod::is_not_reached(int bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   925
  return Interpreter::is_not_reached(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   926
               methodHandle(THREAD, get_methodOop()), bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   927
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   928
489c9b5090e2 Initial load
duke
parents:
diff changeset
   929
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   930
// ciMethod::was_never_executed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
bool ciMethod::was_executed_more_than(int times) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
  return get_methodOop()->was_executed_more_than(times);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
// ciMethod::has_unloaded_classes_in_signature
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
bool ciMethod::has_unloaded_classes_in_signature() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
    EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   942
    methodHandle m(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
    bool has_unloaded = methodOopDesc::has_unloaded_classes_in_signature(m, (JavaThread *)THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
    if( HAS_PENDING_EXCEPTION ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
      return true;     // Declare that we may have unloaded classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
    return has_unloaded;
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_klass_loaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
bool ciMethod::is_klass_loaded(int refinfo_index, bool must_be_resolved) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
  return get_methodOop()->is_klass_loaded(refinfo_index, must_be_resolved);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
// ciMethod::check_call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
bool ciMethod::check_call(int refinfo_index, bool is_static) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
    EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
    HandleMark hm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
    constantPoolHandle pool (THREAD, get_methodOop()->constants());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
    methodHandle spec_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
    KlassHandle  spec_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
    LinkResolver::resolve_method(spec_method, spec_klass, pool, refinfo_index, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
      return (spec_method->is_static() == is_static);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
// ciMethod::print_codes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
// Print the bytecodes for this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
void ciMethod::print_codes_on(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
  GUARDED_VM_ENTRY(get_methodOop()->print_codes_on(st);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   987
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   988
489c9b5090e2 Initial load
duke
parents:
diff changeset
   989
489c9b5090e2 Initial load
duke
parents:
diff changeset
   990
#define FETCH_FLAG_FROM_VM(flag_accessor) { \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
  check_is_loaded(); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
  VM_ENTRY_MARK; \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
  return get_methodOop()->flag_accessor(); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
bool ciMethod::is_empty_method() const {         FETCH_FLAG_FROM_VM(is_empty_method); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
bool ciMethod::is_vanilla_constructor() const {  FETCH_FLAG_FROM_VM(is_vanilla_constructor); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
bool ciMethod::has_loops      () const {         FETCH_FLAG_FROM_VM(has_loops); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
bool ciMethod::has_jsrs       () const {         FETCH_FLAG_FROM_VM(has_jsrs);  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
bool ciMethod::is_accessor    () const {         FETCH_FLAG_FROM_VM(is_accessor); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
bool ciMethod::is_initializer () const {         FETCH_FLAG_FROM_VM(is_initializer); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
BCEscapeAnalyzer  *ciMethod::get_bcea() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
  if (_bcea == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
    _bcea = new (CURRENT_ENV->arena()) BCEscapeAnalyzer(this, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
  return _bcea;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
ciMethodBlocks  *ciMethod::get_method_blocks() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
  Arena *arena = CURRENT_ENV->arena();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
  if (_method_blocks == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
    _method_blocks = new (arena) ciMethodBlocks(arena, this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
  return _method_blocks;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
#undef FETCH_FLAG_FROM_VM
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
// ciMethod::print_codes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
// Print a range of the bytecodes for this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
void ciMethod::print_codes_on(int from, int to, outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
  GUARDED_VM_ENTRY(get_methodOop()->print_codes_on(from, to, st);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
// ciMethod::print_name
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
// Print the name of this method, including signature and some flags.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
void ciMethod::print_name(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
  GUARDED_VM_ENTRY(get_methodOop()->print_name(st);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
// ciMethod::print_short_name
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1041
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
// Print the name of this method, without signature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
void ciMethod::print_short_name(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
  GUARDED_VM_ENTRY(get_methodOop()->print_short_name(st);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1046
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1047
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1048
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1049
// ciMethod::print_impl
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
// Implementation of the print method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
void ciMethod::print_impl(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
  ciObject::print_impl(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
  st->print(" name=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
  name()->print_symbol_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
  st->print(" holder=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
  holder()->print_name_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
  st->print(" signature=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
  signature()->as_symbol()->print_symbol_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
  if (is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
    st->print(" loaded=true flags=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
    flags().print_member_flags(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
    st->print(" loaded=false");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
}