graal-compiler: src/share/vm/opto/bytecodeInfo.cpp comparison

comparison src/share/vm/opto/bytecodeInfo.cpp @ 8124:5fc51c1ecdeb

Merge.

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Tue, 05 Mar 2013 23:44:54 +0100
parents	989155e2d07a 133bf557ef77
children	b8f261ba79c6

comparison

equal deleted inserted replaced

-:a413bcd552a4
+:5fc51c1ecdeb
 _caller_tree((InlineTree*) caller_tree),
 _method(callee),
 _site_invoke_ratio(site_invoke_ratio),
 _max_inline_level(max_inline_level),
 _count_inline_bcs(method()->code_size_for_inlining()),
-_subtrees(c->comp_arena(), 2, 0, NULL)
+_subtrees(c->comp_arena(), 2, 0, NULL),
+_msg(NULL)
 {
 NOT_PRODUCT(_count_inlines = 0;)
 if (_caller_jvms != NULL) {
 // Keep a private copy of the caller_jvms:
 _caller_jvms = new (C) JVMState(caller_jvms->method(), caller_tree->caller_jvms());
 _caller_jvms(caller_jvms),
 _caller_tree(NULL),
 _method(callee_method),
 _site_invoke_ratio(site_invoke_ratio),
 _max_inline_level(max_inline_level),
-_count_inline_bcs(method()->code_size())
+_count_inline_bcs(method()->code_size()),
+_msg(NULL)
 {
 NOT_PRODUCT(_count_inlines = 0;)
 assert(!UseOldInlining, "do not use for old stuff");
 }
 caller_method != C->method() &&
 caller_method->holder()->is_subclass_of(callee_method->holder()))
 );
 }
-// positive filter: should callee be inlined?  returns NULL, if yes, or rejection msg
+// positive filter: should callee be inlined?
-const char* InlineTree::should_inline(ciMethod* callee_method, ciMethod* caller_method, int caller_bci, ciCallProfile& profile, WarmCallInfo* wci_result) const {
+bool InlineTree::should_inline(ciMethod* callee_method, ciMethod* caller_method,
+int caller_bci, ciCallProfile& profile,
+WarmCallInfo* wci_result) {
 // Allows targeted inlining
 if(callee_method->should_inline()) {
 *wci_result = *(WarmCallInfo::always_hot());
 if (PrintInlining && Verbose) {
 CompileTask::print_inline_indent(inline_level());
 tty->print_cr("Inlined method is hot: ");
 }
-return NULL;
+set_msg("force inline by CompilerOracle");
-}
+return true;
+}
-// positive filter: should send be inlined?  returns NULL (--> yes)
-// or rejection msg
 int size = callee_method->code_size_for_inlining();
 // 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 (PrintInlining && Verbose) {
 CompileTask::print_inline_indent(inline_level());
 tty->print_cr("Inlined method with many throws (throws=%d):", callee_method->interpreter_throwout_count());
 }
-return NULL;
+set_msg("many throws");
+return true;
 }
 if (!UseOldInlining) {
-return NULL;  // size and frequency are represented in a new way
+set_msg("!UseOldInlining");
+return true;  // 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;
 }
 } else {
 // Not hot.  Check for medium-sized pre-existing nmethod at cold sites.
 if (callee_method->has_compiled_code() &&
 callee_method->instructions_size() > inline_small_code_size)
-return "already compiled into a medium method";
+set_msg("already compiled into a medium method");
+return false;
 }
 if (size > max_inline_size) {
-if (max_inline_size > default_max_inline_size)
+if (max_inline_size > default_max_inline_size) {
-return "hot method too big";
+set_msg("hot method too big");
-return "too big";
+} else {
-}
+set_msg("too big");
-return NULL;
+}
-}
+return false;
+}
+return true;
-// negative filter: should callee NOT be inlined?  returns NULL, ok to inline, or rejection msg
+}
-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
+// negative filter: should callee NOT be inlined?
+bool InlineTree::should_not_inline(ciMethod *callee_method,
+ciMethod* caller_method,
+WarmCallInfo* wci_result) {
+const char* fail_msg = NULL;
+// First check all inlining restrictions which are required for correctness
+if ( callee_method->is_abstract()) {
+fail_msg = "abstract method"; // // note: we allow ik->is_abstract()
+} else if (!callee_method->holder()->is_initialized()) {
+fail_msg = "method holder not initialized";
+} else if ( callee_method->is_native()) {
+fail_msg = "native method";
+} else if ( callee_method->dont_inline()) {
+fail_msg = "don't inline by annotation";
+}
 if (!UseOldInlining) {
-const char* fail = NULL;
+if (fail_msg != NULL) {
-if ( callee_method->is_abstract())               fail = "abstract method";
-// note: we allow ik->is_abstract()
-if (!callee_method->holder()->is_initialized())  fail = "method holder not initialized";
-if ( callee_method->is_native())                 fail = "native method";
-if ( callee_method->dont_inline())               fail = "don't inline by annotation";
-if (fail) {
 *wci_result = *(WarmCallInfo::always_cold());
-return fail;
+set_msg(fail_msg);
+return true;
 }
 if (callee_method->has_unloaded_classes_in_signature()) {
 wci_result->set_profit(wci_result->profit() * 0.1);
 }
 callee_method->instructions_size() > InlineSmallCode) {
 wci_result->set_profit(wci_result->profit() * 0.1);
 // %%% adjust wci_result->size()?
 }
-return NULL;
+return false;
 }
-// First check all inlining restrictions which are required for correctness
+// one more inlining restriction
-if ( callee_method->is_abstract())                        return "abstract method";
+if (fail_msg == NULL && callee_method->has_unloaded_classes_in_signature()) {
-// note: we allow ik->is_abstract()
+fail_msg = "unloaded signature classes";
-if (!callee_method->holder()->is_initialized())           return "method holder not initialized";
+}
-if ( callee_method->is_native())                          return "native method";
-if ( callee_method->dont_inline())                        return "don't inline by annotation";
+if (fail_msg != NULL) {
-if ( callee_method->has_unloaded_classes_in_signature())  return "unloaded signature classes";
+set_msg(fail_msg);
+return true;
+}
+// ignore heuristic controls on inlining
 if (callee_method->should_inline()) {
-// ignore heuristic controls on inlining
+set_msg("force inline by CompilerOracle");
-return NULL;
+return false;
 }
 if (callee_method->should_not_inline()) {
 return "disallowed by CompilerOracle";
 }
 // Now perform checks which are heuristic
 if (!callee_method->force_inline()) {
 if (callee_method->has_compiled_code() &&
 callee_method->instructions_size() > InlineSmallCode) {
-return "already compiled into a big method";
+set_msg("already compiled into a big method");
+return true;
 }
 }
 // don't inline exception code unless the top method belongs to an
 // exception class
 if (caller_tree() != NULL &&
 callee_method->holder()->is_subclass_of(C->env()->Throwable_klass())) {
 const InlineTree *top = this;
 while (top->caller_tree() != NULL) top = top->caller_tree();
 ciInstanceKlass* k = top->method()->holder();
-if (!k->is_subclass_of(C->env()->Throwable_klass()))
+if (!k->is_subclass_of(C->env()->Throwable_klass())) {
-return "exception method";
+set_msg("exception method");
+return true;
+}
 }
 if (callee_method->should_not_inline()) {
-return "disallowed by CompilerOracle";
+set_msg("disallowed by CompilerOracle");
+return true;
 }
 #ifndef PRODUCT
 if (ciReplay::should_not_inline(callee_method)) {
-return "disallowed by ciReplay";
+set_msg("disallowed by ciReplay");
+return true;
 }
 #endif
 if (UseStringCache) {
 // Do not inline StringCache::profile() method used only at the beginning.
 if (callee_method->name() == ciSymbol::profile_name() &&
 callee_method->holder()->name() == ciSymbol::java_lang_StringCache()) {
-return "profiling method";
+set_msg("profiling method");
+return true;
 }
 }
 // use frequency-based objections only for non-trivial methods
-if (callee_method->code_size() <= MaxTrivialSize) return NULL;
+if (callee_method->code_size() <= MaxTrivialSize) {
+return false;
+}
 // don't use counts with -Xcomp or CTW
 if (UseInterpreter && !CompileTheWorld) {
 if (!callee_method->has_compiled_code() &&
 !callee_method->was_executed_more_than(0)) {
-return "never executed";
+set_msg("never executed");
+return true;
 }
 if (is_init_with_ea(callee_method, caller_method, C)) {
 // Escape Analysis: inline all executed constructors
 } else if (!callee_method->was_executed_more_than(MIN2(MinInliningThreshold,
 CompileThreshold >> 1))) {
-return "executed < MinInliningThreshold times";
+set_msg("executed < MinInliningThreshold times");
-}
+return true;
 }
+}
-return NULL;
+return false;
 }
 //-----------------------------try_to_inline-----------------------------------
-// return NULL if ok, reason for not inlining otherwise
+// return true if ok
 // Relocated from "InliningClosure::try_to_inline"
-const char* InlineTree::try_to_inline(ciMethod* callee_method, ciMethod* caller_method, int caller_bci, ciCallProfile& profile, WarmCallInfo* wci_result, bool& should_delay) {
+bool InlineTree::try_to_inline(ciMethod* callee_method, ciMethod* caller_method,
-// Old algorithm had funny accumulating BC-size counters
+int caller_bci, ciCallProfile& profile,
+WarmCallInfo* wci_result, bool& should_delay) {
+// Old algorithm had funny accumulating BC-size counters
 if (UseOldInlining && ClipInlining
 && (int)count_inline_bcs() >= DesiredMethodLimit) {
 if (!callee_method->force_inline() || !IncrementalInline) {
-return "size > DesiredMethodLimit";
+set_msg("size > DesiredMethodLimit");
+return false;
 } else if (!C->inlining_incrementally()) {
 should_delay = true;
 }
 }
-const char *msg = NULL;
+if (!should_inline(callee_method, caller_method, caller_bci, profile,
-msg = should_inline(callee_method, caller_method, caller_bci, profile, wci_result);
+wci_result)) {
-if (msg != NULL)
+return false;
-return msg;
+}
+if (should_not_inline(callee_method, caller_method, wci_result)) {
-msg = should_not_inline(callee_method, caller_method, wci_result);
+return false;
-if (msg != NULL)
+}
-return msg;
 if (InlineAccessors && callee_method->is_accessor()) {
 // accessor methods are not subject to any of the following limits.
-return NULL;
+set_msg("accessor");
+return true;
 }
 // suppress a few checks for accessors and trivial methods
 if (callee_method->code_size() > MaxTrivialSize) {
 // don't inline into giant methods
 if (C->over_inlining_cutoff()) {
 if ((!callee_method->force_inline() && !caller_method->is_compiled_lambda_form())
 || !IncrementalInline) {
-return "NodeCountInliningCutoff";
+set_msg("NodeCountInliningCutoff");
+return false;
 } else {
 should_delay = true;
 }
 }
 // Escape Analysis stress testing when running Xcomp or CTW:
 // inline constructors even if they are not reached.
 } else if (profile.count() == 0) {
 // don't inline unreached call sites
-return "call site not reached";
+set_msg("call site not reached");
+return false;
 }
 }
 if (!C->do_inlining() && InlineAccessors) {
-return "not an accessor";
+set_msg("not an accessor");
+return false;
 }
 if (inline_level() > _max_inline_level) {
 if (!callee_method->force_inline() || !IncrementalInline) {
-return "inlining too deep";
+set_msg("inlining too deep");
+return false;
 } else if (!C->inlining_incrementally()) {
 should_delay = true;
 }
 }
 // detect direct and indirect recursive inlining
 if (!callee_method->is_compiled_lambda_form()) {
 // count the current method and the callee
 int inline_level = (method() == callee_method) ? 1 : 0;
-if (inline_level > MaxRecursiveInlineLevel)
+if (inline_level > MaxRecursiveInlineLevel) {
-return "recursively inlining too deep";
+set_msg("recursively inlining too deep");
+return false;
+}
 // count callers of current method and callee
 JVMState* jvms = caller_jvms();
 while (jvms != NULL && jvms->has_method()) {
 if (jvms->method() == callee_method) {
 inline_level++;
-if (inline_level > MaxRecursiveInlineLevel)
+if (inline_level > MaxRecursiveInlineLevel) {
-return "recursively inlining too deep";
+set_msg("recursively inlining too deep");
+return false;
+}
 }
 jvms = jvms->caller();
 }
 }
 int size = callee_method->code_size_for_inlining();
 if (UseOldInlining && ClipInlining
 && (int)count_inline_bcs() + size >= DesiredMethodLimit) {
 if (!callee_method->force_inline() || !IncrementalInline) {
-return "size > DesiredMethodLimit";
+set_msg("size > DesiredMethodLimit");
+return false;
 } else if (!C->inlining_incrementally()) {
 should_delay = true;
 }
 }
 // ok, inline this method
-return NULL;
+return true;
 }
 //------------------------------pass_initial_checks----------------------------
 bool pass_initial_checks(ciMethod* caller_method, int caller_bci, ciMethod* callee_method) {
 ciInstanceKlass *callee_holder = callee_method ? callee_method->holder() : NULL;
 if ( callee->get_flow_analysis()->failing())  return "not compilable (flow analysis failed)";
 return NULL;
 }
 //------------------------------print_inlining---------------------------------
-// Really, the failure_msg can be a success message also.
+void InlineTree::print_inlining(ciMethod* callee_method, int caller_bci,
-void InlineTree::print_inlining(ciMethod* callee_method, int caller_bci, const char* failure_msg) const {
+bool success) const {
-C->print_inlining(callee_method, inline_level(), caller_bci, failure_msg ? failure_msg : "inline");
+const char* inline_msg = msg();
-if (callee_method == NULL)  tty->print(" callee not monotonic or profiled");
+assert(inline_msg != NULL, "just checking");
-if (Verbose && callee_method) {
+if (C->log() != NULL) {
-const InlineTree *top = this;
+if (success) {
-while( top->caller_tree() != NULL ) { top = top->caller_tree(); }
+C->log()->inline_success(inline_msg);
-//tty->print("  bcs: %d+%d  invoked: %d", top->count_inline_bcs(), callee_method->code_size(), callee_method->interpreter_invocation_count());
+} else {
+C->log()->inline_fail(inline_msg);
+}
+}
+if (PrintInlining) {
+C->print_inlining(callee_method, inline_level(), caller_bci, inline_msg);
+if (callee_method == NULL) tty->print(" callee not monotonic or profiled");
+if (Verbose && callee_method) {
+const InlineTree *top = this;
+while( top->caller_tree() != NULL ) { top = top->caller_tree(); }
+//tty->print("  bcs: %d+%d  invoked: %d", top->count_inline_bcs(), callee_method->code_size(), callee_method->interpreter_invocation_count());
+}
 }
 }
 //------------------------------ok_to_inline-----------------------------------
 WarmCallInfo* InlineTree::ok_to_inline(ciMethod* callee_method, JVMState* jvms, ciCallProfile& profile, WarmCallInfo* initial_wci, bool& should_delay) {
 } else {
 assert(_caller_jvms->same_calls_as(jvms->caller()), "redundant instance state");
 }
 assert(_method == jvms->method(), "redundant instance state");
 #endif
-const char *failure_msg   = NULL;
 int         caller_bci    = jvms->bci();
-ciMethod   *caller_method = jvms->method();
+ciMethod*   caller_method = jvms->method();
 // Do some initial checks.
 if (!pass_initial_checks(caller_method, caller_bci, callee_method)) {
-if (PrintInlining)  print_inlining(callee_method, caller_bci, "failed initial checks");
+set_msg("failed initial checks");
+print_inlining(callee_method, caller_bci, false /* !success */);
 return NULL;
 }
 // Do some parse checks.
-failure_msg = check_can_parse(callee_method);
+set_msg(check_can_parse(callee_method));
-if (failure_msg != NULL) {
+if (msg() != NULL) {
-if (PrintInlining)  print_inlining(callee_method, caller_bci, failure_msg);
+print_inlining(callee_method, caller_bci, false /* !success */);
 return NULL;
 }
 // Check if inlining policy says no.
 WarmCallInfo wci = *(initial_wci);
-failure_msg = try_to_inline(callee_method, caller_method, caller_bci, profile, &wci, should_delay);
+bool success = try_to_inline(callee_method, caller_method, caller_bci,
-if (failure_msg != NULL && C->log() != NULL) {
+profile, &wci, should_delay);
-C->log()->inline_fail(failure_msg);
-}
 #ifndef PRODUCT
 if (UseOldInlining && InlineWarmCalls
 && (PrintOpto || PrintOptoInlining || PrintInlining)) {
 bool cold = wci.is_cold();
 bool hot  = !cold && wci.is_hot();
-bool old_cold = (failure_msg != NULL);
+bool old_cold = !success;
 if (old_cold != cold || (Verbose || WizardMode)) {
+if (msg() == NULL) {
+set_msg("OK");
+}
 tty->print("   OldInlining= %4s : %s\n           WCI=",
-old_cold ? "cold" : "hot", failure_msg ? failure_msg : "OK");
+old_cold ? "cold" : "hot", msg());
 wci.print();
 }
 }
 #endif
 if (UseOldInlining) {
-if (failure_msg == NULL)
+if (success) {
 wci = *(WarmCallInfo::always_hot());
-else
+} else {
 wci = *(WarmCallInfo::always_cold());
+}
 }
 if (!InlineWarmCalls) {
 if (!wci.is_cold() && !wci.is_hot()) {
 // Do not inline the warm calls.
 wci = *(WarmCallInfo::always_cold());
 }
 }
 if (!wci.is_cold()) {
-// In -UseOldInlining, the failure_msg may also be a success message.
-if (failure_msg == NULL)  failure_msg = "inline (hot)";
 // Inline!
-if (PrintInlining)  print_inlining(callee_method, caller_bci, failure_msg);
+if (msg() == NULL) {
+set_msg("inline (hot)");
+}
+print_inlining(callee_method, caller_bci, true /* success */);
 if (UseOldInlining)
 build_inline_tree_for_callee(callee_method, jvms, caller_bci);
 if (InlineWarmCalls && !wci.is_hot())
 return new (C) WarmCallInfo(wci);  // copy to heap
 return WarmCallInfo::always_hot();
 }
 // Do not inline
-if (failure_msg == NULL)  failure_msg = "too cold to inline";
+if (msg() == NULL) {
-if (PrintInlining)  print_inlining(callee_method, caller_bci, failure_msg);
+set_msg("too cold to inline");
+}
+print_inlining(callee_method, caller_bci, false /* !success */ );
 return NULL;
 }
 //------------------------------compute_callee_frequency-----------------------
 float InlineTree::compute_callee_frequency( int caller_bci ) const {

Mercurial > hg > graal-compiler

comparison src/share/vm/opto/bytecodeInfo.cpp @ 8124:5fc51c1ecdeb