jdk8-mips64-public/hotspot: comparison src/share/vm/opto/bytecodeInfo.cpp

-:3cfb240033d1
+:e2a92dd0d3d2
 caller_method->holder()->is_subclass_of(callee_method->holder()))
 );
 }
 // positive filter: should send be inlined?  returns NULL, if yes, or rejection msg
-const char* InlineTree::shouldInline(ciMethod* callee_method, ciMethod* caller_method, int caller_bci, ciCallProfile& profile, WarmCallInfo* wci_result) const {
+const char* InlineTree::should_inline(ciMethod* callee_method, ciMethod* caller_method, int caller_bci, ciCallProfile& profile, WarmCallInfo* wci_result) const {
 // Allows targeted inlining
 if(callee_method->should_inline()) {
 *wci_result = *(WarmCallInfo::always_hot());
 if (PrintInlining && Verbose) {
 CompileTask::print_inline_indent(inline_depth());
 return NULL;
 }
 // positive filter: should send be inlined?  returns NULL (--> yes)
 // or rejection msg
-int max_size = C->max_inline_size();
+int size = callee_method->code_size();
-int size     = callee_method->code_size();
 // Check for too many throws (and not too huge)
 if(callee_method->interpreter_throwout_count() > InlineThrowCount &&
 size < InlineThrowMaxSize ) {
 wci_result->set_profit(wci_result->profit() * 100);
 if (!UseOldInlining) {
 return NULL;  // size and frequency are represented in a new way
 }
+int default_max_inline_size = C->max_inline_size();
+int inline_small_code_size  = InlineSmallCode / 4;
+int max_inline_size         = default_max_inline_size;
 int call_site_count  = method()->scale_count(profile.count());
 int invoke_count     = method()->interpreter_invocation_count();
-assert( invoke_count != 0, "Require invokation count greater than zero");
-int freq = call_site_count/invoke_count;
+// Bytecoded method handle adapters do not have interpreter
+// profiling data but only made up MDO data.  Get the counter from
+// there.
+if (caller_method->is_method_handle_adapter()) {
+assert(method()->method_data_or_null(), "must have an MDO");
+ciMethodData* mdo = method()->method_data();
+ciProfileData* mha_profile = mdo->bci_to_data(caller_bci);
+assert(mha_profile, "must exist");
+CounterData* cd = mha_profile->as_CounterData();
+invoke_count = cd->count();
+call_site_count = invoke_count;  // use the same value
+}
+assert(invoke_count != 0, "require invocation count greater than zero");
+int freq = call_site_count / invoke_count;
 // bump the max size if the call is frequent
 if ((freq >= InlineFrequencyRatio) ||
 (call_site_count >= InlineFrequencyCount) ||
 is_init_with_ea(callee_method, caller_method, C)) {
-max_size = C->freq_inline_size();
+max_inline_size = C->freq_inline_size();
-if (size <= max_size && TraceFrequencyInlining) {
+if (size <= max_inline_size && TraceFrequencyInlining) {
 CompileTask::print_inline_indent(inline_depth());
 tty->print_cr("Inlined frequent method (freq=%d count=%d):", freq, call_site_count);
 CompileTask::print_inline_indent(inline_depth());
 callee_method->print();
 tty->cr();
 }
 } else {
 // Not hot.  Check for medium-sized pre-existing nmethod at cold sites.
 if (callee_method->has_compiled_code() &&
-callee_method->instructions_size(CompLevel_full_optimization) > InlineSmallCode/4)
+callee_method->instructions_size(CompLevel_full_optimization) > inline_small_code_size)
 return "already compiled into a medium method";
 }
-if (size > max_size) {
+if (size > max_inline_size) {
-if (max_size > C->max_inline_size())
+if (max_inline_size > default_max_inline_size)
 return "hot method too big";
 return "too big";
 }
 return NULL;
 }
 // negative filter: should send NOT be inlined?  returns NULL, ok to inline, or rejection msg
-const char* InlineTree::shouldNotInline(ciMethod *callee_method, ciMethod* caller_method, WarmCallInfo* wci_result) const {
+const char* InlineTree::should_not_inline(ciMethod *callee_method, ciMethod* caller_method, WarmCallInfo* wci_result) const {
 // negative filter: should send NOT be inlined?  returns NULL (--> inline) or rejection msg
 if (!UseOldInlining) {
 const char* fail = NULL;
 if (callee_method->is_abstract())               fail = "abstract method";
 // note: we allow ik->is_abstract()
 && (int)count_inline_bcs() >= DesiredMethodLimit) {
 return "size > DesiredMethodLimit";
 }
 const char *msg = NULL;
-if ((msg = shouldInline(callee_method, caller_method, caller_bci,
+msg = should_inline(callee_method, caller_method, caller_bci, profile, wci_result);
-profile, wci_result)) != NULL) {
+if (msg != NULL)
 return msg;
-}
-if ((msg = shouldNotInline(callee_method, caller_method,
+msg = should_not_inline(callee_method, caller_method, wci_result);
-wci_result)) != NULL) {
+if (msg != NULL)
 return msg;
-}
 if (InlineAccessors && callee_method->is_accessor()) {
 // accessor methods are not subject to any of the following limits.
 return NULL;
 }
 new_depth_adjust -= 1;  // don't count actions in MH or indy adapter frames
 else if (callee_method->is_method_handle_invoke()) {
 new_depth_adjust -= 1;  // don't count method handle calls from java.lang.invoke implem
 }
 if (new_depth_adjust != 0 && PrintInlining) {
-stringStream nm1; caller_jvms->method()->print_name(&nm1);
+CompileTask::print_inline_indent(inline_depth());
-stringStream nm2; callee_method->print_name(&nm2);
+tty->print_cr(" \\-> discounting inline depth");
-tty->print_cr("discounting inlining depth from %s to %s", nm1.base(), nm2.base());
 }
 if (new_depth_adjust != 0 && C->log()) {
 int id1 = C->log()->identify(caller_jvms->method());
 int id2 = C->log()->identify(callee_method);
 C->log()->elem("inline_depth_discount caller='%d' callee='%d'", id1, id2);

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/opto/bytecodeInfo.cpp

src/share/vm/opto/bytecodeInfo.cpp