1 /*
   2  * Copyright (c) 1999, 2017, 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/ciReplay.hpp"
  35 #include "ci/ciUtilities.inline.hpp"
  36 #include "classfile/systemDictionary.hpp"
  37 #include "compiler/abstractCompiler.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/method.inline.hpp"
  46 #include "oops/oop.inline.hpp"
  47 #include "prims/nativeLookup.hpp"
  48 #include "runtime/deoptimization.hpp"
  49 #include "utilities/bitMap.inline.hpp"
  50 #include "utilities/xmlstream.hpp"
  51 #include "trace/tracing.hpp"
  52 #ifdef COMPILER2
  53 #include "ci/bcEscapeAnalyzer.hpp"
  54 #include "ci/ciTypeFlow.hpp"
  55 #include "oops/method.hpp"
  56 #endif
  57 
  58 // ciMethod
  59 //
  60 // This class represents a Method* in the HotSpot virtual
  61 // machine.
  62 
  63 
  64 // ------------------------------------------------------------------
  65 // ciMethod::ciMethod
  66 //
  67 // Loaded method.
  68 ciMethod::ciMethod(const methodHandle& h_m, ciInstanceKlass* holder) :
  69   ciMetadata(h_m()),
  70   _holder(holder)
  71 {
  72   assert(h_m() != NULL, "no null method");
  73 
  74   if (LogTouchedMethods) {
  75     h_m()->log_touched(Thread::current());
  76   }
  77   // These fields are always filled in in loaded methods.
  78   _flags = ciFlags(h_m()->access_flags());
  79 
  80   // Easy to compute, so fill them in now.
  81   _max_stack          = h_m()->max_stack();
  82   _max_locals         = h_m()->max_locals();
  83   _code_size          = h_m()->code_size();
  84   _intrinsic_id       = h_m()->intrinsic_id();
  85   _handler_count      = h_m()->exception_table_length();
  86   _size_of_parameters = h_m()->size_of_parameters();
  87   _uses_monitors      = h_m()->access_flags().has_monitor_bytecodes();
  88   _balanced_monitors  = !_uses_monitors || h_m()->access_flags().is_monitor_matching();
  89   _is_c1_compilable   = !h_m()->is_not_c1_compilable();
  90   _is_c2_compilable   = !h_m()->is_not_c2_compilable();
  91   _can_be_parsed      = true;
  92   _has_reserved_stack_access = h_m()->has_reserved_stack_access();
  93   // Lazy fields, filled in on demand.  Require allocation.
  94   _code               = NULL;
  95   _exception_handlers = NULL;
  96   _liveness           = NULL;
  97   _method_blocks = NULL;
  98 #if defined(COMPILER2)
  99   _flow               = NULL;
 100   _bcea               = NULL;
 101 #endif // COMPILER2
 102 
 103   ciEnv *env = CURRENT_ENV;
 104   if (env->jvmti_can_hotswap_or_post_breakpoint()) {
 105     // 6328518 check hotswap conditions under the right lock.
 106     MutexLocker locker(Compile_lock);
 107     if (Dependencies::check_evol_method(h_m()) != NULL) {
 108       _is_c1_compilable = false;
 109       _is_c2_compilable = false;
 110       _can_be_parsed = false;
 111     }
 112   } else {
 113     CHECK_UNHANDLED_OOPS_ONLY(Thread::current()->clear_unhandled_oops());
 114   }
 115 
 116   if (h_m()->method_holder()->is_linked()) {
 117     _can_be_statically_bound = h_m()->can_be_statically_bound();
 118   } else {
 119     // Have to use a conservative value in this case.
 120     _can_be_statically_bound = false;
 121   }
 122 
 123   // Adjust the definition of this condition to be more useful:
 124   // %%% take these conditions into account in vtable generation
 125   if (!_can_be_statically_bound && h_m()->is_private())
 126     _can_be_statically_bound = true;
 127   if (_can_be_statically_bound && h_m()->is_abstract())
 128     _can_be_statically_bound = false;
 129 
 130   // generating _signature may allow GC and therefore move m.
 131   // These fields are always filled in.
 132   _name = env->get_symbol(h_m()->name());
 133   ciSymbol* sig_symbol = env->get_symbol(h_m()->signature());
 134   constantPoolHandle cpool = h_m()->constants();
 135   _signature = new (env->arena()) ciSignature(_holder, cpool, sig_symbol);
 136   _method_data = NULL;
 137   _nmethod_age = h_m()->nmethod_age();
 138   // Take a snapshot of these values, so they will be commensurate with the MDO.
 139   if (ProfileInterpreter || TieredCompilation) {
 140     int invcnt = h_m()->interpreter_invocation_count();
 141     // if the value overflowed report it as max int
 142     _interpreter_invocation_count = invcnt < 0 ? max_jint : invcnt ;
 143     _interpreter_throwout_count   = h_m()->interpreter_throwout_count();
 144   } else {
 145     _interpreter_invocation_count = 0;
 146     _interpreter_throwout_count = 0;
 147   }
 148   if (_interpreter_invocation_count == 0)
 149     _interpreter_invocation_count = 1;
 150   _instructions_size = -1;
 151 #ifdef ASSERT
 152   if (ReplayCompiles) {
 153     ciReplay::initialize(this);
 154   }
 155 #endif
 156 }
 157 
 158 
 159 // ------------------------------------------------------------------
 160 // ciMethod::ciMethod
 161 //
 162 // Unloaded method.
 163 ciMethod::ciMethod(ciInstanceKlass* holder,
 164                    ciSymbol*        name,
 165                    ciSymbol*        signature,
 166                    ciInstanceKlass* accessor) :
 167   ciMetadata((Metadata*)NULL),
 168   _name(                   name),
 169   _holder(                 holder),
 170   _intrinsic_id(           vmIntrinsics::_none),
 171   _liveness(               NULL),
 172   _can_be_statically_bound(false),
 173   _method_blocks(          NULL),
 174   _method_data(            NULL)
 175 #if defined(COMPILER2)
 176   ,
 177   _flow(                   NULL),
 178   _bcea(                   NULL),
 179   _instructions_size(-1)
 180 #endif // COMPILER2
 181 {
 182   // Usually holder and accessor are the same type but in some cases
 183   // the holder has the wrong class loader (e.g. invokedynamic call
 184   // sites) so we pass the accessor.
 185   _signature = new (CURRENT_ENV->arena()) ciSignature(accessor, constantPoolHandle(), signature);
 186 }
 187 
 188 
 189 // ------------------------------------------------------------------
 190 // ciMethod::load_code
 191 //
 192 // Load the bytecodes and exception handler table for this method.
 193 void ciMethod::load_code() {
 194   VM_ENTRY_MARK;
 195   assert(is_loaded(), "only loaded methods have code");
 196 
 197   Method* me = get_Method();
 198   Arena* arena = CURRENT_THREAD_ENV->arena();
 199 
 200   // Load the bytecodes.
 201   _code = (address)arena->Amalloc(code_size());
 202   memcpy(_code, me->code_base(), code_size());
 203 
 204 #if INCLUDE_JVMTI
 205   // Revert any breakpoint bytecodes in ci's copy
 206   if (me->number_of_breakpoints() > 0) {
 207     BreakpointInfo* bp = me->method_holder()->breakpoints();
 208     for (; bp != NULL; bp = bp->next()) {
 209       if (bp->match(me)) {
 210         code_at_put(bp->bci(), bp->orig_bytecode());
 211       }
 212     }
 213   }
 214 #endif
 215 
 216   // And load the exception table.
 217   ExceptionTable exc_table(me);
 218 
 219   // Allocate one extra spot in our list of exceptions.  This
 220   // last entry will be used to represent the possibility that
 221   // an exception escapes the method.  See ciExceptionHandlerStream
 222   // for details.
 223   _exception_handlers =
 224     (ciExceptionHandler**)arena->Amalloc(sizeof(ciExceptionHandler*)
 225                                          * (_handler_count + 1));
 226   if (_handler_count > 0) {
 227     for (int i=0; i<_handler_count; i++) {
 228       _exception_handlers[i] = new (arena) ciExceptionHandler(
 229                                 holder(),
 230             /* start    */      exc_table.start_pc(i),
 231             /* limit    */      exc_table.end_pc(i),
 232             /* goto pc  */      exc_table.handler_pc(i),
 233             /* cp index */      exc_table.catch_type_index(i));
 234     }
 235   }
 236 
 237   // Put an entry at the end of our list to represent the possibility
 238   // of exceptional exit.
 239   _exception_handlers[_handler_count] =
 240     new (arena) ciExceptionHandler(holder(), 0, code_size(), -1, 0);
 241 
 242   if (CIPrintMethodCodes) {
 243     print_codes();
 244   }
 245 }
 246 
 247 
 248 // ------------------------------------------------------------------
 249 // ciMethod::has_linenumber_table
 250 //
 251 // length unknown until decompression
 252 bool    ciMethod::has_linenumber_table() const {
 253   check_is_loaded();
 254   VM_ENTRY_MARK;
 255   return get_Method()->has_linenumber_table();
 256 }
 257 
 258 
 259 // ------------------------------------------------------------------
 260 // ciMethod::compressed_linenumber_table
 261 u_char* ciMethod::compressed_linenumber_table() const {
 262   check_is_loaded();
 263   VM_ENTRY_MARK;
 264   return get_Method()->compressed_linenumber_table();
 265 }
 266 
 267 
 268 // ------------------------------------------------------------------
 269 // ciMethod::line_number_from_bci
 270 int ciMethod::line_number_from_bci(int bci) const {
 271   check_is_loaded();
 272   VM_ENTRY_MARK;
 273   return get_Method()->line_number_from_bci(bci);
 274 }
 275 
 276 
 277 // ------------------------------------------------------------------
 278 // ciMethod::vtable_index
 279 //
 280 // Get the position of this method's entry in the vtable, if any.
 281 int ciMethod::vtable_index() {
 282   check_is_loaded();
 283   assert(holder()->is_linked(), "must be linked");
 284   VM_ENTRY_MARK;
 285   return get_Method()->vtable_index();
 286 }
 287 
 288 
 289 // ------------------------------------------------------------------
 290 // ciMethod::native_entry
 291 //
 292 // Get the address of this method's native code, if any.
 293 address ciMethod::native_entry() {
 294   check_is_loaded();
 295   assert(flags().is_native(), "must be native method");
 296   VM_ENTRY_MARK;
 297   Method* method = get_Method();
 298   address entry = method->native_function();
 299   assert(entry != NULL, "must be valid entry point");
 300   return entry;
 301 }
 302 
 303 
 304 // ------------------------------------------------------------------
 305 // ciMethod::interpreter_entry
 306 //
 307 // Get the entry point for running this method in the interpreter.
 308 address ciMethod::interpreter_entry() {
 309   check_is_loaded();
 310   VM_ENTRY_MARK;
 311   methodHandle mh(THREAD, get_Method());
 312   return Interpreter::entry_for_method(mh);
 313 }
 314 
 315 
 316 // ------------------------------------------------------------------
 317 // ciMethod::uses_balanced_monitors
 318 //
 319 // Does this method use monitors in a strict stack-disciplined manner?
 320 bool ciMethod::has_balanced_monitors() {
 321   check_is_loaded();
 322   if (_balanced_monitors) return true;
 323 
 324   // Analyze the method to see if monitors are used properly.
 325   VM_ENTRY_MARK;
 326   methodHandle method(THREAD, get_Method());
 327   assert(method->has_monitor_bytecodes(), "should have checked this");
 328 
 329   // Check to see if a previous compilation computed the
 330   // monitor-matching analysis.
 331   if (method->guaranteed_monitor_matching()) {
 332     _balanced_monitors = true;
 333     return true;
 334   }
 335 
 336   {
 337     EXCEPTION_MARK;
 338     ResourceMark rm(THREAD);
 339     GeneratePairingInfo gpi(method);
 340     gpi.compute_map(CATCH);
 341     if (!gpi.monitor_safe()) {
 342       return false;
 343     }
 344     method->set_guaranteed_monitor_matching();
 345     _balanced_monitors = true;
 346   }
 347   return true;
 348 }
 349 
 350 
 351 // ------------------------------------------------------------------
 352 // ciMethod::get_flow_analysis
 353 ciTypeFlow* ciMethod::get_flow_analysis() {
 354 #if defined(COMPILER2)
 355   if (_flow == NULL) {
 356     ciEnv* env = CURRENT_ENV;
 357     _flow = new (env->arena()) ciTypeFlow(env, this);
 358     _flow->do_flow();
 359   }
 360   return _flow;
 361 #else // COMPILER2
 362   ShouldNotReachHere();
 363   return NULL;
 364 #endif // COMPILER2
 365 }
 366 
 367 
 368 // ------------------------------------------------------------------
 369 // ciMethod::get_osr_flow_analysis
 370 ciTypeFlow* ciMethod::get_osr_flow_analysis(int osr_bci) {
 371 #if defined(COMPILER2)
 372   // OSR entry points are always place after a call bytecode of some sort
 373   assert(osr_bci >= 0, "must supply valid OSR entry point");
 374   ciEnv* env = CURRENT_ENV;
 375   ciTypeFlow* flow = new (env->arena()) ciTypeFlow(env, this, osr_bci);
 376   flow->do_flow();
 377   return flow;
 378 #else // COMPILER2
 379   ShouldNotReachHere();
 380   return NULL;
 381 #endif // COMPILER2
 382 }
 383 
 384 // ------------------------------------------------------------------
 385 // ciMethod::raw_liveness_at_bci
 386 //
 387 // Which local variables are live at a specific bci?
 388 MethodLivenessResult ciMethod::raw_liveness_at_bci(int bci) {
 389   check_is_loaded();
 390   if (_liveness == NULL) {
 391     // Create the liveness analyzer.
 392     Arena* arena = CURRENT_ENV->arena();
 393     _liveness = new (arena) MethodLiveness(arena, this);
 394     _liveness->compute_liveness();
 395   }
 396   return _liveness->get_liveness_at(bci);
 397 }
 398 
 399 // ------------------------------------------------------------------
 400 // ciMethod::liveness_at_bci
 401 //
 402 // Which local variables are live at a specific bci?  When debugging
 403 // will return true for all locals in some cases to improve debug
 404 // information.
 405 MethodLivenessResult ciMethod::liveness_at_bci(int bci) {
 406   MethodLivenessResult result = raw_liveness_at_bci(bci);
 407   if (CURRENT_ENV->should_retain_local_variables() || DeoptimizeALot || CompileTheWorld) {
 408     // Keep all locals live for the user's edification and amusement.
 409     result.at_put_range(0, result.size(), true);
 410   }
 411   return result;
 412 }
 413 
 414 // ciMethod::live_local_oops_at_bci
 415 //
 416 // find all the live oops in the locals array for a particular bci
 417 // Compute what the interpreter believes by using the interpreter
 418 // oopmap generator. This is used as a double check during osr to
 419 // guard against conservative result from MethodLiveness making us
 420 // think a dead oop is live.  MethodLiveness is conservative in the
 421 // sense that it may consider locals to be live which cannot be live,
 422 // like in the case where a local could contain an oop or  a primitive
 423 // along different paths.  In that case the local must be dead when
 424 // those paths merge. Since the interpreter's viewpoint is used when
 425 // gc'ing an interpreter frame we need to use its viewpoint  during
 426 // OSR when loading the locals.
 427 
 428 ResourceBitMap ciMethod::live_local_oops_at_bci(int bci) {
 429   VM_ENTRY_MARK;
 430   InterpreterOopMap mask;
 431   OopMapCache::compute_one_oop_map(get_Method(), bci, &mask);
 432   int mask_size = max_locals();
 433   ResourceBitMap result(mask_size);
 434   int i;
 435   for (i = 0; i < mask_size ; i++ ) {
 436     if (mask.is_oop(i)) result.set_bit(i);
 437   }
 438   return result;
 439 }
 440 
 441 
 442 #ifdef COMPILER1
 443 // ------------------------------------------------------------------
 444 // ciMethod::bci_block_start
 445 //
 446 // Marks all bcis where a new basic block starts
 447 const BitMap& ciMethod::bci_block_start() {
 448   check_is_loaded();
 449   if (_liveness == NULL) {
 450     // Create the liveness analyzer.
 451     Arena* arena = CURRENT_ENV->arena();
 452     _liveness = new (arena) MethodLiveness(arena, this);
 453     _liveness->compute_liveness();
 454   }
 455 
 456   return _liveness->get_bci_block_start();
 457 }
 458 #endif // COMPILER1
 459 
 460 
 461 // ------------------------------------------------------------------
 462 // ciMethod::call_profile_at_bci
 463 //
 464 // Get the ciCallProfile for the invocation of this method.
 465 // Also reports receiver types for non-call type checks (if TypeProfileCasts).
 466 ciCallProfile ciMethod::call_profile_at_bci(int bci) {
 467   ResourceMark rm;
 468   ciCallProfile result;
 469   if (method_data() != NULL && method_data()->is_mature()) {
 470     ciProfileData* data = method_data()->bci_to_data(bci);
 471     if (data != NULL && data->is_CounterData()) {
 472       // Every profiled call site has a counter.
 473       int count = data->as_CounterData()->count();
 474 
 475       if (!data->is_ReceiverTypeData()) {
 476         result._receiver_count[0] = 0;  // that's a definite zero
 477       } else { // ReceiverTypeData is a subclass of CounterData
 478         ciReceiverTypeData* call = (ciReceiverTypeData*)data->as_ReceiverTypeData();
 479         // In addition, virtual call sites have receiver type information
 480         int receivers_count_total = 0;
 481         int morphism = 0;
 482         // Precompute morphism for the possible fixup
 483         for (uint i = 0; i < call->row_limit(); i++) {
 484           ciKlass* receiver = call->receiver(i);
 485           if (receiver == NULL)  continue;
 486           morphism++;
 487         }
 488         int epsilon = 0;
 489         if (TieredCompilation) {
 490           // For a call, it is assumed that either the type of the receiver(s)
 491           // is recorded or an associated counter is incremented, but not both. With
 492           // tiered compilation, however, both can happen due to the interpreter and
 493           // C1 profiling invocations differently. Address that inconsistency here.
 494           if (morphism == 1 && count > 0) {
 495             epsilon = count;
 496             count = 0;
 497           }
 498         }
 499         for (uint i = 0; i < call->row_limit(); i++) {
 500           ciKlass* receiver = call->receiver(i);
 501           if (receiver == NULL)  continue;
 502           int rcount = call->receiver_count(i) + epsilon;
 503           if (rcount == 0) rcount = 1; // Should be valid value
 504           receivers_count_total += rcount;
 505           // Add the receiver to result data.
 506           result.add_receiver(receiver, rcount);
 507           // If we extend profiling to record methods,
 508           // we will set result._method also.
 509         }
 510         // Determine call site's morphism.
 511         // The call site count is 0 with known morphism (only 1 or 2 receivers)
 512         // or < 0 in the case of a type check failure for checkcast, aastore, instanceof.
 513         // The call site count is > 0 in the case of a polymorphic virtual call.
 514         if (morphism > 0 && morphism == result._limit) {
 515            // The morphism <= MorphismLimit.
 516            if ((morphism <  ciCallProfile::MorphismLimit) ||
 517                (morphism == ciCallProfile::MorphismLimit && count == 0)) {
 518 #ifdef ASSERT
 519              if (count > 0) {
 520                this->print_short_name(tty);
 521                tty->print_cr(" @ bci:%d", bci);
 522                this->print_codes();
 523                assert(false, "this call site should not be polymorphic");
 524              }
 525 #endif
 526              result._morphism = morphism;
 527            }
 528         }
 529         // Make the count consistent if this is a call profile. If count is
 530         // zero or less, presume that this is a typecheck profile and
 531         // do nothing.  Otherwise, increase count to be the sum of all
 532         // receiver's counts.
 533         if (count >= 0) {
 534           count += receivers_count_total;
 535         }
 536       }
 537       result._count = count;
 538     }
 539   }
 540   return result;
 541 }
 542 
 543 // ------------------------------------------------------------------
 544 // Add new receiver and sort data by receiver's profile count.
 545 void ciCallProfile::add_receiver(ciKlass* receiver, int receiver_count) {
 546   // Add new receiver and sort data by receiver's counts when we have space
 547   // for it otherwise replace the less called receiver (less called receiver
 548   // is placed to the last array element which is not used).
 549   // First array's element contains most called receiver.
 550   int i = _limit;
 551   for (; i > 0 && receiver_count > _receiver_count[i-1]; i--) {
 552     _receiver[i] = _receiver[i-1];
 553     _receiver_count[i] = _receiver_count[i-1];
 554   }
 555   _receiver[i] = receiver;
 556   _receiver_count[i] = receiver_count;
 557   if (_limit < MorphismLimit) _limit++;
 558 }
 559 
 560 
 561 void ciMethod::assert_virtual_call_type_ok(int bci) {
 562   assert(java_code_at_bci(bci) == Bytecodes::_invokevirtual ||
 563          java_code_at_bci(bci) == Bytecodes::_invokeinterface, "unexpected bytecode %s", Bytecodes::name(java_code_at_bci(bci)));
 564 }
 565 
 566 void ciMethod::assert_call_type_ok(int bci) {
 567   assert(java_code_at_bci(bci) == Bytecodes::_invokestatic ||
 568          java_code_at_bci(bci) == Bytecodes::_invokespecial ||
 569          java_code_at_bci(bci) == Bytecodes::_invokedynamic, "unexpected bytecode %s", Bytecodes::name(java_code_at_bci(bci)));
 570 }
 571 
 572 /**
 573  * Check whether profiling provides a type for the argument i to the
 574  * call at bci bci
 575  *
 576  * @param [in]bci         bci of the call
 577  * @param [in]i           argument number
 578  * @param [out]type       profiled type of argument, NULL if none
 579  * @param [out]ptr_kind   whether always null, never null or maybe null
 580  * @return                true if profiling exists
 581  *
 582  */
 583 bool ciMethod::argument_profiled_type(int bci, int i, ciKlass*& type, ProfilePtrKind& ptr_kind) {
 584   if (MethodData::profile_parameters() && method_data() != NULL && method_data()->is_mature()) {
 585     ciProfileData* data = method_data()->bci_to_data(bci);
 586     if (data != NULL) {
 587       if (data->is_VirtualCallTypeData()) {
 588         assert_virtual_call_type_ok(bci);
 589         ciVirtualCallTypeData* call = (ciVirtualCallTypeData*)data->as_VirtualCallTypeData();
 590         if (i >= call->number_of_arguments()) {
 591           return false;
 592         }
 593         type = call->valid_argument_type(i);
 594         ptr_kind = call->argument_ptr_kind(i);
 595         return true;
 596       } else if (data->is_CallTypeData()) {
 597         assert_call_type_ok(bci);
 598         ciCallTypeData* call = (ciCallTypeData*)data->as_CallTypeData();
 599         if (i >= call->number_of_arguments()) {
 600           return false;
 601         }
 602         type = call->valid_argument_type(i);
 603         ptr_kind = call->argument_ptr_kind(i);
 604         return true;
 605       }
 606     }
 607   }
 608   return false;
 609 }
 610 
 611 /**
 612  * Check whether profiling provides a type for the return value from
 613  * the call at bci bci
 614  *
 615  * @param [in]bci         bci of the call
 616  * @param [out]type       profiled type of argument, NULL if none
 617  * @param [out]ptr_kind   whether always null, never null or maybe null
 618  * @return                true if profiling exists
 619  *
 620  */
 621 bool ciMethod::return_profiled_type(int bci, ciKlass*& type, ProfilePtrKind& ptr_kind) {
 622   if (MethodData::profile_return() && method_data() != NULL && method_data()->is_mature()) {
 623     ciProfileData* data = method_data()->bci_to_data(bci);
 624     if (data != NULL) {
 625       if (data->is_VirtualCallTypeData()) {
 626         assert_virtual_call_type_ok(bci);
 627         ciVirtualCallTypeData* call = (ciVirtualCallTypeData*)data->as_VirtualCallTypeData();
 628         if (call->has_return()) {
 629           type = call->valid_return_type();
 630           ptr_kind = call->return_ptr_kind();
 631           return true;
 632         }
 633       } else if (data->is_CallTypeData()) {
 634         assert_call_type_ok(bci);
 635         ciCallTypeData* call = (ciCallTypeData*)data->as_CallTypeData();
 636         if (call->has_return()) {
 637           type = call->valid_return_type();
 638           ptr_kind = call->return_ptr_kind();
 639         }
 640         return true;
 641       }
 642     }
 643   }
 644   return false;
 645 }
 646 
 647 /**
 648  * Check whether profiling provides a type for the parameter i
 649  *
 650  * @param [in]i           parameter number
 651  * @param [out]type       profiled type of parameter, NULL if none
 652  * @param [out]ptr_kind   whether always null, never null or maybe null
 653  * @return                true if profiling exists
 654  *
 655  */
 656 bool ciMethod::parameter_profiled_type(int i, ciKlass*& type, ProfilePtrKind& ptr_kind) {
 657   if (MethodData::profile_parameters() && method_data() != NULL && method_data()->is_mature()) {
 658     ciParametersTypeData* parameters = method_data()->parameters_type_data();
 659     if (parameters != NULL && i < parameters->number_of_parameters()) {
 660       type = parameters->valid_parameter_type(i);
 661       ptr_kind = parameters->parameter_ptr_kind(i);
 662       return true;
 663     }
 664   }
 665   return false;
 666 }
 667 
 668 
 669 // ------------------------------------------------------------------
 670 // ciMethod::find_monomorphic_target
 671 //
 672 // Given a certain calling environment, find the monomorphic target
 673 // for the call.  Return NULL if the call is not monomorphic in
 674 // its calling environment, or if there are only abstract methods.
 675 // The returned method is never abstract.
 676 // Note: If caller uses a non-null result, it must inform dependencies
 677 // via assert_unique_concrete_method or assert_leaf_type.
 678 ciMethod* ciMethod::find_monomorphic_target(ciInstanceKlass* caller,
 679                                             ciInstanceKlass* callee_holder,
 680                                             ciInstanceKlass* actual_recv,
 681                                             bool check_access) {
 682   check_is_loaded();
 683 
 684   if (actual_recv->is_interface()) {
 685     // %%% We cannot trust interface types, yet.  See bug 6312651.
 686     return NULL;
 687   }
 688 
 689   ciMethod* root_m = resolve_invoke(caller, actual_recv, check_access);
 690   if (root_m == NULL) {
 691     // Something went wrong looking up the actual receiver method.
 692     return NULL;
 693   }
 694   assert(!root_m->is_abstract(), "resolve_invoke promise");
 695 
 696   // Make certain quick checks even if UseCHA is false.
 697 
 698   // Is it private or final?
 699   if (root_m->can_be_statically_bound()) {
 700     return root_m;
 701   }
 702 
 703   if (actual_recv->is_leaf_type() && actual_recv == root_m->holder()) {
 704     // Easy case.  There is no other place to put a method, so don't bother
 705     // to go through the VM_ENTRY_MARK and all the rest.
 706     return root_m;
 707   }
 708 
 709   // Array methods (clone, hashCode, etc.) are always statically bound.
 710   // If we were to see an array type here, we'd return root_m.
 711   // However, this method processes only ciInstanceKlasses.  (See 4962591.)
 712   // The inline_native_clone intrinsic narrows Object to T[] properly,
 713   // so there is no need to do the same job here.
 714 
 715   if (!UseCHA)  return NULL;
 716 
 717   VM_ENTRY_MARK;
 718 
 719   // Disable CHA for default methods for now
 720   if (root_m->get_Method()->is_default_method()) {
 721     return NULL;
 722   }
 723 
 724   methodHandle target;
 725   {
 726     MutexLocker locker(Compile_lock);
 727     Klass* context = actual_recv->get_Klass();
 728     target = Dependencies::find_unique_concrete_method(context,
 729                                                        root_m->get_Method());
 730     // %%% Should upgrade this ciMethod API to look for 1 or 2 concrete methods.
 731   }
 732 
 733 #ifndef PRODUCT
 734   if (TraceDependencies && target() != NULL && target() != root_m->get_Method()) {
 735     tty->print("found a non-root unique target method");
 736     tty->print_cr("  context = %s", actual_recv->get_Klass()->external_name());
 737     tty->print("  method  = ");
 738     target->print_short_name(tty);
 739     tty->cr();
 740   }
 741 #endif //PRODUCT
 742 
 743   if (target() == NULL) {
 744     return NULL;
 745   }
 746   if (target() == root_m->get_Method()) {
 747     return root_m;
 748   }
 749   if (!root_m->is_public() &&
 750       !root_m->is_protected()) {
 751     // If we are going to reason about inheritance, it's easiest
 752     // if the method in question is public, protected, or private.
 753     // If the answer is not root_m, it is conservatively correct
 754     // to return NULL, even if the CHA encountered irrelevant
 755     // methods in other packages.
 756     // %%% TO DO: Work out logic for package-private methods
 757     // with the same name but different vtable indexes.
 758     return NULL;
 759   }
 760   return CURRENT_THREAD_ENV->get_method(target());
 761 }
 762 
 763 // ------------------------------------------------------------------
 764 // ciMethod::resolve_invoke
 765 //
 766 // Given a known receiver klass, find the target for the call.
 767 // Return NULL if the call has no target or the target is abstract.
 768 ciMethod* ciMethod::resolve_invoke(ciKlass* caller, ciKlass* exact_receiver, bool check_access) {
 769    check_is_loaded();
 770    VM_ENTRY_MARK;
 771 
 772    Klass* caller_klass = caller->get_Klass();
 773    Klass* recv         = exact_receiver->get_Klass();
 774    Klass* resolved     = holder()->get_Klass();
 775    Symbol* h_name      = name()->get_symbol();
 776    Symbol* h_signature = signature()->get_symbol();
 777 
 778    LinkInfo link_info(resolved, h_name, h_signature, caller_klass,
 779                       check_access ? LinkInfo::needs_access_check : LinkInfo::skip_access_check);
 780    methodHandle m;
 781    // Only do exact lookup if receiver klass has been linked.  Otherwise,
 782    // the vtable has not been setup, and the LinkResolver will fail.
 783    if (recv->is_array_klass()
 784         ||
 785        (InstanceKlass::cast(recv)->is_linked() && !exact_receiver->is_interface())) {
 786      if (holder()->is_interface()) {
 787        m = LinkResolver::resolve_interface_call_or_null(recv, link_info);
 788      } else {
 789        m = LinkResolver::resolve_virtual_call_or_null(recv, link_info);
 790      }
 791    }
 792 
 793    if (m.is_null()) {
 794      // Return NULL only if there was a problem with lookup (uninitialized class, etc.)
 795      return NULL;
 796    }
 797 
 798    ciMethod* result = this;
 799    if (m() != get_Method()) {
 800      result = CURRENT_THREAD_ENV->get_method(m());
 801    }
 802 
 803    // Don't return abstract methods because they aren't
 804    // optimizable or interesting.
 805    if (result->is_abstract()) {
 806      return NULL;
 807    } else {
 808      return result;
 809    }
 810 }
 811 
 812 // ------------------------------------------------------------------
 813 // ciMethod::resolve_vtable_index
 814 //
 815 // Given a known receiver klass, find the vtable index for the call.
 816 // Return Method::invalid_vtable_index if the vtable_index is unknown.
 817 int ciMethod::resolve_vtable_index(ciKlass* caller, ciKlass* receiver) {
 818    check_is_loaded();
 819 
 820    int vtable_index = Method::invalid_vtable_index;
 821    // Only do lookup if receiver klass has been linked.  Otherwise,
 822    // the vtable has not been setup, and the LinkResolver will fail.
 823    if (!receiver->is_interface()
 824        && (!receiver->is_instance_klass() ||
 825            receiver->as_instance_klass()->is_linked())) {
 826      VM_ENTRY_MARK;
 827 
 828      Klass* caller_klass = caller->get_Klass();
 829      Klass* recv         = receiver->get_Klass();
 830      Symbol* h_name = name()->get_symbol();
 831      Symbol* h_signature = signature()->get_symbol();
 832 
 833      LinkInfo link_info(recv, h_name, h_signature, caller_klass);
 834      vtable_index = LinkResolver::resolve_virtual_vtable_index(recv, link_info);
 835      if (vtable_index == Method::nonvirtual_vtable_index) {
 836        // A statically bound method.  Return "no such index".
 837        vtable_index = Method::invalid_vtable_index;
 838      }
 839    }
 840 
 841    return vtable_index;
 842 }
 843 
 844 // ------------------------------------------------------------------
 845 // ciMethod::interpreter_call_site_count
 846 int ciMethod::interpreter_call_site_count(int bci) {
 847   if (method_data() != NULL) {
 848     ResourceMark rm;
 849     ciProfileData* data = method_data()->bci_to_data(bci);
 850     if (data != NULL && data->is_CounterData()) {
 851       return scale_count(data->as_CounterData()->count());
 852     }
 853   }
 854   return -1;  // unknown
 855 }
 856 
 857 // ------------------------------------------------------------------
 858 // ciMethod::get_field_at_bci
 859 ciField* ciMethod::get_field_at_bci(int bci, bool &will_link) {
 860   ciBytecodeStream iter(this);
 861   iter.reset_to_bci(bci);
 862   iter.next();
 863   return iter.get_field(will_link);
 864 }
 865 
 866 // ------------------------------------------------------------------
 867 // ciMethod::get_method_at_bci
 868 ciMethod* ciMethod::get_method_at_bci(int bci, bool &will_link, ciSignature* *declared_signature) {
 869   ciBytecodeStream iter(this);
 870   iter.reset_to_bci(bci);
 871   iter.next();
 872   return iter.get_method(will_link, declared_signature);
 873 }
 874 
 875 // ------------------------------------------------------------------
 876 // Adjust a CounterData count to be commensurate with
 877 // interpreter_invocation_count.  If the MDO exists for
 878 // only 25% of the time the method exists, then the
 879 // counts in the MDO should be scaled by 4X, so that
 880 // they can be usefully and stably compared against the
 881 // invocation counts in methods.
 882 int ciMethod::scale_count(int count, float prof_factor) {
 883   if (count > 0 && method_data() != NULL) {
 884     int counter_life;
 885     int method_life = interpreter_invocation_count();
 886     if (TieredCompilation) {
 887       // In tiered the MDO's life is measured directly, so just use the snapshotted counters
 888       counter_life = MAX2(method_data()->invocation_count(), method_data()->backedge_count());
 889     } else {
 890       int current_mileage = method_data()->current_mileage();
 891       int creation_mileage = method_data()->creation_mileage();
 892       counter_life = current_mileage - creation_mileage;
 893     }
 894 
 895     // counter_life due to backedge_counter could be > method_life
 896     if (counter_life > method_life)
 897       counter_life = method_life;
 898     if (0 < counter_life && counter_life <= method_life) {
 899       count = (int)((double)count * prof_factor * method_life / counter_life + 0.5);
 900       count = (count > 0) ? count : 1;
 901     }
 902   }
 903   return count;
 904 }
 905 
 906 
 907 // ------------------------------------------------------------------
 908 // ciMethod::is_special_get_caller_class_method
 909 //
 910 bool ciMethod::is_ignored_by_security_stack_walk() const {
 911   check_is_loaded();
 912   VM_ENTRY_MARK;
 913   return get_Method()->is_ignored_by_security_stack_walk();
 914 }
 915 
 916 
 917 // ------------------------------------------------------------------
 918 // invokedynamic support
 919 
 920 // ------------------------------------------------------------------
 921 // ciMethod::is_method_handle_intrinsic
 922 //
 923 // Return true if the method is an instance of the JVM-generated
 924 // signature-polymorphic MethodHandle methods, _invokeBasic, _linkToVirtual, etc.
 925 bool ciMethod::is_method_handle_intrinsic() const {
 926   vmIntrinsics::ID iid = _intrinsic_id;  // do not check if loaded
 927   return (MethodHandles::is_signature_polymorphic(iid) &&
 928           MethodHandles::is_signature_polymorphic_intrinsic(iid));
 929 }
 930 
 931 // ------------------------------------------------------------------
 932 // ciMethod::is_compiled_lambda_form
 933 //
 934 // Return true if the method is a generated MethodHandle adapter.
 935 // These are built by Java code.
 936 bool ciMethod::is_compiled_lambda_form() const {
 937   vmIntrinsics::ID iid = _intrinsic_id;  // do not check if loaded
 938   return iid == vmIntrinsics::_compiledLambdaForm;
 939 }
 940 
 941 // ------------------------------------------------------------------
 942 // ciMethod::is_object_initializer
 943 //
 944 bool ciMethod::is_object_initializer() const {
 945    return name() == ciSymbol::object_initializer_name();
 946 }
 947 
 948 // ------------------------------------------------------------------
 949 // ciMethod::has_member_arg
 950 //
 951 // Return true if the method is a linker intrinsic like _linkToVirtual.
 952 // These are built by the JVM.
 953 bool ciMethod::has_member_arg() const {
 954   vmIntrinsics::ID iid = _intrinsic_id;  // do not check if loaded
 955   return (MethodHandles::is_signature_polymorphic(iid) &&
 956           MethodHandles::has_member_arg(iid));
 957 }
 958 
 959 // ------------------------------------------------------------------
 960 // ciMethod::ensure_method_data
 961 //
 962 // Generate new MethodData* objects at compile time.
 963 // Return true if allocation was successful or no MDO is required.
 964 bool ciMethod::ensure_method_data(const methodHandle& h_m) {
 965   EXCEPTION_CONTEXT;
 966   if (is_native() || is_abstract() || h_m()->is_accessor()) {
 967     return true;
 968   }
 969   if (h_m()->method_data() == NULL) {
 970     Method::build_interpreter_method_data(h_m, THREAD);
 971     if (HAS_PENDING_EXCEPTION) {
 972       CLEAR_PENDING_EXCEPTION;
 973     }
 974   }
 975   if (h_m()->method_data() != NULL) {
 976     _method_data = CURRENT_ENV->get_method_data(h_m()->method_data());
 977     _method_data->load_data();
 978     return true;
 979   } else {
 980     _method_data = CURRENT_ENV->get_empty_methodData();
 981     return false;
 982   }
 983 }
 984 
 985 // public, retroactive version
 986 bool ciMethod::ensure_method_data() {
 987   bool result = true;
 988   if (_method_data == NULL || _method_data->is_empty()) {
 989     GUARDED_VM_ENTRY({
 990       result = ensure_method_data(get_Method());
 991     });
 992   }
 993   return result;
 994 }
 995 
 996 
 997 // ------------------------------------------------------------------
 998 // ciMethod::method_data
 999 //
1000 ciMethodData* ciMethod::method_data() {
1001   if (_method_data != NULL) {
1002     return _method_data;
1003   }
1004   VM_ENTRY_MARK;
1005   ciEnv* env = CURRENT_ENV;
1006   Thread* my_thread = JavaThread::current();
1007   methodHandle h_m(my_thread, get_Method());
1008 
1009   if (h_m()->method_data() != NULL) {
1010     _method_data = CURRENT_ENV->get_method_data(h_m()->method_data());
1011     _method_data->load_data();
1012   } else {
1013     _method_data = CURRENT_ENV->get_empty_methodData();
1014   }
1015   return _method_data;
1016 
1017 }
1018 
1019 // ------------------------------------------------------------------
1020 // ciMethod::method_data_or_null
1021 // Returns a pointer to ciMethodData if MDO exists on the VM side,
1022 // NULL otherwise.
1023 ciMethodData* ciMethod::method_data_or_null() {
1024   ciMethodData *md = method_data();
1025   if (md->is_empty()) {
1026     return NULL;
1027   }
1028   return md;
1029 }
1030 
1031 // ------------------------------------------------------------------
1032 // ciMethod::ensure_method_counters
1033 //
1034 MethodCounters* ciMethod::ensure_method_counters() {
1035   check_is_loaded();
1036   VM_ENTRY_MARK;
1037   methodHandle mh(THREAD, get_Method());
1038   MethodCounters* method_counters = mh->get_method_counters(CHECK_NULL);
1039   return method_counters;
1040 }
1041 
1042 // ------------------------------------------------------------------
1043 // ciMethod::has_option
1044 //
1045 bool ciMethod::has_option(const char* option) {
1046   check_is_loaded();
1047   VM_ENTRY_MARK;
1048   methodHandle mh(THREAD, get_Method());
1049   return CompilerOracle::has_option_string(mh, option);
1050 }
1051 
1052 // ------------------------------------------------------------------
1053 // ciMethod::has_option_value
1054 //
1055 bool ciMethod::has_option_value(const char* option, double& value) {
1056   check_is_loaded();
1057   VM_ENTRY_MARK;
1058   methodHandle mh(THREAD, get_Method());
1059   return CompilerOracle::has_option_value(mh, option, value);
1060 }
1061 // ------------------------------------------------------------------
1062 // ciMethod::can_be_compiled
1063 //
1064 // Have previous compilations of this method succeeded?
1065 bool ciMethod::can_be_compiled() {
1066   check_is_loaded();
1067   ciEnv* env = CURRENT_ENV;
1068   if (is_c1_compile(env->comp_level())) {
1069     return _is_c1_compilable;
1070   }
1071   return _is_c2_compilable;
1072 }
1073 
1074 // ------------------------------------------------------------------
1075 // ciMethod::set_not_compilable
1076 //
1077 // Tell the VM that this method cannot be compiled at all.
1078 void ciMethod::set_not_compilable(const char* reason) {
1079   check_is_loaded();
1080   VM_ENTRY_MARK;
1081   ciEnv* env = CURRENT_ENV;
1082   if (is_c1_compile(env->comp_level())) {
1083     _is_c1_compilable = false;
1084   } else {
1085     _is_c2_compilable = false;
1086   }
1087   get_Method()->set_not_compilable(env->comp_level(), true, reason);
1088 }
1089 
1090 // ------------------------------------------------------------------
1091 // ciMethod::can_be_osr_compiled
1092 //
1093 // Have previous compilations of this method succeeded?
1094 //
1095 // Implementation note: the VM does not currently keep track
1096 // of failed OSR compilations per bci.  The entry_bci parameter
1097 // is currently unused.
1098 bool ciMethod::can_be_osr_compiled(int entry_bci) {
1099   check_is_loaded();
1100   VM_ENTRY_MARK;
1101   ciEnv* env = CURRENT_ENV;
1102   return !get_Method()->is_not_osr_compilable(env->comp_level());
1103 }
1104 
1105 // ------------------------------------------------------------------
1106 // ciMethod::has_compiled_code
1107 bool ciMethod::has_compiled_code() {
1108   return instructions_size() > 0;
1109 }
1110 
1111 int ciMethod::comp_level() {
1112   check_is_loaded();
1113   VM_ENTRY_MARK;
1114   CompiledMethod* nm = get_Method()->code();
1115   if (nm != NULL) return nm->comp_level();
1116   return 0;
1117 }
1118 
1119 int ciMethod::highest_osr_comp_level() {
1120   check_is_loaded();
1121   VM_ENTRY_MARK;
1122   return get_Method()->highest_osr_comp_level();
1123 }
1124 
1125 // ------------------------------------------------------------------
1126 // ciMethod::code_size_for_inlining
1127 //
1128 // Code size for inlining decisions.  This method returns a code
1129 // size of 1 for methods which has the ForceInline annotation.
1130 int ciMethod::code_size_for_inlining() {
1131   check_is_loaded();
1132   if (get_Method()->force_inline()) {
1133     return 1;
1134   }
1135   return code_size();
1136 }
1137 
1138 // ------------------------------------------------------------------
1139 // ciMethod::instructions_size
1140 //
1141 // This is a rough metric for "fat" methods, compared before inlining
1142 // with InlineSmallCode.  The CodeBlob::code_size accessor includes
1143 // junk like exception handler, stubs, and constant table, which are
1144 // not highly relevant to an inlined method.  So we use the more
1145 // specific accessor nmethod::insts_size.
1146 int ciMethod::instructions_size() {
1147   if (_instructions_size == -1) {
1148     GUARDED_VM_ENTRY(
1149                      CompiledMethod* code = get_Method()->code();
1150                      if (code != NULL && (code->comp_level() == CompLevel_full_optimization)) {
1151                        _instructions_size = code->insts_end() - code->verified_entry_point();
1152                      } else {
1153                        _instructions_size = 0;
1154                      }
1155                      );
1156   }
1157   return _instructions_size;
1158 }
1159 
1160 // ------------------------------------------------------------------
1161 // ciMethod::log_nmethod_identity
1162 void ciMethod::log_nmethod_identity(xmlStream* log) {
1163   GUARDED_VM_ENTRY(
1164     CompiledMethod* code = get_Method()->code();
1165     if (code != NULL) {
1166       code->log_identity(log);
1167     }
1168   )
1169 }
1170 
1171 // ------------------------------------------------------------------
1172 // ciMethod::is_not_reached
1173 bool ciMethod::is_not_reached(int bci) {
1174   check_is_loaded();
1175   VM_ENTRY_MARK;
1176   return Interpreter::is_not_reached(
1177                methodHandle(THREAD, get_Method()), bci);
1178 }
1179 
1180 // ------------------------------------------------------------------
1181 // ciMethod::was_never_executed
1182 bool ciMethod::was_executed_more_than(int times) {
1183   VM_ENTRY_MARK;
1184   return get_Method()->was_executed_more_than(times);
1185 }
1186 
1187 // ------------------------------------------------------------------
1188 // ciMethod::has_unloaded_classes_in_signature
1189 bool ciMethod::has_unloaded_classes_in_signature() {
1190   VM_ENTRY_MARK;
1191   {
1192     EXCEPTION_MARK;
1193     methodHandle m(THREAD, get_Method());
1194     bool has_unloaded = Method::has_unloaded_classes_in_signature(m, (JavaThread *)THREAD);
1195     if( HAS_PENDING_EXCEPTION ) {
1196       CLEAR_PENDING_EXCEPTION;
1197       return true;     // Declare that we may have unloaded classes
1198     }
1199     return has_unloaded;
1200   }
1201 }
1202 
1203 // ------------------------------------------------------------------
1204 // ciMethod::is_klass_loaded
1205 bool ciMethod::is_klass_loaded(int refinfo_index, bool must_be_resolved) const {
1206   VM_ENTRY_MARK;
1207   return get_Method()->is_klass_loaded(refinfo_index, must_be_resolved);
1208 }
1209 
1210 // ------------------------------------------------------------------
1211 // ciMethod::check_call
1212 bool ciMethod::check_call(int refinfo_index, bool is_static) const {
1213   // This method is used only in C2 from InlineTree::ok_to_inline,
1214   // and is only used under -Xcomp or -XX:CompileTheWorld.
1215   // It appears to fail when applied to an invokeinterface call site.
1216   // FIXME: Remove this method and resolve_method_statically; refactor to use the other LinkResolver entry points.
1217   VM_ENTRY_MARK;
1218   {
1219     EXCEPTION_MARK;
1220     HandleMark hm(THREAD);
1221     constantPoolHandle pool (THREAD, get_Method()->constants());
1222     Bytecodes::Code code = (is_static ? Bytecodes::_invokestatic : Bytecodes::_invokevirtual);
1223     methodHandle spec_method = LinkResolver::resolve_method_statically(code, pool, refinfo_index, THREAD);
1224     if (HAS_PENDING_EXCEPTION) {
1225       CLEAR_PENDING_EXCEPTION;
1226       return false;
1227     } else {
1228       return (spec_method->is_static() == is_static);
1229     }
1230   }
1231   return false;
1232 }
1233 
1234 // ------------------------------------------------------------------
1235 // ciMethod::profile_aging
1236 //
1237 // Should the method be compiled with an age counter?
1238 bool ciMethod::profile_aging() const {
1239   return UseCodeAging && (!MethodCounters::is_nmethod_hot(nmethod_age()) &&
1240                           !MethodCounters::is_nmethod_age_unset(nmethod_age()));
1241 }
1242 // ------------------------------------------------------------------
1243 // ciMethod::print_codes
1244 //
1245 // Print the bytecodes for this method.
1246 void ciMethod::print_codes_on(outputStream* st) {
1247   check_is_loaded();
1248   GUARDED_VM_ENTRY(get_Method()->print_codes_on(st);)
1249 }
1250 
1251 
1252 #define FETCH_FLAG_FROM_VM(flag_accessor) { \
1253   check_is_loaded(); \
1254   VM_ENTRY_MARK; \
1255   return get_Method()->flag_accessor(); \
1256 }
1257 
1258 bool ciMethod::is_empty_method() const {         FETCH_FLAG_FROM_VM(is_empty_method); }
1259 bool ciMethod::is_vanilla_constructor() const {  FETCH_FLAG_FROM_VM(is_vanilla_constructor); }
1260 bool ciMethod::has_loops      () const {         FETCH_FLAG_FROM_VM(has_loops); }
1261 bool ciMethod::has_jsrs       () const {         FETCH_FLAG_FROM_VM(has_jsrs);  }
1262 bool ciMethod::is_getter      () const {         FETCH_FLAG_FROM_VM(is_getter); }
1263 bool ciMethod::is_setter      () const {         FETCH_FLAG_FROM_VM(is_setter); }
1264 bool ciMethod::is_accessor    () const {         FETCH_FLAG_FROM_VM(is_accessor); }
1265 bool ciMethod::is_initializer () const {         FETCH_FLAG_FROM_VM(is_initializer); }
1266 
1267 bool ciMethod::is_boxing_method() const {
1268   if (holder()->is_box_klass()) {
1269     switch (intrinsic_id()) {
1270       case vmIntrinsics::_Boolean_valueOf:
1271       case vmIntrinsics::_Byte_valueOf:
1272       case vmIntrinsics::_Character_valueOf:
1273       case vmIntrinsics::_Short_valueOf:
1274       case vmIntrinsics::_Integer_valueOf:
1275       case vmIntrinsics::_Long_valueOf:
1276       case vmIntrinsics::_Float_valueOf:
1277       case vmIntrinsics::_Double_valueOf:
1278         return true;
1279       default:
1280         return false;
1281     }
1282   }
1283   return false;
1284 }
1285 
1286 bool ciMethod::is_unboxing_method() const {
1287   if (holder()->is_box_klass()) {
1288     switch (intrinsic_id()) {
1289       case vmIntrinsics::_booleanValue:
1290       case vmIntrinsics::_byteValue:
1291       case vmIntrinsics::_charValue:
1292       case vmIntrinsics::_shortValue:
1293       case vmIntrinsics::_intValue:
1294       case vmIntrinsics::_longValue:
1295       case vmIntrinsics::_floatValue:
1296       case vmIntrinsics::_doubleValue:
1297         return true;
1298       default:
1299         return false;
1300     }
1301   }
1302   return false;
1303 }
1304 
1305 BCEscapeAnalyzer  *ciMethod::get_bcea() {
1306 #ifdef COMPILER2
1307   if (_bcea == NULL) {
1308     _bcea = new (CURRENT_ENV->arena()) BCEscapeAnalyzer(this, NULL);
1309   }
1310   return _bcea;
1311 #else // COMPILER2
1312   ShouldNotReachHere();
1313   return NULL;
1314 #endif // COMPILER2
1315 }
1316 
1317 ciMethodBlocks  *ciMethod::get_method_blocks() {
1318   Arena *arena = CURRENT_ENV->arena();
1319   if (_method_blocks == NULL) {
1320     _method_blocks = new (arena) ciMethodBlocks(arena, this);
1321   }
1322   return _method_blocks;
1323 }
1324 
1325 #undef FETCH_FLAG_FROM_VM
1326 
1327 void ciMethod::dump_name_as_ascii(outputStream* st) {
1328   Method* method = get_Method();
1329   st->print("%s %s %s",
1330             method->klass_name()->as_quoted_ascii(),
1331             method->name()->as_quoted_ascii(),
1332             method->signature()->as_quoted_ascii());
1333 }
1334 
1335 void ciMethod::dump_replay_data(outputStream* st) {
1336   ResourceMark rm;
1337   Method* method = get_Method();
1338   MethodCounters* mcs = method->method_counters();
1339   st->print("ciMethod ");
1340   dump_name_as_ascii(st);
1341   st->print_cr(" %d %d %d %d %d",
1342                mcs == NULL ? 0 : mcs->invocation_counter()->raw_counter(),
1343                mcs == NULL ? 0 : mcs->backedge_counter()->raw_counter(),
1344                interpreter_invocation_count(),
1345                interpreter_throwout_count(),
1346                _instructions_size);
1347 }
1348 
1349 // ------------------------------------------------------------------
1350 // ciMethod::print_codes
1351 //
1352 // Print a range of the bytecodes for this method.
1353 void ciMethod::print_codes_on(int from, int to, outputStream* st) {
1354   check_is_loaded();
1355   GUARDED_VM_ENTRY(get_Method()->print_codes_on(from, to, st);)
1356 }
1357 
1358 // ------------------------------------------------------------------
1359 // ciMethod::print_name
1360 //
1361 // Print the name of this method, including signature and some flags.
1362 void ciMethod::print_name(outputStream* st) {
1363   check_is_loaded();
1364   GUARDED_VM_ENTRY(get_Method()->print_name(st);)
1365 }
1366 
1367 // ------------------------------------------------------------------
1368 // ciMethod::print_short_name
1369 //
1370 // Print the name of this method, without signature.
1371 void ciMethod::print_short_name(outputStream* st) {
1372   if (is_loaded()) {
1373     GUARDED_VM_ENTRY(get_Method()->print_short_name(st););
1374   } else {
1375     // Fall back if method is not loaded.
1376     holder()->print_name_on(st);
1377     st->print("::");
1378     name()->print_symbol_on(st);
1379     if (WizardMode)
1380       signature()->as_symbol()->print_symbol_on(st);
1381   }
1382 }
1383 
1384 // ------------------------------------------------------------------
1385 // ciMethod::print_impl
1386 //
1387 // Implementation of the print method.
1388 void ciMethod::print_impl(outputStream* st) {
1389   ciMetadata::print_impl(st);
1390   st->print(" name=");
1391   name()->print_symbol_on(st);
1392   st->print(" holder=");
1393   holder()->print_name_on(st);
1394   st->print(" signature=");
1395   signature()->as_symbol()->print_symbol_on(st);
1396   if (is_loaded()) {
1397     st->print(" loaded=true");
1398     st->print(" arg_size=%d", arg_size());
1399     st->print(" flags=");
1400     flags().print_member_flags(st);
1401   } else {
1402     st->print(" loaded=false");
1403   }
1404 }
1405 
1406 // ------------------------------------------------------------------
1407 
1408 static BasicType erase_to_word_type(BasicType bt) {
1409   if (is_subword_type(bt)) return T_INT;
1410   if (bt == T_ARRAY)       return T_OBJECT;
1411   return bt;
1412 }
1413 
1414 static bool basic_types_match(ciType* t1, ciType* t2) {
1415   if (t1 == t2)  return true;
1416   return erase_to_word_type(t1->basic_type()) == erase_to_word_type(t2->basic_type());
1417 }
1418 
1419 bool ciMethod::is_consistent_info(ciMethod* declared_method, ciMethod* resolved_method) {
1420   bool invoke_through_mh_intrinsic = declared_method->is_method_handle_intrinsic() &&
1421                                   !resolved_method->is_method_handle_intrinsic();
1422 
1423   if (!invoke_through_mh_intrinsic) {
1424     // Method name & descriptor should stay the same.
1425     // Signatures may reference unloaded types and thus they may be not strictly equal.
1426     ciSymbol* declared_signature = declared_method->signature()->as_symbol();
1427     ciSymbol* resolved_signature = resolved_method->signature()->as_symbol();
1428 
1429     return (declared_method->name()->equals(resolved_method->name())) &&
1430            (declared_signature->equals(resolved_signature));
1431   }
1432 
1433   ciMethod* linker = declared_method;
1434   ciMethod* target = resolved_method;
1435   // Linkers have appendix argument which is not passed to callee.
1436   int has_appendix = MethodHandles::has_member_arg(linker->intrinsic_id()) ? 1 : 0;
1437   if (linker->arg_size() != (target->arg_size() + has_appendix)) {
1438     return false; // argument slot count mismatch
1439   }
1440 
1441   ciSignature* linker_sig = linker->signature();
1442   ciSignature* target_sig = target->signature();
1443 
1444   if (linker_sig->count() + (linker->is_static() ? 0 : 1) !=
1445       target_sig->count() + (target->is_static() ? 0 : 1) + has_appendix) {
1446     return false; // argument count mismatch
1447   }
1448 
1449   int sbase = 0, rbase = 0;
1450   switch (linker->intrinsic_id()) {
1451     case vmIntrinsics::_linkToVirtual:
1452     case vmIntrinsics::_linkToInterface:
1453     case vmIntrinsics::_linkToSpecial: {
1454       if (target->is_static()) {
1455         return false;
1456       }
1457       if (linker_sig->type_at(0)->is_primitive_type()) {
1458         return false;  // receiver should be an oop
1459       }
1460       sbase = 1; // skip receiver
1461       break;
1462     }
1463     case vmIntrinsics::_linkToStatic: {
1464       if (!target->is_static()) {
1465         return false;
1466       }
1467       break;
1468     }
1469     case vmIntrinsics::_invokeBasic: {
1470       if (target->is_static()) {
1471         if (target_sig->type_at(0)->is_primitive_type()) {
1472           return false; // receiver should be an oop
1473         }
1474         rbase = 1; // skip receiver
1475       }
1476       break;
1477     }
1478     default:
1479       break;
1480   }
1481   assert(target_sig->count() - rbase == linker_sig->count() - sbase - has_appendix, "argument count mismatch");
1482   int arg_count = target_sig->count() - rbase;
1483   for (int i = 0; i < arg_count; i++) {
1484     if (!basic_types_match(linker_sig->type_at(sbase + i), target_sig->type_at(rbase + i))) {
1485       return false;
1486     }
1487   }
1488   // Only check the return type if the symbolic info has non-void return type.
1489   // I.e. the return value of the resolved method can be dropped.
1490   if (!linker->return_type()->is_void() &&
1491       !basic_types_match(linker->return_type(), target->return_type())) {
1492     return false;
1493   }
1494   return true; // no mismatch found
1495 }
1496 
1497 // ------------------------------------------------------------------
1498 
1499 #if INCLUDE_TRACE
1500 TraceStructCalleeMethod ciMethod::to_trace_struct() const {
1501   TraceStructCalleeMethod result;
1502   result.set_type(holder()->name()->as_utf8());
1503   result.set_name(name()->as_utf8());
1504   result.set_descriptor(signature()->as_symbol()->as_utf8());
1505   return result;
1506 }
1507 #endif