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