1 /*

        2  * Copyright (c) 1998, 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 "classfile/systemDictionary.hpp"

       27 #include "classfile/vmSymbols.hpp"

       28 #include "compiler/compileBroker.hpp"

       29 #include "compiler/compileLog.hpp"

       30 #include "interpreter/linkResolver.hpp"

       31 #include "oops/objArrayKlass.hpp"

       32 #include "opto/callGenerator.hpp"

       33 #include "opto/parse.hpp"

       34 #include "runtime/handles.inline.hpp"

       35 

       36 //=============================================================================

       37 //------------------------------InlineTree-------------------------------------

       38 InlineTree::InlineTree(Compile* c,

       39                        const InlineTree *caller_tree, ciMethod* callee,

       40                        JVMState* caller_jvms, int caller_bci,

       41                        float site_invoke_ratio, int max_inline_level) :

       42   C(c),

       43   _caller_jvms(caller_jvms),

       44   _caller_tree((InlineTree*) caller_tree),

       45   _method(callee),

       46   _site_invoke_ratio(site_invoke_ratio),

       47   _max_inline_level(max_inline_level),

       48   _count_inline_bcs(method()->code_size())

       49 {

       50   NOT_PRODUCT(_count_inlines = 0;)

       51   if (_caller_jvms != NULL) {

       52     // Keep a private copy of the caller_jvms:

       53     _caller_jvms = new (C) JVMState(caller_jvms->method(), caller_tree->caller_jvms());

       54     _caller_jvms->set_bci(caller_jvms->bci());

       55     assert(!caller_jvms->should_reexecute(), "there should be no reexecute bytecode with inlining");

       56   }

       57   assert(_caller_jvms->same_calls_as(caller_jvms), "consistent JVMS");

       58   assert((caller_tree == NULL ? 0 : caller_tree->stack_depth() + 1) == stack_depth(), "correct (redundant) depth parameter");

       59   assert(caller_bci == this->caller_bci(), "correct (redundant) bci parameter");

       60   if (UseOldInlining) {

       61     // Update hierarchical counts, count_inline_bcs() and count_inlines()

       62     InlineTree *caller = (InlineTree *)caller_tree;

       63     for( ; caller != NULL; caller = ((InlineTree *)(caller->caller_tree())) ) {

       64       caller->_count_inline_bcs += count_inline_bcs();

       65       NOT_PRODUCT(caller->_count_inlines++;)

       66     }

       67   }

       68 }

       69 

       70 InlineTree::InlineTree(Compile* c, ciMethod* callee_method, JVMState* caller_jvms,

       71                        float site_invoke_ratio, int max_inline_level) :

       72   C(c),

       73   _caller_jvms(caller_jvms),

       74   _caller_tree(NULL),

       75   _method(callee_method),

       76   _site_invoke_ratio(site_invoke_ratio),

       77   _max_inline_level(max_inline_level),

       78   _count_inline_bcs(method()->code_size())

       79 {

       80   NOT_PRODUCT(_count_inlines = 0;)

       81   assert(!UseOldInlining, "do not use for old stuff");

       82 }

       83 

       84 static bool is_init_with_ea(ciMethod* callee_method,

       85                             ciMethod* caller_method, Compile* C) {

       86   // True when EA is ON and a java constructor is called or

       87   // a super constructor is called from an inlined java constructor.

       88   return C->do_escape_analysis() && EliminateAllocations &&

       89          ( callee_method->is_initializer() ||

       90            (caller_method->is_initializer() &&

       91             caller_method != C->method() &&

       92             caller_method->holder()->is_subclass_of(callee_method->holder()))

       93          );

       94 }

       95 

       96 // positive filter: should send be inlined?  returns NULL, if yes, or rejection msg

       97 const char* InlineTree::should_inline(ciMethod* callee_method, ciMethod* caller_method, int caller_bci, ciCallProfile& profile, WarmCallInfo* wci_result) const {

       98   // Allows targeted inlining

       99   if(callee_method->should_inline()) {

      100     *wci_result = *(WarmCallInfo::always_hot());

      101     if (PrintInlining && Verbose) {

      102       CompileTask::print_inline_indent(inline_level());

      103       tty->print_cr("Inlined method is hot: ");

      104     }

      105     return NULL;

      106   }

      107 

      108   // positive filter: should send be inlined?  returns NULL (--> yes)

      109   // or rejection msg

      110   int size = callee_method->code_size();

      111 

      112   // Check for too many throws (and not too huge)

      113   if(callee_method->interpreter_throwout_count() > InlineThrowCount &&

      114      size < InlineThrowMaxSize ) {

      115     wci_result->set_profit(wci_result->profit() * 100);

      116     if (PrintInlining && Verbose) {

      117       CompileTask::print_inline_indent(inline_level());

      118       tty->print_cr("Inlined method with many throws (throws=%d):", callee_method->interpreter_throwout_count());

      119     }

      120     return NULL;

      121   }

      122 

      123   if (!UseOldInlining) {

      124     return NULL;  // size and frequency are represented in a new way

      125   }

      126 

      127   int default_max_inline_size = C->max_inline_size();

      128   int inline_small_code_size  = InlineSmallCode / 4;

      129   int max_inline_size         = default_max_inline_size;

      130 

      131   int call_site_count  = method()->scale_count(profile.count());

      132   int invoke_count     = method()->interpreter_invocation_count();

      133 

      134   // Bytecoded method handle adapters do not have interpreter

      135   // profiling data but only made up MDO data.  Get the counter from

      136   // there.

      137   if (caller_method->is_method_handle_adapter()) {

      138     assert(method()->method_data_or_null(), "must have an MDO");

      139     ciMethodData* mdo = method()->method_data();

      140     ciProfileData* mha_profile = mdo->bci_to_data(caller_bci);

      141     assert(mha_profile, "must exist");

      142     CounterData* cd = mha_profile->as_CounterData();

      143     invoke_count = cd->count();

      144     call_site_count = invoke_count;  // use the same value

      145   }

      146 

      147   assert(invoke_count != 0, "require invocation count greater than zero");

      148   int freq = call_site_count / invoke_count;

      149 

      150   // bump the max size if the call is frequent

      151   if ((freq >= InlineFrequencyRatio) ||

      152       (call_site_count >= InlineFrequencyCount) ||

      153       is_init_with_ea(callee_method, caller_method, C)) {

      154 

      155     max_inline_size = C->freq_inline_size();

      156     if (size <= max_inline_size && TraceFrequencyInlining) {

      157       CompileTask::print_inline_indent(inline_level());

      158       tty->print_cr("Inlined frequent method (freq=%d count=%d):", freq, call_site_count);

      159       CompileTask::print_inline_indent(inline_level());

      160       callee_method->print();

      161       tty->cr();

      162     }

      163   } else {

      164     // Not hot.  Check for medium-sized pre-existing nmethod at cold sites.

      165     if (callee_method->has_compiled_code() &&

      166         callee_method->instructions_size(CompLevel_full_optimization) > inline_small_code_size)

      167       return "already compiled into a medium method";

      168   }

      169   if (size > max_inline_size) {

      170     if (max_inline_size > default_max_inline_size)

      171       return "hot method too big";

      172     return "too big";

      173   }

      174   return NULL;

      175 }

      176 

      177 

      178 // negative filter: should send NOT be inlined?  returns NULL, ok to inline, or rejection msg

      179 const char* InlineTree::should_not_inline(ciMethod *callee_method, ciMethod* caller_method, WarmCallInfo* wci_result) const {

      180   // negative filter: should send NOT be inlined?  returns NULL (--> inline) or rejection msg

      181   if (!UseOldInlining) {

      182     const char* fail = NULL;

      183     if (callee_method->is_abstract())               fail = "abstract method";

      184     // note: we allow ik->is_abstract()

      185     if (!callee_method->holder()->is_initialized()) fail = "method holder not initialized";

      186     if (callee_method->is_native())                 fail = "native method";

      187 

      188     if (fail) {

      189       *wci_result = *(WarmCallInfo::always_cold());

      190       return fail;

      191     }

      192 

      193     if (callee_method->has_unloaded_classes_in_signature()) {

      194       wci_result->set_profit(wci_result->profit() * 0.1);

      195     }

      196 

      197     // don't inline exception code unless the top method belongs to an

      198     // exception class

      199     if (callee_method->holder()->is_subclass_of(C->env()->Throwable_klass())) {

      200       ciMethod* top_method = caller_jvms() ? caller_jvms()->of_depth(1)->method() : method();

      201       if (!top_method->holder()->is_subclass_of(C->env()->Throwable_klass())) {

      202         wci_result->set_profit(wci_result->profit() * 0.1);

      203       }

      204     }

      205 

      206     if (callee_method->has_compiled_code() && callee_method->instructions_size(CompLevel_full_optimization) > InlineSmallCode) {

      207       wci_result->set_profit(wci_result->profit() * 0.1);

      208       // %%% adjust wci_result->size()?

      209     }

      210 

      211     return NULL;

      212   }

      213 

      214   // Always inline MethodHandle methods and generated MethodHandle adapters.

      215   if (callee_method->is_method_handle_invoke() || callee_method->is_method_handle_adapter())

      216     return NULL;

      217 

      218   // First check all inlining restrictions which are required for correctness

      219   if (callee_method->is_abstract())               return "abstract method";

      220   // note: we allow ik->is_abstract()

      221   if (!callee_method->holder()->is_initialized()) return "method holder not initialized";

      222   if (callee_method->is_native())                 return "native method";

      223   if (callee_method->has_unloaded_classes_in_signature()) return "unloaded signature classes";

      224 

      225   if (callee_method->should_inline()) {

      226     // ignore heuristic controls on inlining

      227     return NULL;

      228   }

      229 

      230   // Now perform checks which are heuristic

      231 

      232   if( callee_method->has_compiled_code() && callee_method->instructions_size(CompLevel_full_optimization) > InlineSmallCode )

      233     return "already compiled into a big method";

      234 

      235   // don't inline exception code unless the top method belongs to an

      236   // exception class

      237   if (caller_tree() != NULL &&

      238       callee_method->holder()->is_subclass_of(C->env()->Throwable_klass())) {

      239     const InlineTree *top = this;

      240     while (top->caller_tree() != NULL) top = top->caller_tree();

      241     ciInstanceKlass* k = top->method()->holder();

      242     if (!k->is_subclass_of(C->env()->Throwable_klass()))

      243       return "exception method";

      244   }

      245 

      246   // use frequency-based objections only for non-trivial methods

      247   if (callee_method->code_size() <= MaxTrivialSize) return NULL;

      248 

      249   // don't use counts with -Xcomp or CTW

      250   if (UseInterpreter && !CompileTheWorld) {

      251 

      252     if (!callee_method->has_compiled_code() &&

      253         !callee_method->was_executed_more_than(0)) {

      254       return "never executed";

      255     }

      256 

      257     if (is_init_with_ea(callee_method, caller_method, C)) {

      258 

      259       // Escape Analysis: inline all executed constructors

      260 

      261     } else if (!callee_method->was_executed_more_than(MIN2(MinInliningThreshold,

      262                                                            CompileThreshold >> 1))) {

      263       return "executed < MinInliningThreshold times";

      264     }

      265   }

      266 

      267   if (callee_method->should_not_inline()) {

      268     return "disallowed by CompilerOracle";

      269   }

      270 

      271   if (UseStringCache) {

      272     // Do not inline StringCache::profile() method used only at the beginning.

      273     if (callee_method->name() == ciSymbol::profile_name() &&

      274         callee_method->holder()->name() == ciSymbol::java_lang_StringCache()) {

      275       return "profiling method";

      276     }

      277   }

      278 

      279   return NULL;

      280 }

      281 

      282 //-----------------------------try_to_inline-----------------------------------

      283 // return NULL if ok, reason for not inlining otherwise

      284 // Relocated from "InliningClosure::try_to_inline"

      285 const char* InlineTree::try_to_inline(ciMethod* callee_method, ciMethod* caller_method, int caller_bci, ciCallProfile& profile, WarmCallInfo* wci_result) {

      286 

      287   // Old algorithm had funny accumulating BC-size counters

      288   if (UseOldInlining && ClipInlining

      289       && (int)count_inline_bcs() >= DesiredMethodLimit) {

      290     return "size > DesiredMethodLimit";

      291   }

      292 

      293   const char *msg = NULL;

      294   msg = should_inline(callee_method, caller_method, caller_bci, profile, wci_result);

      295   if (msg != NULL)

      296     return msg;

      297 

      298   msg = should_not_inline(callee_method, caller_method, wci_result);

      299   if (msg != NULL)

      300     return msg;

      301 

      302   if (InlineAccessors && callee_method->is_accessor()) {

      303     // accessor methods are not subject to any of the following limits.

      304     return NULL;

      305   }

      306 

      307   // suppress a few checks for accessors and trivial methods

      308   if (callee_method->code_size() > MaxTrivialSize) {

      309 

      310     // don't inline into giant methods

      311     if (C->unique() > (uint)NodeCountInliningCutoff) {

      312       return "NodeCountInliningCutoff";

      313     }

      314 

      315     if ((!UseInterpreter || CompileTheWorld) &&

      316         is_init_with_ea(callee_method, caller_method, C)) {

      317 

      318       // Escape Analysis stress testing when running Xcomp or CTW:

      319       // inline constructors even if they are not reached.

      320 

      321     } else if (profile.count() == 0) {

      322       // don't inline unreached call sites

      323       return "call site not reached";

      324     }

      325   }

      326 

      327   if (!C->do_inlining() && InlineAccessors) {

      328     return "not an accessor";

      329   }

      330   if (inline_level() > _max_inline_level) {

      331     return "inlining too deep";

      332   }

      333 

      334   // detect direct and indirect recursive inlining

      335   {

      336     // count the current method and the callee

      337     int inline_level = (method() == callee_method) ? 1 : 0;

      338     if (inline_level > MaxRecursiveInlineLevel)

      339       return "recursively inlining too deep";

      340     // count callers of current method and callee

      341     JVMState* jvms = caller_jvms();

      342     while (jvms != NULL && jvms->has_method()) {

      343       if (jvms->method() == callee_method) {

      344         inline_level++;

      345         if (inline_level > MaxRecursiveInlineLevel)

      346           return "recursively inlining too deep";

      347       }

      348       jvms = jvms->caller();

      349     }

      350   }

      351 

      352   int size = callee_method->code_size();

      353 

      354   if (UseOldInlining && ClipInlining

      355       && (int)count_inline_bcs() + size >= DesiredMethodLimit) {

      356     return "size > DesiredMethodLimit";

      357   }

      358 

      359   // ok, inline this method

      360   return NULL;

      361 }

      362 

      363 //------------------------------pass_initial_checks----------------------------

      364 bool pass_initial_checks(ciMethod* caller_method, int caller_bci, ciMethod* callee_method) {

      365   ciInstanceKlass *callee_holder = callee_method ? callee_method->holder() : NULL;

      366   // Check if a callee_method was suggested

      367   if( callee_method == NULL )            return false;

      368   // Check if klass of callee_method is loaded

      369   if( !callee_holder->is_loaded() )      return false;

      370   if( !callee_holder->is_initialized() ) return false;

      371   if( !UseInterpreter || CompileTheWorld /* running Xcomp or CTW */ ) {

      372     // Checks that constant pool's call site has been visited

      373     // stricter than callee_holder->is_initialized()

      374     ciBytecodeStream iter(caller_method);

      375     iter.force_bci(caller_bci);

      376     Bytecodes::Code call_bc = iter.cur_bc();

      377     // An invokedynamic instruction does not have a klass.

      378     if (call_bc != Bytecodes::_invokedynamic) {

      379       int index = iter.get_index_u2_cpcache();

      380       if (!caller_method->is_klass_loaded(index, true)) {

      381         return false;

      382       }

      383       // Try to do constant pool resolution if running Xcomp

      384       if( !caller_method->check_call(index, call_bc == Bytecodes::_invokestatic) ) {

      385         return false;

      386       }

      387     }

      388   }

      389   // We will attempt to see if a class/field/etc got properly loaded.  If it

      390   // did not, it may attempt to throw an exception during our probing.  Catch

      391   // and ignore such exceptions and do not attempt to compile the method.

      392   if( callee_method->should_exclude() )  return false;

      393 

      394   return true;

      395 }

      396 

      397 //------------------------------print_inlining---------------------------------

      398 // Really, the failure_msg can be a success message also.

      399 void InlineTree::print_inlining(ciMethod* callee_method, int caller_bci, const char* failure_msg) const {

      400   CompileTask::print_inlining(callee_method, inline_level(), caller_bci, failure_msg ? failure_msg : "inline");

      401   if (callee_method == NULL)  tty->print(" callee not monotonic or profiled");

      402   if (Verbose && callee_method) {

      403     const InlineTree *top = this;

      404     while( top->caller_tree() != NULL ) { top = top->caller_tree(); }

      405     tty->print("  bcs: %d+%d  invoked: %d", top->count_inline_bcs(), callee_method->code_size(), callee_method->interpreter_invocation_count());

      406   }

      407 }

      408 

      409 //------------------------------ok_to_inline-----------------------------------

      410 WarmCallInfo* InlineTree::ok_to_inline(ciMethod* callee_method, JVMState* jvms, ciCallProfile& profile, WarmCallInfo* initial_wci) {

      411   assert(callee_method != NULL, "caller checks for optimized virtual!");

      412 #ifdef ASSERT

      413   // Make sure the incoming jvms has the same information content as me.

      414   // This means that we can eventually make this whole class AllStatic.

      415   if (jvms->caller() == NULL) {

      416     assert(_caller_jvms == NULL, "redundant instance state");

      417   } else {

      418     assert(_caller_jvms->same_calls_as(jvms->caller()), "redundant instance state");

      419   }

      420   assert(_method == jvms->method(), "redundant instance state");

      421 #endif

      422   const char *failure_msg   = NULL;

      423   int         caller_bci    = jvms->bci();

      424   ciMethod   *caller_method = jvms->method();

      425 

      426   if( !pass_initial_checks(caller_method, caller_bci, callee_method)) {

      427     if( PrintInlining ) {

      428       failure_msg = "failed_initial_checks";

      429       print_inlining( callee_method, caller_bci, failure_msg);

      430     }

      431     return NULL;

      432   }

      433 

      434   // Check if inlining policy says no.

      435   WarmCallInfo wci = *(initial_wci);

      436   failure_msg = try_to_inline(callee_method, caller_method, caller_bci, profile, &wci);

      437   if (failure_msg != NULL && C->log() != NULL) {

      438     C->log()->begin_elem("inline_fail reason='");

      439     C->log()->text("%s", failure_msg);

      440     C->log()->end_elem("'");

      441   }

      442 

      443 #ifndef PRODUCT

      444   if (UseOldInlining && InlineWarmCalls

      445       && (PrintOpto || PrintOptoInlining || PrintInlining)) {

      446     bool cold = wci.is_cold();

      447     bool hot  = !cold && wci.is_hot();

      448     bool old_cold = (failure_msg != NULL);

      449     if (old_cold != cold || (Verbose || WizardMode)) {

      450       tty->print("   OldInlining= %4s : %s\n           WCI=",

      451                  old_cold ? "cold" : "hot", failure_msg ? failure_msg : "OK");

      452       wci.print();

      453     }

      454   }

      455 #endif

      456   if (UseOldInlining) {

      457     if (failure_msg == NULL)

      458       wci = *(WarmCallInfo::always_hot());

      459     else

      460       wci = *(WarmCallInfo::always_cold());

      461   }

      462   if (!InlineWarmCalls) {

      463     if (!wci.is_cold() && !wci.is_hot()) {

      464       // Do not inline the warm calls.

      465       wci = *(WarmCallInfo::always_cold());

      466     }

      467   }

      468 

      469   if (!wci.is_cold()) {

      470     // In -UseOldInlining, the failure_msg may also be a success message.

      471     if (failure_msg == NULL)  failure_msg = "inline (hot)";

      472 

      473     // Inline!

      474     if( PrintInlining ) print_inlining( callee_method, caller_bci, failure_msg);

      475     if (UseOldInlining)

      476       build_inline_tree_for_callee(callee_method, jvms, caller_bci);

      477     if (InlineWarmCalls && !wci.is_hot())

      478       return new (C) WarmCallInfo(wci);  // copy to heap

      479     return WarmCallInfo::always_hot();

      480   }

      481 

      482   // Do not inline

      483   if (failure_msg == NULL)  failure_msg = "too cold to inline";

      484   if( PrintInlining ) print_inlining( callee_method, caller_bci, failure_msg);

      485   return NULL;

      486 }

      487 

      488 //------------------------------compute_callee_frequency-----------------------

      489 float InlineTree::compute_callee_frequency( int caller_bci ) const {

      490   int count  = method()->interpreter_call_site_count(caller_bci);

      491   int invcnt = method()->interpreter_invocation_count();

      492   float freq = (float)count/(float)invcnt;

      493   // Call-site count / interpreter invocation count, scaled recursively.

      494   // Always between 0.0 and 1.0.  Represents the percentage of the method's

      495   // total execution time used at this call site.

      496 

      497   return freq;

      498 }

      499 

      500 //------------------------------build_inline_tree_for_callee-------------------

      501 InlineTree *InlineTree::build_inline_tree_for_callee( ciMethod* callee_method, JVMState* caller_jvms, int caller_bci) {

      502   float recur_frequency = _site_invoke_ratio * compute_callee_frequency(caller_bci);

      503   // Attempt inlining.

      504   InlineTree* old_ilt = callee_at(caller_bci, callee_method);

      505   if (old_ilt != NULL) {

      506     return old_ilt;

      507   }

      508   int max_inline_level_adjust = 0;

      509   if (caller_jvms->method() != NULL) {

      510     if (caller_jvms->method()->is_method_handle_adapter())

      511       max_inline_level_adjust += 1;  // don't count actions in MH or indy adapter frames

      512     else if (callee_method->is_method_handle_invoke()) {

      513       max_inline_level_adjust += 1;  // don't count method handle calls from java.lang.invoke implem

      514     }

      515     if (max_inline_level_adjust != 0 && PrintInlining && (Verbose || WizardMode)) {

      516       CompileTask::print_inline_indent(inline_level());

      517       tty->print_cr(" \\-> discounting inline depth");

      518     }

      519     if (max_inline_level_adjust != 0 && C->log()) {

      520       int id1 = C->log()->identify(caller_jvms->method());

      521       int id2 = C->log()->identify(callee_method);

      522       C->log()->elem("inline_level_discount caller='%d' callee='%d'", id1, id2);

      523     }

      524   }

      525   InlineTree* ilt = new InlineTree(C, this, callee_method, caller_jvms, caller_bci, recur_frequency, _max_inline_level + max_inline_level_adjust);

      526   _subtrees.append(ilt);

      527 

      528   NOT_PRODUCT( _count_inlines += 1; )

      529 

      530   return ilt;

      531 }

      532 

      533 

      534 //---------------------------------------callee_at-----------------------------

      535 InlineTree *InlineTree::callee_at(int bci, ciMethod* callee) const {

      536   for (int i = 0; i < _subtrees.length(); i++) {

      537     InlineTree* sub = _subtrees.at(i);

      538     if (sub->caller_bci() == bci && callee == sub->method()) {

      539       return sub;

      540     }

      541   }

      542   return NULL;

      543 }

      544 

      545 

      546 //------------------------------build_inline_tree_root-------------------------

      547 InlineTree *InlineTree::build_inline_tree_root() {

      548   Compile* C = Compile::current();

      549 

      550   // Root of inline tree

      551   InlineTree* ilt = new InlineTree(C, NULL, C->method(), NULL, -1, 1.0F, MaxInlineLevel);

      552 

      553   return ilt;

      554 }

      555 

      556 

      557 //-------------------------find_subtree_from_root-----------------------------

      558 // Given a jvms, which determines a call chain from the root method,

      559 // find the corresponding inline tree.

      560 // Note: This method will be removed or replaced as InlineTree goes away.

      561 InlineTree* InlineTree::find_subtree_from_root(InlineTree* root, JVMState* jvms, ciMethod* callee, bool create_if_not_found) {

      562   InlineTree* iltp = root;

      563   uint depth = jvms && jvms->has_method() ? jvms->depth() : 0;

      564   for (uint d = 1; d <= depth; d++) {

      565     JVMState* jvmsp  = jvms->of_depth(d);

      566     // Select the corresponding subtree for this bci.

      567     assert(jvmsp->method() == iltp->method(), "tree still in sync");

      568     ciMethod* d_callee = (d == depth) ? callee : jvms->of_depth(d+1)->method();

      569     InlineTree* sub = iltp->callee_at(jvmsp->bci(), d_callee);

      570     if (!sub) {

      571       if (create_if_not_found && d == depth) {

      572         return iltp->build_inline_tree_for_callee(d_callee, jvmsp, jvmsp->bci());

      573       }

      574       assert(sub != NULL, "should be a sub-ilt here");

      575       return NULL;

      576     }

      577     iltp = sub;

      578   }

      579   return iltp;

      580 }