Mercurial > hg > truffle
annotate src/share/vm/opto/bytecodeInfo.cpp @ 6972:bd7a7ce2e264
6830717: replay of compilations would help with debugging
Summary: When java process crashed in compiler thread, repeat the compilation process will help finding root cause. This is done with using SA dump application class data and replay data from core dump, then use debug version of jvm to recompile the problematic java method.
Reviewed-by: kvn, twisti, sspitsyn
Contributed-by: yumin.qi@oracle.com
| author | minqi |
|---|---|
| date | Mon, 12 Nov 2012 14:03:53 -0800 |
| parents | d804e148cff8 |
| children | 2cb439954abf ad5dd04754ee |
| rev | line source |
|---|---|
| 0 | 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 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 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 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 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 | 27 #include "classfile/systemDictionary.hpp" |
| 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 | 30 #include "compiler/compileLog.hpp" |
| 31 #include "interpreter/linkResolver.hpp" | |
| 32 #include "oops/objArrayKlass.hpp" | |
| 33 #include "opto/callGenerator.hpp" | |
| 34 #include "opto/parse.hpp" | |
| 35 #include "runtime/handles.inline.hpp" | |
| 0 | 36 |
| 37 //============================================================================= | |
| 38 //------------------------------InlineTree------------------------------------- | |
|
3784
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
39 InlineTree::InlineTree(Compile* c, |
|
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
40 const InlineTree *caller_tree, ciMethod* callee, |
|
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
41 JVMState* caller_jvms, int caller_bci, |
|
aabf25fa3f05
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) : |
|
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
43 C(c), |
|
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
44 _caller_jvms(caller_jvms), |
|
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
45 _caller_tree((InlineTree*) caller_tree), |
|
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
46 _method(callee), |
|
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
47 _site_invoke_ratio(site_invoke_ratio), |
|
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
48 _max_inline_level(max_inline_level), |
|
3897
de847cac9235
7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents:
3784
diff
changeset
|
49 _count_inline_bcs(method()->code_size_for_inlining()) |
|
1157
c3b315a0d58a
6912063: inlining parameters need to be adjusted for some uses of the JVM
jrose
parents:
1138
diff
changeset
|
50 { |
| 0 | 51 NOT_PRODUCT(_count_inlines = 0;) |
| 52 if (_caller_jvms != NULL) { | |
| 53 // Keep a private copy of the caller_jvms: | |
| 54 _caller_jvms = new (C) JVMState(caller_jvms->method(), caller_tree->caller_jvms()); | |
| 55 _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
|
56 assert(!caller_jvms->should_reexecute(), "there should be no reexecute bytecode with inlining"); |
| 0 | 57 } |
| 58 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
|
59 assert((caller_tree == NULL ? 0 : caller_tree->stack_depth() + 1) == stack_depth(), "correct (redundant) depth parameter"); |
| 0 | 60 assert(caller_bci == this->caller_bci(), "correct (redundant) bci parameter"); |
| 61 if (UseOldInlining) { | |
| 62 // Update hierarchical counts, count_inline_bcs() and count_inlines() | |
| 63 InlineTree *caller = (InlineTree *)caller_tree; | |
| 64 for( ; caller != NULL; caller = ((InlineTree *)(caller->caller_tree())) ) { | |
| 65 caller->_count_inline_bcs += count_inline_bcs(); | |
| 66 NOT_PRODUCT(caller->_count_inlines++;) | |
| 67 } | |
| 68 } | |
| 69 } | |
| 70 | |
|
1157
c3b315a0d58a
6912063: inlining parameters need to be adjusted for some uses of the JVM
jrose
parents:
1138
diff
changeset
|
71 InlineTree::InlineTree(Compile* c, ciMethod* callee_method, JVMState* caller_jvms, |
|
3784
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
72 float site_invoke_ratio, int max_inline_level) : |
|
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
73 C(c), |
|
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
74 _caller_jvms(caller_jvms), |
|
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
75 _caller_tree(NULL), |
|
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
76 _method(callee_method), |
|
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
77 _site_invoke_ratio(site_invoke_ratio), |
|
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
78 _max_inline_level(max_inline_level), |
|
1157
c3b315a0d58a
6912063: inlining parameters need to be adjusted for some uses of the JVM
jrose
parents:
1138
diff
changeset
|
79 _count_inline_bcs(method()->code_size()) |
|
c3b315a0d58a
6912063: inlining parameters need to be adjusted for some uses of the JVM
jrose
parents:
1138
diff
changeset
|
80 { |
| 0 | 81 NOT_PRODUCT(_count_inlines = 0;) |
| 82 assert(!UseOldInlining, "do not use for old stuff"); | |
| 83 } | |
| 84 | |
|
41
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
85 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
|
86 ciMethod* caller_method, Compile* C) { |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
87 // 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
|
88 // a super constructor is called from an inlined java constructor. |
| 244 | 89 return C->do_escape_analysis() && EliminateAllocations && |
|
41
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
90 ( callee_method->is_initializer() || |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
91 (caller_method->is_initializer() && |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
92 caller_method != C->method() && |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
93 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
|
94 ); |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
95 } |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
96 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
97 // positive filter: should callee be inlined? returns NULL, if yes, or rejection msg |
|
3366
e2a92dd0d3d2
7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters
twisti
parents:
3345
diff
changeset
|
98 const char* InlineTree::should_inline(ciMethod* callee_method, ciMethod* caller_method, int caller_bci, ciCallProfile& profile, WarmCallInfo* wci_result) const { |
| 0 | 99 // Allows targeted inlining |
| 100 if(callee_method->should_inline()) { | |
| 101 *wci_result = *(WarmCallInfo::always_hot()); | |
| 102 if (PrintInlining && Verbose) { | |
|
3784
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
103 CompileTask::print_inline_indent(inline_level()); |
| 0 | 104 tty->print_cr("Inlined method is hot: "); |
| 105 } | |
| 106 return NULL; | |
| 107 } | |
| 108 | |
| 109 // positive filter: should send be inlined? returns NULL (--> yes) | |
| 110 // or rejection msg | |
|
3897
de847cac9235
7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents:
3784
diff
changeset
|
111 int size = callee_method->code_size_for_inlining(); |
| 0 | 112 |
| 113 // 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
|
114 if(callee_method->interpreter_throwout_count() > InlineThrowCount && |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
115 size < InlineThrowMaxSize ) { |
| 0 | 116 wci_result->set_profit(wci_result->profit() * 100); |
| 117 if (PrintInlining && Verbose) { | |
|
3784
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
118 CompileTask::print_inline_indent(inline_level()); |
| 0 | 119 tty->print_cr("Inlined method with many throws (throws=%d):", callee_method->interpreter_throwout_count()); |
| 120 } | |
| 121 return NULL; | |
| 122 } | |
| 123 | |
| 124 if (!UseOldInlining) { | |
| 125 return NULL; // size and frequency are represented in a new way | |
| 126 } | |
| 127 | |
|
3366
e2a92dd0d3d2
7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters
twisti
parents:
3345
diff
changeset
|
128 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
|
129 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
|
130 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
|
131 |
| 0 | 132 int call_site_count = method()->scale_count(profile.count()); |
| 133 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
|
134 |
|
e2a92dd0d3d2
7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters
twisti
parents:
3345
diff
changeset
|
135 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
|
136 int freq = call_site_count / invoke_count; |
|
41
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
137 |
| 0 | 138 // 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
|
139 if ((freq >= InlineFrequencyRatio) || |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
140 (call_site_count >= InlineFrequencyCount) || |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
141 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
|
142 |
|
3366
e2a92dd0d3d2
7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters
twisti
parents:
3345
diff
changeset
|
143 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
|
144 if (size <= max_inline_size && TraceFrequencyInlining) { |
|
3784
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
145 CompileTask::print_inline_indent(inline_level()); |
| 0 | 146 tty->print_cr("Inlined frequent method (freq=%d count=%d):", freq, call_site_count); |
|
3784
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
147 CompileTask::print_inline_indent(inline_level()); |
| 0 | 148 callee_method->print(); |
| 149 tty->cr(); | |
| 150 } | |
| 151 } else { | |
| 152 // 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
|
153 if (callee_method->has_compiled_code() && |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6853
diff
changeset
|
154 callee_method->instructions_size() > inline_small_code_size) |
| 0 | 155 return "already compiled into a medium method"; |
| 156 } | |
|
3366
e2a92dd0d3d2
7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters
twisti
parents:
3345
diff
changeset
|
157 if (size > 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
|
158 if (max_inline_size > default_max_inline_size) |
| 0 | 159 return "hot method too big"; |
| 160 return "too big"; | |
| 161 } | |
| 162 return NULL; | |
| 163 } | |
| 164 | |
| 165 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
166 // negative filter: should callee NOT be inlined? returns NULL, ok to inline, or rejection msg |
|
3366
e2a92dd0d3d2
7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters
twisti
parents:
3345
diff
changeset
|
167 const char* InlineTree::should_not_inline(ciMethod *callee_method, ciMethod* caller_method, WarmCallInfo* wci_result) const { |
| 0 | 168 // negative filter: should send NOT be inlined? returns NULL (--> inline) or rejection msg |
| 169 if (!UseOldInlining) { | |
| 170 const char* fail = NULL; | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
171 if ( callee_method->is_abstract()) fail = "abstract method"; |
| 0 | 172 // note: we allow ik->is_abstract() |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
173 if (!callee_method->holder()->is_initialized()) fail = "method holder not initialized"; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
174 if ( callee_method->is_native()) fail = "native method"; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
175 if ( callee_method->dont_inline()) fail = "don't inline by annotation"; |
| 0 | 176 |
| 177 if (fail) { | |
| 178 *wci_result = *(WarmCallInfo::always_cold()); | |
| 179 return fail; | |
| 180 } | |
| 181 | |
| 182 if (callee_method->has_unloaded_classes_in_signature()) { | |
| 183 wci_result->set_profit(wci_result->profit() * 0.1); | |
| 184 } | |
| 185 | |
| 186 // don't inline exception code unless the top method belongs to an | |
| 187 // exception class | |
| 188 if (callee_method->holder()->is_subclass_of(C->env()->Throwable_klass())) { | |
| 189 ciMethod* top_method = caller_jvms() ? caller_jvms()->of_depth(1)->method() : method(); | |
| 190 if (!top_method->holder()->is_subclass_of(C->env()->Throwable_klass())) { | |
| 191 wci_result->set_profit(wci_result->profit() * 0.1); | |
| 192 } | |
| 193 } | |
| 194 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
195 if (callee_method->has_compiled_code() && |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6853
diff
changeset
|
196 callee_method->instructions_size() > InlineSmallCode) { |
| 0 | 197 wci_result->set_profit(wci_result->profit() * 0.1); |
| 198 // %%% adjust wci_result->size()? | |
| 199 } | |
| 200 | |
| 201 return NULL; | |
| 202 } | |
| 203 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
204 // First check all inlining restrictions which are required for correctness |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
205 if ( callee_method->is_abstract()) return "abstract method"; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
206 // note: we allow ik->is_abstract() |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
207 if (!callee_method->holder()->is_initialized()) return "method holder not initialized"; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
208 if ( callee_method->is_native()) return "native method"; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
209 if ( callee_method->dont_inline()) return "don't inline by annotation"; |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
210 if ( callee_method->has_unloaded_classes_in_signature()) return "unloaded signature classes"; |
|
1138
dd57230ba8fe
6893268: additional dynamic language related optimizations in C2
twisti
parents:
1137
diff
changeset
|
211 |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
212 if (callee_method->force_inline() || callee_method->should_inline()) { |
| 0 | 213 // ignore heuristic controls on inlining |
| 214 return NULL; | |
| 215 } | |
| 216 | |
| 217 // Now perform checks which are heuristic | |
| 218 | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
219 if (callee_method->has_compiled_code() && |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6853
diff
changeset
|
220 callee_method->instructions_size() > InlineSmallCode) { |
| 0 | 221 return "already compiled into a big method"; |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
222 } |
| 0 | 223 |
| 224 // don't inline exception code unless the top method belongs to an | |
| 225 // exception class | |
| 226 if (caller_tree() != NULL && | |
| 227 callee_method->holder()->is_subclass_of(C->env()->Throwable_klass())) { | |
| 228 const InlineTree *top = this; | |
| 229 while (top->caller_tree() != NULL) top = top->caller_tree(); | |
| 230 ciInstanceKlass* k = top->method()->holder(); | |
| 231 if (!k->is_subclass_of(C->env()->Throwable_klass())) | |
| 232 return "exception method"; | |
| 233 } | |
| 234 | |
|
5950
0f4014d7731b
7152961: InlineTree::should_not_inline may exit prematurely
never
parents:
3939
diff
changeset
|
235 if (callee_method->should_not_inline()) { |
|
0f4014d7731b
7152961: InlineTree::should_not_inline may exit prematurely
never
parents:
3939
diff
changeset
|
236 return "disallowed by CompilerOracle"; |
|
0f4014d7731b
7152961: InlineTree::should_not_inline may exit prematurely
never
parents:
3939
diff
changeset
|
237 } |
|
0f4014d7731b
7152961: InlineTree::should_not_inline may exit prematurely
never
parents:
3939
diff
changeset
|
238 |
|
6972
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6853
diff
changeset
|
239 #ifndef PRODUCT |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6853
diff
changeset
|
240 if (ciReplay::should_not_inline(callee_method)) { |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6853
diff
changeset
|
241 return "disallowed by ciReplay"; |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6853
diff
changeset
|
242 } |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6853
diff
changeset
|
243 #endif |
|
bd7a7ce2e264
6830717: replay of compilations would help with debugging
minqi
parents:
6853
diff
changeset
|
244 |
|
5950
0f4014d7731b
7152961: InlineTree::should_not_inline may exit prematurely
never
parents:
3939
diff
changeset
|
245 if (UseStringCache) { |
|
0f4014d7731b
7152961: InlineTree::should_not_inline may exit prematurely
never
parents:
3939
diff
changeset
|
246 // 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
|
247 if (callee_method->name() == ciSymbol::profile_name() && |
|
0f4014d7731b
7152961: InlineTree::should_not_inline may exit prematurely
never
parents:
3939
diff
changeset
|
248 callee_method->holder()->name() == ciSymbol::java_lang_StringCache()) { |
|
0f4014d7731b
7152961: InlineTree::should_not_inline may exit prematurely
never
parents:
3939
diff
changeset
|
249 return "profiling method"; |
|
0f4014d7731b
7152961: InlineTree::should_not_inline may exit prematurely
never
parents:
3939
diff
changeset
|
250 } |
|
0f4014d7731b
7152961: InlineTree::should_not_inline may exit prematurely
never
parents:
3939
diff
changeset
|
251 } |
|
0f4014d7731b
7152961: InlineTree::should_not_inline may exit prematurely
never
parents:
3939
diff
changeset
|
252 |
| 0 | 253 // use frequency-based objections only for non-trivial methods |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
254 if (callee_method->code_size() <= MaxTrivialSize) return NULL; |
|
41
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
255 |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
256 // don't use counts with -Xcomp or CTW |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
257 if (UseInterpreter && !CompileTheWorld) { |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
258 |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
259 if (!callee_method->has_compiled_code() && |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
260 !callee_method->was_executed_more_than(0)) { |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
261 return "never executed"; |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
262 } |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
263 |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
264 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
|
265 |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
266 // Escape Analysis: inline all executed constructors |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
267 |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
268 } 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
|
269 CompileThreshold >> 1))) { |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
270 return "executed < MinInliningThreshold times"; |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
271 } |
| 0 | 272 } |
| 273 | |
| 274 return NULL; | |
| 275 } | |
| 276 | |
| 277 //-----------------------------try_to_inline----------------------------------- | |
| 278 // return NULL if ok, reason for not inlining otherwise | |
| 279 // Relocated from "InliningClosure::try_to_inline" | |
|
41
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
280 const char* InlineTree::try_to_inline(ciMethod* callee_method, ciMethod* caller_method, int caller_bci, ciCallProfile& profile, WarmCallInfo* wci_result) { |
| 0 | 281 |
| 282 // Old algorithm had funny accumulating BC-size counters | |
| 283 if (UseOldInlining && ClipInlining | |
| 284 && (int)count_inline_bcs() >= DesiredMethodLimit) { | |
| 285 return "size > DesiredMethodLimit"; | |
| 286 } | |
| 287 | |
| 288 const char *msg = NULL; | |
|
3366
e2a92dd0d3d2
7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters
twisti
parents:
3345
diff
changeset
|
289 msg = should_inline(callee_method, caller_method, caller_bci, profile, wci_result); |
|
e2a92dd0d3d2
7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters
twisti
parents:
3345
diff
changeset
|
290 if (msg != NULL) |
|
41
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
291 return msg; |
|
3366
e2a92dd0d3d2
7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters
twisti
parents:
3345
diff
changeset
|
292 |
|
e2a92dd0d3d2
7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters
twisti
parents:
3345
diff
changeset
|
293 msg = should_not_inline(callee_method, caller_method, wci_result); |
|
e2a92dd0d3d2
7042122: JSR 292: adjust various inline thresholds for JSR 292 API methods and method handle adapters
twisti
parents:
3345
diff
changeset
|
294 if (msg != NULL) |
|
41
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
295 return msg; |
| 0 | 296 |
|
1157
c3b315a0d58a
6912063: inlining parameters need to be adjusted for some uses of the JVM
jrose
parents:
1138
diff
changeset
|
297 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
|
298 // accessor methods are not subject to any of the following limits. |
|
c3b315a0d58a
6912063: inlining parameters need to be adjusted for some uses of the JVM
jrose
parents:
1138
diff
changeset
|
299 return NULL; |
|
c3b315a0d58a
6912063: inlining parameters need to be adjusted for some uses of the JVM
jrose
parents:
1138
diff
changeset
|
300 } |
| 0 | 301 |
| 302 // 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
|
303 if (callee_method->code_size() > MaxTrivialSize) { |
|
41
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
304 |
| 0 | 305 // don't inline into giant methods |
|
41
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
306 if (C->unique() > (uint)NodeCountInliningCutoff) { |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
307 return "NodeCountInliningCutoff"; |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
308 } |
| 0 | 309 |
|
41
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
310 if ((!UseInterpreter || CompileTheWorld) && |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
311 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
|
312 |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
313 // 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
|
314 // inline constructors even if they are not reached. |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
315 |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
316 } else if (profile.count() == 0) { |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
317 // don't inline unreached call sites |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
318 return "call site not reached"; |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
319 } |
| 0 | 320 } |
| 321 | |
|
1157
c3b315a0d58a
6912063: inlining parameters need to be adjusted for some uses of the JVM
jrose
parents:
1138
diff
changeset
|
322 if (!C->do_inlining() && InlineAccessors) { |
|
41
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
323 return "not an accessor"; |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
324 } |
|
3784
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
325 if (inline_level() > _max_inline_level) { |
|
41
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
326 return "inlining too deep"; |
|
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
327 } |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2357
diff
changeset
|
328 |
|
3334
b21ecca7ccc4
6552561: MaxRecursiveInlineLevel flag doesn't operate correctly
twisti
parents:
2405
diff
changeset
|
329 // 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
|
330 if (!callee_method->is_compiled_lambda_form()) { |
|
3334
b21ecca7ccc4
6552561: MaxRecursiveInlineLevel flag doesn't operate correctly
twisti
parents:
2405
diff
changeset
|
331 // count the current method and the callee |
|
b21ecca7ccc4
6552561: MaxRecursiveInlineLevel flag doesn't operate correctly
twisti
parents:
2405
diff
changeset
|
332 int inline_level = (method() == callee_method) ? 1 : 0; |
|
b21ecca7ccc4
6552561: MaxRecursiveInlineLevel flag doesn't operate correctly
twisti
parents:
2405
diff
changeset
|
333 if (inline_level > MaxRecursiveInlineLevel) |
|
b21ecca7ccc4
6552561: MaxRecursiveInlineLevel flag doesn't operate correctly
twisti
parents:
2405
diff
changeset
|
334 return "recursively inlining too deep"; |
|
b21ecca7ccc4
6552561: MaxRecursiveInlineLevel flag doesn't operate correctly
twisti
parents:
2405
diff
changeset
|
335 // count callers of current method and callee |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2357
diff
changeset
|
336 JVMState* jvms = caller_jvms(); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2357
diff
changeset
|
337 while (jvms != NULL && jvms->has_method()) { |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2357
diff
changeset
|
338 if (jvms->method() == callee_method) { |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2357
diff
changeset
|
339 inline_level++; |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2357
diff
changeset
|
340 if (inline_level > MaxRecursiveInlineLevel) |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2357
diff
changeset
|
341 return "recursively inlining too deep"; |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2357
diff
changeset
|
342 } |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2357
diff
changeset
|
343 jvms = jvms->caller(); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2357
diff
changeset
|
344 } |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2357
diff
changeset
|
345 } |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2357
diff
changeset
|
346 |
|
3897
de847cac9235
7078382: JSR 292: don't count method handle adapters against inlining budgets
twisti
parents:
3784
diff
changeset
|
347 int size = callee_method->code_size_for_inlining(); |
| 0 | 348 |
| 349 if (UseOldInlining && ClipInlining | |
| 350 && (int)count_inline_bcs() + size >= DesiredMethodLimit) { | |
| 351 return "size > DesiredMethodLimit"; | |
| 352 } | |
| 353 | |
| 354 // ok, inline this method | |
| 355 return NULL; | |
| 356 } | |
| 357 | |
| 358 //------------------------------pass_initial_checks---------------------------- | |
| 359 bool pass_initial_checks(ciMethod* caller_method, int caller_bci, ciMethod* callee_method) { | |
| 360 ciInstanceKlass *callee_holder = callee_method ? callee_method->holder() : NULL; | |
| 361 // Check if a callee_method was suggested | |
| 362 if( callee_method == NULL ) return false; | |
| 363 // Check if klass of callee_method is loaded | |
| 364 if( !callee_holder->is_loaded() ) return false; | |
| 365 if( !callee_holder->is_initialized() ) return false; | |
| 366 if( !UseInterpreter || CompileTheWorld /* running Xcomp or CTW */ ) { | |
| 367 // Checks that constant pool's call site has been visited | |
| 368 // stricter than callee_holder->is_initialized() | |
| 369 ciBytecodeStream iter(caller_method); | |
| 370 iter.force_bci(caller_bci); | |
| 371 Bytecodes::Code call_bc = iter.cur_bc(); | |
|
1137
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
903
diff
changeset
|
372 // An invokedynamic instruction does not have a klass. |
|
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
903
diff
changeset
|
373 if (call_bc != Bytecodes::_invokedynamic) { |
| 1565 | 374 int index = iter.get_index_u2_cpcache(); |
|
1137
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
903
diff
changeset
|
375 if (!caller_method->is_klass_loaded(index, true)) { |
|
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
903
diff
changeset
|
376 return false; |
|
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
903
diff
changeset
|
377 } |
|
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
903
diff
changeset
|
378 // Try to do constant pool resolution if running Xcomp |
|
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
903
diff
changeset
|
379 if( !caller_method->check_call(index, call_bc == Bytecodes::_invokestatic) ) { |
|
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
903
diff
changeset
|
380 return false; |
|
97125851f396
6829187: compiler optimizations required for JSR 292
twisti
parents:
903
diff
changeset
|
381 } |
| 0 | 382 } |
| 383 } | |
| 384 // We will attempt to see if a class/field/etc got properly loaded. If it | |
| 385 // did not, it may attempt to throw an exception during our probing. Catch | |
| 386 // and ignore such exceptions and do not attempt to compile the method. | |
| 387 if( callee_method->should_exclude() ) return false; | |
| 388 | |
| 389 return true; | |
| 390 } | |
| 391 | |
|
3900
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
392 //------------------------------check_can_parse-------------------------------- |
|
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
393 const char* InlineTree::check_can_parse(ciMethod* callee) { |
|
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
394 // Certain methods cannot be parsed at all: |
|
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
395 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
|
396 if ( callee->is_abstract()) return "abstract method"; |
|
3900
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
397 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
|
398 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
|
399 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
|
400 return NULL; |
|
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
401 } |
|
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
402 |
| 0 | 403 //------------------------------print_inlining--------------------------------- |
| 404 // Really, the failure_msg can be a success message also. | |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2357
diff
changeset
|
405 void InlineTree::print_inlining(ciMethod* callee_method, int caller_bci, const char* failure_msg) const { |
|
3784
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
406 CompileTask::print_inlining(callee_method, inline_level(), caller_bci, failure_msg ? failure_msg : "inline"); |
|
2405
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2357
diff
changeset
|
407 if (callee_method == NULL) tty->print(" callee not monotonic or profiled"); |
|
3d58a4983660
7022998: JSR 292 recursive method handle calls inline themselves infinitely
twisti
parents:
2357
diff
changeset
|
408 if (Verbose && callee_method) { |
| 0 | 409 const InlineTree *top = this; |
| 410 while( top->caller_tree() != NULL ) { top = top->caller_tree(); } | |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
411 //tty->print(" bcs: %d+%d invoked: %d", top->count_inline_bcs(), callee_method->code_size(), callee_method->interpreter_invocation_count()); |
| 0 | 412 } |
| 413 } | |
| 414 | |
| 415 //------------------------------ok_to_inline----------------------------------- | |
| 416 WarmCallInfo* InlineTree::ok_to_inline(ciMethod* callee_method, JVMState* jvms, ciCallProfile& profile, WarmCallInfo* initial_wci) { | |
| 417 assert(callee_method != NULL, "caller checks for optimized virtual!"); | |
| 418 #ifdef ASSERT | |
| 419 // Make sure the incoming jvms has the same information content as me. | |
| 420 // This means that we can eventually make this whole class AllStatic. | |
| 421 if (jvms->caller() == NULL) { | |
| 422 assert(_caller_jvms == NULL, "redundant instance state"); | |
| 423 } else { | |
| 424 assert(_caller_jvms->same_calls_as(jvms->caller()), "redundant instance state"); | |
| 425 } | |
| 426 assert(_method == jvms->method(), "redundant instance state"); | |
| 427 #endif | |
| 428 const char *failure_msg = NULL; | |
| 429 int caller_bci = jvms->bci(); | |
| 430 ciMethod *caller_method = jvms->method(); | |
| 431 | |
|
3900
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
432 // Do some initial checks. |
|
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
433 if (!pass_initial_checks(caller_method, caller_bci, callee_method)) { |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
434 if (PrintInlining) print_inlining(callee_method, caller_bci, "failed initial checks"); |
| 0 | 435 return NULL; |
| 436 } | |
| 437 | |
|
3900
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
438 // Do some parse checks. |
|
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
439 failure_msg = check_can_parse(callee_method); |
|
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
440 if (failure_msg != NULL) { |
|
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
441 if (PrintInlining) print_inlining(callee_method, caller_bci, failure_msg); |
|
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
442 return NULL; |
|
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
443 } |
|
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
444 |
| 0 | 445 // Check if inlining policy says no. |
| 446 WarmCallInfo wci = *(initial_wci); | |
|
41
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
447 failure_msg = try_to_inline(callee_method, caller_method, caller_bci, profile, &wci); |
| 0 | 448 if (failure_msg != NULL && C->log() != NULL) { |
| 6843 | 449 C->log()->inline_fail(failure_msg); |
| 0 | 450 } |
| 451 | |
| 452 #ifndef PRODUCT | |
| 453 if (UseOldInlining && InlineWarmCalls | |
| 454 && (PrintOpto || PrintOptoInlining || PrintInlining)) { | |
| 455 bool cold = wci.is_cold(); | |
| 456 bool hot = !cold && wci.is_hot(); | |
| 457 bool old_cold = (failure_msg != NULL); | |
| 458 if (old_cold != cold || (Verbose || WizardMode)) { | |
| 459 tty->print(" OldInlining= %4s : %s\n WCI=", | |
| 460 old_cold ? "cold" : "hot", failure_msg ? failure_msg : "OK"); | |
| 461 wci.print(); | |
| 462 } | |
| 463 } | |
| 464 #endif | |
| 465 if (UseOldInlining) { | |
| 466 if (failure_msg == NULL) | |
| 467 wci = *(WarmCallInfo::always_hot()); | |
| 468 else | |
| 469 wci = *(WarmCallInfo::always_cold()); | |
| 470 } | |
| 471 if (!InlineWarmCalls) { | |
| 472 if (!wci.is_cold() && !wci.is_hot()) { | |
| 473 // Do not inline the warm calls. | |
| 474 wci = *(WarmCallInfo::always_cold()); | |
| 475 } | |
| 476 } | |
| 477 | |
| 478 if (!wci.is_cold()) { | |
| 479 // In -UseOldInlining, the failure_msg may also be a success message. | |
| 480 if (failure_msg == NULL) failure_msg = "inline (hot)"; | |
| 481 | |
| 482 // Inline! | |
|
3900
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
483 if (PrintInlining) print_inlining(callee_method, caller_bci, failure_msg); |
| 0 | 484 if (UseOldInlining) |
| 485 build_inline_tree_for_callee(callee_method, jvms, caller_bci); | |
| 486 if (InlineWarmCalls && !wci.is_hot()) | |
| 487 return new (C) WarmCallInfo(wci); // copy to heap | |
| 488 return WarmCallInfo::always_hot(); | |
| 489 } | |
| 490 | |
| 491 // Do not inline | |
| 492 if (failure_msg == NULL) failure_msg = "too cold to inline"; | |
|
3900
a32de5085326
7079673: JSR 292: C1 should inline bytecoded method handle adapters
twisti
parents:
3897
diff
changeset
|
493 if (PrintInlining) print_inlining(callee_method, caller_bci, failure_msg); |
| 0 | 494 return NULL; |
| 495 } | |
| 496 | |
| 497 //------------------------------compute_callee_frequency----------------------- | |
| 498 float InlineTree::compute_callee_frequency( int caller_bci ) const { | |
| 499 int count = method()->interpreter_call_site_count(caller_bci); | |
| 500 int invcnt = method()->interpreter_invocation_count(); | |
| 501 float freq = (float)count/(float)invcnt; | |
| 502 // Call-site count / interpreter invocation count, scaled recursively. | |
| 503 // Always between 0.0 and 1.0. Represents the percentage of the method's | |
| 504 // total execution time used at this call site. | |
| 505 | |
| 506 return freq; | |
| 507 } | |
| 508 | |
| 509 //------------------------------build_inline_tree_for_callee------------------- | |
| 510 InlineTree *InlineTree::build_inline_tree_for_callee( ciMethod* callee_method, JVMState* caller_jvms, int caller_bci) { | |
| 511 float recur_frequency = _site_invoke_ratio * compute_callee_frequency(caller_bci); | |
| 512 // Attempt inlining. | |
| 513 InlineTree* old_ilt = callee_at(caller_bci, callee_method); | |
| 514 if (old_ilt != NULL) { | |
| 515 return old_ilt; | |
| 516 } | |
|
3784
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
517 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
|
518 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
|
519 if (caller_jvms->method()->is_compiled_lambda_form()) |
|
3784
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
520 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
|
521 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
|
522 callee_method->is_compiled_lambda_form()) { |
|
3784
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
523 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
|
524 } |
|
3784
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
525 if (max_inline_level_adjust != 0 && PrintInlining && (Verbose || WizardMode)) { |
|
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
526 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
|
527 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
|
528 } |
|
3784
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
529 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
|
530 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
|
531 int id2 = C->log()->identify(callee_method); |
|
3784
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
532 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
|
533 } |
|
c3b315a0d58a
6912063: inlining parameters need to be adjusted for some uses of the JVM
jrose
parents:
1138
diff
changeset
|
534 } |
|
3784
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
535 InlineTree* ilt = new InlineTree(C, this, callee_method, caller_jvms, caller_bci, recur_frequency, _max_inline_level + max_inline_level_adjust); |
|
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
536 _subtrees.append(ilt); |
| 0 | 537 |
| 538 NOT_PRODUCT( _count_inlines += 1; ) | |
| 539 | |
| 540 return ilt; | |
| 541 } | |
| 542 | |
| 543 | |
| 544 //---------------------------------------callee_at----------------------------- | |
| 545 InlineTree *InlineTree::callee_at(int bci, ciMethod* callee) const { | |
| 546 for (int i = 0; i < _subtrees.length(); i++) { | |
| 547 InlineTree* sub = _subtrees.at(i); | |
| 548 if (sub->caller_bci() == bci && callee == sub->method()) { | |
| 549 return sub; | |
| 550 } | |
| 551 } | |
| 552 return NULL; | |
| 553 } | |
| 554 | |
| 555 | |
| 556 //------------------------------build_inline_tree_root------------------------- | |
| 557 InlineTree *InlineTree::build_inline_tree_root() { | |
| 558 Compile* C = Compile::current(); | |
| 559 | |
| 560 // Root of inline tree | |
|
3784
aabf25fa3f05
7057587: JSR 292 - crash with jruby in test/test_respond_to.rb
never
parents:
3366
diff
changeset
|
561 InlineTree* ilt = new InlineTree(C, NULL, C->method(), NULL, -1, 1.0F, MaxInlineLevel); |
| 0 | 562 |
| 563 return ilt; | |
| 564 } | |
| 565 | |
| 566 | |
| 567 //-------------------------find_subtree_from_root----------------------------- | |
| 568 // Given a jvms, which determines a call chain from the root method, | |
| 569 // find the corresponding inline tree. | |
| 570 // 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
|
571 InlineTree* InlineTree::find_subtree_from_root(InlineTree* root, JVMState* jvms, ciMethod* callee) { |
| 0 | 572 InlineTree* iltp = root; |
| 573 uint depth = jvms && jvms->has_method() ? jvms->depth() : 0; | |
| 574 for (uint d = 1; d <= depth; d++) { | |
| 575 JVMState* jvmsp = jvms->of_depth(d); | |
| 576 // Select the corresponding subtree for this bci. | |
| 577 assert(jvmsp->method() == iltp->method(), "tree still in sync"); | |
| 578 ciMethod* d_callee = (d == depth) ? callee : jvms->of_depth(d+1)->method(); | |
| 579 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
|
580 if (sub == NULL) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
581 if (d == depth) { |
|
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
582 sub = iltp->build_inline_tree_for_callee(d_callee, jvmsp, jvmsp->bci()); |
| 0 | 583 } |
|
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
584 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
|
585 return sub; |
| 0 | 586 } |
| 587 iltp = sub; | |
| 588 } | |
| 589 return iltp; | |
| 590 } | |
| 3939 | 591 |
| 592 | |
| 593 | |
| 594 #ifndef PRODUCT | |
| 595 void InlineTree::print_impl(outputStream* st, int indent) const { | |
| 596 for (int i = 0; i < indent; i++) st->print(" "); | |
| 597 st->print(" @ %d ", caller_bci()); | |
| 598 method()->print_short_name(st); | |
| 599 st->cr(); | |
| 600 | |
| 601 for (int i = 0 ; i < _subtrees.length(); i++) { | |
| 602 _subtrees.at(i)->print_impl(st, indent + 2); | |
| 603 } | |
| 604 } | |
| 605 | |
| 606 void InlineTree::print_value_on(outputStream* st) const { | |
| 607 print_impl(st, 2); | |
| 608 } | |
| 609 #endif |