1 /*
   2  * Copyright (c) 2000, 2013, 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 "code/compiledIC.hpp"
  27 #include "code/nmethod.hpp"
  28 #include "code/scopeDesc.hpp"
  29 #include "compiler/compilerOracle.hpp"
  30 #include "interpreter/interpreter.hpp"
  31 #include "oops/methodData.hpp"
  32 #include "oops/method.hpp"
  33 #include "oops/oop.inline.hpp"
  34 #include "prims/nativeLookup.hpp"
  35 #include "runtime/advancedThresholdPolicy.hpp"
  36 #include "runtime/compilationPolicy.hpp"
  37 #include "runtime/frame.hpp"
  38 #include "runtime/handles.inline.hpp"
  39 #include "runtime/rframe.hpp"
  40 #include "runtime/simpleThresholdPolicy.hpp"
  41 #include "runtime/stubRoutines.hpp"
  42 #include "runtime/thread.hpp"
  43 #include "runtime/timer.hpp"
  44 #include "runtime/vframe.hpp"
  45 #include "runtime/vm_operations.hpp"
  46 #include "utilities/events.hpp"
  47 #include "utilities/globalDefinitions.hpp"
  48 
  49 CompilationPolicy* CompilationPolicy::_policy;
  50 elapsedTimer       CompilationPolicy::_accumulated_time;
  51 bool               CompilationPolicy::_in_vm_startup;
  52 
  53 // Determine compilation policy based on command line argument
  54 void compilationPolicy_init() {
  55   CompilationPolicy::set_in_vm_startup(DelayCompilationDuringStartup);
  56 
  57   switch(CompilationPolicyChoice) {
  58   case 0:
  59     CompilationPolicy::set_policy(new SimpleCompPolicy());
  60     break;
  61 
  62   case 1:
  63 #ifdef COMPILER2
  64     CompilationPolicy::set_policy(new StackWalkCompPolicy());
  65 #else
  66     Unimplemented();
  67 #endif
  68     break;
  69   case 2:
  70 #ifdef TIERED
  71     CompilationPolicy::set_policy(new SimpleThresholdPolicy());
  72 #else
  73     Unimplemented();
  74 #endif
  75     break;
  76   case 3:
  77 #ifdef TIERED
  78     CompilationPolicy::set_policy(new AdvancedThresholdPolicy());
  79 #else
  80     Unimplemented();
  81 #endif
  82     break;
  83   default:
  84     fatal("CompilationPolicyChoice must be in the range: [0-3]");
  85   }
  86   CompilationPolicy::policy()->initialize();
  87 }
  88 
  89 void CompilationPolicy::completed_vm_startup() {
  90   if (TraceCompilationPolicy) {
  91     tty->print("CompilationPolicy: completed vm startup.\n");
  92   }
  93   _in_vm_startup = false;
  94 }
  95 
  96 // Returns true if m must be compiled before executing it
  97 // This is intended to force compiles for methods (usually for
  98 // debugging) that would otherwise be interpreted for some reason.
  99 bool CompilationPolicy::must_be_compiled(methodHandle m, int comp_level) {
 100   // Don't allow Xcomp to cause compiles in replay mode
 101   if (ReplayCompiles) return false;
 102 
 103   if (m->has_compiled_code()) return false;       // already compiled
 104   if (!can_be_compiled(m, comp_level)) return false;
 105 
 106   return !UseInterpreter ||                                              // must compile all methods
 107          (UseCompiler && AlwaysCompileLoopMethods && m->has_loops() && CompileBroker::should_compile_new_jobs()); // eagerly compile loop methods
 108 }
 109 
 110 // Returns true if m is allowed to be compiled
 111 bool CompilationPolicy::can_be_compiled(methodHandle m, int comp_level) {
 112   // allow any levels for WhiteBox
 113   assert(WhiteBoxAPI || comp_level == CompLevel_all || is_compile(comp_level), "illegal compilation level");
 114 
 115   if (m->is_abstract()) return false;
 116   if (DontCompileHugeMethods && m->code_size() > HugeMethodLimit) return false;
 117 
 118   // Math intrinsics should never be compiled as this can lead to
 119   // monotonicity problems because the interpreter will prefer the
 120   // compiled code to the intrinsic version.  This can't happen in
 121   // production because the invocation counter can't be incremented
 122   // but we shouldn't expose the system to this problem in testing
 123   // modes.
 124   if (!AbstractInterpreter::can_be_compiled(m)) {
 125     return false;
 126   }
 127   if (comp_level == CompLevel_all) {
 128     if (TieredCompilation) {
 129       // enough to be compilable at any level for tiered
 130       return !m->is_not_compilable(CompLevel_simple) || !m->is_not_compilable(CompLevel_full_optimization);
 131     } else {
 132       // must be compilable at available level for non-tiered
 133       return !m->is_not_compilable(CompLevel_highest_tier);
 134     }
 135   } else if (is_compile(comp_level)) {
 136     return !m->is_not_compilable(comp_level);
 137   }
 138   return false;
 139 }
 140 
 141 // Returns true if m is allowed to be osr compiled
 142 bool CompilationPolicy::can_be_osr_compiled(methodHandle m, int comp_level) {
 143   bool result = false;
 144   if (comp_level == CompLevel_all) {
 145     if (TieredCompilation) {
 146       // enough to be osr compilable at any level for tiered
 147       result = !m->is_not_osr_compilable(CompLevel_simple) || !m->is_not_osr_compilable(CompLevel_full_optimization);
 148     } else {
 149       // must be osr compilable at available level for non-tiered
 150       result = !m->is_not_osr_compilable(CompLevel_highest_tier);
 151     }
 152   } else if (is_compile(comp_level)) {
 153     result = !m->is_not_osr_compilable(comp_level);
 154   }
 155   return (result && can_be_compiled(m, comp_level));
 156 }
 157 
 158 bool CompilationPolicy::is_compilation_enabled() {
 159   // NOTE: CompileBroker::should_compile_new_jobs() checks for UseCompiler
 160   return !delay_compilation_during_startup() && CompileBroker::should_compile_new_jobs();
 161 }
 162 
 163 #ifndef PRODUCT
 164 void CompilationPolicy::print_time() {
 165   tty->print_cr ("Accumulated compilationPolicy times:");
 166   tty->print_cr ("---------------------------");
 167   tty->print_cr ("  Total: %3.3f sec.", _accumulated_time.seconds());
 168 }
 169 
 170 void NonTieredCompPolicy::trace_osr_completion(nmethod* osr_nm) {
 171   if (TraceOnStackReplacement) {
 172     if (osr_nm == NULL) tty->print_cr("compilation failed");
 173     else tty->print_cr("nmethod " INTPTR_FORMAT, osr_nm);
 174   }
 175 }
 176 #endif // !PRODUCT
 177 
 178 void NonTieredCompPolicy::initialize() {
 179   // Setup the compiler thread numbers
 180   if (CICompilerCountPerCPU) {
 181     // Example: if CICompilerCountPerCPU is true, then we get
 182     // max(log2(8)-1,1) = 2 compiler threads on an 8-way machine.
 183     // May help big-app startup time.
 184     _compiler_count = MAX2(log2_intptr(os::active_processor_count())-1,1);
 185   } else {
 186     _compiler_count = CICompilerCount;
 187   }
 188 }
 189 
 190 // Note: this policy is used ONLY if TieredCompilation is off.
 191 // compiler_count() behaves the following way:
 192 // - with TIERED build (with both COMPILER1 and COMPILER2 defined) it should return
 193 //   zero for the c1 compilation levels, hence the particular ordering of the
 194 //   statements.
 195 // - the same should happen when COMPILER2 is defined and COMPILER1 is not
 196 //   (server build without TIERED defined).
 197 // - if only COMPILER1 is defined (client build), zero should be returned for
 198 //   the c2 level.
 199 // - if neither is defined - always return zero.
 200 int NonTieredCompPolicy::compiler_count(CompLevel comp_level) {
 201   assert(!TieredCompilation, "This policy should not be used with TieredCompilation");
 202   // No need for compiler threads if the VM is started with -Xint
 203   if (Arguments::mode() == Arguments::_int) {
 204     return 0;
 205   }
 206 
 207 #ifdef COMPILER2
 208   if (is_c2_compile(comp_level)) {
 209     return _compiler_count;
 210   } else {
 211     return 0;
 212   }
 213 #endif
 214 
 215 #ifdef COMPILER1
 216   if (is_c1_compile(comp_level)) {
 217     return _compiler_count;
 218   } else {
 219     return 0;
 220   }
 221 #endif
 222 
 223   return 0;
 224 }
 225 
 226 void NonTieredCompPolicy::reset_counter_for_invocation_event(methodHandle m) {
 227   // Make sure invocation and backedge counter doesn't overflow again right away
 228   // as would be the case for native methods.
 229 
 230   // BUT also make sure the method doesn't look like it was never executed.
 231   // Set carry bit and reduce counter's value to min(count, CompileThreshold/2).
 232   MethodCounters* mcs = m->method_counters();
 233   assert(mcs != NULL, "MethodCounters cannot be NULL for profiling");
 234   mcs->invocation_counter()->set_carry();
 235   mcs->backedge_counter()->set_carry();
 236 
 237   assert(!m->was_never_executed(), "don't reset to 0 -- could be mistaken for never-executed");
 238 }
 239 
 240 void NonTieredCompPolicy::reset_counter_for_back_branch_event(methodHandle m) {
 241   // Delay next back-branch event but pump up invocation counter to triger
 242   // whole method compilation.
 243   MethodCounters* mcs = m->method_counters();
 244   assert(mcs != NULL, "MethodCounters cannot be NULL for profiling");
 245   InvocationCounter* i = mcs->invocation_counter();
 246   InvocationCounter* b = mcs->backedge_counter();
 247 
 248   // Don't set invocation_counter's value too low otherwise the method will
 249   // look like immature (ic < ~5300) which prevents the inlining based on
 250   // the type profiling.
 251   i->set(i->state(), CompileThreshold);
 252   // Don't reset counter too low - it is used to check if OSR method is ready.
 253   b->set(b->state(), CompileThreshold / 2);
 254 }
 255 
 256 //
 257 // CounterDecay
 258 //
 259 // Interates through invocation counters and decrements them. This
 260 // is done at each safepoint.
 261 //
 262 class CounterDecay : public AllStatic {
 263   static jlong _last_timestamp;
 264   static void do_method(Method* m) {
 265     MethodCounters* mcs = m->method_counters();
 266     if (mcs != NULL) {
 267       mcs->invocation_counter()->decay();
 268     }
 269   }
 270 public:
 271   static void decay();
 272   static bool is_decay_needed() {
 273     return (os::javaTimeMillis() - _last_timestamp) > CounterDecayMinIntervalLength;
 274   }
 275 };
 276 
 277 jlong CounterDecay::_last_timestamp = 0;
 278 
 279 void CounterDecay::decay() {
 280   _last_timestamp = os::javaTimeMillis();
 281 
 282   // This operation is going to be performed only at the end of a safepoint
 283   // and hence GC's will not be going on, all Java mutators are suspended
 284   // at this point and hence SystemDictionary_lock is also not needed.
 285   assert(SafepointSynchronize::is_at_safepoint(), "can only be executed at a safepoint");
 286   int nclasses = SystemDictionary::number_of_classes();
 287   double classes_per_tick = nclasses * (CounterDecayMinIntervalLength * 1e-3 /
 288                                         CounterHalfLifeTime);
 289   for (int i = 0; i < classes_per_tick; i++) {
 290     Klass* k = SystemDictionary::try_get_next_class();
 291     if (k != NULL && k->oop_is_instance()) {
 292       InstanceKlass::cast(k)->methods_do(do_method);
 293     }
 294   }
 295 }
 296 
 297 // Called at the end of the safepoint
 298 void NonTieredCompPolicy::do_safepoint_work() {
 299   if(UseCounterDecay && CounterDecay::is_decay_needed()) {
 300     CounterDecay::decay();
 301   }
 302 }
 303 
 304 void NonTieredCompPolicy::reprofile(ScopeDesc* trap_scope, bool is_osr) {
 305   ScopeDesc* sd = trap_scope;
 306   MethodCounters* mcs;
 307   InvocationCounter* c;
 308   for (; !sd->is_top(); sd = sd->sender()) {
 309     mcs = sd->method()->method_counters();
 310     if (mcs != NULL) {
 311       // Reset ICs of inlined methods, since they can trigger compilations also.
 312       mcs->invocation_counter()->reset();
 313     }
 314   }
 315   mcs = sd->method()->method_counters();
 316   if (mcs != NULL) {
 317     c = mcs->invocation_counter();
 318     if (is_osr) {
 319       // It was an OSR method, so bump the count higher.
 320       c->set(c->state(), CompileThreshold);
 321     } else {
 322       c->reset();
 323     }
 324     mcs->backedge_counter()->reset();
 325   }
 326 }
 327 
 328 // This method can be called by any component of the runtime to notify the policy
 329 // that it's recommended to delay the complation of this method.
 330 void NonTieredCompPolicy::delay_compilation(Method* method) {
 331   MethodCounters* mcs = method->method_counters();
 332   if (mcs != NULL) {
 333     mcs->invocation_counter()->decay();
 334     mcs->backedge_counter()->decay();
 335   }
 336 }
 337 
 338 void NonTieredCompPolicy::disable_compilation(Method* method) {
 339   MethodCounters* mcs = method->method_counters();
 340   if (mcs != NULL) {
 341     mcs->invocation_counter()->set_state(InvocationCounter::wait_for_nothing);
 342     mcs->backedge_counter()->set_state(InvocationCounter::wait_for_nothing);
 343   }
 344 }
 345 
 346 CompileTask* NonTieredCompPolicy::select_task(CompileQueue* compile_queue) {
 347   return compile_queue->first();
 348 }
 349 
 350 bool NonTieredCompPolicy::is_mature(Method* method) {
 351   MethodData* mdo = method->method_data();
 352   assert(mdo != NULL, "Should be");
 353   uint current = mdo->mileage_of(method);
 354   uint initial = mdo->creation_mileage();
 355   if (current < initial)
 356     return true;  // some sort of overflow
 357   uint target;
 358   if (ProfileMaturityPercentage <= 0)
 359     target = (uint) -ProfileMaturityPercentage;  // absolute value
 360   else
 361     target = (uint)( (ProfileMaturityPercentage * CompileThreshold) / 100 );
 362   return (current >= initial + target);
 363 }
 364 
 365 nmethod* NonTieredCompPolicy::event(methodHandle method, methodHandle inlinee, int branch_bci,
 366                                     int bci, CompLevel comp_level, nmethod* nm, JavaThread* thread) {
 367   assert(comp_level == CompLevel_none, "This should be only called from the interpreter");
 368   NOT_PRODUCT(trace_frequency_counter_overflow(method, branch_bci, bci));
 369   if (JvmtiExport::can_post_interpreter_events() && thread->is_interp_only_mode()) {
 370     // If certain JVMTI events (e.g. frame pop event) are requested then the
 371     // thread is forced to remain in interpreted code. This is
 372     // implemented partly by a check in the run_compiled_code
 373     // section of the interpreter whether we should skip running
 374     // compiled code, and partly by skipping OSR compiles for
 375     // interpreted-only threads.
 376     if (bci != InvocationEntryBci) {
 377       reset_counter_for_back_branch_event(method);
 378       return NULL;
 379     }
 380   }
 381   if (CompileTheWorld || ReplayCompiles) {
 382     // Don't trigger other compiles in testing mode
 383     if (bci == InvocationEntryBci) {
 384       reset_counter_for_invocation_event(method);
 385     } else {
 386       reset_counter_for_back_branch_event(method);
 387     }
 388     return NULL;
 389   }
 390 
 391   if (bci == InvocationEntryBci) {
 392     // when code cache is full, compilation gets switched off, UseCompiler
 393     // is set to false
 394     if (!method->has_compiled_code() && UseCompiler) {
 395       method_invocation_event(method, thread);
 396     } else {
 397       // Force counter overflow on method entry, even if no compilation
 398       // happened.  (The method_invocation_event call does this also.)
 399       reset_counter_for_invocation_event(method);
 400     }
 401     // compilation at an invocation overflow no longer goes and retries test for
 402     // compiled method. We always run the loser of the race as interpreted.
 403     // so return NULL
 404     return NULL;
 405   } else {
 406     // counter overflow in a loop => try to do on-stack-replacement
 407     nmethod* osr_nm = method->lookup_osr_nmethod_for(bci, CompLevel_highest_tier, true);
 408     NOT_PRODUCT(trace_osr_request(method, osr_nm, bci));
 409     // when code cache is full, we should not compile any more...
 410     if (osr_nm == NULL && UseCompiler) {
 411       method_back_branch_event(method, bci, thread);
 412       osr_nm = method->lookup_osr_nmethod_for(bci, CompLevel_highest_tier, true);
 413     }
 414     if (osr_nm == NULL) {
 415       reset_counter_for_back_branch_event(method);
 416       return NULL;
 417     }
 418     return osr_nm;
 419   }
 420   return NULL;
 421 }
 422 
 423 #ifndef PRODUCT
 424 void NonTieredCompPolicy::trace_frequency_counter_overflow(methodHandle m, int branch_bci, int bci) {
 425   if (TraceInvocationCounterOverflow) {
 426     MethodCounters* mcs = m->method_counters();
 427     assert(mcs != NULL, "MethodCounters cannot be NULL for profiling");
 428     InvocationCounter* ic = mcs->invocation_counter();
 429     InvocationCounter* bc = mcs->backedge_counter();
 430     ResourceMark rm;
 431     const char* msg =
 432       bci == InvocationEntryBci
 433       ? "comp-policy cntr ovfl @ %d in entry of "
 434       : "comp-policy cntr ovfl @ %d in loop of ";
 435     tty->print(msg, bci);
 436     m->print_value();
 437     tty->cr();
 438     ic->print();
 439     bc->print();
 440     if (ProfileInterpreter) {
 441       if (bci != InvocationEntryBci) {
 442         MethodData* mdo = m->method_data();
 443         if (mdo != NULL) {
 444           int count = mdo->bci_to_data(branch_bci)->as_JumpData()->taken();
 445           tty->print_cr("back branch count = %d", count);
 446         }
 447       }
 448     }
 449   }
 450 }
 451 
 452 void NonTieredCompPolicy::trace_osr_request(methodHandle method, nmethod* osr, int bci) {
 453   if (TraceOnStackReplacement) {
 454     ResourceMark rm;
 455     tty->print(osr != NULL ? "Reused OSR entry for " : "Requesting OSR entry for ");
 456     method->print_short_name(tty);
 457     tty->print_cr(" at bci %d", bci);
 458   }
 459 }
 460 #endif // !PRODUCT
 461 
 462 // SimpleCompPolicy - compile current method
 463 
 464 void SimpleCompPolicy::method_invocation_event(methodHandle m, JavaThread* thread) {
 465   const int comp_level = CompLevel_highest_tier;
 466   const int hot_count = m->invocation_count();
 467   reset_counter_for_invocation_event(m);
 468   const char* comment = "count";
 469 
 470   if (is_compilation_enabled() && can_be_compiled(m, comp_level)) {
 471     nmethod* nm = m->code();
 472     if (nm == NULL ) {
 473       CompileBroker::compile_method(m, InvocationEntryBci, comp_level, m, hot_count, comment, thread);
 474     }
 475   }
 476 }
 477 
 478 void SimpleCompPolicy::method_back_branch_event(methodHandle m, int bci, JavaThread* thread) {
 479   const int comp_level = CompLevel_highest_tier;
 480   const int hot_count = m->backedge_count();
 481   const char* comment = "backedge_count";
 482 
 483   if (is_compilation_enabled() && can_be_osr_compiled(m, comp_level)) {
 484     CompileBroker::compile_method(m, bci, comp_level, m, hot_count, comment, thread);
 485     NOT_PRODUCT(trace_osr_completion(m->lookup_osr_nmethod_for(bci, comp_level, true));)
 486   }
 487 }
 488 // StackWalkCompPolicy - walk up stack to find a suitable method to compile
 489 
 490 #ifdef COMPILER2
 491 const char* StackWalkCompPolicy::_msg = NULL;
 492 
 493 
 494 // Consider m for compilation
 495 void StackWalkCompPolicy::method_invocation_event(methodHandle m, JavaThread* thread) {
 496   const int comp_level = CompLevel_highest_tier;
 497   const int hot_count = m->invocation_count();
 498   reset_counter_for_invocation_event(m);
 499   const char* comment = "count";
 500 
 501   if (is_compilation_enabled() && m->code() == NULL && can_be_compiled(m, comp_level)) {
 502     ResourceMark rm(thread);
 503     frame       fr     = thread->last_frame();
 504     assert(fr.is_interpreted_frame(), "must be interpreted");
 505     assert(fr.interpreter_frame_method() == m(), "bad method");
 506 
 507     if (TraceCompilationPolicy) {
 508       tty->print("method invocation trigger: ");
 509       m->print_short_name(tty);
 510       tty->print(" ( interpreted " INTPTR_FORMAT ", size=%d ) ", (address)m(), m->code_size());
 511     }
 512     RegisterMap reg_map(thread, false);
 513     javaVFrame* triggerVF = thread->last_java_vframe(&reg_map);
 514     // triggerVF is the frame that triggered its counter
 515     RFrame* first = new InterpretedRFrame(triggerVF->fr(), thread, m);
 516 
 517     if (first->top_method()->code() != NULL) {
 518       // called obsolete method/nmethod -- no need to recompile
 519       if (TraceCompilationPolicy) tty->print_cr(" --> " INTPTR_FORMAT, first->top_method()->code());
 520     } else {
 521       if (TimeCompilationPolicy) accumulated_time()->start();
 522       GrowableArray<RFrame*>* stack = new GrowableArray<RFrame*>(50);
 523       stack->push(first);
 524       RFrame* top = findTopInlinableFrame(stack);
 525       if (TimeCompilationPolicy) accumulated_time()->stop();
 526       assert(top != NULL, "findTopInlinableFrame returned null");
 527       if (TraceCompilationPolicy) top->print();
 528       CompileBroker::compile_method(top->top_method(), InvocationEntryBci, comp_level,
 529                                     m, hot_count, comment, thread);
 530     }
 531   }
 532 }
 533 
 534 void StackWalkCompPolicy::method_back_branch_event(methodHandle m, int bci, JavaThread* thread) {
 535   const int comp_level = CompLevel_highest_tier;
 536   const int hot_count = m->backedge_count();
 537   const char* comment = "backedge_count";
 538 
 539   if (is_compilation_enabled() && can_be_osr_compiled(m, comp_level)) {
 540     CompileBroker::compile_method(m, bci, comp_level, m, hot_count, comment, thread);
 541     NOT_PRODUCT(trace_osr_completion(m->lookup_osr_nmethod_for(bci, comp_level, true));)
 542   }
 543 }
 544 
 545 RFrame* StackWalkCompPolicy::findTopInlinableFrame(GrowableArray<RFrame*>* stack) {
 546   // go up the stack until finding a frame that (probably) won't be inlined
 547   // into its caller
 548   RFrame* current = stack->at(0); // current choice for stopping
 549   assert( current && !current->is_compiled(), "" );
 550   const char* msg = NULL;
 551 
 552   while (1) {
 553 
 554     // before going up the stack further, check if doing so would get us into
 555     // compiled code
 556     RFrame* next = senderOf(current, stack);
 557     if( !next )               // No next frame up the stack?
 558       break;                  // Then compile with current frame
 559 
 560     methodHandle m = current->top_method();
 561     methodHandle next_m = next->top_method();
 562 
 563     if (TraceCompilationPolicy && Verbose) {
 564       tty->print("[caller: ");
 565       next_m->print_short_name(tty);
 566       tty->print("] ");
 567     }
 568 
 569     if( !Inline ) {           // Inlining turned off
 570       msg = "Inlining turned off";
 571       break;
 572     }
 573     if (next_m->is_not_compilable()) { // Did fail to compile this before/
 574       msg = "caller not compilable";
 575       break;
 576     }
 577     if (next->num() > MaxRecompilationSearchLength) {
 578       // don't go up too high when searching for recompilees
 579       msg = "don't go up any further: > MaxRecompilationSearchLength";
 580       break;
 581     }
 582     if (next->distance() > MaxInterpretedSearchLength) {
 583       // don't go up too high when searching for recompilees
 584       msg = "don't go up any further: next > MaxInterpretedSearchLength";
 585       break;
 586     }
 587     // Compiled frame above already decided not to inline;
 588     // do not recompile him.
 589     if (next->is_compiled()) {
 590       msg = "not going up into optimized code";
 591       break;
 592     }
 593 
 594     // Interpreted frame above us was already compiled.  Do not force
 595     // a recompile, although if the frame above us runs long enough an
 596     // OSR might still happen.
 597     if( current->is_interpreted() && next_m->has_compiled_code() ) {
 598       msg = "not going up -- already compiled caller";
 599       break;
 600     }
 601 
 602     // Compute how frequent this call site is.  We have current method 'm'.
 603     // We know next method 'next_m' is interpreted.  Find the call site and
 604     // check the various invocation counts.
 605     int invcnt = 0;             // Caller counts
 606     if (ProfileInterpreter) {
 607       invcnt = next_m->interpreter_invocation_count();
 608     }
 609     int cnt = 0;                // Call site counts
 610     if (ProfileInterpreter && next_m->method_data() != NULL) {
 611       ResourceMark rm;
 612       int bci = next->top_vframe()->bci();
 613       ProfileData* data = next_m->method_data()->bci_to_data(bci);
 614       if (data != NULL && data->is_CounterData())
 615         cnt = data->as_CounterData()->count();
 616     }
 617 
 618     // Caller counts / call-site counts; i.e. is this call site
 619     // a hot call site for method next_m?
 620     int freq = (invcnt) ? cnt/invcnt : cnt;
 621 
 622     // Check size and frequency limits
 623     if ((msg = shouldInline(m, freq, cnt)) != NULL) {
 624       break;
 625     }
 626     // Check inlining negative tests
 627     if ((msg = shouldNotInline(m)) != NULL) {
 628       break;
 629     }
 630 
 631 
 632     // If the caller method is too big or something then we do not want to
 633     // compile it just to inline a method
 634     if (!can_be_compiled(next_m, CompLevel_any)) {
 635       msg = "caller cannot be compiled";
 636       break;
 637     }
 638 
 639     if( next_m->name() == vmSymbols::class_initializer_name() ) {
 640       msg = "do not compile class initializer (OSR ok)";
 641       break;
 642     }
 643 
 644     if (TraceCompilationPolicy && Verbose) {
 645       tty->print("\n\t     check caller: ");
 646       next_m->print_short_name(tty);
 647       tty->print(" ( interpreted " INTPTR_FORMAT ", size=%d ) ", (address)next_m(), next_m->code_size());
 648     }
 649 
 650     current = next;
 651   }
 652 
 653   assert( !current || !current->is_compiled(), "" );
 654 
 655   if (TraceCompilationPolicy && msg) tty->print("(%s)\n", msg);
 656 
 657   return current;
 658 }
 659 
 660 RFrame* StackWalkCompPolicy::senderOf(RFrame* rf, GrowableArray<RFrame*>* stack) {
 661   RFrame* sender = rf->caller();
 662   if (sender && sender->num() == stack->length()) stack->push(sender);
 663   return sender;
 664 }
 665 
 666 
 667 const char* StackWalkCompPolicy::shouldInline(methodHandle m, float freq, int cnt) {
 668   // Allows targeted inlining
 669   // positive filter: should send be inlined?  returns NULL (--> yes)
 670   // or rejection msg
 671   int max_size = MaxInlineSize;
 672   int cost = m->code_size();
 673 
 674   // Check for too many throws (and not too huge)
 675   if (m->interpreter_throwout_count() > InlineThrowCount && cost < InlineThrowMaxSize ) {
 676     return NULL;
 677   }
 678 
 679   // bump the max size if the call is frequent
 680   if ((freq >= InlineFrequencyRatio) || (cnt >= InlineFrequencyCount)) {
 681     if (TraceFrequencyInlining) {
 682       tty->print("(Inlined frequent method)\n");
 683       m->print();
 684     }
 685     max_size = FreqInlineSize;
 686   }
 687   if (cost > max_size) {
 688     return (_msg = "too big");
 689   }
 690   return NULL;
 691 }
 692 
 693 
 694 const char* StackWalkCompPolicy::shouldNotInline(methodHandle m) {
 695   // negative filter: should send NOT be inlined?  returns NULL (--> inline) or rejection msg
 696   if (m->is_abstract()) return (_msg = "abstract method");
 697   // note: we allow ik->is_abstract()
 698   if (!m->method_holder()->is_initialized()) return (_msg = "method holder not initialized");
 699   if (m->is_native()) return (_msg = "native method");
 700   nmethod* m_code = m->code();
 701   if (m_code != NULL && m_code->code_size() > InlineSmallCode)
 702     return (_msg = "already compiled into a big method");
 703 
 704   // use frequency-based objections only for non-trivial methods
 705   if (m->code_size() <= MaxTrivialSize) return NULL;
 706   if (UseInterpreter) {     // don't use counts with -Xcomp
 707     if ((m->code() == NULL) && m->was_never_executed()) return (_msg = "never executed");
 708     if (!m->was_executed_more_than(MIN2(MinInliningThreshold, CompileThreshold >> 1))) return (_msg = "executed < MinInliningThreshold times");
 709   }
 710   if (Method::has_unloaded_classes_in_signature(m, JavaThread::current())) return (_msg = "unloaded signature classes");
 711 
 712   return NULL;
 713 }
 714 
 715 
 716 
 717 #endif // COMPILER2