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

annotate src/share/vm/opto/bytecodeInfo.cpp @ 9126:bc26f978b0ce

HotSpotResolvedObjectType: implement hasFinalizeSubclass() correctly don't use the (wrong) cached value, but ask the runtime on each request. Fixes regression on xml.* benchmarks @ specjvm2008. The problem was: After the constructor of Object was deoptimized due to an assumption violation, it was recompiled again after some time. However, on recompilation, the value of hasFinalizeSubclass for the class was not updated and it was compiled again with a, now wrong, assumption, which then triggers deoptimization again. This was repeated until it hit the recompilation limit (defined by PerMethodRecompilationCutoff), and therefore only executed by the interpreter from now on, causing the performance regression.

author	Bernhard Urban <bernhard.urban@jku.at>
date	Mon, 15 Apr 2013 19:54:58 +0200
parents	b9a918201d47
children	836a62f43af9

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
6842 b9a9ed0f8eeb 7197424: update copyright year to match last edit in jdk8 hotspot repository mikael parents: 6266 diff changeset	2 * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1507 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1507 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1507 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	25 #include "precompiled.hpp"
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6853 diff changeset	26 #include "ci/ciReplay.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	27 #include "classfile/systemDictionary.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	28 #include "classfile/vmSymbols.hpp"
2405 3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2357 diff changeset	29 #include "compiler/compileBroker.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	30 #include "compiler/compileLog.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	31 #include "interpreter/linkResolver.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	32 #include "oops/objArrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	33 #include "opto/callGenerator.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	34 #include "opto/parse.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1783 diff changeset	35 #include "runtime/handles.inline.hpp"
0 a61af66fc99e Initial load duke parents: diff changeset	36
a61af66fc99e Initial load duke parents: diff changeset	37 //=============================================================================
a61af66fc99e Initial load duke parents: diff changeset	38 //------------------------------InlineTree-------------------------------------
3458 393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	39 InlineTree::InlineTree(Compile* c,
393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	40 const InlineTree caller_tree, ciMethod callee,
393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	41 JVMState* caller_jvms, int caller_bci,
393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	42 float site_invoke_ratio, int max_inline_level) :
393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	43 C(c),
393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	44 _caller_jvms(caller_jvms),
393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	45 _caller_tree((InlineTree*) caller_tree),
393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	46 _method(callee),
393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	47 _site_invoke_ratio(site_invoke_ratio),
393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	48 _max_inline_level(max_inline_level),
7473 d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	49 _count_inline_bcs(method()->code_size_for_inlining()),
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	50 _subtrees(c->comp_arena(), 2, 0, NULL),
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	51 _msg(NULL)
1157 c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1138 diff changeset	52 {
0 a61af66fc99e Initial load duke parents: diff changeset	53 NOT_PRODUCT(_count_inlines = 0;)
a61af66fc99e Initial load duke parents: diff changeset	54 if (_caller_jvms != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	55 // Keep a private copy of the caller_jvms:
a61af66fc99e Initial load duke parents: diff changeset	56 _caller_jvms = new (C) JVMState(caller_jvms->method(), caller_tree->caller_jvms());
a61af66fc99e Initial load duke parents: diff changeset	57 _caller_jvms->set_bci(caller_jvms->bci());
900 9987d9d5eb0e 6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot cfang parents: 726 diff changeset	58 assert(!caller_jvms->should_reexecute(), "there should be no reexecute bytecode with inlining");
0 a61af66fc99e Initial load duke parents: diff changeset	59 }
a61af66fc99e Initial load duke parents: diff changeset	60 assert(_caller_jvms->same_calls_as(caller_jvms), "consistent JVMS");
1157 c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1138 diff changeset	61 assert((caller_tree == NULL ? 0 : caller_tree->stack_depth() + 1) == stack_depth(), "correct (redundant) depth parameter");
0 a61af66fc99e Initial load duke parents: diff changeset	62 assert(caller_bci == this->caller_bci(), "correct (redundant) bci parameter");
a61af66fc99e Initial load duke parents: diff changeset	63 if (UseOldInlining) {
a61af66fc99e Initial load duke parents: diff changeset	64 // Update hierarchical counts, count_inline_bcs() and count_inlines()
a61af66fc99e Initial load duke parents: diff changeset	65 InlineTree caller = (InlineTree )caller_tree;
a61af66fc99e Initial load duke parents: diff changeset	66 for( ; caller != NULL; caller = ((InlineTree *)(caller->caller_tree())) ) {
a61af66fc99e Initial load duke parents: diff changeset	67 caller->_count_inline_bcs += count_inline_bcs();
a61af66fc99e Initial load duke parents: diff changeset	68 NOT_PRODUCT(caller->_count_inlines++;)
a61af66fc99e Initial load duke parents: diff changeset	69 }
a61af66fc99e Initial load duke parents: diff changeset	70 }
a61af66fc99e Initial load duke parents: diff changeset	71 }
a61af66fc99e Initial load duke parents: diff changeset	72
1157 c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1138 diff changeset	73 InlineTree::InlineTree(Compile* c, ciMethod* callee_method, JVMState* caller_jvms,
3458 393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	74 float site_invoke_ratio, int max_inline_level) :
393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	75 C(c),
393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	76 _caller_jvms(caller_jvms),
393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	77 _caller_tree(NULL),
393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	78 _method(callee_method),
393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	79 _site_invoke_ratio(site_invoke_ratio),
393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	80 _max_inline_level(max_inline_level),
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	81 _count_inline_bcs(method()->code_size()),
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	82 _msg(NULL)
1157 c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1138 diff changeset	83 {
0 a61af66fc99e Initial load duke parents: diff changeset	84 NOT_PRODUCT(_count_inlines = 0;)
a61af66fc99e Initial load duke parents: diff changeset	85 assert(!UseOldInlining, "do not use for old stuff");
a61af66fc99e Initial load duke parents: diff changeset	86 }
a61af66fc99e Initial load duke parents: diff changeset	87
41 874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	88 static bool is_init_with_ea(ciMethod* callee_method,
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	89 ciMethod* caller_method, Compile* C) {
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	90 // True when EA is ON and a java constructor is called or
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	91 // a super constructor is called from an inlined java constructor.
244 524eca34ea76 6684714: Optimize EA Connection Graph build performance kvn parents: 41 diff changeset	92 return C->do_escape_analysis() && EliminateAllocations &&
41 874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	93 ( callee_method->is_initializer() \|\|
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	94 (caller_method->is_initializer() &&
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	95 caller_method != C->method() &&
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	96 caller_method->holder()->is_subclass_of(callee_method->holder()))
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	97 );
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	98 }
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	99
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	100 // positive filter: should callee be inlined?
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	101 bool InlineTree::should_inline(ciMethod* callee_method, ciMethod* caller_method,
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	102 int caller_bci, ciCallProfile& profile,
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	103 WarmCallInfo* wci_result) {
0 a61af66fc99e Initial load duke parents: diff changeset	104 // Allows targeted inlining
a61af66fc99e Initial load duke parents: diff changeset	105 if(callee_method->should_inline()) {
a61af66fc99e Initial load duke parents: diff changeset	106 wci_result = (WarmCallInfo::always_hot());
a61af66fc99e Initial load duke parents: diff changeset	107 if (PrintInlining && Verbose) {
3458 393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	108 CompileTask::print_inline_indent(inline_level());
0 a61af66fc99e Initial load duke parents: diff changeset	109 tty->print_cr("Inlined method is hot: ");
a61af66fc99e Initial load duke parents: diff changeset	110 }
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	111 set_msg("force inline by CompilerOracle");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	112 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	113 }
a61af66fc99e Initial load duke parents: diff changeset	114
3897 de847cac9235 7078382: JSR 292: don't count method handle adapters against inlining budgets twisti parents: 3458 diff changeset	115 int size = callee_method->code_size_for_inlining();
0 a61af66fc99e Initial load duke parents: diff changeset	116
a61af66fc99e Initial load duke parents: diff changeset	117 // Check for too many throws (and not too huge)
41 874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	118 if(callee_method->interpreter_throwout_count() > InlineThrowCount &&
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	119 size < InlineThrowMaxSize ) {
0 a61af66fc99e Initial load duke parents: diff changeset	120 wci_result->set_profit(wci_result->profit() * 100);
a61af66fc99e Initial load duke parents: diff changeset	121 if (PrintInlining && Verbose) {
3458 393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	122 CompileTask::print_inline_indent(inline_level());
0 a61af66fc99e Initial load duke parents: diff changeset	123 tty->print_cr("Inlined method with many throws (throws=%d):", callee_method->interpreter_throwout_count());
a61af66fc99e Initial load duke parents: diff changeset	124 }
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	125 set_msg("many throws");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	126 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	127 }
a61af66fc99e Initial load duke parents: diff changeset	128
a61af66fc99e Initial load duke parents: diff changeset	129 if (!UseOldInlining) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	130 set_msg("!UseOldInlining");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	131 return true; // size and frequency are represented in a new way
0 a61af66fc99e Initial load duke parents: diff changeset	132 }
a61af66fc99e Initial load duke parents: diff changeset	133
3366 e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3345 diff changeset	134 int default_max_inline_size = C->max_inline_size();
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3345 diff changeset	135 int inline_small_code_size = InlineSmallCode / 4;
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3345 diff changeset	136 int max_inline_size = default_max_inline_size;
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3345 diff changeset	137
0 a61af66fc99e Initial load duke parents: diff changeset	138 int call_site_count = method()->scale_count(profile.count());
a61af66fc99e Initial load duke parents: diff changeset	139 int invoke_count = method()->interpreter_invocation_count();
3366 e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3345 diff changeset	140
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3345 diff changeset	141 assert(invoke_count != 0, "require invocation count greater than zero");
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3345 diff changeset	142 int freq = call_site_count / invoke_count;
41 874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	143
0 a61af66fc99e Initial load duke parents: diff changeset	144 // bump the max size if the call is frequent
41 874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	145 if ((freq >= InlineFrequencyRatio) \|\|
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	146 (call_site_count >= InlineFrequencyCount) \|\|
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	147 is_init_with_ea(callee_method, caller_method, C)) {
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	148
3366 e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3345 diff changeset	149 max_inline_size = C->freq_inline_size();
e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3345 diff changeset	150 if (size <= max_inline_size && TraceFrequencyInlining) {
3458 393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	151 CompileTask::print_inline_indent(inline_level());
0 a61af66fc99e Initial load duke parents: diff changeset	152 tty->print_cr("Inlined frequent method (freq=%d count=%d):", freq, call_site_count);
3458 393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	153 CompileTask::print_inline_indent(inline_level());
0 a61af66fc99e Initial load duke parents: diff changeset	154 callee_method->print();
a61af66fc99e Initial load duke parents: diff changeset	155 tty->cr();
a61af66fc99e Initial load duke parents: diff changeset	156 }
a61af66fc99e Initial load duke parents: diff changeset	157 } else {
a61af66fc99e Initial load duke parents: diff changeset	158 // Not hot. Check for medium-sized pre-existing nmethod at cold sites.
41 874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	159 if (callee_method->has_compiled_code() &&
8772 80208f353616 8010222: 8007439 disabled inlining of cold accessor methods kvn parents: 8119 diff changeset	160 callee_method->instructions_size() > inline_small_code_size) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	161 set_msg("already compiled into a medium method");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	162 return false;
8772 80208f353616 8010222: 8007439 disabled inlining of cold accessor methods kvn parents: 8119 diff changeset	163 }
0 a61af66fc99e Initial load duke parents: diff changeset	164 }
3366 e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3345 diff changeset	165 if (size > max_inline_size) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	166 if (max_inline_size > default_max_inline_size) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	167 set_msg("hot method too big");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	168 } else {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	169 set_msg("too big");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	170 }
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	171 return false;
0 a61af66fc99e Initial load duke parents: diff changeset	172 }
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	173 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	174 }
a61af66fc99e Initial load duke parents: diff changeset	175
a61af66fc99e Initial load duke parents: diff changeset	176
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	177 // negative filter: should callee NOT be inlined?
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	178 bool InlineTree::should_not_inline(ciMethod *callee_method,
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	179 ciMethod* caller_method,
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	180 WarmCallInfo* wci_result) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	181
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	182 const char* fail_msg = NULL;
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	183
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	184 // First check all inlining restrictions which are required for correctness
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	185 if ( callee_method->is_abstract()) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	186 fail_msg = "abstract method"; // // note: we allow ik->is_abstract()
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	187 } else if (!callee_method->holder()->is_initialized()) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	188 fail_msg = "method holder not initialized";
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	189 } else if ( callee_method->is_native()) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	190 fail_msg = "native method";
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	191 } else if ( callee_method->dont_inline()) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	192 fail_msg = "don't inline by annotation";
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	193 }
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	194
0 a61af66fc99e Initial load duke parents: diff changeset	195 if (!UseOldInlining) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	196 if (fail_msg != NULL) {
0 a61af66fc99e Initial load duke parents: diff changeset	197 wci_result = (WarmCallInfo::always_cold());
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	198 set_msg(fail_msg);
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	199 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	200 }
a61af66fc99e Initial load duke parents: diff changeset	201
a61af66fc99e Initial load duke parents: diff changeset	202 if (callee_method->has_unloaded_classes_in_signature()) {
a61af66fc99e Initial load duke parents: diff changeset	203 wci_result->set_profit(wci_result->profit() * 0.1);
a61af66fc99e Initial load duke parents: diff changeset	204 }
a61af66fc99e Initial load duke parents: diff changeset	205
a61af66fc99e Initial load duke parents: diff changeset	206 // don't inline exception code unless the top method belongs to an
a61af66fc99e Initial load duke parents: diff changeset	207 // exception class
a61af66fc99e Initial load duke parents: diff changeset	208 if (callee_method->holder()->is_subclass_of(C->env()->Throwable_klass())) {
a61af66fc99e Initial load duke parents: diff changeset	209 ciMethod* top_method = caller_jvms() ? caller_jvms()->of_depth(1)->method() : method();
a61af66fc99e Initial load duke parents: diff changeset	210 if (!top_method->holder()->is_subclass_of(C->env()->Throwable_klass())) {
a61af66fc99e Initial load duke parents: diff changeset	211 wci_result->set_profit(wci_result->profit() * 0.1);
a61af66fc99e Initial load duke parents: diff changeset	212 }
a61af66fc99e Initial load duke parents: diff changeset	213 }
a61af66fc99e Initial load duke parents: diff changeset	214
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5950 diff changeset	215 if (callee_method->has_compiled_code() &&
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6853 diff changeset	216 callee_method->instructions_size() > InlineSmallCode) {
0 a61af66fc99e Initial load duke parents: diff changeset	217 wci_result->set_profit(wci_result->profit() * 0.1);
a61af66fc99e Initial load duke parents: diff changeset	218 // %%% adjust wci_result->size()?
a61af66fc99e Initial load duke parents: diff changeset	219 }
a61af66fc99e Initial load duke parents: diff changeset	220
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	221 return false;
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	222 }
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	223
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	224 // one more inlining restriction
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	225 if (fail_msg == NULL && callee_method->has_unloaded_classes_in_signature()) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	226 fail_msg = "unloaded signature classes";
0 a61af66fc99e Initial load duke parents: diff changeset	227 }
a61af66fc99e Initial load duke parents: diff changeset	228
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	229 if (fail_msg != NULL) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	230 set_msg(fail_msg);
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	231 return true;
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	232 }
1138 dd57230ba8fe 6893268: additional dynamic language related optimizations in C2 twisti parents: 1137 diff changeset	233
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	234 // ignore heuristic controls on inlining
7473 d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	235 if (callee_method->should_inline()) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	236 set_msg("force inline by CompilerOracle");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	237 return false;
0 a61af66fc99e Initial load duke parents: diff changeset	238 }
5407 80ae8033fe01 Perform compiler oracle should_not_inline check before heuristic checks Gilles Duboscq <duboscq@ssw.jku.at> parents: 3939 diff changeset	239 if (callee_method->should_not_inline()) {
8151 b8f261ba79c6 Minimize diff to plain HotSpot version. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 8124 diff changeset	240 set_msg("disallowed by CompilerOracle");
b8f261ba79c6 Minimize diff to plain HotSpot version. Thomas Wuerthinger <thomas.wuerthinger@oracle.com> parents: 8124 diff changeset	241 return false;
5407 80ae8033fe01 Perform compiler oracle should_not_inline check before heuristic checks Gilles Duboscq <duboscq@ssw.jku.at> parents: 3939 diff changeset	242 }
0 a61af66fc99e Initial load duke parents: diff changeset	243
a61af66fc99e Initial load duke parents: diff changeset	244 // Now perform checks which are heuristic
a61af66fc99e Initial load duke parents: diff changeset	245
7473 d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	246 if (!callee_method->force_inline()) {
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	247 if (callee_method->has_compiled_code() &&
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	248 callee_method->instructions_size() > InlineSmallCode) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	249 set_msg("already compiled into a big method");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	250 return true;
7473 d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	251 }
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5950 diff changeset	252 }
0 a61af66fc99e Initial load duke parents: diff changeset	253
a61af66fc99e Initial load duke parents: diff changeset	254 // don't inline exception code unless the top method belongs to an
a61af66fc99e Initial load duke parents: diff changeset	255 // exception class
a61af66fc99e Initial load duke parents: diff changeset	256 if (caller_tree() != NULL &&
a61af66fc99e Initial load duke parents: diff changeset	257 callee_method->holder()->is_subclass_of(C->env()->Throwable_klass())) {
a61af66fc99e Initial load duke parents: diff changeset	258 const InlineTree *top = this;
a61af66fc99e Initial load duke parents: diff changeset	259 while (top->caller_tree() != NULL) top = top->caller_tree();
a61af66fc99e Initial load duke parents: diff changeset	260 ciInstanceKlass* k = top->method()->holder();
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	261 if (!k->is_subclass_of(C->env()->Throwable_klass())) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	262 set_msg("exception method");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	263 return true;
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	264 }
0 a61af66fc99e Initial load duke parents: diff changeset	265 }
a61af66fc99e Initial load duke parents: diff changeset	266
5950 0f4014d7731b 7152961: InlineTree::should_not_inline may exit prematurely never parents: 3939 diff changeset	267 if (callee_method->should_not_inline()) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	268 set_msg("disallowed by CompilerOracle");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	269 return true;
5950 0f4014d7731b 7152961: InlineTree::should_not_inline may exit prematurely never parents: 3939 diff changeset	270 }
0f4014d7731b 7152961: InlineTree::should_not_inline may exit prematurely never parents: 3939 diff changeset	271
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6853 diff changeset	272 #ifndef PRODUCT
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6853 diff changeset	273 if (ciReplay::should_not_inline(callee_method)) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	274 set_msg("disallowed by ciReplay");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	275 return true;
6972 bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6853 diff changeset	276 }
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6853 diff changeset	277 #endif
bd7a7ce2e264 6830717: replay of compilations would help with debugging minqi parents: 6853 diff changeset	278
5950 0f4014d7731b 7152961: InlineTree::should_not_inline may exit prematurely never parents: 3939 diff changeset	279 if (UseStringCache) {
0f4014d7731b 7152961: InlineTree::should_not_inline may exit prematurely never parents: 3939 diff changeset	280 // Do not inline StringCache::profile() method used only at the beginning.
0f4014d7731b 7152961: InlineTree::should_not_inline may exit prematurely never parents: 3939 diff changeset	281 if (callee_method->name() == ciSymbol::profile_name() &&
0f4014d7731b 7152961: InlineTree::should_not_inline may exit prematurely never parents: 3939 diff changeset	282 callee_method->holder()->name() == ciSymbol::java_lang_StringCache()) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	283 set_msg("profiling method");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	284 return true;
5950 0f4014d7731b 7152961: InlineTree::should_not_inline may exit prematurely never parents: 3939 diff changeset	285 }
0f4014d7731b 7152961: InlineTree::should_not_inline may exit prematurely never parents: 3939 diff changeset	286 }
0f4014d7731b 7152961: InlineTree::should_not_inline may exit prematurely never parents: 3939 diff changeset	287
0 a61af66fc99e Initial load duke parents: diff changeset	288 // use frequency-based objections only for non-trivial methods
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	289 if (callee_method->code_size() <= MaxTrivialSize) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	290 return false;
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	291 }
41 874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	292
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	293 // don't use counts with -Xcomp or CTW
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	294 if (UseInterpreter && !CompileTheWorld) {
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	295
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	296 if (!callee_method->has_compiled_code() &&
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	297 !callee_method->was_executed_more_than(0)) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	298 set_msg("never executed");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	299 return true;
41 874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	300 }
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	301
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	302 if (is_init_with_ea(callee_method, caller_method, C)) {
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	303
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	304 // Escape Analysis: inline all executed constructors
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	305
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	306 } else if (!callee_method->was_executed_more_than(MIN2(MinInliningThreshold,
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	307 CompileThreshold >> 1))) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	308 set_msg("executed < MinInliningThreshold times");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	309 return true;
41 874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	310 }
0 a61af66fc99e Initial load duke parents: diff changeset	311 }
a61af66fc99e Initial load duke parents: diff changeset	312
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	313 return false;
0 a61af66fc99e Initial load duke parents: diff changeset	314 }
a61af66fc99e Initial load duke parents: diff changeset	315
a61af66fc99e Initial load duke parents: diff changeset	316 //-----------------------------try_to_inline-----------------------------------
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	317 // return true if ok
0 a61af66fc99e Initial load duke parents: diff changeset	318 // Relocated from "InliningClosure::try_to_inline"
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	319 bool InlineTree::try_to_inline(ciMethod* callee_method, ciMethod* caller_method,
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	320 int caller_bci, ciCallProfile& profile,
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	321 WarmCallInfo* wci_result, bool& should_delay) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	322
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	323 // Old algorithm had funny accumulating BC-size counters
0 a61af66fc99e Initial load duke parents: diff changeset	324 if (UseOldInlining && ClipInlining
a61af66fc99e Initial load duke parents: diff changeset	325 && (int)count_inline_bcs() >= DesiredMethodLimit) {
7473 d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	326 if (!callee_method->force_inline() \|\| !IncrementalInline) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	327 set_msg("size > DesiredMethodLimit");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	328 return false;
7473 d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	329 } else if (!C->inlining_incrementally()) {
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	330 should_delay = true;
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	331 }
0 a61af66fc99e Initial load duke parents: diff changeset	332 }
a61af66fc99e Initial load duke parents: diff changeset	333
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	334 if (!should_inline(callee_method, caller_method, caller_bci, profile,
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	335 wci_result)) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	336 return false;
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	337 }
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	338 if (should_not_inline(callee_method, caller_method, wci_result)) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	339 return false;
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	340 }
0 a61af66fc99e Initial load duke parents: diff changeset	341
1157 c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1138 diff changeset	342 if (InlineAccessors && callee_method->is_accessor()) {
c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1138 diff changeset	343 // accessor methods are not subject to any of the following limits.
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	344 set_msg("accessor");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	345 return true;
1157 c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1138 diff changeset	346 }
0 a61af66fc99e Initial load duke parents: diff changeset	347
a61af66fc99e Initial load duke parents: diff changeset	348 // suppress a few checks for accessors and trivial methods
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5950 diff changeset	349 if (callee_method->code_size() > MaxTrivialSize) {
41 874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	350
0 a61af66fc99e Initial load duke parents: diff changeset	351 // don't inline into giant methods
7473 d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	352 if (C->over_inlining_cutoff()) {
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	353 if ((!callee_method->force_inline() && !caller_method->is_compiled_lambda_form())
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	354 \|\| !IncrementalInline) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	355 set_msg("NodeCountInliningCutoff");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	356 return false;
7473 d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	357 } else {
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	358 should_delay = true;
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	359 }
41 874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	360 }
0 a61af66fc99e Initial load duke parents: diff changeset	361
41 874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	362 if ((!UseInterpreter \|\| CompileTheWorld) &&
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	363 is_init_with_ea(callee_method, caller_method, C)) {
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	364
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	365 // Escape Analysis stress testing when running Xcomp or CTW:
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	366 // inline constructors even if they are not reached.
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	367
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	368 } else if (profile.count() == 0) {
874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	369 // don't inline unreached call sites
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	370 set_msg("call site not reached");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	371 return false;
41 874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	372 }
0 a61af66fc99e Initial load duke parents: diff changeset	373 }
a61af66fc99e Initial load duke parents: diff changeset	374
1157 c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1138 diff changeset	375 if (!C->do_inlining() && InlineAccessors) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	376 set_msg("not an accessor");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	377 return false;
41 874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	378 }
3458 393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	379 if (inline_level() > _max_inline_level) {
7473 d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	380 if (!callee_method->force_inline() \|\| !IncrementalInline) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	381 set_msg("inlining too deep");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	382 return false;
7473 d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	383 } else if (!C->inlining_incrementally()) {
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	384 should_delay = true;
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	385 }
41 874b2c4f43d1 6667605: (Escape Analysis) inline java constructors when EA is on kvn parents: 0 diff changeset	386 }
2405 3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2357 diff changeset	387
3334 b21ecca7ccc4 6552561: MaxRecursiveInlineLevel flag doesn't operate correctly twisti parents: 2405 diff changeset	388 // detect direct and indirect recursive inlining
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5950 diff changeset	389 if (!callee_method->is_compiled_lambda_form()) {
3334 b21ecca7ccc4 6552561: MaxRecursiveInlineLevel flag doesn't operate correctly twisti parents: 2405 diff changeset	390 // count the current method and the callee
b21ecca7ccc4 6552561: MaxRecursiveInlineLevel flag doesn't operate correctly twisti parents: 2405 diff changeset	391 int inline_level = (method() == callee_method) ? 1 : 0;
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	392 if (inline_level > MaxRecursiveInlineLevel) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	393 set_msg("recursively inlining too deep");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	394 return false;
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	395 }
3334 b21ecca7ccc4 6552561: MaxRecursiveInlineLevel flag doesn't operate correctly twisti parents: 2405 diff changeset	396 // count callers of current method and callee
2405 3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2357 diff changeset	397 JVMState* jvms = caller_jvms();
3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2357 diff changeset	398 while (jvms != NULL && jvms->has_method()) {
3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2357 diff changeset	399 if (jvms->method() == callee_method) {
3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2357 diff changeset	400 inline_level++;
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	401 if (inline_level > MaxRecursiveInlineLevel) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	402 set_msg("recursively inlining too deep");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	403 return false;
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	404 }
2405 3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2357 diff changeset	405 }
3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2357 diff changeset	406 jvms = jvms->caller();
3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2357 diff changeset	407 }
3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2357 diff changeset	408 }
3d58a4983660 7022998: JSR 292 recursive method handle calls inline themselves infinitely twisti parents: 2357 diff changeset	409
3897 de847cac9235 7078382: JSR 292: don't count method handle adapters against inlining budgets twisti parents: 3458 diff changeset	410 int size = callee_method->code_size_for_inlining();
0 a61af66fc99e Initial load duke parents: diff changeset	411
a61af66fc99e Initial load duke parents: diff changeset	412 if (UseOldInlining && ClipInlining
a61af66fc99e Initial load duke parents: diff changeset	413 && (int)count_inline_bcs() + size >= DesiredMethodLimit) {
7473 d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	414 if (!callee_method->force_inline() \|\| !IncrementalInline) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	415 set_msg("size > DesiredMethodLimit");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	416 return false;
7473 d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	417 } else if (!C->inlining_incrementally()) {
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	418 should_delay = true;
d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	419 }
0 a61af66fc99e Initial load duke parents: diff changeset	420 }
a61af66fc99e Initial load duke parents: diff changeset	421
a61af66fc99e Initial load duke parents: diff changeset	422 // ok, inline this method
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	423 return true;
0 a61af66fc99e Initial load duke parents: diff changeset	424 }
a61af66fc99e Initial load duke parents: diff changeset	425
a61af66fc99e Initial load duke parents: diff changeset	426 //------------------------------pass_initial_checks----------------------------
a61af66fc99e Initial load duke parents: diff changeset	427 bool pass_initial_checks(ciMethod* caller_method, int caller_bci, ciMethod* callee_method) {
a61af66fc99e Initial load duke parents: diff changeset	428 ciInstanceKlass *callee_holder = callee_method ? callee_method->holder() : NULL;
a61af66fc99e Initial load duke parents: diff changeset	429 // Check if a callee_method was suggested
a61af66fc99e Initial load duke parents: diff changeset	430 if( callee_method == NULL ) return false;
a61af66fc99e Initial load duke parents: diff changeset	431 // Check if klass of callee_method is loaded
a61af66fc99e Initial load duke parents: diff changeset	432 if( !callee_holder->is_loaded() ) return false;
a61af66fc99e Initial load duke parents: diff changeset	433 if( !callee_holder->is_initialized() ) return false;
a61af66fc99e Initial load duke parents: diff changeset	434 if( !UseInterpreter \|\| CompileTheWorld /* running Xcomp or CTW */ ) {
a61af66fc99e Initial load duke parents: diff changeset	435 // Checks that constant pool's call site has been visited
a61af66fc99e Initial load duke parents: diff changeset	436 // stricter than callee_holder->is_initialized()
a61af66fc99e Initial load duke parents: diff changeset	437 ciBytecodeStream iter(caller_method);
a61af66fc99e Initial load duke parents: diff changeset	438 iter.force_bci(caller_bci);
a61af66fc99e Initial load duke parents: diff changeset	439 Bytecodes::Code call_bc = iter.cur_bc();
1137 97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 903 diff changeset	440 // An invokedynamic instruction does not have a klass.
97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 903 diff changeset	441 if (call_bc != Bytecodes::_invokedynamic) {
1565 ab102d5d923e 6939207: refactor constant pool index processing jrose parents: 1564 diff changeset	442 int index = iter.get_index_u2_cpcache();
1137 97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 903 diff changeset	443 if (!caller_method->is_klass_loaded(index, true)) {
97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 903 diff changeset	444 return false;
97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 903 diff changeset	445 }
97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 903 diff changeset	446 // Try to do constant pool resolution if running Xcomp
97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 903 diff changeset	447 if( !caller_method->check_call(index, call_bc == Bytecodes::_invokestatic) ) {
97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 903 diff changeset	448 return false;
97125851f396 6829187: compiler optimizations required for JSR 292 twisti parents: 903 diff changeset	449 }
0 a61af66fc99e Initial load duke parents: diff changeset	450 }
a61af66fc99e Initial load duke parents: diff changeset	451 }
a61af66fc99e Initial load duke parents: diff changeset	452 // We will attempt to see if a class/field/etc got properly loaded. If it
a61af66fc99e Initial load duke parents: diff changeset	453 // did not, it may attempt to throw an exception during our probing. Catch
a61af66fc99e Initial load duke parents: diff changeset	454 // and ignore such exceptions and do not attempt to compile the method.
a61af66fc99e Initial load duke parents: diff changeset	455 if( callee_method->should_exclude() ) return false;
a61af66fc99e Initial load duke parents: diff changeset	456
a61af66fc99e Initial load duke parents: diff changeset	457 return true;
a61af66fc99e Initial load duke parents: diff changeset	458 }
a61af66fc99e Initial load duke parents: diff changeset	459
3900 a32de5085326 7079673: JSR 292: C1 should inline bytecoded method handle adapters twisti parents: 3897 diff changeset	460 //------------------------------check_can_parse--------------------------------
a32de5085326 7079673: JSR 292: C1 should inline bytecoded method handle adapters twisti parents: 3897 diff changeset	461 const char* InlineTree::check_can_parse(ciMethod* callee) {
a32de5085326 7079673: JSR 292: C1 should inline bytecoded method handle adapters twisti parents: 3897 diff changeset	462 // Certain methods cannot be parsed at all:
a32de5085326 7079673: JSR 292: C1 should inline bytecoded method handle adapters twisti parents: 3897 diff changeset	463 if ( callee->is_native()) return "native method";
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5950 diff changeset	464 if ( callee->is_abstract()) return "abstract method";
3900 a32de5085326 7079673: JSR 292: C1 should inline bytecoded method handle adapters twisti parents: 3897 diff changeset	465 if (!callee->can_be_compiled()) return "not compilable (disabled)";
a32de5085326 7079673: JSR 292: C1 should inline bytecoded method handle adapters twisti parents: 3897 diff changeset	466 if (!callee->has_balanced_monitors()) return "not compilable (unbalanced monitors)";
a32de5085326 7079673: JSR 292: C1 should inline bytecoded method handle adapters twisti parents: 3897 diff changeset	467 if ( callee->get_flow_analysis()->failing()) return "not compilable (flow analysis failed)";
a32de5085326 7079673: JSR 292: C1 should inline bytecoded method handle adapters twisti parents: 3897 diff changeset	468 return NULL;
a32de5085326 7079673: JSR 292: C1 should inline bytecoded method handle adapters twisti parents: 3897 diff changeset	469 }
a32de5085326 7079673: JSR 292: C1 should inline bytecoded method handle adapters twisti parents: 3897 diff changeset	470
0 a61af66fc99e Initial load duke parents: diff changeset	471 //------------------------------print_inlining---------------------------------
7991 60bba1398c51 8005439: no message about inline method if it specifed by CompileCommand vlivanov parents: 7473 diff changeset	472 void InlineTree::print_inlining(ciMethod* callee_method, int caller_bci,
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	473 bool success) const {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	474 const char* inline_msg = msg();
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	475 assert(inline_msg != NULL, "just checking");
7991 60bba1398c51 8005439: no message about inline method if it specifed by CompileCommand vlivanov parents: 7473 diff changeset	476 if (C->log() != NULL) {
60bba1398c51 8005439: no message about inline method if it specifed by CompileCommand vlivanov parents: 7473 diff changeset	477 if (success) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	478 C->log()->inline_success(inline_msg);
7991 60bba1398c51 8005439: no message about inline method if it specifed by CompileCommand vlivanov parents: 7473 diff changeset	479 } else {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	480 C->log()->inline_fail(inline_msg);
7991 60bba1398c51 8005439: no message about inline method if it specifed by CompileCommand vlivanov parents: 7473 diff changeset	481 }
60bba1398c51 8005439: no message about inline method if it specifed by CompileCommand vlivanov parents: 7473 diff changeset	482 }
60bba1398c51 8005439: no message about inline method if it specifed by CompileCommand vlivanov parents: 7473 diff changeset	483 if (PrintInlining) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	484 C->print_inlining(callee_method, inline_level(), caller_bci, inline_msg);
7991 60bba1398c51 8005439: no message about inline method if it specifed by CompileCommand vlivanov parents: 7473 diff changeset	485 if (callee_method == NULL) tty->print(" callee not monotonic or profiled");
60bba1398c51 8005439: no message about inline method if it specifed by CompileCommand vlivanov parents: 7473 diff changeset	486 if (Verbose && callee_method) {
60bba1398c51 8005439: no message about inline method if it specifed by CompileCommand vlivanov parents: 7473 diff changeset	487 const InlineTree *top = this;
60bba1398c51 8005439: no message about inline method if it specifed by CompileCommand vlivanov parents: 7473 diff changeset	488 while( top->caller_tree() != NULL ) { top = top->caller_tree(); }
60bba1398c51 8005439: no message about inline method if it specifed by CompileCommand vlivanov parents: 7473 diff changeset	489 //tty->print(" bcs: %d+%d invoked: %d", top->count_inline_bcs(), callee_method->code_size(), callee_method->interpreter_invocation_count());
60bba1398c51 8005439: no message about inline method if it specifed by CompileCommand vlivanov parents: 7473 diff changeset	490 }
0 a61af66fc99e Initial load duke parents: diff changeset	491 }
a61af66fc99e Initial load duke parents: diff changeset	492 }
a61af66fc99e Initial load duke parents: diff changeset	493
a61af66fc99e Initial load duke parents: diff changeset	494 //------------------------------ok_to_inline-----------------------------------
7473 d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	495 WarmCallInfo* InlineTree::ok_to_inline(ciMethod* callee_method, JVMState* jvms, ciCallProfile& profile, WarmCallInfo* initial_wci, bool& should_delay) {
0 a61af66fc99e Initial load duke parents: diff changeset	496 assert(callee_method != NULL, "caller checks for optimized virtual!");
7473 d092d1b31229 8005071: Incremental inlining for JSR 292 roland parents: 7421 diff changeset	497 assert(!should_delay, "should be initialized to false");
0 a61af66fc99e Initial load duke parents: diff changeset	498 #ifdef ASSERT
a61af66fc99e Initial load duke parents: diff changeset	499 // Make sure the incoming jvms has the same information content as me.
a61af66fc99e Initial load duke parents: diff changeset	500 // This means that we can eventually make this whole class AllStatic.
a61af66fc99e Initial load duke parents: diff changeset	501 if (jvms->caller() == NULL) {
a61af66fc99e Initial load duke parents: diff changeset	502 assert(_caller_jvms == NULL, "redundant instance state");
a61af66fc99e Initial load duke parents: diff changeset	503 } else {
a61af66fc99e Initial load duke parents: diff changeset	504 assert(_caller_jvms->same_calls_as(jvms->caller()), "redundant instance state");
a61af66fc99e Initial load duke parents: diff changeset	505 }
a61af66fc99e Initial load duke parents: diff changeset	506 assert(_method == jvms->method(), "redundant instance state");
a61af66fc99e Initial load duke parents: diff changeset	507 #endif
a61af66fc99e Initial load duke parents: diff changeset	508 int caller_bci = jvms->bci();
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	509 ciMethod* caller_method = jvms->method();
0 a61af66fc99e Initial load duke parents: diff changeset	510
3900 a32de5085326 7079673: JSR 292: C1 should inline bytecoded method handle adapters twisti parents: 3897 diff changeset	511 // Do some initial checks.
a32de5085326 7079673: JSR 292: C1 should inline bytecoded method handle adapters twisti parents: 3897 diff changeset	512 if (!pass_initial_checks(caller_method, caller_bci, callee_method)) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	513 set_msg("failed initial checks");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	514 print_inlining(callee_method, caller_bci, false /* !success */);
0 a61af66fc99e Initial load duke parents: diff changeset	515 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	516 }
a61af66fc99e Initial load duke parents: diff changeset	517
3900 a32de5085326 7079673: JSR 292: C1 should inline bytecoded method handle adapters twisti parents: 3897 diff changeset	518 // Do some parse checks.
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	519 set_msg(check_can_parse(callee_method));
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	520 if (msg() != NULL) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	521 print_inlining(callee_method, caller_bci, false /* !success */);
3900 a32de5085326 7079673: JSR 292: C1 should inline bytecoded method handle adapters twisti parents: 3897 diff changeset	522 return NULL;
a32de5085326 7079673: JSR 292: C1 should inline bytecoded method handle adapters twisti parents: 3897 diff changeset	523 }
a32de5085326 7079673: JSR 292: C1 should inline bytecoded method handle adapters twisti parents: 3897 diff changeset	524
0 a61af66fc99e Initial load duke parents: diff changeset	525 // Check if inlining policy says no.
a61af66fc99e Initial load duke parents: diff changeset	526 WarmCallInfo wci = *(initial_wci);
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	527 bool success = try_to_inline(callee_method, caller_method, caller_bci,
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	528 profile, &wci, should_delay);
0 a61af66fc99e Initial load duke parents: diff changeset	529
a61af66fc99e Initial load duke parents: diff changeset	530 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	531 if (UseOldInlining && InlineWarmCalls
a61af66fc99e Initial load duke parents: diff changeset	532 && (PrintOpto \|\| PrintOptoInlining \|\| PrintInlining)) {
a61af66fc99e Initial load duke parents: diff changeset	533 bool cold = wci.is_cold();
a61af66fc99e Initial load duke parents: diff changeset	534 bool hot = !cold && wci.is_hot();
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	535 bool old_cold = !success;
0 a61af66fc99e Initial load duke parents: diff changeset	536 if (old_cold != cold \|\| (Verbose \|\| WizardMode)) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	537 if (msg() == NULL) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	538 set_msg("OK");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	539 }
0 a61af66fc99e Initial load duke parents: diff changeset	540 tty->print(" OldInlining= %4s : %s\n WCI=",
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	541 old_cold ? "cold" : "hot", msg());
0 a61af66fc99e Initial load duke parents: diff changeset	542 wci.print();
a61af66fc99e Initial load duke parents: diff changeset	543 }
a61af66fc99e Initial load duke parents: diff changeset	544 }
a61af66fc99e Initial load duke parents: diff changeset	545 #endif
a61af66fc99e Initial load duke parents: diff changeset	546 if (UseOldInlining) {
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	547 if (success) {
0 a61af66fc99e Initial load duke parents: diff changeset	548 wci = *(WarmCallInfo::always_hot());
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	549 } else {
0 a61af66fc99e Initial load duke parents: diff changeset	550 wci = *(WarmCallInfo::always_cold());
7991 60bba1398c51 8005439: no message about inline method if it specifed by CompileCommand vlivanov parents: 7473 diff changeset	551 }
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	552 }
0 a61af66fc99e Initial load duke parents: diff changeset	553 if (!InlineWarmCalls) {
a61af66fc99e Initial load duke parents: diff changeset	554 if (!wci.is_cold() && !wci.is_hot()) {
a61af66fc99e Initial load duke parents: diff changeset	555 // Do not inline the warm calls.
a61af66fc99e Initial load duke parents: diff changeset	556 wci = *(WarmCallInfo::always_cold());
a61af66fc99e Initial load duke parents: diff changeset	557 }
a61af66fc99e Initial load duke parents: diff changeset	558 }
a61af66fc99e Initial load duke parents: diff changeset	559
a61af66fc99e Initial load duke parents: diff changeset	560 if (!wci.is_cold()) {
a61af66fc99e Initial load duke parents: diff changeset	561 // Inline!
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	562 if (msg() == NULL) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	563 set_msg("inline (hot)");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	564 }
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	565 print_inlining(callee_method, caller_bci, true /* success */);
0 a61af66fc99e Initial load duke parents: diff changeset	566 if (UseOldInlining)
a61af66fc99e Initial load duke parents: diff changeset	567 build_inline_tree_for_callee(callee_method, jvms, caller_bci);
a61af66fc99e Initial load duke parents: diff changeset	568 if (InlineWarmCalls && !wci.is_hot())
a61af66fc99e Initial load duke parents: diff changeset	569 return new (C) WarmCallInfo(wci); // copy to heap
a61af66fc99e Initial load duke parents: diff changeset	570 return WarmCallInfo::always_hot();
a61af66fc99e Initial load duke parents: diff changeset	571 }
a61af66fc99e Initial load duke parents: diff changeset	572
a61af66fc99e Initial load duke parents: diff changeset	573 // Do not inline
8119 133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	574 if (msg() == NULL) {
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	575 set_msg("too cold to inline");
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	576 }
133bf557ef77 8007439: C2: adding successful message of inlining iignatyev parents: 7991 diff changeset	577 print_inlining(callee_method, caller_bci, false /* !success */ );
0 a61af66fc99e Initial load duke parents: diff changeset	578 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	579 }
a61af66fc99e Initial load duke parents: diff changeset	580
a61af66fc99e Initial load duke parents: diff changeset	581 //------------------------------compute_callee_frequency-----------------------
a61af66fc99e Initial load duke parents: diff changeset	582 float InlineTree::compute_callee_frequency( int caller_bci ) const {
a61af66fc99e Initial load duke parents: diff changeset	583 int count = method()->interpreter_call_site_count(caller_bci);
a61af66fc99e Initial load duke parents: diff changeset	584 int invcnt = method()->interpreter_invocation_count();
a61af66fc99e Initial load duke parents: diff changeset	585 float freq = (float)count/(float)invcnt;
a61af66fc99e Initial load duke parents: diff changeset	586 // Call-site count / interpreter invocation count, scaled recursively.
a61af66fc99e Initial load duke parents: diff changeset	587 // Always between 0.0 and 1.0. Represents the percentage of the method's
a61af66fc99e Initial load duke parents: diff changeset	588 // total execution time used at this call site.
a61af66fc99e Initial load duke parents: diff changeset	589
a61af66fc99e Initial load duke parents: diff changeset	590 return freq;
a61af66fc99e Initial load duke parents: diff changeset	591 }
a61af66fc99e Initial load duke parents: diff changeset	592
a61af66fc99e Initial load duke parents: diff changeset	593 //------------------------------build_inline_tree_for_callee-------------------
a61af66fc99e Initial load duke parents: diff changeset	594 InlineTree InlineTree::build_inline_tree_for_callee( ciMethod callee_method, JVMState* caller_jvms, int caller_bci) {
a61af66fc99e Initial load duke parents: diff changeset	595 float recur_frequency = _site_invoke_ratio * compute_callee_frequency(caller_bci);
a61af66fc99e Initial load duke parents: diff changeset	596 // Attempt inlining.
a61af66fc99e Initial load duke parents: diff changeset	597 InlineTree* old_ilt = callee_at(caller_bci, callee_method);
a61af66fc99e Initial load duke parents: diff changeset	598 if (old_ilt != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	599 return old_ilt;
a61af66fc99e Initial load duke parents: diff changeset	600 }
3458 393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	601 int max_inline_level_adjust = 0;
1157 c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1138 diff changeset	602 if (caller_jvms->method() != NULL) {
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5950 diff changeset	603 if (caller_jvms->method()->is_compiled_lambda_form())
3458 393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	604 max_inline_level_adjust += 1; // don't count actions in MH or indy adapter frames
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5950 diff changeset	605 else if (callee_method->is_method_handle_intrinsic() \|\|
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5950 diff changeset	606 callee_method->is_compiled_lambda_form()) {
3458 393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	607 max_inline_level_adjust += 1; // don't count method handle calls from java.lang.invoke implem
1157 c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1138 diff changeset	608 }
3458 393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	609 if (max_inline_level_adjust != 0 && PrintInlining && (Verbose \|\| WizardMode)) {
393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	610 CompileTask::print_inline_indent(inline_level());
3366 e2a92dd0d3d2 7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters twisti parents: 3345 diff changeset	611 tty->print_cr(" \\-> discounting inline depth");
1157 c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1138 diff changeset	612 }
3458 393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	613 if (max_inline_level_adjust != 0 && C->log()) {
1157 c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1138 diff changeset	614 int id1 = C->log()->identify(caller_jvms->method());
c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1138 diff changeset	615 int id2 = C->log()->identify(callee_method);
3458 393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	616 C->log()->elem("inline_level_discount caller='%d' callee='%d'", id1, id2);
1157 c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1138 diff changeset	617 }
c3b315a0d58a 6912063: inlining parameters need to be adjusted for some uses of the JVM jrose parents: 1138 diff changeset	618 }
3458 393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	619 InlineTree* ilt = new InlineTree(C, this, callee_method, caller_jvms, caller_bci, recur_frequency, _max_inline_level + max_inline_level_adjust);
393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	620 _subtrees.append(ilt);
0 a61af66fc99e Initial load duke parents: diff changeset	621
a61af66fc99e Initial load duke parents: diff changeset	622 NOT_PRODUCT( _count_inlines += 1; )
a61af66fc99e Initial load duke parents: diff changeset	623
a61af66fc99e Initial load duke parents: diff changeset	624 return ilt;
a61af66fc99e Initial load duke parents: diff changeset	625 }
a61af66fc99e Initial load duke parents: diff changeset	626
a61af66fc99e Initial load duke parents: diff changeset	627
a61af66fc99e Initial load duke parents: diff changeset	628 //---------------------------------------callee_at-----------------------------
a61af66fc99e Initial load duke parents: diff changeset	629 InlineTree InlineTree::callee_at(int bci, ciMethod callee) const {
a61af66fc99e Initial load duke parents: diff changeset	630 for (int i = 0; i < _subtrees.length(); i++) {
a61af66fc99e Initial load duke parents: diff changeset	631 InlineTree* sub = _subtrees.at(i);
a61af66fc99e Initial load duke parents: diff changeset	632 if (sub->caller_bci() == bci && callee == sub->method()) {
a61af66fc99e Initial load duke parents: diff changeset	633 return sub;
a61af66fc99e Initial load duke parents: diff changeset	634 }
a61af66fc99e Initial load duke parents: diff changeset	635 }
a61af66fc99e Initial load duke parents: diff changeset	636 return NULL;
a61af66fc99e Initial load duke parents: diff changeset	637 }
a61af66fc99e Initial load duke parents: diff changeset	638
a61af66fc99e Initial load duke parents: diff changeset	639
a61af66fc99e Initial load duke parents: diff changeset	640 //------------------------------build_inline_tree_root-------------------------
a61af66fc99e Initial load duke parents: diff changeset	641 InlineTree *InlineTree::build_inline_tree_root() {
a61af66fc99e Initial load duke parents: diff changeset	642 Compile* C = Compile::current();
a61af66fc99e Initial load duke parents: diff changeset	643
a61af66fc99e Initial load duke parents: diff changeset	644 // Root of inline tree
3458 393e144bb99b 7057587: JSR 292 - crash with jruby in test/test_respond_to.rb never parents: 3366 diff changeset	645 InlineTree* ilt = new InlineTree(C, NULL, C->method(), NULL, -1, 1.0F, MaxInlineLevel);
0 a61af66fc99e Initial load duke parents: diff changeset	646
a61af66fc99e Initial load duke parents: diff changeset	647 return ilt;
a61af66fc99e Initial load duke parents: diff changeset	648 }
a61af66fc99e Initial load duke parents: diff changeset	649
a61af66fc99e Initial load duke parents: diff changeset	650
a61af66fc99e Initial load duke parents: diff changeset	651 //-------------------------find_subtree_from_root-----------------------------
a61af66fc99e Initial load duke parents: diff changeset	652 // Given a jvms, which determines a call chain from the root method,
a61af66fc99e Initial load duke parents: diff changeset	653 // find the corresponding inline tree.
a61af66fc99e Initial load duke parents: diff changeset	654 // Note: This method will be removed or replaced as InlineTree goes away.
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5950 diff changeset	655 InlineTree* InlineTree::find_subtree_from_root(InlineTree* root, JVMState* jvms, ciMethod* callee) {
0 a61af66fc99e Initial load duke parents: diff changeset	656 InlineTree* iltp = root;
a61af66fc99e Initial load duke parents: diff changeset	657 uint depth = jvms && jvms->has_method() ? jvms->depth() : 0;
a61af66fc99e Initial load duke parents: diff changeset	658 for (uint d = 1; d <= depth; d++) {
a61af66fc99e Initial load duke parents: diff changeset	659 JVMState* jvmsp = jvms->of_depth(d);
a61af66fc99e Initial load duke parents: diff changeset	660 // Select the corresponding subtree for this bci.
a61af66fc99e Initial load duke parents: diff changeset	661 assert(jvmsp->method() == iltp->method(), "tree still in sync");
a61af66fc99e Initial load duke parents: diff changeset	662 ciMethod* d_callee = (d == depth) ? callee : jvms->of_depth(d+1)->method();
a61af66fc99e Initial load duke parents: diff changeset	663 InlineTree* sub = iltp->callee_at(jvmsp->bci(), d_callee);
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5950 diff changeset	664 if (sub == NULL) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5950 diff changeset	665 if (d == depth) {
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5950 diff changeset	666 sub = iltp->build_inline_tree_for_callee(d_callee, jvmsp, jvmsp->bci());
0 a61af66fc99e Initial load duke parents: diff changeset	667 }
6266 1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5950 diff changeset	668 guarantee(sub != NULL, "should be a sub-ilt here");
1d7922586cf6 7023639: JSR 292 method handle invocation needs a fast path for compiled code twisti parents: 5950 diff changeset	669 return sub;
0 a61af66fc99e Initial load duke parents: diff changeset	670 }
a61af66fc99e Initial load duke parents: diff changeset	671 iltp = sub;
a61af66fc99e Initial load duke parents: diff changeset	672 }
a61af66fc99e Initial load duke parents: diff changeset	673 return iltp;
a61af66fc99e Initial load duke parents: diff changeset	674 }
3939 f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	675
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	676
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	677
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	678 #ifndef PRODUCT
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	679 void InlineTree::print_impl(outputStream* st, int indent) const {
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	680 for (int i = 0; i < indent; i++) st->print(" ");
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	681 st->print(" @ %d ", caller_bci());
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	682 method()->print_short_name(st);
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	683 st->cr();
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	684
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	685 for (int i = 0 ; i < _subtrees.length(); i++) {
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	686 _subtrees.at(i)->print_impl(st, indent + 2);
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	687 }
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	688 }
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	689
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	690 void InlineTree::print_value_on(outputStream* st) const {
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	691 print_impl(st, 2);
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	692 }
f6f3bb0ee072 7088955: add C2 IR support to the SA never parents: 3905 diff changeset	693 #endif

Mercurial > hg > truffle

annotate src/share/vm/opto/bytecodeInfo.cpp @ 9126:bc26f978b0ce