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