diff --git a/src/hotspot/share/opto/callGenerator.cpp b/src/hotspot/share/opto/callGenerator.cpp index 7dfba3b04f4..7c98ac483b1 100644 --- a/src/hotspot/share/opto/callGenerator.cpp +++ b/src/hotspot/share/opto/callGenerator.cpp @@ -355,6 +355,10 @@ class LateInlineCallGenerator : public DirectCallGenerator { virtual jlong unique_id() const { return _unique_id; } + + virtual CallGenerator* inline_cg() { + return _inline_cg; + } }; void LateInlineCallGenerator::do_late_inline() { @@ -587,7 +591,14 @@ class LateInlineMHCallGenerator : public LateInlineCallGenerator { bool LateInlineMHCallGenerator::do_late_inline_check(JVMState* jvms) { - CallGenerator* cg = for_method_handle_inline(jvms, _caller, method(), _input_not_const, AlwaysIncrementalInline); + CallGenerator* cg = for_method_handle_inline(jvms, _caller, method(), _input_not_const); + + // AlwaysIncrementalInline causes for_method_handle_inline() to + // return a LateInlineCallGenerator. Extract the + // InlineCallGenerato from it. + if (AlwaysIncrementalInline && cg != NULL && cg->is_late_inline()) { + cg = cg->inline_cg(); + } Compile::current()->print_inlining_update_delayed(this); @@ -929,13 +940,13 @@ JVMState* PredictedCallGenerator::generate(JVMState* jvms) { } -CallGenerator* CallGenerator::for_method_handle_call(JVMState* jvms, ciMethod* caller, ciMethod* callee, bool delayed_forbidden) { +CallGenerator* CallGenerator::for_method_handle_call(JVMState* jvms, ciMethod* caller, ciMethod* callee) { assert(callee->is_method_handle_intrinsic(), "for_method_handle_call mismatch"); bool input_not_const; - CallGenerator* cg = CallGenerator::for_method_handle_inline(jvms, caller, callee, input_not_const, false); + CallGenerator* cg = CallGenerator::for_method_handle_inline(jvms, caller, callee, input_not_const); Compile* C = Compile::current(); if (cg != NULL) { - if (!delayed_forbidden && AlwaysIncrementalInline) { + if (AlwaysIncrementalInline) { return CallGenerator::for_late_inline(callee, cg); } else { return cg; @@ -971,7 +982,7 @@ static void cast_argument(int nargs, int arg_nb, ciType* t, GraphKit& kit) { } } -CallGenerator* CallGenerator::for_method_handle_inline(JVMState* jvms, ciMethod* caller, ciMethod* callee, bool& input_not_const, bool delayed_forbidden) { +CallGenerator* CallGenerator::for_method_handle_inline(JVMState* jvms, ciMethod* caller, ciMethod* callee, bool& input_not_const) { GraphKit kit(jvms); PhaseGVN& gvn = kit.gvn(); Compile* C = kit.C; @@ -1000,8 +1011,7 @@ CallGenerator* CallGenerator::for_method_handle_inline(JVMState* jvms, ciMethod* true /* allow_inline */, PROB_ALWAYS, NULL, - true, - delayed_forbidden); + true); return cg; } else { print_inlining_failure(C, callee, jvms->depth() - 1, jvms->bci(), @@ -1075,8 +1085,7 @@ CallGenerator* CallGenerator::for_method_handle_inline(JVMState* jvms, ciMethod* !StressMethodHandleLinkerInlining /* allow_inline */, PROB_ALWAYS, speculative_receiver_type, - true, - delayed_forbidden); + true); return cg; } else { print_inlining_failure(C, callee, jvms->depth() - 1, jvms->bci(), diff --git a/src/hotspot/share/opto/callGenerator.hpp b/src/hotspot/share/opto/callGenerator.hpp index dd8c23757ee..e37437ada52 100644 --- a/src/hotspot/share/opto/callGenerator.hpp +++ b/src/hotspot/share/opto/callGenerator.hpp @@ -86,6 +86,8 @@ class CallGenerator : public ResourceObj { virtual void set_unique_id(jlong id) { fatal("unique id only for late inlines"); }; virtual jlong unique_id() const { fatal("unique id only for late inlines"); return 0; }; + virtual CallGenerator* inline_cg() { ShouldNotReachHere(); return NULL; } + // Note: It is possible for a CG to be both inline and virtual. // (The hashCode intrinsic does a vtable check and an inlined fast path.) @@ -124,8 +126,8 @@ class CallGenerator : public ResourceObj { static CallGenerator* for_direct_call(ciMethod* m, bool separate_io_projs = false); // static, special static CallGenerator* for_virtual_call(ciMethod* m, int vtable_index); // virtual, interface - static CallGenerator* for_method_handle_call( JVMState* jvms, ciMethod* caller, ciMethod* callee, bool delayed_forbidden); - static CallGenerator* for_method_handle_inline(JVMState* jvms, ciMethod* caller, ciMethod* callee, bool& input_not_const, bool delayed_forbidden); + static CallGenerator* for_method_handle_call( JVMState* jvms, ciMethod* caller, ciMethod* callee); + static CallGenerator* for_method_handle_inline(JVMState* jvms, ciMethod* caller, ciMethod* callee, bool& input_not_const); // How to generate a replace a direct call with an inline version static CallGenerator* for_late_inline(ciMethod* m, CallGenerator* inline_cg); diff --git a/src/hotspot/share/opto/compile.hpp b/src/hotspot/share/opto/compile.hpp index 4b17dfdadf3..f00640effe1 100644 --- a/src/hotspot/share/opto/compile.hpp +++ b/src/hotspot/share/opto/compile.hpp @@ -886,7 +886,7 @@ class Compile : public Phase { // The profile factor is a discount to apply to this site's interp. profile. CallGenerator* call_generator(ciMethod* call_method, int vtable_index, bool call_does_dispatch, JVMState* jvms, bool allow_inline, float profile_factor, ciKlass* speculative_receiver_type = NULL, - bool allow_intrinsics = true, bool delayed_forbidden = false); + bool allow_intrinsics = true); bool should_delay_inlining(ciMethod* call_method, JVMState* jvms) { return should_delay_string_inlining(call_method, jvms) || should_delay_boxing_inlining(call_method, jvms); diff --git a/src/hotspot/share/opto/doCall.cpp b/src/hotspot/share/opto/doCall.cpp index a434d02cd67..3543cb5f2cf 100644 --- a/src/hotspot/share/opto/doCall.cpp +++ b/src/hotspot/share/opto/doCall.cpp @@ -66,7 +66,7 @@ void trace_type_profile(Compile* C, ciMethod *method, int depth, int bci, ciMeth CallGenerator* Compile::call_generator(ciMethod* callee, int vtable_index, bool call_does_dispatch, JVMState* jvms, bool allow_inline, float prof_factor, ciKlass* speculative_receiver_type, - bool allow_intrinsics, bool delayed_forbidden) { + bool allow_intrinsics) { ciMethod* caller = jvms->method(); int bci = jvms->bci(); Bytecodes::Code bytecode = caller->java_code_at_bci(bci); @@ -146,8 +146,7 @@ CallGenerator* Compile::call_generator(ciMethod* callee, int vtable_index, bool // MethodHandle.invoke* are native methods which obviously don't // have bytecodes and so normal inlining fails. if (callee->is_method_handle_intrinsic()) { - CallGenerator* cg = CallGenerator::for_method_handle_call(jvms, caller, callee, delayed_forbidden); - assert(cg == NULL || !delayed_forbidden || !cg->is_late_inline() || cg->is_mh_late_inline(), "unexpected CallGenerator"); + CallGenerator* cg = CallGenerator::for_method_handle_call(jvms, caller, callee); return cg; } @@ -183,12 +182,10 @@ CallGenerator* Compile::call_generator(ciMethod* callee, int vtable_index, bool // opportunity to perform some high level optimizations // first. if (should_delay_string_inlining(callee, jvms)) { - assert(!delayed_forbidden, "strange"); return CallGenerator::for_string_late_inline(callee, cg); } else if (should_delay_boxing_inlining(callee, jvms)) { - assert(!delayed_forbidden, "strange"); return CallGenerator::for_boxing_late_inline(callee, cg); - } else if ((should_delay || AlwaysIncrementalInline) && !delayed_forbidden) { + } else if (should_delay || AlwaysIncrementalInline) { return CallGenerator::for_late_inline(callee, cg); } }