1 /*
   2  * Copyright (c) 2000, 2014, 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, p2i(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     FLAG_SET_ERGO(intx, CICompilerCount, _compiler_count);
 186   } else {
 187     _compiler_count = CICompilerCount;
 188   }
 189 }
 190 
 191 // Note: this policy is used ONLY if TieredCompilation is off.
 192 // compiler_count() behaves the following way:
 193 // - with TIERED build (with both COMPILER1 and COMPILER2 defined) it should return
 194 //   zero for the c1 compilation levels, hence the particular ordering of the
 195 //   statements.
 196 // - the same should happen when COMPILER2 is defined and COMPILER1 is not
 197 //   (server build without TIERED defined).
 198 // - if only COMPILER1 is defined (client build), zero should be returned for
 199 //   the c2 level.
 200 // - if neither is defined - always return zero.
 201 int NonTieredCompPolicy::compiler_count(CompLevel comp_level) {
 202   assert(!TieredCompilation, "This policy should not be used with TieredCompilation");
 203 #ifdef COMPILER2
 204   if (is_c2_compile(comp_level)) {
 205     return _compiler_count;
 206   } else {
 207     return 0;
 208   }
 209 #endif
 210 
 211 #ifdef COMPILER1
 212   if (is_c1_compile(comp_level)) {
 213     return _compiler_count;
 214   } else {
 215     return 0;
 216   }
 217 #endif
 218 
 219   return 0;
 220 }
 221 
 222 void NonTieredCompPolicy::reset_counter_for_invocation_event(methodHandle m) {
 223   // Make sure invocation and backedge counter doesn't overflow again right away
 224   // as would be the case for native methods.
 225 
 226   // BUT also make sure the method doesn't look like it was never executed.
 227   // Set carry bit and reduce counter's value to min(count, CompileThreshold/2).
 228   MethodCounters* mcs = m->method_counters();
 229   assert(mcs != NULL, "MethodCounters cannot be NULL for profiling");
 230   mcs->invocation_counter()->set_carry();
 231   mcs->backedge_counter()->set_carry();
 232 
 233   assert(!m->was_never_executed(), "don't reset to 0 -- could be mistaken for never-executed");
 234 }
 235 
 236 void NonTieredCompPolicy::reset_counter_for_back_branch_event(methodHandle m) {
 237   // Delay next back-branch event but pump up invocation counter to triger
 238   // whole method compilation.
 239   MethodCounters* mcs = m->method_counters();
 240   assert(mcs != NULL, "MethodCounters cannot be NULL for profiling");
 241   InvocationCounter* i = mcs->invocation_counter();
 242   InvocationCounter* b = mcs->backedge_counter();
 243 
 244   // Don't set invocation_counter's value too low otherwise the method will
 245   // look like immature (ic < ~5300) which prevents the inlining based on
 246   // the type profiling.
 247   i->set(i->state(), CompileThreshold);
 248   // Don't reset counter too low - it is used to check if OSR method is ready.
 249   b->set(b->state(), CompileThreshold / 2);
 250 }
 251 
 252 //
 253 // CounterDecay
 254 //
 255 // Interates through invocation counters and decrements them. This
 256 // is done at each safepoint.
 257 //
 258 class CounterDecay : public AllStatic {
 259   static jlong _last_timestamp;
 260   static void do_method(Method* m) {
 261     MethodCounters* mcs = m->method_counters();
 262     if (mcs != NULL) {
 263       mcs->invocation_counter()->decay();
 264     }
 265   }
 266 public:
 267   static void decay();
 268   static bool is_decay_needed() {
 269     return (os::javaTimeMillis() - _last_timestamp) > CounterDecayMinIntervalLength;
 270   }
 271 };
 272 
 273 jlong CounterDecay::_last_timestamp = 0;
 274 
 275 void CounterDecay::decay() {
 276   _last_timestamp = os::javaTimeMillis();
 277 
 278   // This operation is going to be performed only at the end of a safepoint
 279   // and hence GC's will not be going on, all Java mutators are suspended
 280   // at this point and hence SystemDictionary_lock is also not needed.
 281   assert(SafepointSynchronize::is_at_safepoint(), "can only be executed at a safepoint");
 282   int nclasses = SystemDictionary::number_of_classes();
 283   double classes_per_tick = nclasses * (CounterDecayMinIntervalLength * 1e-3 /
 284                                         CounterHalfLifeTime);
 285   for (int i = 0; i < classes_per_tick; i++) {
 286     Klass* k = SystemDictionary::try_get_next_class();
 287     if (k != NULL && k->oop_is_instance()) {
 288       InstanceKlass::cast(k)->methods_do(do_method);
 289     }
 290   }
 291 }
 292 
 293 // Called at the end of the safepoint
 294 void NonTieredCompPolicy::do_safepoint_work() {
 295   if(UseCounterDecay && CounterDecay::is_decay_needed()) {
 296     CounterDecay::decay();
 297   }
 298 }
 299 
 300 void NonTieredCompPolicy::reprofile(ScopeDesc* trap_scope, bool is_osr) {
 301   ScopeDesc* sd = trap_scope;
 302   MethodCounters* mcs;
 303   InvocationCounter* c;
 304   for (; !sd->is_top(); sd = sd->sender()) {
 305     mcs = sd->method()->method_counters();
 306     if (mcs != NULL) {
 307       // Reset ICs of inlined methods, since they can trigger compilations also.
 308       mcs->invocation_counter()->reset();
 309     }
 310   }
 311   mcs = sd->method()->method_counters();
 312   if (mcs != NULL) {
 313     c = mcs->invocation_counter();
 314     if (is_osr) {
 315       // It was an OSR method, so bump the count higher.
 316       c->set(c->state(), CompileThreshold);
 317     } else {
 318       c->reset();
 319     }
 320     mcs->backedge_counter()->reset();
 321   }
 322 }
 323 
 324 // This method can be called by any component of the runtime to notify the policy
 325 // that it's recommended to delay the complation of this method.
 326 void NonTieredCompPolicy::delay_compilation(Method* method) {
 327   MethodCounters* mcs = method->method_counters();
 328   if (mcs != NULL) {
 329     mcs->invocation_counter()->decay();
 330     mcs->backedge_counter()->decay();
 331   }
 332 }
 333 
 334 void NonTieredCompPolicy::disable_compilation(Method* method) {
 335   MethodCounters* mcs = method->method_counters();
 336   if (mcs != NULL) {
 337     mcs->invocation_counter()->set_state(InvocationCounter::wait_for_nothing);
 338     mcs->backedge_counter()->set_state(InvocationCounter::wait_for_nothing);
 339   }
 340 }
 341 
 342 CompileTask* NonTieredCompPolicy::select_task(CompileQueue* compile_queue) {
 343   return compile_queue->first();
 344 }
 345 
 346 bool NonTieredCompPolicy::is_mature(Method* method) {
 347   MethodData* mdo = method->method_data();
 348   assert(mdo != NULL, "Should be");
 349   uint current = mdo->mileage_of(method);
 350   uint initial = mdo->creation_mileage();
 351   if (current < initial)
 352     return true;  // some sort of overflow
 353   uint target;
 354   if (ProfileMaturityPercentage <= 0)
 355     target = (uint) -ProfileMaturityPercentage;  // absolute value
 356   else
 357     target = (uint)( (ProfileMaturityPercentage * CompileThreshold) / 100 );
 358   return (current >= initial + target);
 359 }
 360 
 361 nmethod* NonTieredCompPolicy::event(methodHandle method, methodHandle inlinee, int branch_bci,
 362                                     int bci, CompLevel comp_level, nmethod* nm, JavaThread* thread) {
 363   assert(comp_level == CompLevel_none, "This should be only called from the interpreter");
 364   NOT_PRODUCT(trace_frequency_counter_overflow(method, branch_bci, bci));
 365   if (JvmtiExport::can_post_interpreter_events() && thread->is_interp_only_mode()) {
 366     // If certain JVMTI events (e.g. frame pop event) are requested then the
 367     // thread is forced to remain in interpreted code. This is
 368     // implemented partly by a check in the run_compiled_code
 369     // section of the interpreter whether we should skip running
 370     // compiled code, and partly by skipping OSR compiles for
 371     // interpreted-only threads.
 372     if (bci != InvocationEntryBci) {
 373       reset_counter_for_back_branch_event(method);
 374       return NULL;
 375     }
 376   }
 377   if (CompileTheWorld || ReplayCompiles) {
 378     // Don't trigger other compiles in testing mode
 379     if (bci == InvocationEntryBci) {
 380       reset_counter_for_invocation_event(method);
 381     } else {
 382       reset_counter_for_back_branch_event(method);
 383     }
 384     return NULL;
 385   }
 386 
 387   if (bci == InvocationEntryBci) {
 388     // when code cache is full, compilation gets switched off, UseCompiler
 389     // is set to false
 390     if (!method->has_compiled_code() && UseCompiler) {
 391       method_invocation_event(method, thread);
 392     } else {
 393       // Force counter overflow on method entry, even if no compilation
 394       // happened.  (The method_invocation_event call does this also.)
 395       reset_counter_for_invocation_event(method);
 396     }
 397     // compilation at an invocation overflow no longer goes and retries test for
 398     // compiled method. We always run the loser of the race as interpreted.
 399     // so return NULL
 400     return NULL;
 401   } else {
 402     // counter overflow in a loop => try to do on-stack-replacement
 403     nmethod* osr_nm = method->lookup_osr_nmethod_for(bci, CompLevel_highest_tier, true);
 404     NOT_PRODUCT(trace_osr_request(method, osr_nm, bci));
 405     // when code cache is full, we should not compile any more...
 406     if (osr_nm == NULL && UseCompiler) {
 407       method_back_branch_event(method, bci, thread);
 408       osr_nm = method->lookup_osr_nmethod_for(bci, CompLevel_highest_tier, true);
 409     }
 410     if (osr_nm == NULL) {
 411       reset_counter_for_back_branch_event(method);
 412       return NULL;
 413     }
 414     return osr_nm;
 415   }
 416   return NULL;
 417 }
 418 
 419 #ifndef PRODUCT
 420 PRAGMA_FORMAT_NONLITERAL_IGNORED_EXTERNAL
 421 void NonTieredCompPolicy::trace_frequency_counter_overflow(methodHandle m, int branch_bci, int bci) {
 422   if (TraceInvocationCounterOverflow) {
 423     MethodCounters* mcs = m->method_counters();
 424     assert(mcs != NULL, "MethodCounters cannot be NULL for profiling");
 425     InvocationCounter* ic = mcs->invocation_counter();
 426     InvocationCounter* bc = mcs->backedge_counter();
 427     ResourceMark rm;
 428     const char* msg =
 429       bci == InvocationEntryBci
 430       ? "comp-policy cntr ovfl @ %d in entry of "
 431       : "comp-policy cntr ovfl @ %d in loop of ";
 432 PRAGMA_DIAG_PUSH
 433 PRAGMA_FORMAT_NONLITERAL_IGNORED_INTERNAL
 434     tty->print(msg, bci);
 435 PRAGMA_DIAG_POP
 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 ) ", p2i((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, p2i(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 ) ", p2i((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