Mercurial > hg > truffle
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 | 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------------------------------------- | |
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 | 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 | 53 NOT_PRODUCT(_count_inlines = 0;) |
54 if (_caller_jvms != NULL) { | |
55 // Keep a private copy of the caller_jvms: | |
56 _caller_jvms = new (C) JVMState(caller_jvms->method(), caller_tree->caller_jvms()); | |
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 | 59 } |
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 | 62 assert(caller_bci == this->caller_bci(), "correct (redundant) bci parameter"); |
63 if (UseOldInlining) { | |
64 // Update hierarchical counts, count_inline_bcs() and count_inlines() | |
65 InlineTree *caller = (InlineTree *)caller_tree; | |
66 for( ; caller != NULL; caller = ((InlineTree *)(caller->caller_tree())) ) { | |
67 caller->_count_inline_bcs += count_inline_bcs(); | |
68 NOT_PRODUCT(caller->_count_inlines++;) | |
69 } | |
70 } | |
71 } | |
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 | 84 NOT_PRODUCT(_count_inlines = 0;) |
85 assert(!UseOldInlining, "do not use for old stuff"); | |
86 } | |
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 | 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 | 104 // Allows targeted inlining |
105 if(callee_method->should_inline()) { | |
106 *wci_result = *(WarmCallInfo::always_hot()); | |
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 | 109 tty->print_cr("Inlined method is hot: "); |
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 | 113 } |
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 | 116 |
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 | 120 wci_result->set_profit(wci_result->profit() * 100); |
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 | 123 tty->print_cr("Inlined method with many throws (throws=%d):", callee_method->interpreter_throwout_count()); |
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 | 127 } |
128 | |
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 | 132 } |
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 | 138 int call_site_count = method()->scale_count(profile.count()); |
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 | 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 | 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 | 154 callee_method->print(); |
155 tty->cr(); | |
156 } | |
157 } else { | |
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 | 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 | 172 } |
8119
133bf557ef77
8007439: C2: adding successful message of inlining
iignatyev
parents:
7991
diff
changeset
|
173 return true; |
0 | 174 } |
175 | |
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 | 195 if (!UseOldInlining) { |
8119
133bf557ef77
8007439: C2: adding successful message of inlining
iignatyev
parents:
7991
diff
changeset
|
196 if (fail_msg != NULL) { |
0 | 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 | 200 } |
201 | |
202 if (callee_method->has_unloaded_classes_in_signature()) { | |
203 wci_result->set_profit(wci_result->profit() * 0.1); | |
204 } | |
205 | |
206 // don't inline exception code unless the top method belongs to an | |
207 // exception class | |
208 if (callee_method->holder()->is_subclass_of(C->env()->Throwable_klass())) { | |
209 ciMethod* top_method = caller_jvms() ? caller_jvms()->of_depth(1)->method() : method(); | |
210 if (!top_method->holder()->is_subclass_of(C->env()->Throwable_klass())) { | |
211 wci_result->set_profit(wci_result->profit() * 0.1); | |
212 } | |
213 } | |
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 | 217 wci_result->set_profit(wci_result->profit() * 0.1); |
218 // %%% adjust wci_result->size()? | |
219 } | |
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 | 227 } |
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 | 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 | 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 | 243 |
244 // Now perform checks which are heuristic | |
245 | |
7473 | 246 if (!callee_method->force_inline()) { |
247 if (callee_method->has_compiled_code() && | |
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 | 251 } |
6266
1d7922586cf6
7023639: JSR 292 method handle invocation needs a fast path for compiled code
twisti
parents:
5950
diff
changeset
|
252 } |
0 | 253 |
254 // don't inline exception code unless the top method belongs to an | |
255 // exception class | |
256 if (caller_tree() != NULL && | |
257 callee_method->holder()->is_subclass_of(C->env()->Throwable_klass())) { | |
258 const InlineTree *top = this; | |
259 while (top->caller_tree() != NULL) top = top->caller_tree(); | |
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 | 265 } |
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 | 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 | 311 } |
312 | |
8119
133bf557ef77
8007439: C2: adding successful message of inlining
iignatyev
parents:
7991
diff
changeset
|
313 return false; |
0 | 314 } |
315 | |
316 //-----------------------------try_to_inline----------------------------------- | |
8119
133bf557ef77
8007439: C2: adding successful message of inlining
iignatyev
parents:
7991
diff
changeset
|
317 // return true if ok |
0 | 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 | 324 if (UseOldInlining && ClipInlining |
325 && (int)count_inline_bcs() >= DesiredMethodLimit) { | |
7473 | 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 | 329 } else if (!C->inlining_incrementally()) { |
330 should_delay = true; | |
331 } | |
0 | 332 } |
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 | 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 | 347 |
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 | 351 // don't inline into giant methods |
7473 | 352 if (C->over_inlining_cutoff()) { |
353 if ((!callee_method->force_inline() && !caller_method->is_compiled_lambda_form()) | |
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 | 357 } else { |
358 should_delay = true; | |
359 } | |
41
874b2c4f43d1
6667605: (Escape Analysis) inline java constructors when EA is on
kvn
parents:
0
diff
changeset
|
360 } |
0 | 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 | 373 } |
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 | 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 | 383 } else if (!C->inlining_incrementally()) { |
384 should_delay = true; | |
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 | 411 |
412 if (UseOldInlining && ClipInlining | |
413 && (int)count_inline_bcs() + size >= DesiredMethodLimit) { | |
7473 | 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 | 417 } else if (!C->inlining_incrementally()) { |
418 should_delay = true; | |
419 } | |
0 | 420 } |
421 | |
422 // ok, inline this method | |
8119
133bf557ef77
8007439: C2: adding successful message of inlining
iignatyev
parents:
7991
diff
changeset
|
423 return true; |
0 | 424 } |
425 | |
426 //------------------------------pass_initial_checks---------------------------- | |
427 bool pass_initial_checks(ciMethod* caller_method, int caller_bci, ciMethod* callee_method) { | |
428 ciInstanceKlass *callee_holder = callee_method ? callee_method->holder() : NULL; | |
429 // Check if a callee_method was suggested | |
430 if( callee_method == NULL ) return false; | |
431 // Check if klass of callee_method is loaded | |
432 if( !callee_holder->is_loaded() ) return false; | |
433 if( !callee_holder->is_initialized() ) return false; | |
434 if( !UseInterpreter || CompileTheWorld /* running Xcomp or CTW */ ) { | |
435 // Checks that constant pool's call site has been visited | |
436 // stricter than callee_holder->is_initialized() | |
437 ciBytecodeStream iter(caller_method); | |
438 iter.force_bci(caller_bci); | |
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 | 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 | 450 } |
451 } | |
452 // We will attempt to see if a class/field/etc got properly loaded. If it | |
453 // did not, it may attempt to throw an exception during our probing. Catch | |
454 // and ignore such exceptions and do not attempt to compile the method. | |
455 if( callee_method->should_exclude() ) return false; | |
456 | |
457 return true; | |
458 } | |
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 | 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 | 491 } |
492 } | |
493 | |
494 //------------------------------ok_to_inline----------------------------------- | |
7473 | 495 WarmCallInfo* InlineTree::ok_to_inline(ciMethod* callee_method, JVMState* jvms, ciCallProfile& profile, WarmCallInfo* initial_wci, bool& should_delay) { |
0 | 496 assert(callee_method != NULL, "caller checks for optimized virtual!"); |
7473 | 497 assert(!should_delay, "should be initialized to false"); |
0 | 498 #ifdef ASSERT |
499 // Make sure the incoming jvms has the same information content as me. | |
500 // This means that we can eventually make this whole class AllStatic. | |
501 if (jvms->caller() == NULL) { | |
502 assert(_caller_jvms == NULL, "redundant instance state"); | |
503 } else { | |
504 assert(_caller_jvms->same_calls_as(jvms->caller()), "redundant instance state"); | |
505 } | |
506 assert(_method == jvms->method(), "redundant instance state"); | |
507 #endif | |
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 | 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 | 515 return NULL; |
516 } | |
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 | 525 // Check if inlining policy says no. |
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 | 529 |
530 #ifndef PRODUCT | |
531 if (UseOldInlining && InlineWarmCalls | |
532 && (PrintOpto || PrintOptoInlining || PrintInlining)) { | |
533 bool cold = wci.is_cold(); | |
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 | 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 | 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 | 542 wci.print(); |
543 } | |
544 } | |
545 #endif | |
546 if (UseOldInlining) { | |
8119
133bf557ef77
8007439: C2: adding successful message of inlining
iignatyev
parents:
7991
diff
changeset
|
547 if (success) { |
0 | 548 wci = *(WarmCallInfo::always_hot()); |
8119
133bf557ef77
8007439: C2: adding successful message of inlining
iignatyev
parents:
7991
diff
changeset
|
549 } else { |
0 | 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 | 553 if (!InlineWarmCalls) { |
554 if (!wci.is_cold() && !wci.is_hot()) { | |
555 // Do not inline the warm calls. | |
556 wci = *(WarmCallInfo::always_cold()); | |
557 } | |
558 } | |
559 | |
560 if (!wci.is_cold()) { | |
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 | 566 if (UseOldInlining) |
567 build_inline_tree_for_callee(callee_method, jvms, caller_bci); | |
568 if (InlineWarmCalls && !wci.is_hot()) | |
569 return new (C) WarmCallInfo(wci); // copy to heap | |
570 return WarmCallInfo::always_hot(); | |
571 } | |
572 | |
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 | 578 return NULL; |
579 } | |
580 | |
581 //------------------------------compute_callee_frequency----------------------- | |
582 float InlineTree::compute_callee_frequency( int caller_bci ) const { | |
583 int count = method()->interpreter_call_site_count(caller_bci); | |
584 int invcnt = method()->interpreter_invocation_count(); | |
585 float freq = (float)count/(float)invcnt; | |
586 // Call-site count / interpreter invocation count, scaled recursively. | |
587 // Always between 0.0 and 1.0. Represents the percentage of the method's | |
588 // total execution time used at this call site. | |
589 | |
590 return freq; | |
591 } | |
592 | |
593 //------------------------------build_inline_tree_for_callee------------------- | |
594 InlineTree *InlineTree::build_inline_tree_for_callee( ciMethod* callee_method, JVMState* caller_jvms, int caller_bci) { | |
595 float recur_frequency = _site_invoke_ratio * compute_callee_frequency(caller_bci); | |
596 // Attempt inlining. | |
597 InlineTree* old_ilt = callee_at(caller_bci, callee_method); | |
598 if (old_ilt != NULL) { | |
599 return old_ilt; | |
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 | 621 |
622 NOT_PRODUCT( _count_inlines += 1; ) | |
623 | |
624 return ilt; | |
625 } | |
626 | |
627 | |
628 //---------------------------------------callee_at----------------------------- | |
629 InlineTree *InlineTree::callee_at(int bci, ciMethod* callee) const { | |
630 for (int i = 0; i < _subtrees.length(); i++) { | |
631 InlineTree* sub = _subtrees.at(i); | |
632 if (sub->caller_bci() == bci && callee == sub->method()) { | |
633 return sub; | |
634 } | |
635 } | |
636 return NULL; | |
637 } | |
638 | |
639 | |
640 //------------------------------build_inline_tree_root------------------------- | |
641 InlineTree *InlineTree::build_inline_tree_root() { | |
642 Compile* C = Compile::current(); | |
643 | |
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 | 646 |
647 return ilt; | |
648 } | |
649 | |
650 | |
651 //-------------------------find_subtree_from_root----------------------------- | |
652 // Given a jvms, which determines a call chain from the root method, | |
653 // find the corresponding inline tree. | |
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 | 656 InlineTree* iltp = root; |
657 uint depth = jvms && jvms->has_method() ? jvms->depth() : 0; | |
658 for (uint d = 1; d <= depth; d++) { | |
659 JVMState* jvmsp = jvms->of_depth(d); | |
660 // Select the corresponding subtree for this bci. | |
661 assert(jvmsp->method() == iltp->method(), "tree still in sync"); | |
662 ciMethod* d_callee = (d == depth) ? callee : jvms->of_depth(d+1)->method(); | |
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 | 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 | 670 } |
671 iltp = sub; | |
672 } | |
673 return iltp; | |
674 } | |
3939 | 675 |
676 | |
677 | |
678 #ifndef PRODUCT | |
679 void InlineTree::print_impl(outputStream* st, int indent) const { | |
680 for (int i = 0; i < indent; i++) st->print(" "); | |
681 st->print(" @ %d ", caller_bci()); | |
682 method()->print_short_name(st); | |
683 st->cr(); | |
684 | |
685 for (int i = 0 ; i < _subtrees.length(); i++) { | |
686 _subtrees.at(i)->print_impl(st, indent + 2); | |
687 } | |
688 } | |
689 | |
690 void InlineTree::print_value_on(outputStream* st) const { | |
691 print_impl(st, 2); | |
692 } | |
693 #endif |