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

comparison src/share/vm/opto/bytecodeInfo.cpp @ 13086:096c224171c4

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/

author	Doug Simon <doug.simon@oracle.com>
date	Wed, 20 Nov 2013 00:10:38 +0100
parents	359f7e70ae7f e74074c34312
children	d8041d695d19

comparison

equal deleted inserted replaced

-:92b7ec34ddfa
+:096c224171c4
 // 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.
 if (!C->do_inlining() && InlineAccessors) {
 set_msg("not an accessor");
 return false;
 }
 if (inline_level() > _max_inline_level) {
+if (callee_method->force_inline() && inline_level() > MaxForceInlineLevel) {
+set_msg("MaxForceInlineLevel");
+return false;
+}
 if (!callee_method->force_inline() || !IncrementalInline) {
 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;
+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();
 }
 // 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 || C->print_inlining())) {
 bool cold = wci.is_cold();

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/opto/bytecodeInfo.cpp @ 13086:096c224171c4