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

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

Merge

author	kvn
date	Tue, 05 Nov 2013 17:38:04 -0800
parents	b2ee5dc63353
children	de6a9e811145

comparison

equal deleted inserted replaced

-:3068270ba476
+:2b8e28fdf503
 #include "opto/subnode.hpp"
 #include "prims/nativeLookup.hpp"
 #include "runtime/sharedRuntime.hpp"
 void trace_type_profile(Compile* C, ciMethod *method, int depth, int bci, ciMethod *prof_method, ciKlass *prof_klass, int site_count, int receiver_count) {
-if (TraceTypeProfile || PrintInlining NOT_PRODUCT(|| PrintOptoInlining)) {
+if (TraceTypeProfile || C->print_inlining()) {
 outputStream* out = tty;
-if (!PrintInlining) {
+if (!C->print_inlining()) {
 if (NOT_PRODUCT(!PrintOpto &&) !PrintCompilation) {
 method->print_short_name();
 tty->cr();
 }
 CompileTask::print_inlining(prof_method, depth, bci);
 }
 }
 CallGenerator* Compile::call_generator(ciMethod* callee, int vtable_index, bool call_does_dispatch,
 JVMState* jvms, bool allow_inline,
-float prof_factor, bool allow_intrinsics, bool delayed_forbidden) {
+float prof_factor, ciKlass* speculative_receiver_type,
+bool allow_intrinsics, bool delayed_forbidden) {
 ciMethod*       caller   = jvms->method();
 int             bci      = jvms->bci();
 Bytecodes::Code bytecode = caller->java_code_at_bci(bci);
 guarantee(callee != NULL, "failed method resolution");
 // Special case the handling of certain common, profitable library
 // methods.  If these methods are replaced with specialized code,
 // then we return it as the inlined version of the call.
 // We do this before the strict f.p. check below because the
 // intrinsics handle strict f.p. correctly.
+CallGenerator* cg_intrinsic = NULL;
 if (allow_inline && allow_intrinsics) {
 CallGenerator* cg = find_intrinsic(callee, call_does_dispatch);
 if (cg != NULL) {
 if (cg->is_predicted()) {
 // Code without intrinsic but, hopefully, inlined.
 CallGenerator* inline_cg = this->call_generator(callee,
-vtable_index, call_does_dispatch, jvms, allow_inline, prof_factor, false);
+vtable_index, call_does_dispatch, jvms, allow_inline, prof_factor, speculative_receiver_type, false);
 if (inline_cg != NULL) {
 cg = CallGenerator::for_predicted_intrinsic(cg, inline_cg);
 }
 }
-return cg;
+// If intrinsic does the virtual dispatch, we try to use the type profile
+// first, and hopefully inline it as the regular virtual call below.
+// We will retry the intrinsic if nothing had claimed it afterwards.
+if (cg->does_virtual_dispatch()) {
+cg_intrinsic = cg;
+cg = NULL;
+} else {
+return cg;
+}
 }
 }
 // Do method handle calls.
 // NOTE: This must happen before normal inlining logic below since
 // Try using the type profile.
 if (call_does_dispatch && site_count > 0 && receiver_count > 0) {
 // The major receiver's count >= TypeProfileMajorReceiverPercent of site_count.
 bool have_major_receiver = (100.*profile.receiver_prob(0) >= (float)TypeProfileMajorReceiverPercent);
 ciMethod* receiver_method = NULL;
-if (have_major_receiver || profile.morphism() == 1 ||
-(profile.morphism() == 2 && UseBimorphicInlining)) {
+int morphism = profile.morphism();
+if (speculative_receiver_type != NULL) {
+// We have a speculative type, we should be able to resolve
+// the call. We do that before looking at the profiling at
+// this invoke because it may lead to bimorphic inlining which
+// a speculative type should help us avoid.
+receiver_method = callee->resolve_invoke(jvms->method()->holder(),
+speculative_receiver_type);
+if (receiver_method == NULL) {
+speculative_receiver_type = NULL;
+} else {
+morphism = 1;
+}
+}
+if (receiver_method == NULL &&
+(have_major_receiver || morphism == 1 ||
+(morphism == 2 && UseBimorphicInlining))) {
 // receiver_method = profile.method();
 // Profiles do not suggest methods now.  Look it up in the major receiver.
 receiver_method = callee->resolve_invoke(jvms->method()->holder(),
 profile.receiver(0));
 }
 vtable_index, !call_does_dispatch, jvms, allow_inline, prof_factor);
 if (hit_cg != NULL) {
 // Look up second receiver.
 CallGenerator* next_hit_cg = NULL;
 ciMethod* next_receiver_method = NULL;
-if (profile.morphism() == 2 && UseBimorphicInlining) {
+if (morphism == 2 && UseBimorphicInlining) {
 next_receiver_method = callee->resolve_invoke(jvms->method()->holder(),
 profile.receiver(1));
 if (next_receiver_method != NULL) {
 next_hit_cg = this->call_generator(next_receiver_method,
 vtable_index, !call_does_dispatch, jvms,
 next_hit_cg = NULL;
 }
 }
 }
 CallGenerator* miss_cg;
-Deoptimization::DeoptReason reason = (profile.morphism() == 2) ?
+Deoptimization::DeoptReason reason = morphism == 2 ?
 Deoptimization::Reason_bimorphic :
 Deoptimization::Reason_class_check;
-if (( profile.morphism() == 1 ||
+if ((morphism == 1 || (morphism == 2 && next_hit_cg != NULL)) &&
-(profile.morphism() == 2 && next_hit_cg != NULL) ) &&
 !too_many_traps(jvms->method(), jvms->bci(), reason)
 ) {
 // Generate uncommon trap for class check failure path
 // in case of monomorphic or bimorphic virtual call site.
 miss_cg = CallGenerator::for_uncommon_trap(callee, reason,
 // in case of polymorphic virtual call site.
 miss_cg = CallGenerator::for_virtual_call(callee, vtable_index);
 }
 if (miss_cg != NULL) {
 if (next_hit_cg != NULL) {
+assert(speculative_receiver_type == NULL, "shouldn't end up here if we used speculation");
 trace_type_profile(C, jvms->method(), jvms->depth() - 1, jvms->bci(), next_receiver_method, profile.receiver(1), site_count, profile.receiver_count(1));
 // We don't need to record dependency on a receiver here and below.
 // Whenever we inline, the dependency is added by Parse::Parse().
 miss_cg = CallGenerator::for_predicted_call(profile.receiver(1), miss_cg, next_hit_cg, PROB_MAX);
 }
 if (miss_cg != NULL) {
 trace_type_profile(C, jvms->method(), jvms->depth() - 1, jvms->bci(), receiver_method, profile.receiver(0), site_count, receiver_count);
-CallGenerator* cg = CallGenerator::for_predicted_call(profile.receiver(0), miss_cg, hit_cg, profile.receiver_prob(0));
+ciKlass* k = speculative_receiver_type != NULL ? speculative_receiver_type : profile.receiver(0);
+float hit_prob = speculative_receiver_type != NULL ? 1.0 : profile.receiver_prob(0);
+CallGenerator* cg = CallGenerator::for_predicted_call(k, miss_cg, hit_cg, hit_prob);
 if (cg != NULL)  return cg;
 }
 }
 }
 }
 }
+}
+// Nothing claimed the intrinsic, we go with straight-forward inlining
+// for already discovered intrinsic.
+if (allow_inline && allow_intrinsics && cg_intrinsic != NULL) {
+assert(cg_intrinsic->does_virtual_dispatch(), "sanity");
+return cg_intrinsic;
 }
 // There was no special inlining tactic, or it bailed out.
 // Use a more generic tactic, like a simple call.
 if (call_does_dispatch) {
 // Try to get the most accurate receiver type
 ciMethod* callee             = orig_callee;
 int       vtable_index       = Method::invalid_vtable_index;
 bool      call_does_dispatch = false;
+// Speculative type of the receiver if any
+ciKlass* speculative_receiver_type = NULL;
 if (is_virtual_or_interface) {
-Node*             receiver_node = stack(sp() - nargs);
+Node* receiver_node             = stack(sp() - nargs);
 const TypeOopPtr* receiver_type = _gvn.type(receiver_node)->isa_oopptr();
 // call_does_dispatch and vtable_index are out-parameters.  They might be changed.
 callee = C->optimize_virtual_call(method(), bci(), klass, orig_callee, receiver_type,
 is_virtual,
 call_does_dispatch, vtable_index);  // out-parameters
+speculative_receiver_type = receiver_type != NULL ? receiver_type->speculative_type() : NULL;
 }
 // Note:  It's OK to try to inline a virtual call.
 // The call generator will not attempt to inline a polymorphic call
 // unless it knows how to optimize the receiver dispatch.
 // ---------------------
 // Decide call tactic.
 // This call checks with CHA, the interpreter profile, intrinsics table, etc.
 // It decides whether inlining is desirable or not.
-CallGenerator* cg = C->call_generator(callee, vtable_index, call_does_dispatch, jvms, try_inline, prof_factor());
+CallGenerator* cg = C->call_generator(callee, vtable_index, call_does_dispatch, jvms, try_inline, prof_factor(), speculative_receiver_type);
 // NOTE:  Don't use orig_callee and callee after this point!  Use cg->method() instead.
 orig_callee = callee = NULL;
 // ---------------------
 // Round double arguments before call
 round_double_arguments(cg->method());
+// Feed profiling data for arguments to the type system so it can
+// propagate it as speculative types
+record_profiled_arguments_for_speculation(cg->method(), bc());
 #ifndef PRODUCT
 // bump global counters for calls
 count_compiled_calls(/*at_method_entry*/ false, cg->is_inline());
 // Record first part of parsing work for this call
 assert(jvms_in_sync(),       "jvms must carry full info into CG");
 // save across call, for a subsequent cast_not_null.
 Node* receiver = has_receiver ? argument(0) : NULL;
+// The extra CheckCastPP for speculative types mess with PhaseStringOpts
+if (receiver != NULL && !call_does_dispatch && !cg->is_string_late_inline()) {
+// Feed profiling data for a single receiver to the type system so
+// it can propagate it as a speculative type
+receiver = record_profiled_receiver_for_speculation(receiver);
+}
 // Bump method data counters (We profile *before* the call is made
 // because exceptions don't return to the call site.)
 profile_call(receiver);
-JVMState* new_jvms = cg->generate(jvms);
+JVMState* new_jvms = cg->generate(jvms, this);
 if (new_jvms == NULL) {
 // When inlining attempt fails (e.g., too many arguments),
 // it may contaminate the current compile state, making it
 // impossible to pull back and try again.  Once we call
 // cg->generate(), we are committed.  If it fails, the whole
 // This can happen if a library intrinsic is available, but refuses
 // the call site, perhaps because it did not match a pattern the
 // intrinsic was expecting to optimize. Should always be possible to
 // get a normal java call that may inline in that case
-cg = C->call_generator(cg->method(), vtable_index, call_does_dispatch, jvms, try_inline, prof_factor(), /* allow_intrinsics= */ false);
+cg = C->call_generator(cg->method(), vtable_index, call_does_dispatch, jvms, try_inline, prof_factor(), speculative_receiver_type, /* allow_intrinsics= */ false);
-if ((new_jvms = cg->generate(jvms)) == NULL) {
+if ((new_jvms = cg->generate(jvms, this)) == NULL) {
 guarantee(failing(), "call failed to generate:  calls should work");
 return;
 }
 }
 // If there is going to be a trap, put it at the next bytecode:
 set_bci(iter().next_bci());
 null_assert(peek());
 set_bci(iter().cur_bci()); // put it back
 }
+BasicType ct = ctype->basic_type();
+if (ct == T_OBJECT || ct == T_ARRAY) {
+ciKlass* better_type = method()->return_profiled_type(bci());
+if (UseTypeSpeculation && better_type != NULL) {
+// If profiling reports a single type for the return value,
+// feed it to the type system so it can propagate it as a
+// speculative type
+record_profile_for_speculation(stack(sp()-1), better_type);
+}
+}
 }
 // Restart record of parsing work after possible inlining of call
 #ifndef PRODUCT
 parse_histogram()->set_initial_state(bc());

Mercurial > hg > graal-jvmci-8

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