truffle: src/share/vm/opto/bytecodeInfo.cpp comparison

comparison src/share/vm/opto/bytecodeInfo.cpp @ 6266:1d7922586cf6

7023639: JSR 292 method handle invocation needs a fast path for compiled code 6984705: JSR 292 method handle creation should not go through JNI Summary: remove assembly code for JDK 7 chained method handles Reviewed-by: jrose, twisti, kvn, mhaupt Contributed-by: John Rose <john.r.rose@oracle.com>, Christian Thalinger <christian.thalinger@oracle.com>, Michael Haupt <michael.haupt@oracle.com>

author	twisti
date	Tue, 24 Jul 2012 10:51:00 -0700
parents	0f4014d7731b
children	957c266d8bc5 b9a9ed0f8eeb c3e799c37717

comparison

equal deleted inserted replaced

-:aba91a731143
+:1d7922586cf6
 caller_method != C->method() &&
 caller_method->holder()->is_subclass_of(callee_method->holder()))
 );
 }
-// positive filter: should send be inlined?  returns NULL, if yes, or rejection msg
+// positive filter: should callee be inlined?  returns NULL, if yes, or rejection msg
 const char* InlineTree::should_inline(ciMethod* callee_method, ciMethod* caller_method, int caller_bci, ciCallProfile& profile, WarmCallInfo* wci_result) const {
 // Allows targeted inlining
 if(callee_method->should_inline()) {
 *wci_result = *(WarmCallInfo::always_hot());
 if (PrintInlining && Verbose) {
 int max_inline_size         = default_max_inline_size;
 int call_site_count  = method()->scale_count(profile.count());
 int invoke_count     = method()->interpreter_invocation_count();
-// Bytecoded method handle adapters do not have interpreter
-// profiling data but only made up MDO data.  Get the counter from
-// there.
-if (caller_method->is_method_handle_adapter()) {
-assert(method()->method_data_or_null(), "must have an MDO");
-ciMethodData* mdo = method()->method_data();
-ciProfileData* mha_profile = mdo->bci_to_data(caller_bci);
-assert(mha_profile, "must exist");
-CounterData* cd = mha_profile->as_CounterData();
-invoke_count = cd->count();
-if (invoke_count == 0) {
-return "method handle not reached";
-}
-if (_caller_jvms != NULL && _caller_jvms->method() != NULL &&
-_caller_jvms->method()->method_data() != NULL &&
-!_caller_jvms->method()->method_data()->is_empty()) {
-ciMethodData* mdo = _caller_jvms->method()->method_data();
-ciProfileData* mha_profile = mdo->bci_to_data(_caller_jvms->bci());
-assert(mha_profile, "must exist");
-CounterData* cd = mha_profile->as_CounterData();
-call_site_count = cd->count();
-} else {
-call_site_count = invoke_count;  // use the same value
-}
-}
 assert(invoke_count != 0, "require invocation count greater than zero");
 int freq = call_site_count / invoke_count;
 // bump the max size if the call is frequent
 if ((freq >= InlineFrequencyRatio) ||
 }
 return NULL;
 }
-// negative filter: should send NOT be inlined?  returns NULL, ok to inline, or rejection msg
+// 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
 if (!UseOldInlining) {
 const char* fail = NULL;
-if (callee_method->is_abstract())               fail = "abstract method";
+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->holder()->is_initialized())  fail = "method holder not initialized";
-if (callee_method->is_native())                 fail = "native method";
+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;
 }
 if (!top_method->holder()->is_subclass_of(C->env()->Throwable_klass())) {
 wci_result->set_profit(wci_result->profit() * 0.1);
 }
 }
-if (callee_method->has_compiled_code() && callee_method->instructions_size(CompLevel_full_optimization) > InlineSmallCode) {
+if (callee_method->has_compiled_code() &&
+callee_method->instructions_size(CompLevel_full_optimization) > InlineSmallCode) {
 wci_result->set_profit(wci_result->profit() * 0.1);
 // %%% adjust wci_result->size()?
 }
 return NULL;
 }
-// Always inline MethodHandle methods and generated MethodHandle adapters.
-if (callee_method->is_method_handle_invoke() || callee_method->is_method_handle_adapter())
-return NULL;
 // First check all inlining restrictions which are required for correctness
-if (callee_method->is_abstract())               return "abstract method";
+if ( callee_method->is_abstract())                        return "abstract method";
 // note: we allow ik->is_abstract()
-if (!callee_method->holder()->is_initialized()) return "method holder not initialized";
+if (!callee_method->holder()->is_initialized())           return "method holder not initialized";
-if (callee_method->is_native())                 return "native method";
+if ( callee_method->is_native())                          return "native method";
-if (callee_method->has_unloaded_classes_in_signature()) return "unloaded signature classes";
+if ( callee_method->dont_inline())                        return "don't inline by annotation";
+if ( callee_method->has_unloaded_classes_in_signature())  return "unloaded signature classes";
-if (callee_method->should_inline()) {
+if (callee_method->force_inline() || callee_method->should_inline()) {
 // ignore heuristic controls on inlining
 return NULL;
 }
 // Now perform checks which are heuristic
-if( callee_method->has_compiled_code() && callee_method->instructions_size(CompLevel_full_optimization) > InlineSmallCode )
+if (callee_method->has_compiled_code() &&
+callee_method->instructions_size(CompLevel_full_optimization) > InlineSmallCode) {
 return "already compiled into a big method";
+}
 // 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())) {
 return "profiling method";
 }
 }
 // use frequency-based objections only for non-trivial methods
-if (callee_method->code_size_for_inlining() <= MaxTrivialSize) return NULL;
+if (callee_method->code_size() <= MaxTrivialSize) return NULL;
 // don't use counts with -Xcomp or CTW
 if (UseInterpreter && !CompileTheWorld) {
 if (!callee_method->has_compiled_code() &&
 // accessor methods are not subject to any of the following limits.
 return NULL;
 }
 // suppress a few checks for accessors and trivial methods
-if (callee_method->code_size_for_inlining() > MaxTrivialSize) {
+if (callee_method->code_size() > MaxTrivialSize) {
 // don't inline into giant methods
 if (C->unique() > (uint)NodeCountInliningCutoff) {
 return "NodeCountInliningCutoff";
 }
 if (inline_level() > _max_inline_level) {
 return "inlining too deep";
 }
 // 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)
 return "recursively inlining too deep";
 // count callers of current method and callee
 //------------------------------check_can_parse--------------------------------
 const char* InlineTree::check_can_parse(ciMethod* callee) {
 // Certain methods cannot be parsed at all:
 if ( callee->is_native())                     return "native method";
+if ( callee->is_abstract())                   return "abstract method";
 if (!callee->can_be_compiled())               return "not compilable (disabled)";
 if (!callee->has_balanced_monitors())         return "not compilable (unbalanced monitors)";
 if ( callee->get_flow_analysis()->failing())  return "not compilable (flow analysis failed)";
 return NULL;
 }
 CompileTask::print_inlining(callee_method, inline_level(), caller_bci, failure_msg ? failure_msg : "inline");
 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());
+//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) {
 int         caller_bci    = jvms->bci();
 ciMethod   *caller_method = jvms->method();
 // Do some initial checks.
 if (!pass_initial_checks(caller_method, caller_bci, callee_method)) {
-if (PrintInlining) {
+if (PrintInlining)  print_inlining(callee_method, caller_bci, "failed initial checks");
-failure_msg = "failed_initial_checks";
-print_inlining(callee_method, caller_bci, failure_msg);
-}
 return NULL;
 }
 // Do some parse checks.
 failure_msg = check_can_parse(callee_method);
 if (old_ilt != NULL) {
 return old_ilt;
 }
 int max_inline_level_adjust = 0;
 if (caller_jvms->method() != NULL) {
-if (caller_jvms->method()->is_method_handle_adapter())
+if (caller_jvms->method()->is_compiled_lambda_form())
 max_inline_level_adjust += 1;  // don't count actions in MH or indy adapter frames
-else if (callee_method->is_method_handle_invoke()) {
+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)) {
 CompileTask::print_inline_indent(inline_level());
 tty->print_cr(" \\-> discounting inline depth");
 //-------------------------find_subtree_from_root-----------------------------
 // Given a jvms, which determines a call chain from the root method,
 // find the corresponding inline tree.
 // Note: This method will be removed or replaced as InlineTree goes away.
-InlineTree* InlineTree::find_subtree_from_root(InlineTree* root, JVMState* jvms, ciMethod* callee, bool create_if_not_found) {
+InlineTree* InlineTree::find_subtree_from_root(InlineTree* root, JVMState* jvms, ciMethod* callee) {
 InlineTree* iltp = root;
 uint depth = jvms && jvms->has_method() ? jvms->depth() : 0;
 for (uint d = 1; d <= depth; d++) {
 JVMState* jvmsp  = jvms->of_depth(d);
 // Select the corresponding subtree for this bci.
 assert(jvmsp->method() == iltp->method(), "tree still in sync");
 ciMethod* d_callee = (d == depth) ? callee : jvms->of_depth(d+1)->method();
 InlineTree* sub = iltp->callee_at(jvmsp->bci(), d_callee);
-if (!sub) {
+if (sub == NULL) {
-if (create_if_not_found && d == depth) {
+if (d == depth) {
-return iltp->build_inline_tree_for_callee(d_callee, jvmsp, jvmsp->bci());
+sub = iltp->build_inline_tree_for_callee(d_callee, jvmsp, jvmsp->bci());
 }
-assert(sub != NULL, "should be a sub-ilt here");
+guarantee(sub != NULL, "should be a sub-ilt here");
-return NULL;
+return sub;
 }
 iltp = sub;
 }
 return iltp;
 }

Mercurial > hg > truffle

comparison src/share/vm/opto/bytecodeInfo.cpp @ 6266:1d7922586cf6