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

comparison src/share/vm/opto/bytecodeInfo.cpp @ 14422:2b8e28fdf503

Merge

author	kvn
date	Tue, 05 Nov 2013 17:38:04 -0800
parents	0c4c40f5c399
children	e74074c34312

comparison

equal deleted inserted replaced

-:3068270ba476
+:2b8e28fdf503
 int caller_bci, ciCallProfile& profile,
 WarmCallInfo* wci_result) {
 // Allows targeted inlining
 if(callee_method->should_inline()) {
 *wci_result = *(WarmCallInfo::always_hot());
-if (PrintInlining && Verbose) {
+if (C->print_inlining() && Verbose) {
 CompileTask::print_inline_indent(inline_level());
 tty->print_cr("Inlined method is hot: ");
 }
 set_msg("force inline by CompilerOracle");
 return true;
 // 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) {
+if (C->print_inlining() && Verbose) {
 CompileTask::print_inline_indent(inline_level());
 tty->print_cr("Inlined method with many throws (throws=%d):", callee_method->interpreter_throwout_count());
 }
 set_msg("many throws");
 return true;
 // negative filter: should callee NOT be inlined?
 bool InlineTree::should_not_inline(ciMethod *callee_method,
 ciMethod* caller_method,
+JVMState* jvms,
 WarmCallInfo* wci_result) {
 const char* fail_msg = NULL;
 // First check all inlining restrictions which are required for correctness
 }
 // don't inline exception code unless the top method belongs to an
 // exception class
 if (callee_method->holder()->is_subclass_of(C->env()->Throwable_klass())) {
-ciMethod* top_method = caller_jvms() ? caller_jvms()->of_depth(1)->method() : method();
+ciMethod* top_method = jvms->caller() != NULL ? jvms->caller()->of_depth(1)->method() : method();
 if (!top_method->holder()->is_subclass_of(C->env()->Throwable_klass())) {
 wci_result->set_profit(wci_result->profit() * 0.1);
 }
 }
 //-----------------------------try_to_inline-----------------------------------
 // return true if ok
 // Relocated from "InliningClosure::try_to_inline"
 bool InlineTree::try_to_inline(ciMethod* callee_method, ciMethod* caller_method,
-int caller_bci, ciCallProfile& profile,
+int caller_bci, JVMState* jvms, 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 (!should_inline(callee_method, caller_method, caller_bci, profile,
 wci_result)) {
 return false;
 }
-if (should_not_inline(callee_method, caller_method, wci_result)) {
+if (should_not_inline(callee_method, caller_method, jvms, wci_result)) {
 return false;
 }
 if (InlineAccessors && callee_method->is_accessor()) {
 // accessor methods are not subject to any of the following limits.
 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;
+const bool is_compiled_lambda_form = callee_method->is_compiled_lambda_form();
-if (inline_level > MaxRecursiveInlineLevel) {
+int inline_level = 0;
-set_msg("recursively inlining too deep");
+if (!is_compiled_lambda_form) {
-return false;
+if (method() == callee_method) {
+inline_level++;
+}
 }
 // count callers of current method and callee
-JVMState* jvms = caller_jvms();
+Node* callee_argument0 = is_compiled_lambda_form ? jvms->map()->argument(jvms, 0)->uncast() : NULL;
-while (jvms != NULL && jvms->has_method()) {
+for (JVMState* j = jvms->caller(); j != NULL && j->has_method(); j = j->caller()) {
-if (jvms->method() == callee_method) {
+if (j->method() == callee_method) {
-inline_level++;
+if (is_compiled_lambda_form) {
-if (inline_level > MaxRecursiveInlineLevel) {
+// Since compiled lambda forms are heavily reused we allow recursive inlining.  If it is truly
-set_msg("recursively inlining too deep");
+// a recursion (using the same "receiver") we limit inlining otherwise we can easily blow the
-return false;
+// compiler stack.
+Node* caller_argument0 = j->map()->argument(j, 0)->uncast();
+if (caller_argument0 == callee_argument0) {
+inline_level++;
+}
+} else {
+inline_level++;
 }
 }
-jvms = jvms->caller();
+}
+if (inline_level > MaxRecursiveInlineLevel) {
+set_msg("recursive inlining is too deep");
+return false;
 }
 }
 int size = callee_method->code_size_for_inlining();
 C->log()->inline_success(inline_msg);
 } else {
 C->log()->inline_fail(inline_msg);
 }
 }
-if (PrintInlining) {
+if (C->print_inlining()) {
 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(); }
 }
 // Check if inlining policy says no.
 WarmCallInfo wci = *(initial_wci);
 bool success = try_to_inline(callee_method, caller_method, caller_bci,
-profile, &wci, should_delay);
+jvms, profile, &wci, should_delay);
 #ifndef PRODUCT
 if (UseOldInlining && InlineWarmCalls
-&& (PrintOpto || PrintOptoInlining || PrintInlining)) {
+&& (PrintOpto || C->print_inlining())) {
 bool cold = wci.is_cold();
 bool hot  = !cold && wci.is_hot();
 bool old_cold = !success;
 if (old_cold != cold || (Verbose || WizardMode)) {
 if (msg() == NULL) {
 max_inline_level_adjust += 1;  // don't count actions in MH or indy adapter frames
 else if (callee_method->is_method_handle_intrinsic() ||
 callee_method->is_compiled_lambda_form()) {
 max_inline_level_adjust += 1;  // don't count method handle calls from java.lang.invoke implem
 }
-if (max_inline_level_adjust != 0 && PrintInlining && (Verbose || WizardMode)) {
+if (max_inline_level_adjust != 0 && C->print_inlining() && (Verbose || WizardMode)) {
 CompileTask::print_inline_indent(inline_level());
 tty->print_cr(" \\-> discounting inline depth");
 }
 if (max_inline_level_adjust != 0 && C->log()) {
 int id1 = C->log()->identify(caller_jvms->method());

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/opto/bytecodeInfo.cpp @ 14422:2b8e28fdf503