hotspot/src/share/vm/ci/ciMethod.cpp
author twisti
Wed, 25 Aug 2010 05:27:54 -0700
changeset 6418 6671edbd230e
parent 6187 4fa7845f7c14
child 6453 970dc585ab63
permissions -rw-r--r--
6978355: renaming for 6961697 Summary: This is the renaming part of 6961697 to keep the actual changes small for review. Reviewed-by: kvn, never
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     1
/*
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4892
diff changeset
     2
 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     4
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
489c9b5090e2 Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
489c9b5090e2 Initial load
duke
parents:
diff changeset
     7
 * published by the Free Software Foundation.
489c9b5090e2 Initial load
duke
parents:
diff changeset
     8
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
489c9b5090e2 Initial load
duke
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
489c9b5090e2 Initial load
duke
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
489c9b5090e2 Initial load
duke
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
489c9b5090e2 Initial load
duke
parents:
diff changeset
    13
 * accompanied this code).
489c9b5090e2 Initial load
duke
parents:
diff changeset
    14
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
489c9b5090e2 Initial load
duke
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
489c9b5090e2 Initial load
duke
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
489c9b5090e2 Initial load
duke
parents:
diff changeset
    18
 *
5547
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4892
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4892
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
f4b087cbb361 6941466: Oracle rebranding changes for Hotspot repositories
trims
parents: 4892
diff changeset
    21
 * questions.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    22
 *
489c9b5090e2 Initial load
duke
parents:
diff changeset
    23
 */
489c9b5090e2 Initial load
duke
parents:
diff changeset
    24
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
  _method_blocks = NULL;
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
    58
#if defined(COMPILER2) || defined(SHARK)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
    59
  _flow               = NULL;
5928
f6e69b46e9e3 6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents: 5702
diff changeset
    60
  _bcea               = NULL;
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
    61
#endif // COMPILER2 || SHARK
1
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
  _method_blocks = NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   125
  _method_data = NULL;
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   126
#if defined(COMPILER2) || defined(SHARK)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   127
  _flow = NULL;
5928
f6e69b46e9e3 6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents: 5702
diff changeset
   128
  _bcea = NULL;
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   129
#endif // COMPILER2 || SHARK
1
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
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   232
#ifdef SHARK
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   233
// ------------------------------------------------------------------
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   234
// ciMethod::itable_index
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   235
//
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   236
// Get the position of this method's entry in the itable, if any.
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   237
int ciMethod::itable_index() {
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   238
  check_is_loaded();
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   239
  assert(holder()->is_linked(), "must be linked");
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   240
  VM_ENTRY_MARK;
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   241
  return klassItable::compute_itable_index(get_methodOop());
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   242
}
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   243
#endif // SHARK
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   244
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   245
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   246
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   247
// ciMethod::native_entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   248
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   249
// Get the address of this method's native code, if any.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   250
address ciMethod::native_entry() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   251
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   252
  assert(flags().is_native(), "must be native method");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   253
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   254
  methodOop method = get_methodOop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   255
  address entry = method->native_function();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   256
  assert(entry != NULL, "must be valid entry point");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   257
  return entry;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   258
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   259
489c9b5090e2 Initial load
duke
parents:
diff changeset
   260
489c9b5090e2 Initial load
duke
parents:
diff changeset
   261
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   262
// ciMethod::interpreter_entry
489c9b5090e2 Initial load
duke
parents:
diff changeset
   263
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   264
// Get the entry point for running this method in the interpreter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   265
address ciMethod::interpreter_entry() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   266
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   267
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   268
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   269
  return Interpreter::entry_for_method(mh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   270
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   271
489c9b5090e2 Initial load
duke
parents:
diff changeset
   272
489c9b5090e2 Initial load
duke
parents:
diff changeset
   273
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   274
// ciMethod::uses_balanced_monitors
489c9b5090e2 Initial load
duke
parents:
diff changeset
   275
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   276
// Does this method use monitors in a strict stack-disciplined manner?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   277
bool ciMethod::has_balanced_monitors() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   278
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   279
  if (_balanced_monitors) return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   280
489c9b5090e2 Initial load
duke
parents:
diff changeset
   281
  // Analyze the method to see if monitors are used properly.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   282
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   283
  methodHandle method(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   284
  assert(method->has_monitor_bytecodes(), "should have checked this");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   285
489c9b5090e2 Initial load
duke
parents:
diff changeset
   286
  // Check to see if a previous compilation computed the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   287
  // monitor-matching analysis.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   288
  if (method->guaranteed_monitor_matching()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   289
    _balanced_monitors = true;
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
    EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   295
    ResourceMark rm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   296
    GeneratePairingInfo gpi(method);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   297
    gpi.compute_map(CATCH);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   298
    if (!gpi.monitor_safe()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   299
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   300
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   301
    method->set_guaranteed_monitor_matching();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   302
    _balanced_monitors = true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   303
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   304
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   305
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   306
489c9b5090e2 Initial load
duke
parents:
diff changeset
   307
489c9b5090e2 Initial load
duke
parents:
diff changeset
   308
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   309
// ciMethod::get_flow_analysis
489c9b5090e2 Initial load
duke
parents:
diff changeset
   310
ciTypeFlow* ciMethod::get_flow_analysis() {
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   311
#if defined(COMPILER2) || defined(SHARK)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   312
  if (_flow == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   313
    ciEnv* env = CURRENT_ENV;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   314
    _flow = new (env->arena()) ciTypeFlow(env, this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   315
    _flow->do_flow();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   316
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   317
  return _flow;
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   318
#else // COMPILER2 || SHARK
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   319
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   320
  return NULL;
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   321
#endif // COMPILER2 || SHARK
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   322
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   323
489c9b5090e2 Initial load
duke
parents:
diff changeset
   324
489c9b5090e2 Initial load
duke
parents:
diff changeset
   325
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   326
// ciMethod::get_osr_flow_analysis
489c9b5090e2 Initial load
duke
parents:
diff changeset
   327
ciTypeFlow* ciMethod::get_osr_flow_analysis(int osr_bci) {
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   328
#if defined(COMPILER2) || defined(SHARK)
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   329
  // OSR entry points are always place after a call bytecode of some sort
489c9b5090e2 Initial load
duke
parents:
diff changeset
   330
  assert(osr_bci >= 0, "must supply valid OSR entry point");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   331
  ciEnv* env = CURRENT_ENV;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   332
  ciTypeFlow* flow = new (env->arena()) ciTypeFlow(env, this, osr_bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   333
  flow->do_flow();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   334
  return flow;
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   335
#else // COMPILER2 || SHARK
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   336
  ShouldNotReachHere();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   337
  return NULL;
6187
4fa7845f7c14 6976186: integrate Shark HotSpot changes
twisti
parents: 6064
diff changeset
   338
#endif // COMPILER2 || SHARK
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   339
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   340
489c9b5090e2 Initial load
duke
parents:
diff changeset
   341
// ------------------------------------------------------------------
3910
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   342
// ciMethod::raw_liveness_at_bci
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   343
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   344
// Which local variables are live at a specific bci?
3910
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   345
MethodLivenessResult ciMethod::raw_liveness_at_bci(int bci) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   346
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   347
  if (_liveness == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   348
    // Create the liveness analyzer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   349
    Arena* arena = CURRENT_ENV->arena();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   350
    _liveness = new (arena) MethodLiveness(arena, this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   351
    _liveness->compute_liveness();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   352
  }
3910
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   353
  return _liveness->get_liveness_at(bci);
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   354
}
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   355
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   356
// ------------------------------------------------------------------
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   357
// ciMethod::liveness_at_bci
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   358
//
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   359
// Which local variables are live at a specific bci?  When debugging
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   360
// will return true for all locals in some cases to improve debug
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   361
// information.
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   362
MethodLivenessResult ciMethod::liveness_at_bci(int bci) {
67050ceda719 6854812: 6.0_14-b08 crashes with a SIGSEGV
never
parents: 2867
diff changeset
   363
  MethodLivenessResult result = raw_liveness_at_bci(bci);
2867
69187054225f 6788527: Server vm intermittently fails with assertion "live value must not be garbage" with fastdebug bits
kvn
parents: 2534
diff changeset
   364
  if (CURRENT_ENV->jvmti_can_access_local_variables() || DeoptimizeALot || CompileTheWorld) {
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   365
    // Keep all locals live for the user's edification and amusement.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   366
    result.at_put_range(0, result.size(), true);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   367
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   368
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   369
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   370
489c9b5090e2 Initial load
duke
parents:
diff changeset
   371
// ciMethod::live_local_oops_at_bci
489c9b5090e2 Initial load
duke
parents:
diff changeset
   372
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   373
// find all the live oops in the locals array for a particular bci
489c9b5090e2 Initial load
duke
parents:
diff changeset
   374
// Compute what the interpreter believes by using the interpreter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   375
// oopmap generator. This is used as a double check during osr to
489c9b5090e2 Initial load
duke
parents:
diff changeset
   376
// guard against conservative result from MethodLiveness making us
489c9b5090e2 Initial load
duke
parents:
diff changeset
   377
// think a dead oop is live.  MethodLiveness is conservative in the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   378
// sense that it may consider locals to be live which cannot be live,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   379
// like in the case where a local could contain an oop or  a primitive
489c9b5090e2 Initial load
duke
parents:
diff changeset
   380
// along different paths.  In that case the local must be dead when
489c9b5090e2 Initial load
duke
parents:
diff changeset
   381
// those paths merge. Since the interpreter's viewpoint is used when
489c9b5090e2 Initial load
duke
parents:
diff changeset
   382
// gc'ing an interpreter frame we need to use its viewpoint  during
489c9b5090e2 Initial load
duke
parents:
diff changeset
   383
// OSR when loading the locals.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   384
489c9b5090e2 Initial load
duke
parents:
diff changeset
   385
BitMap ciMethod::live_local_oops_at_bci(int bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   386
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   387
  InterpreterOopMap mask;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   388
  OopMapCache::compute_one_oop_map(get_methodOop(), bci, &mask);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   389
  int mask_size = max_locals();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   390
  BitMap result(mask_size);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   391
  result.clear();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   392
  int i;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   393
  for (i = 0; i < mask_size ; i++ ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   394
    if (mask.is_oop(i)) result.set_bit(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   395
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   396
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   397
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   398
489c9b5090e2 Initial load
duke
parents:
diff changeset
   399
489c9b5090e2 Initial load
duke
parents:
diff changeset
   400
#ifdef COMPILER1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   401
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   402
// ciMethod::bci_block_start
489c9b5090e2 Initial load
duke
parents:
diff changeset
   403
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   404
// Marks all bcis where a new basic block starts
489c9b5090e2 Initial load
duke
parents:
diff changeset
   405
const BitMap ciMethod::bci_block_start() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   406
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   407
  if (_liveness == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   408
    // Create the liveness analyzer.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   409
    Arena* arena = CURRENT_ENV->arena();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   410
    _liveness = new (arena) MethodLiveness(arena, this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   411
    _liveness->compute_liveness();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   412
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   413
489c9b5090e2 Initial load
duke
parents:
diff changeset
   414
  return _liveness->get_bci_block_start();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   415
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   416
#endif // COMPILER1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   417
489c9b5090e2 Initial load
duke
parents:
diff changeset
   418
489c9b5090e2 Initial load
duke
parents:
diff changeset
   419
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   420
// ciMethod::call_profile_at_bci
489c9b5090e2 Initial load
duke
parents:
diff changeset
   421
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   422
// Get the ciCallProfile for the invocation of this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   423
// Also reports receiver types for non-call type checks (if TypeProfileCasts).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   424
ciCallProfile ciMethod::call_profile_at_bci(int bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   425
  ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   426
  ciCallProfile result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   427
  if (method_data() != NULL && method_data()->is_mature()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   428
    ciProfileData* data = method_data()->bci_to_data(bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   429
    if (data != NULL && data->is_CounterData()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   430
      // Every profiled call site has a counter.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   431
      int count = data->as_CounterData()->count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   432
489c9b5090e2 Initial load
duke
parents:
diff changeset
   433
      if (!data->is_ReceiverTypeData()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   434
        result._receiver_count[0] = 0;  // that's a definite zero
489c9b5090e2 Initial load
duke
parents:
diff changeset
   435
      } else { // ReceiverTypeData is a subclass of CounterData
489c9b5090e2 Initial load
duke
parents:
diff changeset
   436
        ciReceiverTypeData* call = (ciReceiverTypeData*)data->as_ReceiverTypeData();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   437
        // In addition, virtual call sites have receiver type information
489c9b5090e2 Initial load
duke
parents:
diff changeset
   438
        int receivers_count_total = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   439
        int morphism = 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   440
        for (uint i = 0; i < call->row_limit(); i++) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   441
          ciKlass* receiver = call->receiver(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   442
          if (receiver == NULL)  continue;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   443
          morphism += 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   444
          int rcount = call->receiver_count(i);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   445
          if (rcount == 0) rcount = 1; // Should be valid value
489c9b5090e2 Initial load
duke
parents:
diff changeset
   446
          receivers_count_total += rcount;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   447
          // Add the receiver to result data.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   448
          result.add_receiver(receiver, rcount);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   449
          // If we extend profiling to record methods,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   450
          // we will set result._method also.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   451
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   452
        // Determine call site's morphism.
4754
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   453
        // The call site count is 0 with known morphism (onlt 1 or 2 receivers)
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   454
        // or < 0 in the case of a type check failured for checkcast, aastore, instanceof.
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   455
        // The call site count is > 0 in the case of a polymorphic virtual call.
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   456
        if (morphism > 0 && morphism == result._limit) {
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   457
           // The morphism <= MorphismLimit.
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   458
           if ((morphism <  ciCallProfile::MorphismLimit) ||
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   459
               (morphism == ciCallProfile::MorphismLimit && count == 0)) {
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   460
#ifdef ASSERT
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   461
             if (count > 0) {
4892
e977b527544a 6923002: assert(false,"this call site should not be polymorphic")
kvn
parents: 4754
diff changeset
   462
               this->print_short_name(tty);
e977b527544a 6923002: assert(false,"this call site should not be polymorphic")
kvn
parents: 4754
diff changeset
   463
               tty->print_cr(" @ bci:%d", bci);
4754
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   464
               this->print_codes();
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   465
               assert(false, "this call site should not be polymorphic");
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   466
             }
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   467
#endif
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   468
             result._morphism = morphism;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   469
           }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   470
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   471
        // Make the count consistent if this is a call profile. If count is
489c9b5090e2 Initial load
duke
parents:
diff changeset
   472
        // zero or less, presume that this is a typecheck profile and
489c9b5090e2 Initial load
duke
parents:
diff changeset
   473
        // do nothing.  Otherwise, increase count to be the sum of all
489c9b5090e2 Initial load
duke
parents:
diff changeset
   474
        // receiver's counts.
4754
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   475
        if (count >= 0) {
8aef16f24e16 6614597: Performance variability in jvm2008 xml.validation
kvn
parents: 4581
diff changeset
   476
          count += receivers_count_total;
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   477
        }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   478
      }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   479
      result._count = count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   480
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   481
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   482
  return result;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   483
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   484
489c9b5090e2 Initial load
duke
parents:
diff changeset
   485
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   486
// Add new receiver and sort data by receiver's profile count.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   487
void ciCallProfile::add_receiver(ciKlass* receiver, int receiver_count) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   488
  // Add new receiver and sort data by receiver's counts when we have space
489c9b5090e2 Initial load
duke
parents:
diff changeset
   489
  // for it otherwise replace the less called receiver (less called receiver
489c9b5090e2 Initial load
duke
parents:
diff changeset
   490
  // is placed to the last array element which is not used).
489c9b5090e2 Initial load
duke
parents:
diff changeset
   491
  // First array's element contains most called receiver.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   492
  int i = _limit;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   493
  for (; i > 0 && receiver_count > _receiver_count[i-1]; i--) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   494
    _receiver[i] = _receiver[i-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   495
    _receiver_count[i] = _receiver_count[i-1];
489c9b5090e2 Initial load
duke
parents:
diff changeset
   496
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   497
  _receiver[i] = receiver;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   498
  _receiver_count[i] = receiver_count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   499
  if (_limit < MorphismLimit) _limit++;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   500
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   501
489c9b5090e2 Initial load
duke
parents:
diff changeset
   502
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   503
// ciMethod::find_monomorphic_target
489c9b5090e2 Initial load
duke
parents:
diff changeset
   504
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   505
// Given a certain calling environment, find the monomorphic target
489c9b5090e2 Initial load
duke
parents:
diff changeset
   506
// for the call.  Return NULL if the call is not monomorphic in
489c9b5090e2 Initial load
duke
parents:
diff changeset
   507
// its calling environment, or if there are only abstract methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   508
// The returned method is never abstract.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   509
// Note: If caller uses a non-null result, it must inform dependencies
489c9b5090e2 Initial load
duke
parents:
diff changeset
   510
// via assert_unique_concrete_method or assert_leaf_type.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   511
ciMethod* ciMethod::find_monomorphic_target(ciInstanceKlass* caller,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   512
                                            ciInstanceKlass* callee_holder,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   513
                                            ciInstanceKlass* actual_recv) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   514
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   515
489c9b5090e2 Initial load
duke
parents:
diff changeset
   516
  if (actual_recv->is_interface()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   517
    // %%% We cannot trust interface types, yet.  See bug 6312651.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   518
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   519
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   520
489c9b5090e2 Initial load
duke
parents:
diff changeset
   521
  ciMethod* root_m = resolve_invoke(caller, actual_recv);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   522
  if (root_m == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   523
    // Something went wrong looking up the actual receiver method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   524
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   525
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   526
  assert(!root_m->is_abstract(), "resolve_invoke promise");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   527
489c9b5090e2 Initial load
duke
parents:
diff changeset
   528
  // Make certain quick checks even if UseCHA is false.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   529
489c9b5090e2 Initial load
duke
parents:
diff changeset
   530
  // Is it private or final?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   531
  if (root_m->can_be_statically_bound()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   532
    return root_m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   533
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   534
489c9b5090e2 Initial load
duke
parents:
diff changeset
   535
  if (actual_recv->is_leaf_type() && actual_recv == root_m->holder()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   536
    // Easy case.  There is no other place to put a method, so don't bother
489c9b5090e2 Initial load
duke
parents:
diff changeset
   537
    // to go through the VM_ENTRY_MARK and all the rest.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   538
    return root_m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   539
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   540
489c9b5090e2 Initial load
duke
parents:
diff changeset
   541
  // Array methods (clone, hashCode, etc.) are always statically bound.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   542
  // If we were to see an array type here, we'd return root_m.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   543
  // However, this method processes only ciInstanceKlasses.  (See 4962591.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   544
  // The inline_native_clone intrinsic narrows Object to T[] properly,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   545
  // so there is no need to do the same job here.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   546
489c9b5090e2 Initial load
duke
parents:
diff changeset
   547
  if (!UseCHA)  return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   548
489c9b5090e2 Initial load
duke
parents:
diff changeset
   549
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   550
489c9b5090e2 Initial load
duke
parents:
diff changeset
   551
  methodHandle target;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   552
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   553
    MutexLocker locker(Compile_lock);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   554
    klassOop context = actual_recv->get_klassOop();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   555
    target = Dependencies::find_unique_concrete_method(context,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   556
                                                       root_m->get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   557
    // %%% Should upgrade this ciMethod API to look for 1 or 2 concrete methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   558
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   559
489c9b5090e2 Initial load
duke
parents:
diff changeset
   560
#ifndef PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   561
  if (TraceDependencies && target() != NULL && target() != root_m->get_methodOop()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   562
    tty->print("found a non-root unique target method");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   563
    tty->print_cr("  context = %s", instanceKlass::cast(actual_recv->get_klassOop())->external_name());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   564
    tty->print("  method  = ");
489c9b5090e2 Initial load
duke
parents:
diff changeset
   565
    target->print_short_name(tty);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   566
    tty->cr();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   567
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   568
#endif //PRODUCT
489c9b5090e2 Initial load
duke
parents:
diff changeset
   569
489c9b5090e2 Initial load
duke
parents:
diff changeset
   570
  if (target() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   571
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   572
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   573
  if (target() == root_m->get_methodOop()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   574
    return root_m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   575
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   576
  if (!root_m->is_public() &&
489c9b5090e2 Initial load
duke
parents:
diff changeset
   577
      !root_m->is_protected()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   578
    // If we are going to reason about inheritance, it's easiest
489c9b5090e2 Initial load
duke
parents:
diff changeset
   579
    // if the method in question is public, protected, or private.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   580
    // If the answer is not root_m, it is conservatively correct
489c9b5090e2 Initial load
duke
parents:
diff changeset
   581
    // to return NULL, even if the CHA encountered irrelevant
489c9b5090e2 Initial load
duke
parents:
diff changeset
   582
    // methods in other packages.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   583
    // %%% TO DO: Work out logic for package-private methods
489c9b5090e2 Initial load
duke
parents:
diff changeset
   584
    // with the same name but different vtable indexes.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   585
    return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   586
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   587
  return CURRENT_THREAD_ENV->get_object(target())->as_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   588
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   589
489c9b5090e2 Initial load
duke
parents:
diff changeset
   590
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   591
// ciMethod::resolve_invoke
489c9b5090e2 Initial load
duke
parents:
diff changeset
   592
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   593
// Given a known receiver klass, find the target for the call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   594
// Return NULL if the call has no target or the target is abstract.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   595
ciMethod* ciMethod::resolve_invoke(ciKlass* caller, ciKlass* exact_receiver) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   596
   check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   597
   VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   598
489c9b5090e2 Initial load
duke
parents:
diff changeset
   599
   KlassHandle caller_klass (THREAD, caller->get_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   600
   KlassHandle h_recv       (THREAD, exact_receiver->get_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   601
   KlassHandle h_resolved   (THREAD, holder()->get_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   602
   symbolHandle h_name      (THREAD, name()->get_symbolOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   603
   symbolHandle h_signature (THREAD, signature()->get_symbolOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   604
489c9b5090e2 Initial load
duke
parents:
diff changeset
   605
   methodHandle m;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   606
   // Only do exact lookup if receiver klass has been linked.  Otherwise,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   607
   // the vtable has not been setup, and the LinkResolver will fail.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   608
   if (h_recv->oop_is_javaArray()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   609
        ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   610
       instanceKlass::cast(h_recv())->is_linked() && !exact_receiver->is_interface()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   611
     if (holder()->is_interface()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   612
       m = LinkResolver::resolve_interface_call_or_null(h_recv, h_resolved, h_name, h_signature, caller_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   613
     } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   614
       m = LinkResolver::resolve_virtual_call_or_null(h_recv, h_resolved, h_name, h_signature, caller_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   615
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   616
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   617
489c9b5090e2 Initial load
duke
parents:
diff changeset
   618
   if (m.is_null()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   619
     // Return NULL only if there was a problem with lookup (uninitialized class, etc.)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   620
     return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   621
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   622
489c9b5090e2 Initial load
duke
parents:
diff changeset
   623
   ciMethod* result = this;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   624
   if (m() != get_methodOop()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   625
     result = CURRENT_THREAD_ENV->get_object(m())->as_method();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   626
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   627
489c9b5090e2 Initial load
duke
parents:
diff changeset
   628
   // Don't return abstract methods because they aren't
489c9b5090e2 Initial load
duke
parents:
diff changeset
   629
   // optimizable or interesting.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   630
   if (result->is_abstract()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   631
     return NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   632
   } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   633
     return result;
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
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   638
// ciMethod::resolve_vtable_index
489c9b5090e2 Initial load
duke
parents:
diff changeset
   639
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   640
// Given a known receiver klass, find the vtable index for the call.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   641
// Return methodOopDesc::invalid_vtable_index if the vtable_index is unknown.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   642
int ciMethod::resolve_vtable_index(ciKlass* caller, ciKlass* receiver) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   643
   check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   644
489c9b5090e2 Initial load
duke
parents:
diff changeset
   645
   int vtable_index = methodOopDesc::invalid_vtable_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   646
   // Only do lookup if receiver klass has been linked.  Otherwise,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   647
   // the vtable has not been setup, and the LinkResolver will fail.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   648
   if (!receiver->is_interface()
489c9b5090e2 Initial load
duke
parents:
diff changeset
   649
       && (!receiver->is_instance_klass() ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   650
           receiver->as_instance_klass()->is_linked())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   651
     VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   652
489c9b5090e2 Initial load
duke
parents:
diff changeset
   653
     KlassHandle caller_klass (THREAD, caller->get_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   654
     KlassHandle h_recv       (THREAD, receiver->get_klassOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   655
     symbolHandle h_name      (THREAD, name()->get_symbolOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   656
     symbolHandle h_signature (THREAD, signature()->get_symbolOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   657
489c9b5090e2 Initial load
duke
parents:
diff changeset
   658
     vtable_index = LinkResolver::resolve_virtual_vtable_index(h_recv, h_recv, h_name, h_signature, caller_klass);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   659
     if (vtable_index == methodOopDesc::nonvirtual_vtable_index) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   660
       // A statically bound method.  Return "no such index".
489c9b5090e2 Initial load
duke
parents:
diff changeset
   661
       vtable_index = methodOopDesc::invalid_vtable_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   662
     }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   663
   }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   664
489c9b5090e2 Initial load
duke
parents:
diff changeset
   665
   return vtable_index;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   666
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   667
489c9b5090e2 Initial load
duke
parents:
diff changeset
   668
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   669
// ciMethod::interpreter_call_site_count
489c9b5090e2 Initial load
duke
parents:
diff changeset
   670
int ciMethod::interpreter_call_site_count(int bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   671
  if (method_data() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   672
    ResourceMark rm;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   673
    ciProfileData* data = method_data()->bci_to_data(bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   674
    if (data != NULL && data->is_CounterData()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   675
      return scale_count(data->as_CounterData()->count());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   676
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   677
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   678
  return -1;  // unknown
489c9b5090e2 Initial load
duke
parents:
diff changeset
   679
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   680
489c9b5090e2 Initial load
duke
parents:
diff changeset
   681
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   682
// Adjust a CounterData count to be commensurate with
489c9b5090e2 Initial load
duke
parents:
diff changeset
   683
// interpreter_invocation_count.  If the MDO exists for
489c9b5090e2 Initial load
duke
parents:
diff changeset
   684
// only 25% of the time the method exists, then the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   685
// counts in the MDO should be scaled by 4X, so that
489c9b5090e2 Initial load
duke
parents:
diff changeset
   686
// they can be usefully and stably compared against the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   687
// invocation counts in methods.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   688
int ciMethod::scale_count(int count, float prof_factor) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   689
  if (count > 0 && method_data() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   690
    int current_mileage = method_data()->current_mileage();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   691
    int creation_mileage = method_data()->creation_mileage();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   692
    int counter_life = current_mileage - creation_mileage;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   693
    int method_life = interpreter_invocation_count();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   694
    // counter_life due to backedge_counter could be > method_life
489c9b5090e2 Initial load
duke
parents:
diff changeset
   695
    if (counter_life > method_life)
489c9b5090e2 Initial load
duke
parents:
diff changeset
   696
      counter_life = method_life;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   697
    if (0 < counter_life && counter_life <= method_life) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   698
      count = (int)((double)count * prof_factor * method_life / counter_life + 0.5);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   699
      count = (count > 0) ? count : 1;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   700
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   701
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   702
  return count;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   703
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   704
489c9b5090e2 Initial load
duke
parents:
diff changeset
   705
// ------------------------------------------------------------------
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   706
// invokedynamic support
5687
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   707
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   708
// ------------------------------------------------------------------
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   709
// ciMethod::is_method_handle_invoke
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   710
//
6064
71e316283a85 6969574: invokedynamic call sites deoptimize instead of executing
jrose
parents: 5928
diff changeset
   711
// Return true if the method is an instance of one of the two
71e316283a85 6969574: invokedynamic call sites deoptimize instead of executing
jrose
parents: 5928
diff changeset
   712
// signature-polymorphic MethodHandle methods, invokeExact or invokeGeneric.
4566
b363f6ef4068 6829187: compiler optimizations required for JSR 292
twisti
parents: 3910
diff changeset
   713
bool ciMethod::is_method_handle_invoke() const {
6064
71e316283a85 6969574: invokedynamic call sites deoptimize instead of executing
jrose
parents: 5928
diff changeset
   714
  if (!is_loaded())  return false;
71e316283a85 6969574: invokedynamic call sites deoptimize instead of executing
jrose
parents: 5928
diff changeset
   715
  VM_ENTRY_MARK;
71e316283a85 6969574: invokedynamic call sites deoptimize instead of executing
jrose
parents: 5928
diff changeset
   716
  return get_methodOop()->is_method_handle_invoke();
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   717
}
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   718
5687
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   719
// ------------------------------------------------------------------
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   720
// ciMethod::is_method_handle_adapter
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   721
//
b862d1f189bd 6930772: JSR 292 needs to support SPARC C1
twisti
parents: 4892
diff changeset
   722
// Return true if the method is a generated MethodHandle adapter.
6064
71e316283a85 6969574: invokedynamic call sites deoptimize instead of executing
jrose
parents: 5928
diff changeset
   723
// These are built by MethodHandleCompiler.
4581
e89fbd1bcb3d 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 4566
diff changeset
   724
bool ciMethod::is_method_handle_adapter() const {
6064
71e316283a85 6969574: invokedynamic call sites deoptimize instead of executing
jrose
parents: 5928
diff changeset
   725
  if (!is_loaded())  return false;
4581
e89fbd1bcb3d 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 4566
diff changeset
   726
  VM_ENTRY_MARK;
e89fbd1bcb3d 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 4566
diff changeset
   727
  return get_methodOop()->is_method_handle_adapter();
e89fbd1bcb3d 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 4566
diff changeset
   728
}
e89fbd1bcb3d 6914206: change way of permission checking for generated MethodHandle adapters
twisti
parents: 4566
diff changeset
   729
2534
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   730
ciInstance* ciMethod::method_handle_type() {
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   731
  check_is_loaded();
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   732
  VM_ENTRY_MARK;
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   733
  oop mtype = get_methodOop()->method_handle_type();
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   734
  return CURRENT_THREAD_ENV->get_object(mtype)->as_instance();
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   735
}
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   736
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   737
08dac9ce0cd7 6655638: dynamic languages need method handles
jrose
parents: 670
diff changeset
   738
// ------------------------------------------------------------------
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   739
// ciMethod::build_method_data
489c9b5090e2 Initial load
duke
parents:
diff changeset
   740
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   741
// Generate new methodDataOop objects at compile time.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   742
void ciMethod::build_method_data(methodHandle h_m) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   743
  EXCEPTION_CONTEXT;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   744
  if (is_native() || is_abstract() || h_m()->is_accessor()) return;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   745
  if (h_m()->method_data() == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   746
    methodOopDesc::build_interpreter_method_data(h_m, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   747
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   748
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   749
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   750
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   751
  if (h_m()->method_data() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   752
    _method_data = CURRENT_ENV->get_object(h_m()->method_data())->as_method_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   753
    _method_data->load_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   754
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   755
    _method_data = CURRENT_ENV->get_empty_methodData();
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
// public, retroactive version
489c9b5090e2 Initial load
duke
parents:
diff changeset
   760
void ciMethod::build_method_data() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   761
  if (_method_data == NULL || _method_data->is_empty()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   762
    GUARDED_VM_ENTRY({
489c9b5090e2 Initial load
duke
parents:
diff changeset
   763
      build_method_data(get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   764
    });
489c9b5090e2 Initial load
duke
parents:
diff changeset
   765
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   766
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   767
489c9b5090e2 Initial load
duke
parents:
diff changeset
   768
489c9b5090e2 Initial load
duke
parents:
diff changeset
   769
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   770
// ciMethod::method_data
489c9b5090e2 Initial load
duke
parents:
diff changeset
   771
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   772
ciMethodData* ciMethod::method_data() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   773
  if (_method_data != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   774
    return _method_data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   775
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   776
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   777
  ciEnv* env = CURRENT_ENV;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   778
  Thread* my_thread = JavaThread::current();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   779
  methodHandle h_m(my_thread, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   780
489c9b5090e2 Initial load
duke
parents:
diff changeset
   781
  if (Tier1UpdateMethodData && is_tier1_compile(env->comp_level())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   782
    build_method_data(h_m);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   783
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   784
489c9b5090e2 Initial load
duke
parents:
diff changeset
   785
  if (h_m()->method_data() != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   786
    _method_data = CURRENT_ENV->get_object(h_m()->method_data())->as_method_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   787
    _method_data->load_data();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   788
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   789
    _method_data = CURRENT_ENV->get_empty_methodData();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   790
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   791
  return _method_data;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   792
489c9b5090e2 Initial load
duke
parents:
diff changeset
   793
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   794
489c9b5090e2 Initial load
duke
parents:
diff changeset
   795
489c9b5090e2 Initial load
duke
parents:
diff changeset
   796
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   797
// ciMethod::will_link
489c9b5090e2 Initial load
duke
parents:
diff changeset
   798
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   799
// Will this method link in a specific calling context?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   800
bool ciMethod::will_link(ciKlass* accessing_klass,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   801
                         ciKlass* declared_method_holder,
489c9b5090e2 Initial load
duke
parents:
diff changeset
   802
                         Bytecodes::Code bc) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   803
  if (!is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   804
    // Method lookup failed.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   805
    return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   806
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   807
489c9b5090e2 Initial load
duke
parents:
diff changeset
   808
  // The link checks have been front-loaded into the get_method
489c9b5090e2 Initial load
duke
parents:
diff changeset
   809
  // call.  This method (ciMethod::will_link()) will be removed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   810
  // in the future.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   811
489c9b5090e2 Initial load
duke
parents:
diff changeset
   812
  return true;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   813
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   814
489c9b5090e2 Initial load
duke
parents:
diff changeset
   815
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   816
// ciMethod::should_exclude
489c9b5090e2 Initial load
duke
parents:
diff changeset
   817
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   818
// Should this method be excluded from compilation?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   819
bool ciMethod::should_exclude() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   820
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   821
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   822
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   823
  bool ignore;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   824
  return CompilerOracle::should_exclude(mh, ignore);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   825
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   826
489c9b5090e2 Initial load
duke
parents:
diff changeset
   827
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   828
// ciMethod::should_inline
489c9b5090e2 Initial load
duke
parents:
diff changeset
   829
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   830
// Should this method be inlined during compilation?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   831
bool ciMethod::should_inline() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   832
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   833
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   834
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   835
  return CompilerOracle::should_inline(mh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   836
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   837
489c9b5090e2 Initial load
duke
parents:
diff changeset
   838
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   839
// ciMethod::should_not_inline
489c9b5090e2 Initial load
duke
parents:
diff changeset
   840
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   841
// Should this method be disallowed from inlining during compilation?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   842
bool ciMethod::should_not_inline() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   843
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   844
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   845
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   846
  return CompilerOracle::should_not_inline(mh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   847
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   848
489c9b5090e2 Initial load
duke
parents:
diff changeset
   849
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   850
// ciMethod::should_print_assembly
489c9b5090e2 Initial load
duke
parents:
diff changeset
   851
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   852
// Should the compiler print the generated code for this method?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   853
bool ciMethod::should_print_assembly() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   854
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   855
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   856
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   857
  return CompilerOracle::should_print(mh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   858
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   859
489c9b5090e2 Initial load
duke
parents:
diff changeset
   860
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   861
// ciMethod::break_at_execute
489c9b5090e2 Initial load
duke
parents:
diff changeset
   862
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   863
// Should the compiler insert a breakpoint into the generated code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   864
// method?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   865
bool ciMethod::break_at_execute() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   866
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   867
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   868
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   869
  return CompilerOracle::should_break_at(mh);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   870
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   871
489c9b5090e2 Initial load
duke
parents:
diff changeset
   872
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   873
// ciMethod::has_option
489c9b5090e2 Initial load
duke
parents:
diff changeset
   874
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   875
bool ciMethod::has_option(const char* option) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   876
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   877
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   878
  methodHandle mh(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   879
  return CompilerOracle::has_option_string(mh, option);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   880
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   881
489c9b5090e2 Initial load
duke
parents:
diff changeset
   882
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   883
// ciMethod::can_be_compiled
489c9b5090e2 Initial load
duke
parents:
diff changeset
   884
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   885
// Have previous compilations of this method succeeded?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   886
bool ciMethod::can_be_compiled() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   887
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   888
  return _is_compilable;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   889
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   890
489c9b5090e2 Initial load
duke
parents:
diff changeset
   891
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   892
// ciMethod::set_not_compilable
489c9b5090e2 Initial load
duke
parents:
diff changeset
   893
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   894
// Tell the VM that this method cannot be compiled at all.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   895
void ciMethod::set_not_compilable() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   896
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   897
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   898
  _is_compilable = false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   899
  get_methodOop()->set_not_compilable();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   900
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   901
489c9b5090e2 Initial load
duke
parents:
diff changeset
   902
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   903
// ciMethod::can_be_osr_compiled
489c9b5090e2 Initial load
duke
parents:
diff changeset
   904
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   905
// Have previous compilations of this method succeeded?
489c9b5090e2 Initial load
duke
parents:
diff changeset
   906
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
   907
// Implementation note: the VM does not currently keep track
489c9b5090e2 Initial load
duke
parents:
diff changeset
   908
// of failed OSR compilations per bci.  The entry_bci parameter
489c9b5090e2 Initial load
duke
parents:
diff changeset
   909
// is currently unused.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   910
bool ciMethod::can_be_osr_compiled(int entry_bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   911
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   912
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   913
  return !get_methodOop()->access_flags().is_not_osr_compilable();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   914
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   915
489c9b5090e2 Initial load
duke
parents:
diff changeset
   916
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   917
// ciMethod::has_compiled_code
489c9b5090e2 Initial load
duke
parents:
diff changeset
   918
bool ciMethod::has_compiled_code() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   919
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   920
  return get_methodOop()->code() != NULL;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   921
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   922
489c9b5090e2 Initial load
duke
parents:
diff changeset
   923
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   924
// ciMethod::instructions_size
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6187
diff changeset
   925
//
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6187
diff changeset
   926
// This is a rough metric for "fat" methods, compared before inlining
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6187
diff changeset
   927
// with InlineSmallCode.  The CodeBlob::code_size accessor includes
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6187
diff changeset
   928
// junk like exception handler, stubs, and constant table, which are
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6187
diff changeset
   929
// not highly relevant to an inlined method.  So we use the more
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6187
diff changeset
   930
// specific accessor nmethod::insts_size.
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   931
int ciMethod::instructions_size() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   932
  GUARDED_VM_ENTRY(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   933
    nmethod* code = get_methodOop()->code();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   934
    // if there's no compiled code or the code was produced by the
489c9b5090e2 Initial load
duke
parents:
diff changeset
   935
    // tier1 profiler return 0 for the code size.  This should
489c9b5090e2 Initial load
duke
parents:
diff changeset
   936
    // probably be based on the compilation level of the nmethod but
489c9b5090e2 Initial load
duke
parents:
diff changeset
   937
    // that currently isn't properly recorded.
489c9b5090e2 Initial load
duke
parents:
diff changeset
   938
    if (code == NULL ||
489c9b5090e2 Initial load
duke
parents:
diff changeset
   939
        (TieredCompilation && code->compiler() != NULL && code->compiler()->is_c1())) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   940
      return 0;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   941
    }
6418
6671edbd230e 6978355: renaming for 6961697
twisti
parents: 6187
diff changeset
   942
    return code->insts_end() - code->verified_entry_point();
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
   943
  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   944
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   945
489c9b5090e2 Initial load
duke
parents:
diff changeset
   946
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   947
// ciMethod::log_nmethod_identity
489c9b5090e2 Initial load
duke
parents:
diff changeset
   948
void ciMethod::log_nmethod_identity(xmlStream* log) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   949
  GUARDED_VM_ENTRY(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   950
    nmethod* code = get_methodOop()->code();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   951
    if (code != NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   952
      code->log_identity(log);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   953
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   954
  )
489c9b5090e2 Initial load
duke
parents:
diff changeset
   955
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   956
489c9b5090e2 Initial load
duke
parents:
diff changeset
   957
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   958
// ciMethod::is_not_reached
489c9b5090e2 Initial load
duke
parents:
diff changeset
   959
bool ciMethod::is_not_reached(int bci) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   960
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
   961
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   962
  return Interpreter::is_not_reached(
489c9b5090e2 Initial load
duke
parents:
diff changeset
   963
               methodHandle(THREAD, get_methodOop()), bci);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   964
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   965
489c9b5090e2 Initial load
duke
parents:
diff changeset
   966
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   967
// ciMethod::was_never_executed
489c9b5090e2 Initial load
duke
parents:
diff changeset
   968
bool ciMethod::was_executed_more_than(int times) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   969
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   970
  return get_methodOop()->was_executed_more_than(times);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   971
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   972
489c9b5090e2 Initial load
duke
parents:
diff changeset
   973
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   974
// ciMethod::has_unloaded_classes_in_signature
489c9b5090e2 Initial load
duke
parents:
diff changeset
   975
bool ciMethod::has_unloaded_classes_in_signature() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   976
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   977
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   978
    EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   979
    methodHandle m(THREAD, get_methodOop());
489c9b5090e2 Initial load
duke
parents:
diff changeset
   980
    bool has_unloaded = methodOopDesc::has_unloaded_classes_in_signature(m, (JavaThread *)THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   981
    if( HAS_PENDING_EXCEPTION ) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   982
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   983
      return true;     // Declare that we may have unloaded classes
489c9b5090e2 Initial load
duke
parents:
diff changeset
   984
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
   985
    return has_unloaded;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   986
  }
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
// ciMethod::is_klass_loaded
489c9b5090e2 Initial load
duke
parents:
diff changeset
   991
bool ciMethod::is_klass_loaded(int refinfo_index, bool must_be_resolved) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   992
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
   993
  return get_methodOop()->is_klass_loaded(refinfo_index, must_be_resolved);
489c9b5090e2 Initial load
duke
parents:
diff changeset
   994
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
   995
489c9b5090e2 Initial load
duke
parents:
diff changeset
   996
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
   997
// ciMethod::check_call
489c9b5090e2 Initial load
duke
parents:
diff changeset
   998
bool ciMethod::check_call(int refinfo_index, bool is_static) const {
489c9b5090e2 Initial load
duke
parents:
diff changeset
   999
  VM_ENTRY_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1000
  {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1001
    EXCEPTION_MARK;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1002
    HandleMark hm(THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1003
    constantPoolHandle pool (THREAD, get_methodOop()->constants());
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1004
    methodHandle spec_method;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1005
    KlassHandle  spec_klass;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1006
    LinkResolver::resolve_method(spec_method, spec_klass, pool, refinfo_index, THREAD);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1007
    if (HAS_PENDING_EXCEPTION) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1008
      CLEAR_PENDING_EXCEPTION;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1009
      return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1010
    } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1011
      return (spec_method->is_static() == is_static);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1012
    }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1013
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1014
  return false;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1015
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1016
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1017
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1018
// ciMethod::print_codes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1019
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1020
// Print the bytecodes for this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1021
void ciMethod::print_codes_on(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1022
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1023
  GUARDED_VM_ENTRY(get_methodOop()->print_codes_on(st);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1024
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1025
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1026
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1027
#define FETCH_FLAG_FROM_VM(flag_accessor) { \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1028
  check_is_loaded(); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1029
  VM_ENTRY_MARK; \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1030
  return get_methodOop()->flag_accessor(); \
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1031
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1032
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1033
bool ciMethod::is_empty_method() const {         FETCH_FLAG_FROM_VM(is_empty_method); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1034
bool ciMethod::is_vanilla_constructor() const {  FETCH_FLAG_FROM_VM(is_vanilla_constructor); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1035
bool ciMethod::has_loops      () const {         FETCH_FLAG_FROM_VM(has_loops); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1036
bool ciMethod::has_jsrs       () const {         FETCH_FLAG_FROM_VM(has_jsrs);  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1037
bool ciMethod::is_accessor    () const {         FETCH_FLAG_FROM_VM(is_accessor); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1038
bool ciMethod::is_initializer () const {         FETCH_FLAG_FROM_VM(is_initializer); }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1039
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1040
BCEscapeAnalyzer  *ciMethod::get_bcea() {
5928
f6e69b46e9e3 6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents: 5702
diff changeset
  1041
#ifdef COMPILER2
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1042
  if (_bcea == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1043
    _bcea = new (CURRENT_ENV->arena()) BCEscapeAnalyzer(this, NULL);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1044
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1045
  return _bcea;
5928
f6e69b46e9e3 6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents: 5702
diff changeset
  1046
#else // COMPILER2
f6e69b46e9e3 6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents: 5702
diff changeset
  1047
  ShouldNotReachHere();
f6e69b46e9e3 6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents: 5702
diff changeset
  1048
  return NULL;
f6e69b46e9e3 6968368: SIGSEGV in the BCEscapeAnalyzer::copy_dependencies
kvn
parents: 5702
diff changeset
  1049
#endif // COMPILER2
1
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1050
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1051
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1052
ciMethodBlocks  *ciMethod::get_method_blocks() {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1053
  Arena *arena = CURRENT_ENV->arena();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1054
  if (_method_blocks == NULL) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1055
    _method_blocks = new (arena) ciMethodBlocks(arena, this);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1056
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1057
  return _method_blocks;
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1058
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1059
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1060
#undef FETCH_FLAG_FROM_VM
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1061
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1062
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1063
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1064
// ciMethod::print_codes
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1065
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1066
// Print a range of the bytecodes for this method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1067
void ciMethod::print_codes_on(int from, int to, outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1068
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1069
  GUARDED_VM_ENTRY(get_methodOop()->print_codes_on(from, to, st);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1070
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1071
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1072
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1073
// ciMethod::print_name
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1074
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1075
// Print the name of this method, including signature and some flags.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1076
void ciMethod::print_name(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1077
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1078
  GUARDED_VM_ENTRY(get_methodOop()->print_name(st);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1079
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1080
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1081
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1082
// ciMethod::print_short_name
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1083
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1084
// Print the name of this method, without signature.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1085
void ciMethod::print_short_name(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1086
  check_is_loaded();
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1087
  GUARDED_VM_ENTRY(get_methodOop()->print_short_name(st);)
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1088
}
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1089
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1090
// ------------------------------------------------------------------
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1091
// ciMethod::print_impl
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1092
//
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1093
// Implementation of the print method.
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1094
void ciMethod::print_impl(outputStream* st) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1095
  ciObject::print_impl(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1096
  st->print(" name=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1097
  name()->print_symbol_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1098
  st->print(" holder=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1099
  holder()->print_name_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1100
  st->print(" signature=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1101
  signature()->as_symbol()->print_symbol_on(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1102
  if (is_loaded()) {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1103
    st->print(" loaded=true flags=");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1104
    flags().print_member_flags(st);
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1105
  } else {
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1106
    st->print(" loaded=false");
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1107
  }
489c9b5090e2 Initial load
duke
parents:
diff changeset
  1108
}