annotate src/share/vm/ci/ciMethod.cpp @ 3897:bd7a7ce2e264

6830717: replay of compilations would help with debugging Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method. Reviewed-by: kvn, twisti, sspitsyn Contributed-by: yumin.qi@oracle.com
author minqi
date Mon, 12 Nov 2012 14:03:53 -0800
parents 18fb7da42534
children bb33c6fdcf0d
rev   line source
duke@0 1 /*
jiangli@3530 2 * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
duke@0 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@0 4 *
duke@0 5 * This code is free software; you can redistribute it and/or modify it
duke@0 6 * under the terms of the GNU General Public License version 2 only, as
duke@0 7 * published by the Free Software Foundation.
duke@0 8 *
duke@0 9 * This code is distributed in the hope that it will be useful, but WITHOUT
duke@0 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@0 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@0 12 * version 2 for more details (a copy is included in the LICENSE file that
duke@0 13 * accompanied this code).
duke@0 14 *
duke@0 15 * You should have received a copy of the GNU General Public License version
duke@0 16 * 2 along with this work; if not, write to the Free Software Foundation,
duke@0 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@0 18 *
trims@1472 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1472 20 * or visit www.oracle.com if you need additional information or have any
trims@1472 21 * questions.
duke@0 22 *
duke@0 23 */
duke@0 24
stefank@1885 25 #include "precompiled.hpp"
stefank@1885 26 #include "ci/ciCallProfile.hpp"
stefank@1885 27 #include "ci/ciExceptionHandler.hpp"
stefank@1885 28 #include "ci/ciInstanceKlass.hpp"
stefank@1885 29 #include "ci/ciMethod.hpp"
stefank@1885 30 #include "ci/ciMethodBlocks.hpp"
stefank@1885 31 #include "ci/ciMethodData.hpp"
stefank@1885 32 #include "ci/ciStreams.hpp"
stefank@1885 33 #include "ci/ciSymbol.hpp"
minqi@3897 34 #include "ci/ciReplay.hpp"
stefank@1885 35 #include "ci/ciUtilities.hpp"
stefank@1885 36 #include "classfile/systemDictionary.hpp"
stefank@1885 37 #include "compiler/abstractCompiler.hpp"
stefank@1885 38 #include "compiler/compilerOracle.hpp"
stefank@1885 39 #include "compiler/methodLiveness.hpp"
stefank@1885 40 #include "interpreter/interpreter.hpp"
stefank@1885 41 #include "interpreter/linkResolver.hpp"
stefank@1885 42 #include "interpreter/oopMapCache.hpp"
stefank@1885 43 #include "memory/allocation.inline.hpp"
stefank@1885 44 #include "memory/resourceArea.hpp"
stefank@1885 45 #include "oops/generateOopMap.hpp"
stefank@1885 46 #include "oops/oop.inline.hpp"
stefank@1885 47 #include "prims/nativeLookup.hpp"
stefank@1885 48 #include "runtime/deoptimization.hpp"
stefank@1885 49 #include "utilities/bitMap.inline.hpp"
stefank@1885 50 #include "utilities/xmlstream.hpp"
stefank@1885 51 #ifdef COMPILER2
stefank@1885 52 #include "ci/bcEscapeAnalyzer.hpp"
stefank@1885 53 #include "ci/ciTypeFlow.hpp"
coleenp@3656 54 #include "oops/method.hpp"
stefank@1885 55 #endif
stefank@1885 56 #ifdef SHARK
stefank@1885 57 #include "ci/ciTypeFlow.hpp"
coleenp@3656 58 #include "oops/method.hpp"
stefank@1885 59 #endif
duke@0 60
duke@0 61 // ciMethod
duke@0 62 //
coleenp@3656 63 // This class represents a Method* in the HotSpot virtual
duke@0 64 // machine.
duke@0 65
duke@0 66
duke@0 67 // ------------------------------------------------------------------
duke@0 68 // ciMethod::ciMethod
duke@0 69 //
duke@0 70 // Loaded method.
coleenp@3656 71 ciMethod::ciMethod(methodHandle h_m) : ciMetadata(h_m()) {
duke@0 72 assert(h_m() != NULL, "no null method");
duke@0 73
duke@0 74 // These fields are always filled in in loaded methods.
duke@0 75 _flags = ciFlags(h_m()->access_flags());
duke@0 76
duke@0 77 // Easy to compute, so fill them in now.
duke@0 78 _max_stack = h_m()->max_stack();
duke@0 79 _max_locals = h_m()->max_locals();
duke@0 80 _code_size = h_m()->code_size();
duke@0 81 _intrinsic_id = h_m()->intrinsic_id();
jiangli@3530 82 _handler_count = h_m()->exception_table_length();
duke@0 83 _uses_monitors = h_m()->access_flags().has_monitor_bytecodes();
duke@0 84 _balanced_monitors = !_uses_monitors || h_m()->access_flags().is_monitor_matching();
iveresov@1707 85 _is_c1_compilable = !h_m()->is_not_c1_compilable();
iveresov@1707 86 _is_c2_compilable = !h_m()->is_not_c2_compilable();
duke@0 87 // Lazy fields, filled in on demand. Require allocation.
duke@0 88 _code = NULL;
duke@0 89 _exception_handlers = NULL;
duke@0 90 _liveness = NULL;
duke@0 91 _method_blocks = NULL;
twisti@1616 92 #if defined(COMPILER2) || defined(SHARK)
duke@0 93 _flow = NULL;
kvn@1570 94 _bcea = NULL;
twisti@1616 95 #endif // COMPILER2 || SHARK
duke@0 96
kvn@780 97 ciEnv *env = CURRENT_ENV;
iveresov@1707 98 if (env->jvmti_can_hotswap_or_post_breakpoint() && can_be_compiled()) {
duke@0 99 // 6328518 check hotswap conditions under the right lock.
duke@0 100 MutexLocker locker(Compile_lock);
duke@0 101 if (Dependencies::check_evol_method(h_m()) != NULL) {
iveresov@1707 102 _is_c1_compilable = false;
iveresov@1707 103 _is_c2_compilable = false;
duke@0 104 }
duke@0 105 } else {
duke@0 106 CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
duke@0 107 }
duke@0 108
coleenp@3880 109 if (h_m()->method_holder()->is_linked()) {
duke@0 110 _can_be_statically_bound = h_m()->can_be_statically_bound();
duke@0 111 } else {
duke@0 112 // Have to use a conservative value in this case.
duke@0 113 _can_be_statically_bound = false;
duke@0 114 }
duke@0 115
duke@0 116 // Adjust the definition of this condition to be more useful:
duke@0 117 // %%% take these conditions into account in vtable generation
duke@0 118 if (!_can_be_statically_bound && h_m()->is_private())
duke@0 119 _can_be_statically_bound = true;
duke@0 120 if (_can_be_statically_bound && h_m()->is_abstract())
duke@0 121 _can_be_statically_bound = false;
duke@0 122
duke@0 123 // generating _signature may allow GC and therefore move m.
duke@0 124 // These fields are always filled in.
coleenp@2069 125 _name = env->get_symbol(h_m()->name());
coleenp@3656 126 _holder = env->get_instance_klass(h_m()->method_holder());
coleenp@2069 127 ciSymbol* sig_symbol = env->get_symbol(h_m()->signature());
jrose@2557 128 constantPoolHandle cpool = h_m()->constants();
jrose@2557 129 _signature = new (env->arena()) ciSignature(_holder, cpool, sig_symbol);
duke@0 130 _method_data = NULL;
duke@0 131 // Take a snapshot of these values, so they will be commensurate with the MDO.
iveresov@1707 132 if (ProfileInterpreter || TieredCompilation) {
duke@0 133 int invcnt = h_m()->interpreter_invocation_count();
duke@0 134 // if the value overflowed report it as max int
duke@0 135 _interpreter_invocation_count = invcnt < 0 ? max_jint : invcnt ;
duke@0 136 _interpreter_throwout_count = h_m()->interpreter_throwout_count();
duke@0 137 } else {
duke@0 138 _interpreter_invocation_count = 0;
duke@0 139 _interpreter_throwout_count = 0;
duke@0 140 }
duke@0 141 if (_interpreter_invocation_count == 0)
duke@0 142 _interpreter_invocation_count = 1;
minqi@3897 143 _instructions_size = -1;
minqi@3897 144 #ifdef ASSERT
minqi@3897 145 if (ReplayCompiles) {
minqi@3897 146 ciReplay::initialize(this);
minqi@3897 147 }
minqi@3897 148 #endif
duke@0 149 }
duke@0 150
duke@0 151
duke@0 152 // ------------------------------------------------------------------
duke@0 153 // ciMethod::ciMethod
duke@0 154 //
duke@0 155 // Unloaded method.
duke@0 156 ciMethod::ciMethod(ciInstanceKlass* holder,
twisti@2772 157 ciSymbol* name,
twisti@2772 158 ciSymbol* signature,
twisti@2772 159 ciInstanceKlass* accessor) :
coleenp@3656 160 ciMetadata((Metadata*)NULL),
twisti@2772 161 _name( name),
twisti@2772 162 _holder( holder),
twisti@2772 163 _intrinsic_id( vmIntrinsics::_none),
twisti@2772 164 _liveness( NULL),
twisti@2772 165 _can_be_statically_bound(false),
twisti@2772 166 _method_blocks( NULL),
twisti@2772 167 _method_data( NULL)
twisti@1616 168 #if defined(COMPILER2) || defined(SHARK)
twisti@2772 169 ,
twisti@2772 170 _flow( NULL),
minqi@3897 171 _bcea( NULL),
minqi@3897 172 _instructions_size(-1)
twisti@1616 173 #endif // COMPILER2 || SHARK
twisti@2772 174 {
twisti@2772 175 // Usually holder and accessor are the same type but in some cases
twisti@2772 176 // the holder has the wrong class loader (e.g. invokedynamic call
twisti@2772 177 // sites) so we pass the accessor.
twisti@2772 178 _signature = new (CURRENT_ENV->arena()) ciSignature(accessor, constantPoolHandle(), signature);
duke@0 179 }
duke@0 180
duke@0 181
duke@0 182 // ------------------------------------------------------------------
duke@0 183 // ciMethod::load_code
duke@0 184 //
duke@0 185 // Load the bytecodes and exception handler table for this method.
duke@0 186 void ciMethod::load_code() {
duke@0 187 VM_ENTRY_MARK;
duke@0 188 assert(is_loaded(), "only loaded methods have code");
duke@0 189
coleenp@3656 190 Method* me = get_Method();
duke@0 191 Arena* arena = CURRENT_THREAD_ENV->arena();
duke@0 192
duke@0 193 // Load the bytecodes.
duke@0 194 _code = (address)arena->Amalloc(code_size());
duke@0 195 memcpy(_code, me->code_base(), code_size());
duke@0 196
duke@0 197 // Revert any breakpoint bytecodes in ci's copy
kvn@27 198 if (me->number_of_breakpoints() > 0) {
coleenp@3880 199 BreakpointInfo* bp = me->method_holder()->breakpoints();
duke@0 200 for (; bp != NULL; bp = bp->next()) {
duke@0 201 if (bp->match(me)) {
duke@0 202 code_at_put(bp->bci(), bp->orig_bytecode());
duke@0 203 }
duke@0 204 }
duke@0 205 }
duke@0 206
duke@0 207 // And load the exception table.
jiangli@3530 208 ExceptionTable exc_table(me);
duke@0 209
duke@0 210 // Allocate one extra spot in our list of exceptions. This
duke@0 211 // last entry will be used to represent the possibility that
duke@0 212 // an exception escapes the method. See ciExceptionHandlerStream
duke@0 213 // for details.
duke@0 214 _exception_handlers =
duke@0 215 (ciExceptionHandler**)arena->Amalloc(sizeof(ciExceptionHandler*)
duke@0 216 * (_handler_count + 1));
duke@0 217 if (_handler_count > 0) {
duke@0 218 for (int i=0; i<_handler_count; i++) {
duke@0 219 _exception_handlers[i] = new (arena) ciExceptionHandler(
duke@0 220 holder(),
jiangli@3530 221 /* start */ exc_table.start_pc(i),
jiangli@3530 222 /* limit */ exc_table.end_pc(i),
jiangli@3530 223 /* goto pc */ exc_table.handler_pc(i),
jiangli@3530 224 /* cp index */ exc_table.catch_type_index(i));
duke@0 225 }
duke@0 226 }
duke@0 227
duke@0 228 // Put an entry at the end of our list to represent the possibility
duke@0 229 // of exceptional exit.
duke@0 230 _exception_handlers[_handler_count] =
duke@0 231 new (arena) ciExceptionHandler(holder(), 0, code_size(), -1, 0);
duke@0 232
duke@0 233 if (CIPrintMethodCodes) {
duke@0 234 print_codes();
duke@0 235 }
duke@0 236 }
duke@0 237
duke@0 238
duke@0 239 // ------------------------------------------------------------------
duke@0 240 // ciMethod::has_linenumber_table
duke@0 241 //
duke@0 242 // length unknown until decompression
duke@0 243 bool ciMethod::has_linenumber_table() const {
duke@0 244 check_is_loaded();
duke@0 245 VM_ENTRY_MARK;
coleenp@3656 246 return get_Method()->has_linenumber_table();
duke@0 247 }
duke@0 248
duke@0 249
duke@0 250 // ------------------------------------------------------------------
duke@0 251 // ciMethod::compressed_linenumber_table
duke@0 252 u_char* ciMethod::compressed_linenumber_table() const {
duke@0 253 check_is_loaded();
duke@0 254 VM_ENTRY_MARK;
coleenp@3656 255 return get_Method()->compressed_linenumber_table();
duke@0 256 }
duke@0 257
duke@0 258
duke@0 259 // ------------------------------------------------------------------
duke@0 260 // ciMethod::line_number_from_bci
duke@0 261 int ciMethod::line_number_from_bci(int bci) const {
duke@0 262 check_is_loaded();
duke@0 263 VM_ENTRY_MARK;
coleenp@3656 264 return get_Method()->line_number_from_bci(bci);
duke@0 265 }
duke@0 266
duke@0 267
duke@0 268 // ------------------------------------------------------------------
duke@0 269 // ciMethod::vtable_index
duke@0 270 //
duke@0 271 // Get the position of this method's entry in the vtable, if any.
duke@0 272 int ciMethod::vtable_index() {
duke@0 273 check_is_loaded();
duke@0 274 assert(holder()->is_linked(), "must be linked");
duke@0 275 VM_ENTRY_MARK;
coleenp@3656 276 return get_Method()->vtable_index();
duke@0 277 }
duke@0 278
duke@0 279
twisti@1616 280 #ifdef SHARK
twisti@1616 281 // ------------------------------------------------------------------
twisti@1616 282 // ciMethod::itable_index
twisti@1616 283 //
twisti@1616 284 // Get the position of this method's entry in the itable, if any.
twisti@1616 285 int ciMethod::itable_index() {
twisti@1616 286 check_is_loaded();
twisti@1616 287 assert(holder()->is_linked(), "must be linked");
twisti@1616 288 VM_ENTRY_MARK;
coleenp@3656 289 return klassItable::compute_itable_index(get_Method());
twisti@1616 290 }
twisti@1616 291 #endif // SHARK
twisti@1616 292
twisti@1616 293
duke@0 294 // ------------------------------------------------------------------
duke@0 295 // ciMethod::native_entry
duke@0 296 //
duke@0 297 // Get the address of this method's native code, if any.
duke@0 298 address ciMethod::native_entry() {
duke@0 299 check_is_loaded();
duke@0 300 assert(flags().is_native(), "must be native method");
duke@0 301 VM_ENTRY_MARK;
coleenp@3656 302 Method* method = get_Method();
duke@0 303 address entry = method->native_function();
duke@0 304 assert(entry != NULL, "must be valid entry point");
duke@0 305 return entry;
duke@0 306 }
duke@0 307
duke@0 308
duke@0 309 // ------------------------------------------------------------------
duke@0 310 // ciMethod::interpreter_entry
duke@0 311 //
duke@0 312 // Get the entry point for running this method in the interpreter.
duke@0 313 address ciMethod::interpreter_entry() {
duke@0 314 check_is_loaded();
duke@0 315 VM_ENTRY_MARK;
coleenp@3656 316 methodHandle mh(THREAD, get_Method());
duke@0 317 return Interpreter::entry_for_method(mh);
duke@0 318 }
duke@0 319
duke@0 320
duke@0 321 // ------------------------------------------------------------------
duke@0 322 // ciMethod::uses_balanced_monitors
duke@0 323 //
duke@0 324 // Does this method use monitors in a strict stack-disciplined manner?
duke@0 325 bool ciMethod::has_balanced_monitors() {
duke@0 326 check_is_loaded();
duke@0 327 if (_balanced_monitors) return true;
duke@0 328
duke@0 329 // Analyze the method to see if monitors are used properly.
duke@0 330 VM_ENTRY_MARK;
coleenp@3656 331 methodHandle method(THREAD, get_Method());
duke@0 332 assert(method->has_monitor_bytecodes(), "should have checked this");
duke@0 333
duke@0 334 // Check to see if a previous compilation computed the
duke@0 335 // monitor-matching analysis.
duke@0 336 if (method->guaranteed_monitor_matching()) {
duke@0 337 _balanced_monitors = true;
duke@0 338 return true;
duke@0 339 }
duke@0 340
duke@0 341 {
duke@0 342 EXCEPTION_MARK;
duke@0 343 ResourceMark rm(THREAD);
duke@0 344 GeneratePairingInfo gpi(method);
duke@0 345 gpi.compute_map(CATCH);
duke@0 346 if (!gpi.monitor_safe()) {
duke@0 347 return false;
duke@0 348 }
duke@0 349 method->set_guaranteed_monitor_matching();
duke@0 350 _balanced_monitors = true;
duke@0 351 }
duke@0 352 return true;
duke@0 353 }
duke@0 354
duke@0 355
duke@0 356 // ------------------------------------------------------------------
duke@0 357 // ciMethod::get_flow_analysis
duke@0 358 ciTypeFlow* ciMethod::get_flow_analysis() {
twisti@1616 359 #if defined(COMPILER2) || defined(SHARK)
duke@0 360 if (_flow == NULL) {
duke@0 361 ciEnv* env = CURRENT_ENV;
duke@0 362 _flow = new (env->arena()) ciTypeFlow(env, this);
duke@0 363 _flow->do_flow();
duke@0 364 }
duke@0 365 return _flow;
twisti@1616 366 #else // COMPILER2 || SHARK
duke@0 367 ShouldNotReachHere();
duke@0 368 return NULL;
twisti@1616 369 #endif // COMPILER2 || SHARK
duke@0 370 }
duke@0 371
duke@0 372
duke@0 373 // ------------------------------------------------------------------
duke@0 374 // ciMethod::get_osr_flow_analysis
duke@0 375 ciTypeFlow* ciMethod::get_osr_flow_analysis(int osr_bci) {
twisti@1616 376 #if defined(COMPILER2) || defined(SHARK)
duke@0 377 // OSR entry points are always place after a call bytecode of some sort
duke@0 378 assert(osr_bci >= 0, "must supply valid OSR entry point");
duke@0 379 ciEnv* env = CURRENT_ENV;
duke@0 380 ciTypeFlow* flow = new (env->arena()) ciTypeFlow(env, this, osr_bci);
duke@0 381 flow->do_flow();
duke@0 382 return flow;
twisti@1616 383 #else // COMPILER2 || SHARK
duke@0 384 ShouldNotReachHere();
duke@0 385 return NULL;
twisti@1616 386 #endif // COMPILER2 || SHARK
duke@0 387 }
duke@0 388
duke@0 389 // ------------------------------------------------------------------
never@991 390 // ciMethod::raw_liveness_at_bci
duke@0 391 //
duke@0 392 // Which local variables are live at a specific bci?
never@991 393 MethodLivenessResult ciMethod::raw_liveness_at_bci(int bci) {
duke@0 394 check_is_loaded();
duke@0 395 if (_liveness == NULL) {
duke@0 396 // Create the liveness analyzer.
duke@0 397 Arena* arena = CURRENT_ENV->arena();
duke@0 398 _liveness = new (arena) MethodLiveness(arena, this);
duke@0 399 _liveness->compute_liveness();
duke@0 400 }
never@991 401 return _liveness->get_liveness_at(bci);
never@991 402 }
never@991 403
never@991 404 // ------------------------------------------------------------------
never@991 405 // ciMethod::liveness_at_bci
never@991 406 //
never@991 407 // Which local variables are live at a specific bci? When debugging
never@991 408 // will return true for all locals in some cases to improve debug
never@991 409 // information.
never@991 410 MethodLivenessResult ciMethod::liveness_at_bci(int bci) {
never@991 411 MethodLivenessResult result = raw_liveness_at_bci(bci);
kvn@780 412 if (CURRENT_ENV->jvmti_can_access_local_variables() || DeoptimizeALot || CompileTheWorld) {
duke@0 413 // Keep all locals live for the user's edification and amusement.
duke@0 414 result.at_put_range(0, result.size(), true);
duke@0 415 }
duke@0 416 return result;
duke@0 417 }
duke@0 418
duke@0 419 // ciMethod::live_local_oops_at_bci
duke@0 420 //
duke@0 421 // find all the live oops in the locals array for a particular bci
duke@0 422 // Compute what the interpreter believes by using the interpreter
duke@0 423 // oopmap generator. This is used as a double check during osr to
duke@0 424 // guard against conservative result from MethodLiveness making us
duke@0 425 // think a dead oop is live. MethodLiveness is conservative in the
duke@0 426 // sense that it may consider locals to be live which cannot be live,
duke@0 427 // like in the case where a local could contain an oop or a primitive
duke@0 428 // along different paths. In that case the local must be dead when
duke@0 429 // those paths merge. Since the interpreter's viewpoint is used when
duke@0 430 // gc'ing an interpreter frame we need to use its viewpoint during
duke@0 431 // OSR when loading the locals.
duke@0 432
duke@0 433 BitMap ciMethod::live_local_oops_at_bci(int bci) {
duke@0 434 VM_ENTRY_MARK;
duke@0 435 InterpreterOopMap mask;
coleenp@3656 436 OopMapCache::compute_one_oop_map(get_Method(), bci, &mask);
duke@0 437 int mask_size = max_locals();
duke@0 438 BitMap result(mask_size);
duke@0 439 result.clear();
duke@0 440 int i;
duke@0 441 for (i = 0; i < mask_size ; i++ ) {
duke@0 442 if (mask.is_oop(i)) result.set_bit(i);
duke@0 443 }
duke@0 444 return result;
duke@0 445 }
duke@0 446
duke@0 447
duke@0 448 #ifdef COMPILER1
duke@0 449 // ------------------------------------------------------------------
duke@0 450 // ciMethod::bci_block_start
duke@0 451 //
duke@0 452 // Marks all bcis where a new basic block starts
duke@0 453 const BitMap ciMethod::bci_block_start() {
duke@0 454 check_is_loaded();
duke@0 455 if (_liveness == NULL) {
duke@0 456 // Create the liveness analyzer.
duke@0 457 Arena* arena = CURRENT_ENV->arena();
duke@0 458 _liveness = new (arena) MethodLiveness(arena, this);
duke@0 459 _liveness->compute_liveness();
duke@0 460 }
duke@0 461
duke@0 462 return _liveness->get_bci_block_start();
duke@0 463 }
duke@0 464 #endif // COMPILER1
duke@0 465
duke@0 466
duke@0 467 // ------------------------------------------------------------------
duke@0 468 // ciMethod::call_profile_at_bci
duke@0 469 //
duke@0 470 // Get the ciCallProfile for the invocation of this method.
duke@0 471 // Also reports receiver types for non-call type checks (if TypeProfileCasts).
duke@0 472 ciCallProfile ciMethod::call_profile_at_bci(int bci) {
duke@0 473 ResourceMark rm;
duke@0 474 ciCallProfile result;
duke@0 475 if (method_data() != NULL && method_data()->is_mature()) {
duke@0 476 ciProfileData* data = method_data()->bci_to_data(bci);
duke@0 477 if (data != NULL && data->is_CounterData()) {
duke@0 478 // Every profiled call site has a counter.
duke@0 479 int count = data->as_CounterData()->count();
duke@0 480
duke@0 481 if (!data->is_ReceiverTypeData()) {
duke@0 482 result._receiver_count[0] = 0; // that's a definite zero
duke@0 483 } else { // ReceiverTypeData is a subclass of CounterData
duke@0 484 ciReceiverTypeData* call = (ciReceiverTypeData*)data->as_ReceiverTypeData();
duke@0 485 // In addition, virtual call sites have receiver type information
duke@0 486 int receivers_count_total = 0;
duke@0 487 int morphism = 0;
iveresov@1707 488 // Precompute morphism for the possible fixup
duke@0 489 for (uint i = 0; i < call->row_limit(); i++) {
duke@0 490 ciKlass* receiver = call->receiver(i);
duke@0 491 if (receiver == NULL) continue;
iveresov@1707 492 morphism++;
iveresov@1707 493 }
iveresov@1707 494 int epsilon = 0;
iveresov@1707 495 if (TieredCompilation && ProfileInterpreter) {
iveresov@1707 496 // Interpreter and C1 treat final and special invokes differently.
iveresov@1707 497 // C1 will record a type, whereas the interpreter will just
iveresov@1707 498 // increment the count. Detect this case.
iveresov@1707 499 if (morphism == 1 && count > 0) {
iveresov@1707 500 epsilon = count;
iveresov@1707 501 count = 0;
iveresov@1707 502 }
iveresov@1707 503 }
iveresov@1707 504 for (uint i = 0; i < call->row_limit(); i++) {
iveresov@1707 505 ciKlass* receiver = call->receiver(i);
iveresov@1707 506 if (receiver == NULL) continue;
iveresov@1707 507 int rcount = call->receiver_count(i) + epsilon;
duke@0 508 if (rcount == 0) rcount = 1; // Should be valid value
duke@0 509 receivers_count_total += rcount;
duke@0 510 // Add the receiver to result data.
duke@0 511 result.add_receiver(receiver, rcount);
duke@0 512 // If we extend profiling to record methods,
duke@0 513 // we will set result._method also.
duke@0 514 }
duke@0 515 // Determine call site's morphism.
kvn@1206 516 // The call site count is 0 with known morphism (onlt 1 or 2 receivers)
kvn@1206 517 // or < 0 in the case of a type check failured for checkcast, aastore, instanceof.
kvn@1206 518 // The call site count is > 0 in the case of a polymorphic virtual call.
kvn@1206 519 if (morphism > 0 && morphism == result._limit) {
kvn@1206 520 // The morphism <= MorphismLimit.
kvn@1206 521 if ((morphism < ciCallProfile::MorphismLimit) ||
kvn@1206 522 (morphism == ciCallProfile::MorphismLimit && count == 0)) {
kvn@1206 523 #ifdef ASSERT
kvn@1206 524 if (count > 0) {
kvn@1251 525 this->print_short_name(tty);
kvn@1251 526 tty->print_cr(" @ bci:%d", bci);
kvn@1206 527 this->print_codes();
kvn@1206 528 assert(false, "this call site should not be polymorphic");
kvn@1206 529 }
kvn@1206 530 #endif
duke@0 531 result._morphism = morphism;
duke@0 532 }
duke@0 533 }
duke@0 534 // Make the count consistent if this is a call profile. If count is
duke@0 535 // zero or less, presume that this is a typecheck profile and
duke@0 536 // do nothing. Otherwise, increase count to be the sum of all
duke@0 537 // receiver's counts.
kvn@1206 538 if (count >= 0) {
kvn@1206 539 count += receivers_count_total;
duke@0 540 }
duke@0 541 }
duke@0 542 result._count = count;
duke@0 543 }
duke@0 544 }
duke@0 545 return result;
duke@0 546 }
duke@0 547
duke@0 548 // ------------------------------------------------------------------
duke@0 549 // Add new receiver and sort data by receiver's profile count.
duke@0 550 void ciCallProfile::add_receiver(ciKlass* receiver, int receiver_count) {
duke@0 551 // Add new receiver and sort data by receiver's counts when we have space
duke@0 552 // for it otherwise replace the less called receiver (less called receiver
duke@0 553 // is placed to the last array element which is not used).
duke@0 554 // First array's element contains most called receiver.
duke@0 555 int i = _limit;
duke@0 556 for (; i > 0 && receiver_count > _receiver_count[i-1]; i--) {
duke@0 557 _receiver[i] = _receiver[i-1];
duke@0 558 _receiver_count[i] = _receiver_count[i-1];
duke@0 559 }
duke@0 560 _receiver[i] = receiver;
duke@0 561 _receiver_count[i] = receiver_count;
duke@0 562 if (_limit < MorphismLimit) _limit++;
duke@0 563 }
duke@0 564
duke@0 565 // ------------------------------------------------------------------
duke@0 566 // ciMethod::find_monomorphic_target
duke@0 567 //
duke@0 568 // Given a certain calling environment, find the monomorphic target
duke@0 569 // for the call. Return NULL if the call is not monomorphic in
duke@0 570 // its calling environment, or if there are only abstract methods.
duke@0 571 // The returned method is never abstract.
duke@0 572 // Note: If caller uses a non-null result, it must inform dependencies
duke@0 573 // via assert_unique_concrete_method or assert_leaf_type.
duke@0 574 ciMethod* ciMethod::find_monomorphic_target(ciInstanceKlass* caller,
duke@0 575 ciInstanceKlass* callee_holder,
duke@0 576 ciInstanceKlass* actual_recv) {
duke@0 577 check_is_loaded();
duke@0 578
duke@0 579 if (actual_recv->is_interface()) {
duke@0 580 // %%% We cannot trust interface types, yet. See bug 6312651.
duke@0 581 return NULL;
duke@0 582 }
duke@0 583
duke@0 584 ciMethod* root_m = resolve_invoke(caller, actual_recv);
duke@0 585 if (root_m == NULL) {
duke@0 586 // Something went wrong looking up the actual receiver method.
duke@0 587 return NULL;
duke@0 588 }
duke@0 589 assert(!root_m->is_abstract(), "resolve_invoke promise");
duke@0 590
duke@0 591 // Make certain quick checks even if UseCHA is false.
duke@0 592
duke@0 593 // Is it private or final?
duke@0 594 if (root_m->can_be_statically_bound()) {
duke@0 595 return root_m;
duke@0 596 }
duke@0 597
duke@0 598 if (actual_recv->is_leaf_type() && actual_recv == root_m->holder()) {
duke@0 599 // Easy case. There is no other place to put a method, so don't bother
duke@0 600 // to go through the VM_ENTRY_MARK and all the rest.
duke@0 601 return root_m;
duke@0 602 }
duke@0 603
duke@0 604 // Array methods (clone, hashCode, etc.) are always statically bound.
duke@0 605 // If we were to see an array type here, we'd return root_m.
duke@0 606 // However, this method processes only ciInstanceKlasses. (See 4962591.)
duke@0 607 // The inline_native_clone intrinsic narrows Object to T[] properly,
duke@0 608 // so there is no need to do the same job here.
duke@0 609
duke@0 610 if (!UseCHA) return NULL;
duke@0 611
duke@0 612 VM_ENTRY_MARK;
duke@0 613
duke@0 614 methodHandle target;
duke@0 615 {
duke@0 616 MutexLocker locker(Compile_lock);
coleenp@3656 617 Klass* context = actual_recv->get_Klass();
duke@0 618 target = Dependencies::find_unique_concrete_method(context,
coleenp@3656 619 root_m->get_Method());
duke@0 620 // %%% Should upgrade this ciMethod API to look for 1 or 2 concrete methods.
duke@0 621 }
duke@0 622
duke@0 623 #ifndef PRODUCT
coleenp@3656 624 if (TraceDependencies && target() != NULL && target() != root_m->get_Method()) {
duke@0 625 tty->print("found a non-root unique target method");
coleenp@3656 626 tty->print_cr(" context = %s", InstanceKlass::cast(actual_recv->get_Klass())->external_name());
duke@0 627 tty->print(" method = ");
duke@0 628 target->print_short_name(tty);
duke@0 629 tty->cr();
duke@0 630 }
duke@0 631 #endif //PRODUCT
duke@0 632
duke@0 633 if (target() == NULL) {
duke@0 634 return NULL;
duke@0 635 }
coleenp@3656 636 if (target() == root_m->get_Method()) {
duke@0 637 return root_m;
duke@0 638 }
duke@0 639 if (!root_m->is_public() &&
duke@0 640 !root_m->is_protected()) {
duke@0 641 // If we are going to reason about inheritance, it's easiest
duke@0 642 // if the method in question is public, protected, or private.
duke@0 643 // If the answer is not root_m, it is conservatively correct
duke@0 644 // to return NULL, even if the CHA encountered irrelevant
duke@0 645 // methods in other packages.
duke@0 646 // %%% TO DO: Work out logic for package-private methods
duke@0 647 // with the same name but different vtable indexes.
duke@0 648 return NULL;
duke@0 649 }
coleenp@3656 650 return CURRENT_THREAD_ENV->get_method(target());
duke@0 651 }
duke@0 652
duke@0 653 // ------------------------------------------------------------------
duke@0 654 // ciMethod::resolve_invoke
duke@0 655 //
duke@0 656 // Given a known receiver klass, find the target for the call.
duke@0 657 // Return NULL if the call has no target or the target is abstract.
duke@0 658 ciMethod* ciMethod::resolve_invoke(ciKlass* caller, ciKlass* exact_receiver) {
duke@0 659 check_is_loaded();
duke@0 660 VM_ENTRY_MARK;
duke@0 661
coleenp@3656 662 KlassHandle caller_klass (THREAD, caller->get_Klass());
coleenp@3656 663 KlassHandle h_recv (THREAD, exact_receiver->get_Klass());
coleenp@3656 664 KlassHandle h_resolved (THREAD, holder()->get_Klass());
coleenp@2069 665 Symbol* h_name = name()->get_symbol();
coleenp@2069 666 Symbol* h_signature = signature()->get_symbol();
duke@0 667
duke@0 668 methodHandle m;
duke@0 669 // Only do exact lookup if receiver klass has been linked. Otherwise,
duke@0 670 // the vtable has not been setup, and the LinkResolver will fail.
coleenp@3656 671 if (h_recv->oop_is_array()
duke@0 672 ||
coleenp@3656 673 InstanceKlass::cast(h_recv())->is_linked() && !exact_receiver->is_interface()) {
duke@0 674 if (holder()->is_interface()) {
duke@0 675 m = LinkResolver::resolve_interface_call_or_null(h_recv, h_resolved, h_name, h_signature, caller_klass);
duke@0 676 } else {
duke@0 677 m = LinkResolver::resolve_virtual_call_or_null(h_recv, h_resolved, h_name, h_signature, caller_klass);
duke@0 678 }
duke@0 679 }
duke@0 680
duke@0 681 if (m.is_null()) {
duke@0 682 // Return NULL only if there was a problem with lookup (uninitialized class, etc.)
duke@0 683 return NULL;
duke@0 684 }
duke@0 685
duke@0 686 ciMethod* result = this;
coleenp@3656 687 if (m() != get_Method()) {
coleenp@3656 688 result = CURRENT_THREAD_ENV->get_method(m());
duke@0 689 }
duke@0 690
duke@0 691 // Don't return abstract methods because they aren't
duke@0 692 // optimizable or interesting.
duke@0 693 if (result->is_abstract()) {
duke@0 694 return NULL;
duke@0 695 } else {
duke@0 696 return result;
duke@0 697 }
duke@0 698 }
duke@0 699
duke@0 700 // ------------------------------------------------------------------
duke@0 701 // ciMethod::resolve_vtable_index
duke@0 702 //
duke@0 703 // Given a known receiver klass, find the vtable index for the call.
coleenp@3656 704 // Return Method::invalid_vtable_index if the vtable_index is unknown.
duke@0 705 int ciMethod::resolve_vtable_index(ciKlass* caller, ciKlass* receiver) {
duke@0 706 check_is_loaded();
duke@0 707
coleenp@3656 708 int vtable_index = Method::invalid_vtable_index;
duke@0 709 // Only do lookup if receiver klass has been linked. Otherwise,
duke@0 710 // the vtable has not been setup, and the LinkResolver will fail.
duke@0 711 if (!receiver->is_interface()
duke@0 712 && (!receiver->is_instance_klass() ||
duke@0 713 receiver->as_instance_klass()->is_linked())) {
duke@0 714 VM_ENTRY_MARK;
duke@0 715
coleenp@3656 716 KlassHandle caller_klass (THREAD, caller->get_Klass());
coleenp@3656 717 KlassHandle h_recv (THREAD, receiver->get_Klass());
coleenp@2069 718 Symbol* h_name = name()->get_symbol();
coleenp@2069 719 Symbol* h_signature = signature()->get_symbol();
duke@0 720
duke@0 721 vtable_index = LinkResolver::resolve_virtual_vtable_index(h_recv, h_recv, h_name, h_signature, caller_klass);
coleenp@3656 722 if (vtable_index == Method::nonvirtual_vtable_index) {
duke@0 723 // A statically bound method. Return "no such index".
coleenp@3656 724 vtable_index = Method::invalid_vtable_index;
duke@0 725 }
duke@0 726 }
duke@0 727
duke@0 728 return vtable_index;
duke@0 729 }
duke@0 730
duke@0 731 // ------------------------------------------------------------------
duke@0 732 // ciMethod::interpreter_call_site_count
duke@0 733 int ciMethod::interpreter_call_site_count(int bci) {
duke@0 734 if (method_data() != NULL) {
duke@0 735 ResourceMark rm;
duke@0 736 ciProfileData* data = method_data()->bci_to_data(bci);
duke@0 737 if (data != NULL && data->is_CounterData()) {
duke@0 738 return scale_count(data->as_CounterData()->count());
duke@0 739 }
duke@0 740 }
duke@0 741 return -1; // unknown
duke@0 742 }
duke@0 743
duke@0 744 // ------------------------------------------------------------------
duke@0 745 // Adjust a CounterData count to be commensurate with
duke@0 746 // interpreter_invocation_count. If the MDO exists for
duke@0 747 // only 25% of the time the method exists, then the
duke@0 748 // counts in the MDO should be scaled by 4X, so that
duke@0 749 // they can be usefully and stably compared against the
duke@0 750 // invocation counts in methods.
duke@0 751 int ciMethod::scale_count(int count, float prof_factor) {
duke@0 752 if (count > 0 && method_data() != NULL) {
iveresov@1707 753 int counter_life;
duke@0 754 int method_life = interpreter_invocation_count();
iveresov@1707 755 if (TieredCompilation) {
iveresov@1707 756 // In tiered the MDO's life is measured directly, so just use the snapshotted counters
iveresov@1707 757 counter_life = MAX2(method_data()->invocation_count(), method_data()->backedge_count());
iveresov@1707 758 } else {
iveresov@1707 759 int current_mileage = method_data()->current_mileage();
iveresov@1707 760 int creation_mileage = method_data()->creation_mileage();
iveresov@1707 761 counter_life = current_mileage - creation_mileage;
iveresov@1707 762 }
iveresov@1707 763
duke@0 764 // counter_life due to backedge_counter could be > method_life
duke@0 765 if (counter_life > method_life)
duke@0 766 counter_life = method_life;
duke@0 767 if (0 < counter_life && counter_life <= method_life) {
duke@0 768 count = (int)((double)count * prof_factor * method_life / counter_life + 0.5);
duke@0 769 count = (count > 0) ? count : 1;
duke@0 770 }
duke@0 771 }
duke@0 772 return count;
duke@0 773 }
duke@0 774
duke@0 775 // ------------------------------------------------------------------
jrose@710 776 // invokedynamic support
twisti@1485 777
twisti@1485 778 // ------------------------------------------------------------------
twisti@3582 779 // ciMethod::is_method_handle_intrinsic
jrose@710 780 //
twisti@3582 781 // Return true if the method is an instance of the JVM-generated
twisti@3582 782 // signature-polymorphic MethodHandle methods, _invokeBasic, _linkToVirtual, etc.
twisti@3582 783 bool ciMethod::is_method_handle_intrinsic() const {
twisti@3582 784 vmIntrinsics::ID iid = _intrinsic_id; // do not check if loaded
twisti@3582 785 return (MethodHandles::is_signature_polymorphic(iid) &&
twisti@3582 786 MethodHandles::is_signature_polymorphic_intrinsic(iid));
jrose@710 787 }
jrose@710 788
twisti@1485 789 // ------------------------------------------------------------------
twisti@3582 790 // ciMethod::is_compiled_lambda_form
twisti@1485 791 //
twisti@1485 792 // Return true if the method is a generated MethodHandle adapter.
twisti@3582 793 // These are built by Java code.
twisti@3582 794 bool ciMethod::is_compiled_lambda_form() const {
twisti@3582 795 vmIntrinsics::ID iid = _intrinsic_id; // do not check if loaded
twisti@3582 796 return iid == vmIntrinsics::_compiledLambdaForm;
twisti@1152 797 }
twisti@1152 798
twisti@3582 799 // ------------------------------------------------------------------
twisti@3582 800 // ciMethod::has_member_arg
twisti@3582 801 //
twisti@3582 802 // Return true if the method is a linker intrinsic like _linkToVirtual.
twisti@3582 803 // These are built by the JVM.
twisti@3582 804 bool ciMethod::has_member_arg() const {
twisti@3582 805 vmIntrinsics::ID iid = _intrinsic_id; // do not check if loaded
twisti@3582 806 return (MethodHandles::is_signature_polymorphic(iid) &&
twisti@3582 807 MethodHandles::has_member_arg(iid));
jrose@710 808 }
jrose@710 809
jrose@710 810 // ------------------------------------------------------------------
iveresov@1920 811 // ciMethod::ensure_method_data
duke@0 812 //
coleenp@3656 813 // Generate new MethodData* objects at compile time.
iveresov@1920 814 // Return true if allocation was successful or no MDO is required.
iveresov@1920 815 bool ciMethod::ensure_method_data(methodHandle h_m) {
duke@0 816 EXCEPTION_CONTEXT;
iveresov@1920 817 if (is_native() || is_abstract() || h_m()->is_accessor()) return true;
duke@0 818 if (h_m()->method_data() == NULL) {
coleenp@3656 819 Method::build_interpreter_method_data(h_m, THREAD);
duke@0 820 if (HAS_PENDING_EXCEPTION) {
duke@0 821 CLEAR_PENDING_EXCEPTION;
duke@0 822 }
duke@0 823 }
duke@0 824 if (h_m()->method_data() != NULL) {
coleenp@3656 825 _method_data = CURRENT_ENV->get_method_data(h_m()->method_data());
duke@0 826 _method_data->load_data();
iveresov@1920 827 return true;
duke@0 828 } else {
duke@0 829 _method_data = CURRENT_ENV->get_empty_methodData();
iveresov@1920 830 return false;
duke@0 831 }
duke@0 832 }
duke@0 833
duke@0 834 // public, retroactive version
iveresov@1920 835 bool ciMethod::ensure_method_data() {
iveresov@1920 836 bool result = true;
duke@0 837 if (_method_data == NULL || _method_data->is_empty()) {
duke@0 838 GUARDED_VM_ENTRY({
coleenp@3656 839 result = ensure_method_data(get_Method());
duke@0 840 });
duke@0 841 }
iveresov@1920 842 return result;
duke@0 843 }
duke@0 844
duke@0 845
duke@0 846 // ------------------------------------------------------------------
duke@0 847 // ciMethod::method_data
duke@0 848 //
duke@0 849 ciMethodData* ciMethod::method_data() {
duke@0 850 if (_method_data != NULL) {
duke@0 851 return _method_data;
duke@0 852 }
duke@0 853 VM_ENTRY_MARK;
duke@0 854 ciEnv* env = CURRENT_ENV;
duke@0 855 Thread* my_thread = JavaThread::current();
coleenp@3656 856 methodHandle h_m(my_thread, get_Method());
duke@0 857
duke@0 858 if (h_m()->method_data() != NULL) {
coleenp@3656 859 _method_data = CURRENT_ENV->get_method_data(h_m()->method_data());
duke@0 860 _method_data->load_data();
duke@0 861 } else {
duke@0 862 _method_data = CURRENT_ENV->get_empty_methodData();
duke@0 863 }
duke@0 864 return _method_data;
duke@0 865
duke@0 866 }
duke@0 867
iveresov@1920 868 // ------------------------------------------------------------------
iveresov@1920 869 // ciMethod::method_data_or_null
iveresov@1920 870 // Returns a pointer to ciMethodData if MDO exists on the VM side,
iveresov@1920 871 // NULL otherwise.
iveresov@1920 872 ciMethodData* ciMethod::method_data_or_null() {
iveresov@1920 873 ciMethodData *md = method_data();
iveresov@1920 874 if (md->is_empty()) return NULL;
iveresov@1920 875 return md;
iveresov@1920 876 }
duke@0 877
duke@0 878 // ------------------------------------------------------------------
duke@0 879 // ciMethod::will_link
duke@0 880 //
duke@0 881 // Will this method link in a specific calling context?
duke@0 882 bool ciMethod::will_link(ciKlass* accessing_klass,
duke@0 883 ciKlass* declared_method_holder,
duke@0 884 Bytecodes::Code bc) {
duke@0 885 if (!is_loaded()) {
duke@0 886 // Method lookup failed.
duke@0 887 return false;
duke@0 888 }
duke@0 889
duke@0 890 // The link checks have been front-loaded into the get_method
duke@0 891 // call. This method (ciMethod::will_link()) will be removed
duke@0 892 // in the future.
duke@0 893
duke@0 894 return true;
duke@0 895 }
duke@0 896
duke@0 897 // ------------------------------------------------------------------
duke@0 898 // ciMethod::should_exclude
duke@0 899 //
duke@0 900 // Should this method be excluded from compilation?
duke@0 901 bool ciMethod::should_exclude() {
duke@0 902 check_is_loaded();
duke@0 903 VM_ENTRY_MARK;
coleenp@3656 904 methodHandle mh(THREAD, get_Method());
duke@0 905 bool ignore;
duke@0 906 return CompilerOracle::should_exclude(mh, ignore);
duke@0 907 }
duke@0 908
duke@0 909 // ------------------------------------------------------------------
duke@0 910 // ciMethod::should_inline
duke@0 911 //
duke@0 912 // Should this method be inlined during compilation?
duke@0 913 bool ciMethod::should_inline() {
duke@0 914 check_is_loaded();
duke@0 915 VM_ENTRY_MARK;
coleenp@3656 916 methodHandle mh(THREAD, get_Method());
duke@0 917 return CompilerOracle::should_inline(mh);
duke@0 918 }
duke@0 919
duke@0 920 // ------------------------------------------------------------------
duke@0 921 // ciMethod::should_not_inline
duke@0 922 //
duke@0 923 // Should this method be disallowed from inlining during compilation?
duke@0 924 bool ciMethod::should_not_inline() {
duke@0 925 check_is_loaded();
duke@0 926 VM_ENTRY_MARK;
coleenp@3656 927 methodHandle mh(THREAD, get_Method());
duke@0 928 return CompilerOracle::should_not_inline(mh);
duke@0 929 }
duke@0 930
duke@0 931 // ------------------------------------------------------------------
duke@0 932 // ciMethod::should_print_assembly
duke@0 933 //
duke@0 934 // Should the compiler print the generated code for this method?
duke@0 935 bool ciMethod::should_print_assembly() {
duke@0 936 check_is_loaded();
duke@0 937 VM_ENTRY_MARK;
coleenp@3656 938 methodHandle mh(THREAD, get_Method());
duke@0 939 return CompilerOracle::should_print(mh);
duke@0 940 }
duke@0 941
duke@0 942 // ------------------------------------------------------------------
duke@0 943 // ciMethod::break_at_execute
duke@0 944 //
duke@0 945 // Should the compiler insert a breakpoint into the generated code
duke@0 946 // method?
duke@0 947 bool ciMethod::break_at_execute() {
duke@0 948 check_is_loaded();
duke@0 949 VM_ENTRY_MARK;
coleenp@3656 950 methodHandle mh(THREAD, get_Method());
duke@0 951 return CompilerOracle::should_break_at(mh);
duke@0 952 }
duke@0 953
duke@0 954 // ------------------------------------------------------------------
duke@0 955 // ciMethod::has_option
duke@0 956 //
duke@0 957 bool ciMethod::has_option(const char* option) {
duke@0 958 check_is_loaded();
duke@0 959 VM_ENTRY_MARK;
coleenp@3656 960 methodHandle mh(THREAD, get_Method());
duke@0 961 return CompilerOracle::has_option_string(mh, option);
duke@0 962 }
duke@0 963
duke@0 964 // ------------------------------------------------------------------
duke@0 965 // ciMethod::can_be_compiled
duke@0 966 //
duke@0 967 // Have previous compilations of this method succeeded?
duke@0 968 bool ciMethod::can_be_compiled() {
duke@0 969 check_is_loaded();
iveresov@1707 970 ciEnv* env = CURRENT_ENV;
iveresov@1707 971 if (is_c1_compile(env->comp_level())) {
iveresov@1707 972 return _is_c1_compilable;
iveresov@1707 973 }
iveresov@1707 974 return _is_c2_compilable;
duke@0 975 }
duke@0 976
duke@0 977 // ------------------------------------------------------------------
duke@0 978 // ciMethod::set_not_compilable
duke@0 979 //
duke@0 980 // Tell the VM that this method cannot be compiled at all.
duke@0 981 void ciMethod::set_not_compilable() {
duke@0 982 check_is_loaded();
duke@0 983 VM_ENTRY_MARK;
iveresov@1707 984 ciEnv* env = CURRENT_ENV;
iveresov@1707 985 if (is_c1_compile(env->comp_level())) {
iveresov@1707 986 _is_c1_compilable = false;
iveresov@1707 987 } else {
iveresov@1707 988 _is_c2_compilable = false;
iveresov@1707 989 }
coleenp@3656 990 get_Method()->set_not_compilable(env->comp_level());
duke@0 991 }
duke@0 992
duke@0 993 // ------------------------------------------------------------------
duke@0 994 // ciMethod::can_be_osr_compiled
duke@0 995 //
duke@0 996 // Have previous compilations of this method succeeded?
duke@0 997 //
duke@0 998 // Implementation note: the VM does not currently keep track
duke@0 999 // of failed OSR compilations per bci. The entry_bci parameter
duke@0 1000 // is currently unused.
duke@0 1001 bool ciMethod::can_be_osr_compiled(int entry_bci) {
duke@0 1002 check_is_loaded();
duke@0 1003 VM_ENTRY_MARK;
iveresov@1707 1004 ciEnv* env = CURRENT_ENV;
coleenp@3656 1005 return !get_Method()->is_not_osr_compilable(env->comp_level());
duke@0 1006 }
duke@0 1007
duke@0 1008 // ------------------------------------------------------------------
duke@0 1009 // ciMethod::has_compiled_code
duke@0 1010 bool ciMethod::has_compiled_code() {
minqi@3897 1011 return instructions_size() > 0;
duke@0 1012 }
duke@0 1013
iveresov@1707 1014 int ciMethod::comp_level() {
iveresov@1707 1015 check_is_loaded();
iveresov@1707 1016 VM_ENTRY_MARK;
coleenp@3656 1017 nmethod* nm = get_Method()->code();
iveresov@1707 1018 if (nm != NULL) return nm->comp_level();
iveresov@1707 1019 return 0;
iveresov@1707 1020 }
iveresov@1707 1021
iveresov@2563 1022 int ciMethod::highest_osr_comp_level() {
iveresov@2563 1023 check_is_loaded();
iveresov@2563 1024 VM_ENTRY_MARK;
coleenp@3656 1025 return get_Method()->highest_osr_comp_level();
iveresov@2563 1026 }
iveresov@2563 1027
duke@0 1028 // ------------------------------------------------------------------
twisti@2672 1029 // ciMethod::code_size_for_inlining
twisti@2672 1030 //
twisti@3582 1031 // Code size for inlining decisions. This method returns a code
twisti@3582 1032 // size of 1 for methods which has the ForceInline annotation.
twisti@2672 1033 int ciMethod::code_size_for_inlining() {
twisti@2672 1034 check_is_loaded();
coleenp@3656 1035 if (get_Method()->force_inline()) {
twisti@3582 1036 return 1;
twisti@2672 1037 }
twisti@2672 1038 return code_size();
twisti@2672 1039 }
twisti@2672 1040
twisti@2672 1041 // ------------------------------------------------------------------
duke@0 1042 // ciMethod::instructions_size
twisti@1672 1043 //
twisti@1672 1044 // This is a rough metric for "fat" methods, compared before inlining
twisti@1672 1045 // with InlineSmallCode. The CodeBlob::code_size accessor includes
twisti@1672 1046 // junk like exception handler, stubs, and constant table, which are
twisti@1672 1047 // not highly relevant to an inlined method. So we use the more
twisti@1672 1048 // specific accessor nmethod::insts_size.
minqi@3897 1049 int ciMethod::instructions_size() {
minqi@3897 1050 if (_instructions_size == -1) {
minqi@3897 1051 GUARDED_VM_ENTRY(
minqi@3897 1052 nmethod* code = get_Method()->code();
minqi@3897 1053 if (code != NULL && (code->comp_level() == CompLevel_full_optimization)) {
minqi@3897 1054 _instructions_size = code->insts_end() - code->verified_entry_point();
minqi@3897 1055 } else {
minqi@3897 1056 _instructions_size = 0;
minqi@3897 1057 }
minqi@3897 1058 );
minqi@3897 1059 }
minqi@3897 1060 return _instructions_size;
duke@0 1061 }
duke@0 1062
duke@0 1063 // ------------------------------------------------------------------
duke@0 1064 // ciMethod::log_nmethod_identity
duke@0 1065 void ciMethod::log_nmethod_identity(xmlStream* log) {
duke@0 1066 GUARDED_VM_ENTRY(
coleenp@3656 1067 nmethod* code = get_Method()->code();
duke@0 1068 if (code != NULL) {
duke@0 1069 code->log_identity(log);
duke@0 1070 }
duke@0 1071 )
duke@0 1072 }
duke@0 1073
duke@0 1074 // ------------------------------------------------------------------
duke@0 1075 // ciMethod::is_not_reached
duke@0 1076 bool ciMethod::is_not_reached(int bci) {
duke@0 1077 check_is_loaded();
duke@0 1078 VM_ENTRY_MARK;
duke@0 1079 return Interpreter::is_not_reached(
coleenp@3656 1080 methodHandle(THREAD, get_Method()), bci);
duke@0 1081 }
duke@0 1082
duke@0 1083 // ------------------------------------------------------------------
duke@0 1084 // ciMethod::was_never_executed
duke@0 1085 bool ciMethod::was_executed_more_than(int times) {
duke@0 1086 VM_ENTRY_MARK;
coleenp@3656 1087 return get_Method()->was_executed_more_than(times);
duke@0 1088 }
duke@0 1089
duke@0 1090 // ------------------------------------------------------------------
duke@0 1091 // ciMethod::has_unloaded_classes_in_signature
duke@0 1092 bool ciMethod::has_unloaded_classes_in_signature() {
duke@0 1093 VM_ENTRY_MARK;
duke@0 1094 {
duke@0 1095 EXCEPTION_MARK;
coleenp@3656 1096 methodHandle m(THREAD, get_Method());
coleenp@3656 1097 bool has_unloaded = Method::has_unloaded_classes_in_signature(m, (JavaThread *)THREAD);
duke@0 1098 if( HAS_PENDING_EXCEPTION ) {
duke@0 1099 CLEAR_PENDING_EXCEPTION;
duke@0 1100 return true; // Declare that we may have unloaded classes
duke@0 1101 }
duke@0 1102 return has_unloaded;
duke@0 1103 }
duke@0 1104 }
duke@0 1105
duke@0 1106 // ------------------------------------------------------------------
duke@0 1107 // ciMethod::is_klass_loaded
duke@0 1108 bool ciMethod::is_klass_loaded(int refinfo_index, bool must_be_resolved) const {
duke@0 1109 VM_ENTRY_MARK;
coleenp@3656 1110 return get_Method()->is_klass_loaded(refinfo_index, must_be_resolved);
duke@0 1111 }
duke@0 1112
duke@0 1113 // ------------------------------------------------------------------
duke@0 1114 // ciMethod::check_call
duke@0 1115 bool ciMethod::check_call(int refinfo_index, bool is_static) const {
duke@0 1116 VM_ENTRY_MARK;
duke@0 1117 {
duke@0 1118 EXCEPTION_MARK;
duke@0 1119 HandleMark hm(THREAD);
coleenp@3656 1120 constantPoolHandle pool (THREAD, get_Method()->constants());
duke@0 1121 methodHandle spec_method;
duke@0 1122 KlassHandle spec_klass;
twisti@3582 1123 Bytecodes::Code code = (is_static ? Bytecodes::_invokestatic : Bytecodes::_invokevirtual);
twisti@3582 1124 LinkResolver::resolve_method_statically(spec_method, spec_klass, code, pool, refinfo_index, THREAD);
duke@0 1125 if (HAS_PENDING_EXCEPTION) {
duke@0 1126 CLEAR_PENDING_EXCEPTION;
duke@0 1127 return false;
duke@0 1128 } else {
duke@0 1129 return (spec_method->is_static() == is_static);
duke@0 1130 }
duke@0 1131 }
duke@0 1132 return false;
duke@0 1133 }
duke@0 1134
duke@0 1135 // ------------------------------------------------------------------
duke@0 1136 // ciMethod::print_codes
duke@0 1137 //
duke@0 1138 // Print the bytecodes for this method.
duke@0 1139 void ciMethod::print_codes_on(outputStream* st) {
duke@0 1140 check_is_loaded();
coleenp@3656 1141 GUARDED_VM_ENTRY(get_Method()->print_codes_on(st);)
duke@0 1142 }
duke@0 1143
duke@0 1144
duke@0 1145 #define FETCH_FLAG_FROM_VM(flag_accessor) { \
duke@0 1146 check_is_loaded(); \
duke@0 1147 VM_ENTRY_MARK; \
coleenp@3656 1148 return get_Method()->flag_accessor(); \
duke@0 1149 }
duke@0 1150
duke@0 1151 bool ciMethod::is_empty_method() const { FETCH_FLAG_FROM_VM(is_empty_method); }
duke@0 1152 bool ciMethod::is_vanilla_constructor() const { FETCH_FLAG_FROM_VM(is_vanilla_constructor); }
duke@0 1153 bool ciMethod::has_loops () const { FETCH_FLAG_FROM_VM(has_loops); }
duke@0 1154 bool ciMethod::has_jsrs () const { FETCH_FLAG_FROM_VM(has_jsrs); }
duke@0 1155 bool ciMethod::is_accessor () const { FETCH_FLAG_FROM_VM(is_accessor); }
duke@0 1156 bool ciMethod::is_initializer () const { FETCH_FLAG_FROM_VM(is_initializer); }
duke@0 1157
duke@0 1158 BCEscapeAnalyzer *ciMethod::get_bcea() {
kvn@1570 1159 #ifdef COMPILER2
duke@0 1160 if (_bcea == NULL) {
duke@0 1161 _bcea = new (CURRENT_ENV->arena()) BCEscapeAnalyzer(this, NULL);
duke@0 1162 }
duke@0 1163 return _bcea;
kvn@1570 1164 #else // COMPILER2
kvn@1570 1165 ShouldNotReachHere();
kvn@1570 1166 return NULL;
kvn@1570 1167 #endif // COMPILER2
duke@0 1168 }
duke@0 1169
duke@0 1170 ciMethodBlocks *ciMethod::get_method_blocks() {
duke@0 1171 Arena *arena = CURRENT_ENV->arena();
duke@0 1172 if (_method_blocks == NULL) {
duke@0 1173 _method_blocks = new (arena) ciMethodBlocks(arena, this);
duke@0 1174 }
duke@0 1175 return _method_blocks;
duke@0 1176 }
duke@0 1177
duke@0 1178 #undef FETCH_FLAG_FROM_VM
duke@0 1179
minqi@3897 1180 void ciMethod::dump_replay_data(outputStream* st) {
minqi@3897 1181 ASSERT_IN_VM;
minqi@3897 1182 Method* method = get_Method();
minqi@3897 1183 Klass* holder = method->method_holder();
minqi@3897 1184 st->print_cr("ciMethod %s %s %s %d %d %d %d %d",
minqi@3897 1185 holder->name()->as_quoted_ascii(),
minqi@3897 1186 method->name()->as_quoted_ascii(),
minqi@3897 1187 method->signature()->as_quoted_ascii(),
minqi@3897 1188 method->invocation_counter()->raw_counter(),
minqi@3897 1189 method->backedge_counter()->raw_counter(),
minqi@3897 1190 interpreter_invocation_count(),
minqi@3897 1191 interpreter_throwout_count(),
minqi@3897 1192 _instructions_size);
minqi@3897 1193 }
duke@0 1194
duke@0 1195 // ------------------------------------------------------------------
duke@0 1196 // ciMethod::print_codes
duke@0 1197 //
duke@0 1198 // Print a range of the bytecodes for this method.
duke@0 1199 void ciMethod::print_codes_on(int from, int to, outputStream* st) {
duke@0 1200 check_is_loaded();
coleenp@3656 1201 GUARDED_VM_ENTRY(get_Method()->print_codes_on(from, to, st);)
duke@0 1202 }
duke@0 1203
duke@0 1204 // ------------------------------------------------------------------
duke@0 1205 // ciMethod::print_name
duke@0 1206 //
duke@0 1207 // Print the name of this method, including signature and some flags.
duke@0 1208 void ciMethod::print_name(outputStream* st) {
duke@0 1209 check_is_loaded();
coleenp@3656 1210 GUARDED_VM_ENTRY(get_Method()->print_name(st);)
duke@0 1211 }
duke@0 1212
duke@0 1213 // ------------------------------------------------------------------
duke@0 1214 // ciMethod::print_short_name
duke@0 1215 //
duke@0 1216 // Print the name of this method, without signature.
duke@0 1217 void ciMethod::print_short_name(outputStream* st) {
twisti@3582 1218 if (is_loaded()) {
coleenp@3656 1219 GUARDED_VM_ENTRY(get_Method()->print_short_name(st););
twisti@3582 1220 } else {
twisti@3582 1221 // Fall back if method is not loaded.
twisti@3582 1222 holder()->print_name_on(st);
twisti@3582 1223 st->print("::");
twisti@3582 1224 name()->print_symbol_on(st);
twisti@3582 1225 if (WizardMode)
twisti@3582 1226 signature()->as_symbol()->print_symbol_on(st);
twisti@3582 1227 }
duke@0 1228 }
duke@0 1229
duke@0 1230 // ------------------------------------------------------------------
duke@0 1231 // ciMethod::print_impl
duke@0 1232 //
duke@0 1233 // Implementation of the print method.
duke@0 1234 void ciMethod::print_impl(outputStream* st) {
coleenp@3656 1235 ciMetadata::print_impl(st);
duke@0 1236 st->print(" name=");
duke@0 1237 name()->print_symbol_on(st);
duke@0 1238 st->print(" holder=");
duke@0 1239 holder()->print_name_on(st);
duke@0 1240 st->print(" signature=");
duke@0 1241 signature()->as_symbol()->print_symbol_on(st);
duke@0 1242 if (is_loaded()) {
twisti@3641 1243 st->print(" loaded=true");
twisti@3641 1244 st->print(" arg_size=%d", arg_size());
twisti@3641 1245 st->print(" flags=");
duke@0 1246 flags().print_member_flags(st);
duke@0 1247 } else {
duke@0 1248 st->print(" loaded=false");
duke@0 1249 }
duke@0 1250 }